ARM: tegra: pcie: Remove dock detect variable
[linux-3.10.git] / arch / arm / mach-tegra / apbio.c
1 /*
2  * Copyright (C) 2010 NVIDIA Corporation.
3  * Copyright (C) 2010 Google, Inc.
4  *
5  * This software is licensed under the terms of the GNU General Public
6  * License version 2, as published by the Free Software Foundation, and
7  * may be copied, distributed, and modified under those terms.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  */
15
16 #include <linux/kernel.h>
17 #include <linux/io.h>
18 #include <linux/of.h>
19 #include <linux/dmaengine.h>
20 #include <linux/dma-mapping.h>
21 #include <linux/spinlock.h>
22 #include <linux/completion.h>
23 #include <linux/sched.h>
24 #include <linux/mutex.h>
25
26 #include "apbio.h"
27 #include "iomap.h"
28
29 #if defined(CONFIG_TEGRA20_APB_DMA)
30 static DEFINE_MUTEX(tegra_apb_dma_lock);
31 static u32 *tegra_apb_bb;
32 static dma_addr_t tegra_apb_bb_phys;
33 static DECLARE_COMPLETION(tegra_apb_wait);
34
35 static u32 tegra_apb_readl_direct(unsigned long offset);
36 static void tegra_apb_writel_direct(u32 value, unsigned long offset);
37
38 static struct dma_chan *tegra_apb_dma_chan;
39 static struct dma_slave_config dma_sconfig;
40
41 bool tegra_apb_dma_init(void)
42 {
43         dma_cap_mask_t mask;
44
45         mutex_lock(&tegra_apb_dma_lock);
46
47         /* Check to see if we raced to setup */
48         if (tegra_apb_dma_chan)
49                 goto skip_init;
50
51         dma_cap_zero(mask);
52         dma_cap_set(DMA_SLAVE, mask);
53         tegra_apb_dma_chan = dma_request_channel(mask, NULL, NULL);
54         if (!tegra_apb_dma_chan) {
55                 /*
56                  * This is common until the device is probed, so don't
57                  * shout about it.
58                  */
59                 pr_debug("%s: can not allocate dma channel\n", __func__);
60                 goto err_dma_alloc;
61         }
62
63         tegra_apb_bb = dma_alloc_coherent(NULL, sizeof(u32),
64                 &tegra_apb_bb_phys, GFP_KERNEL);
65         if (!tegra_apb_bb) {
66                 pr_err("%s: can not allocate bounce buffer\n", __func__);
67                 goto err_buff_alloc;
68         }
69
70         dma_sconfig.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
71         dma_sconfig.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
72         dma_sconfig.src_maxburst = 1;
73         dma_sconfig.dst_maxburst = 1;
74
75 skip_init:
76         mutex_unlock(&tegra_apb_dma_lock);
77         return true;
78
79 err_buff_alloc:
80         dma_release_channel(tegra_apb_dma_chan);
81         tegra_apb_dma_chan = NULL;
82
83 err_dma_alloc:
84         mutex_unlock(&tegra_apb_dma_lock);
85         return false;
86 }
87
88 static void apb_dma_complete(void *args)
89 {
90         complete(&tegra_apb_wait);
91 }
92
93 static int do_dma_transfer(unsigned long apb_add,
94                 enum dma_transfer_direction dir)
95 {
96         struct dma_async_tx_descriptor *dma_desc;
97         int ret;
98
99         if (dir == DMA_DEV_TO_MEM)
100                 dma_sconfig.src_addr = apb_add;
101         else
102                 dma_sconfig.dst_addr = apb_add;
103
104         ret = dmaengine_slave_config(tegra_apb_dma_chan, &dma_sconfig);
105         if (ret)
106                 return ret;
107
108         dma_desc = dmaengine_prep_slave_single(tegra_apb_dma_chan,
109                         tegra_apb_bb_phys, sizeof(u32), dir,
110                         DMA_PREP_INTERRUPT |  DMA_CTRL_ACK);
111         if (!dma_desc)
112                 return -EINVAL;
113
114         dma_desc->callback = apb_dma_complete;
115         dma_desc->callback_param = NULL;
116
117         INIT_COMPLETION(tegra_apb_wait);
118
119         dmaengine_submit(dma_desc);
120         dma_async_issue_pending(tegra_apb_dma_chan);
121         ret = wait_for_completion_timeout(&tegra_apb_wait,
122                 msecs_to_jiffies(50));
123
124         if (WARN(ret == 0, "apb read dma timed out")) {
125                 dmaengine_terminate_all(tegra_apb_dma_chan);
126                 return -EFAULT;
127         }
128         return 0;
129 }
130
131 static u32 tegra_apb_readl_using_dma(unsigned long offset)
132 {
133         int ret;
134
135         if (!tegra_apb_dma_chan && !tegra_apb_dma_init())
136                 return tegra_apb_readl_direct(offset);
137
138         mutex_lock(&tegra_apb_dma_lock);
139         ret = do_dma_transfer(offset, DMA_DEV_TO_MEM);
140         if (ret < 0) {
141                 pr_err("error in reading offset 0x%08lx using dma\n", offset);
142                 *(u32 *)tegra_apb_bb = 0;
143         }
144         mutex_unlock(&tegra_apb_dma_lock);
145         return *((u32 *)tegra_apb_bb);
146 }
147
148 static void tegra_apb_writel_using_dma(u32 value, unsigned long offset)
149 {
150         int ret;
151
152         if (!tegra_apb_dma_chan && !tegra_apb_dma_init()) {
153                 tegra_apb_writel_direct(value, offset);
154                 return;
155         }
156
157         mutex_lock(&tegra_apb_dma_lock);
158         *((u32 *)tegra_apb_bb) = value;
159         ret = do_dma_transfer(offset, DMA_MEM_TO_DEV);
160         if (ret < 0)
161                 pr_err("error in writing offset 0x%08lx using dma\n", offset);
162         mutex_unlock(&tegra_apb_dma_lock);
163 }
164 #else
165 #define tegra_apb_readl_using_dma tegra_apb_readl_direct
166 #define tegra_apb_writel_using_dma tegra_apb_writel_direct
167 #endif
168
169 typedef u32 (*apbio_read_fptr)(unsigned long offset);
170 typedef void (*apbio_write_fptr)(u32 value, unsigned long offset);
171
172 static apbio_read_fptr apbio_read;
173 static apbio_write_fptr apbio_write;
174
175 static u32 tegra_apb_readl_direct(unsigned long offset)
176 {
177         return readl(IO_ADDRESS(offset));
178 }
179
180 static void tegra_apb_writel_direct(u32 value, unsigned long offset)
181 {
182         writel(value, IO_ADDRESS(offset));
183 }
184
185 void tegra_apb_io_init(void)
186 {
187         /* Need to use dma only when it is Tegra20 based platform */
188         if (of_machine_is_compatible("nvidia,tegra20") ||
189                         !of_have_populated_dt()) {
190                 apbio_read = tegra_apb_readl_using_dma;
191                 apbio_write = tegra_apb_writel_using_dma;
192         } else {
193                 apbio_read = tegra_apb_readl_direct;
194                 apbio_write = tegra_apb_writel_direct;
195         }
196 }
197
198 u32 tegra_apb_readl(unsigned long offset)
199 {
200         return apbio_read(offset);
201 }
202
203 void tegra_apb_writel(u32 value, unsigned long offset)
204 {
205         apbio_write(value, offset);
206 }