diff options
author | Eric Miao <eric.y.miao@gmail.com> | 2010-03-16 02:44:05 -0400 |
---|---|---|
committer | Eric Miao <eric.y.miao@gmail.com> | 2010-05-11 11:24:57 -0400 |
commit | 793ffb9ed3179906760874689a99d4863d76914e (patch) | |
tree | 69d587d5b9f76807c926a8cbee4b5914833b9d49 /arch/arm/mach-pxa | |
parent | 639b91a364fafea24fc1d2e8853c12ce45d4ceea (diff) |
[ARM] pxa: remove the now legacy SSP API
Signed-off-by: Eric Miao <eric.y.miao@gmail.com>
Diffstat (limited to 'arch/arm/mach-pxa')
-rw-r--r-- | arch/arm/mach-pxa/Kconfig | 5 | ||||
-rw-r--r-- | arch/arm/mach-pxa/include/mach/ssp.h | 35 | ||||
-rw-r--r-- | arch/arm/mach-pxa/ssp.c | 286 |
3 files changed, 0 insertions, 326 deletions
diff --git a/arch/arm/mach-pxa/Kconfig b/arch/arm/mach-pxa/Kconfig index 089579fda6c5..8f7eb12776a9 100644 --- a/arch/arm/mach-pxa/Kconfig +++ b/arch/arm/mach-pxa/Kconfig | |||
@@ -653,11 +653,6 @@ config PXA_SSP | |||
653 | help | 653 | help |
654 | Enable support for PXA2xx SSP ports | 654 | Enable support for PXA2xx SSP ports |
655 | 655 | ||
656 | config PXA_SSP_LEGACY | ||
657 | bool | ||
658 | help | ||
659 | Support of legacy SSP API | ||
660 | |||
661 | config TOSA_BT | 656 | config TOSA_BT |
662 | tristate "Control the state of built-in bluetooth chip on Sharp SL-6000" | 657 | tristate "Control the state of built-in bluetooth chip on Sharp SL-6000" |
663 | depends on MACH_TOSA | 658 | depends on MACH_TOSA |
diff --git a/arch/arm/mach-pxa/include/mach/ssp.h b/arch/arm/mach-pxa/include/mach/ssp.h index be1be5b6db51..8470a73d18b9 100644 --- a/arch/arm/mach-pxa/include/mach/ssp.h +++ b/arch/arm/mach-pxa/include/mach/ssp.h | |||
@@ -46,41 +46,6 @@ struct ssp_device { | |||
46 | int drcmr_tx; | 46 | int drcmr_tx; |
47 | }; | 47 | }; |
48 | 48 | ||
49 | #ifdef CONFIG_PXA_SSP_LEGACY | ||
50 | /* | ||
51 | * SSP initialisation flags | ||
52 | */ | ||
53 | #define SSP_NO_IRQ 0x1 /* don't register an irq handler in SSP driver */ | ||
54 | |||
55 | struct ssp_state { | ||
56 | u32 cr0; | ||
57 | u32 cr1; | ||
58 | u32 to; | ||
59 | u32 psp; | ||
60 | }; | ||
61 | |||
62 | struct ssp_dev { | ||
63 | struct ssp_device *ssp; | ||
64 | u32 port; | ||
65 | u32 mode; | ||
66 | u32 flags; | ||
67 | u32 psp_flags; | ||
68 | u32 speed; | ||
69 | int irq; | ||
70 | }; | ||
71 | |||
72 | int ssp_write_word(struct ssp_dev *dev, u32 data); | ||
73 | int ssp_read_word(struct ssp_dev *dev, u32 *data); | ||
74 | int ssp_flush(struct ssp_dev *dev); | ||
75 | void ssp_enable(struct ssp_dev *dev); | ||
76 | void ssp_disable(struct ssp_dev *dev); | ||
77 | void ssp_save_state(struct ssp_dev *dev, struct ssp_state *ssp); | ||
78 | void ssp_restore_state(struct ssp_dev *dev, struct ssp_state *ssp); | ||
79 | int ssp_init(struct ssp_dev *dev, u32 port, u32 init_flags); | ||
80 | int ssp_config(struct ssp_dev *dev, u32 mode, u32 flags, u32 psp_flags, u32 speed); | ||
81 | void ssp_exit(struct ssp_dev *dev); | ||
82 | #endif /* CONFIG_PXA_SSP_LEGACY */ | ||
83 | |||
84 | /** | 49 | /** |
85 | * ssp_write_reg - Write to a SSP register | 50 | * ssp_write_reg - Write to a SSP register |
86 | * | 51 | * |
diff --git a/arch/arm/mach-pxa/ssp.c b/arch/arm/mach-pxa/ssp.c index a81d6dbf662d..6e7df7af61e1 100644 --- a/arch/arm/mach-pxa/ssp.c +++ b/arch/arm/mach-pxa/ssp.c | |||
@@ -35,278 +35,6 @@ | |||
35 | #include <mach/ssp.h> | 35 | #include <mach/ssp.h> |
36 | #include <mach/regs-ssp.h> | 36 | #include <mach/regs-ssp.h> |
37 | 37 | ||
38 | #ifdef CONFIG_PXA_SSP_LEGACY | ||
39 | |||
40 | #define TIMEOUT 100000 | ||
41 | |||
42 | static irqreturn_t ssp_interrupt(int irq, void *dev_id) | ||
43 | { | ||
44 | struct ssp_dev *dev = dev_id; | ||
45 | struct ssp_device *ssp = dev->ssp; | ||
46 | unsigned int status; | ||
47 | |||
48 | status = __raw_readl(ssp->mmio_base + SSSR); | ||
49 | __raw_writel(status, ssp->mmio_base + SSSR); | ||
50 | |||
51 | if (status & SSSR_ROR) | ||
52 | printk(KERN_WARNING "SSP(%d): receiver overrun\n", dev->port); | ||
53 | |||
54 | if (status & SSSR_TUR) | ||
55 | printk(KERN_WARNING "SSP(%d): transmitter underrun\n", dev->port); | ||
56 | |||
57 | if (status & SSSR_BCE) | ||
58 | printk(KERN_WARNING "SSP(%d): bit count error\n", dev->port); | ||
59 | |||
60 | return IRQ_HANDLED; | ||
61 | } | ||
62 | |||
63 | /** | ||
64 | * ssp_write_word - write a word to the SSP port | ||
65 | * @data: 32-bit, MSB justified data to write. | ||
66 | * | ||
67 | * Wait for a free entry in the SSP transmit FIFO, and write a data | ||
68 | * word to the SSP port. | ||
69 | * | ||
70 | * The caller is expected to perform the necessary locking. | ||
71 | * | ||
72 | * Returns: | ||
73 | * %-ETIMEDOUT timeout occurred | ||
74 | * 0 success | ||
75 | */ | ||
76 | int ssp_write_word(struct ssp_dev *dev, u32 data) | ||
77 | { | ||
78 | struct ssp_device *ssp = dev->ssp; | ||
79 | int timeout = TIMEOUT; | ||
80 | |||
81 | while (!(__raw_readl(ssp->mmio_base + SSSR) & SSSR_TNF)) { | ||
82 | if (!--timeout) | ||
83 | return -ETIMEDOUT; | ||
84 | cpu_relax(); | ||
85 | } | ||
86 | |||
87 | __raw_writel(data, ssp->mmio_base + SSDR); | ||
88 | |||
89 | return 0; | ||
90 | } | ||
91 | |||
92 | /** | ||
93 | * ssp_read_word - read a word from the SSP port | ||
94 | * | ||
95 | * Wait for a data word in the SSP receive FIFO, and return the | ||
96 | * received data. Data is LSB justified. | ||
97 | * | ||
98 | * Note: Currently, if data is not expected to be received, this | ||
99 | * function will wait for ever. | ||
100 | * | ||
101 | * The caller is expected to perform the necessary locking. | ||
102 | * | ||
103 | * Returns: | ||
104 | * %-ETIMEDOUT timeout occurred | ||
105 | * 32-bit data success | ||
106 | */ | ||
107 | int ssp_read_word(struct ssp_dev *dev, u32 *data) | ||
108 | { | ||
109 | struct ssp_device *ssp = dev->ssp; | ||
110 | int timeout = TIMEOUT; | ||
111 | |||
112 | while (!(__raw_readl(ssp->mmio_base + SSSR) & SSSR_RNE)) { | ||
113 | if (!--timeout) | ||
114 | return -ETIMEDOUT; | ||
115 | cpu_relax(); | ||
116 | } | ||
117 | |||
118 | *data = __raw_readl(ssp->mmio_base + SSDR); | ||
119 | return 0; | ||
120 | } | ||
121 | |||
122 | /** | ||
123 | * ssp_flush - flush the transmit and receive FIFOs | ||
124 | * | ||
125 | * Wait for the SSP to idle, and ensure that the receive FIFO | ||
126 | * is empty. | ||
127 | * | ||
128 | * The caller is expected to perform the necessary locking. | ||
129 | */ | ||
130 | int ssp_flush(struct ssp_dev *dev) | ||
131 | { | ||
132 | struct ssp_device *ssp = dev->ssp; | ||
133 | int timeout = TIMEOUT * 2; | ||
134 | |||
135 | /* ensure TX FIFO is empty instead of not full */ | ||
136 | if (cpu_is_pxa3xx()) { | ||
137 | while (__raw_readl(ssp->mmio_base + SSSR) & 0xf00) { | ||
138 | if (!--timeout) | ||
139 | return -ETIMEDOUT; | ||
140 | cpu_relax(); | ||
141 | } | ||
142 | timeout = TIMEOUT * 2; | ||
143 | } | ||
144 | |||
145 | do { | ||
146 | while (__raw_readl(ssp->mmio_base + SSSR) & SSSR_RNE) { | ||
147 | if (!--timeout) | ||
148 | return -ETIMEDOUT; | ||
149 | (void)__raw_readl(ssp->mmio_base + SSDR); | ||
150 | } | ||
151 | if (!--timeout) | ||
152 | return -ETIMEDOUT; | ||
153 | } while (__raw_readl(ssp->mmio_base + SSSR) & SSSR_BSY); | ||
154 | |||
155 | return 0; | ||
156 | } | ||
157 | |||
158 | /** | ||
159 | * ssp_enable - enable the SSP port | ||
160 | * | ||
161 | * Turn on the SSP port. | ||
162 | */ | ||
163 | void ssp_enable(struct ssp_dev *dev) | ||
164 | { | ||
165 | struct ssp_device *ssp = dev->ssp; | ||
166 | uint32_t sscr0; | ||
167 | |||
168 | sscr0 = __raw_readl(ssp->mmio_base + SSCR0); | ||
169 | sscr0 |= SSCR0_SSE; | ||
170 | __raw_writel(sscr0, ssp->mmio_base + SSCR0); | ||
171 | } | ||
172 | |||
173 | /** | ||
174 | * ssp_disable - shut down the SSP port | ||
175 | * | ||
176 | * Turn off the SSP port, optionally powering it down. | ||
177 | */ | ||
178 | void ssp_disable(struct ssp_dev *dev) | ||
179 | { | ||
180 | struct ssp_device *ssp = dev->ssp; | ||
181 | uint32_t sscr0; | ||
182 | |||
183 | sscr0 = __raw_readl(ssp->mmio_base + SSCR0); | ||
184 | sscr0 &= ~SSCR0_SSE; | ||
185 | __raw_writel(sscr0, ssp->mmio_base + SSCR0); | ||
186 | } | ||
187 | |||
188 | /** | ||
189 | * ssp_save_state - save the SSP configuration | ||
190 | * @ssp: pointer to structure to save SSP configuration | ||
191 | * | ||
192 | * Save the configured SSP state for suspend. | ||
193 | */ | ||
194 | void ssp_save_state(struct ssp_dev *dev, struct ssp_state *state) | ||
195 | { | ||
196 | struct ssp_device *ssp = dev->ssp; | ||
197 | |||
198 | state->cr0 = __raw_readl(ssp->mmio_base + SSCR0); | ||
199 | state->cr1 = __raw_readl(ssp->mmio_base + SSCR1); | ||
200 | state->to = __raw_readl(ssp->mmio_base + SSTO); | ||
201 | state->psp = __raw_readl(ssp->mmio_base + SSPSP); | ||
202 | |||
203 | ssp_disable(dev); | ||
204 | } | ||
205 | |||
206 | /** | ||
207 | * ssp_restore_state - restore a previously saved SSP configuration | ||
208 | * @ssp: pointer to configuration saved by ssp_save_state | ||
209 | * | ||
210 | * Restore the SSP configuration saved previously by ssp_save_state. | ||
211 | */ | ||
212 | void ssp_restore_state(struct ssp_dev *dev, struct ssp_state *state) | ||
213 | { | ||
214 | struct ssp_device *ssp = dev->ssp; | ||
215 | uint32_t sssr = SSSR_ROR | SSSR_TUR | SSSR_BCE; | ||
216 | |||
217 | __raw_writel(sssr, ssp->mmio_base + SSSR); | ||
218 | |||
219 | __raw_writel(state->cr0 & ~SSCR0_SSE, ssp->mmio_base + SSCR0); | ||
220 | __raw_writel(state->cr1, ssp->mmio_base + SSCR1); | ||
221 | __raw_writel(state->to, ssp->mmio_base + SSTO); | ||
222 | __raw_writel(state->psp, ssp->mmio_base + SSPSP); | ||
223 | __raw_writel(state->cr0, ssp->mmio_base + SSCR0); | ||
224 | } | ||
225 | |||
226 | /** | ||
227 | * ssp_config - configure SSP port settings | ||
228 | * @mode: port operating mode | ||
229 | * @flags: port config flags | ||
230 | * @psp_flags: port PSP config flags | ||
231 | * @speed: port speed | ||
232 | * | ||
233 | * Port MUST be disabled by ssp_disable before making any config changes. | ||
234 | */ | ||
235 | int ssp_config(struct ssp_dev *dev, u32 mode, u32 flags, u32 psp_flags, u32 speed) | ||
236 | { | ||
237 | struct ssp_device *ssp = dev->ssp; | ||
238 | |||
239 | dev->mode = mode; | ||
240 | dev->flags = flags; | ||
241 | dev->psp_flags = psp_flags; | ||
242 | dev->speed = speed; | ||
243 | |||
244 | /* set up port type, speed, port settings */ | ||
245 | __raw_writel((dev->speed | dev->mode), ssp->mmio_base + SSCR0); | ||
246 | __raw_writel(dev->flags, ssp->mmio_base + SSCR1); | ||
247 | __raw_writel(dev->psp_flags, ssp->mmio_base + SSPSP); | ||
248 | |||
249 | return 0; | ||
250 | } | ||
251 | |||
252 | /** | ||
253 | * ssp_init - setup the SSP port | ||
254 | * | ||
255 | * initialise and claim resources for the SSP port. | ||
256 | * | ||
257 | * Returns: | ||
258 | * %-ENODEV if the SSP port is unavailable | ||
259 | * %-EBUSY if the resources are already in use | ||
260 | * %0 on success | ||
261 | */ | ||
262 | int ssp_init(struct ssp_dev *dev, u32 port, u32 init_flags) | ||
263 | { | ||
264 | struct ssp_device *ssp; | ||
265 | int ret; | ||
266 | |||
267 | ssp = ssp_request(port, "SSP"); | ||
268 | if (ssp == NULL) | ||
269 | return -ENODEV; | ||
270 | |||
271 | dev->ssp = ssp; | ||
272 | dev->port = port; | ||
273 | |||
274 | /* do we need to get irq */ | ||
275 | if (!(init_flags & SSP_NO_IRQ)) { | ||
276 | ret = request_irq(ssp->irq, ssp_interrupt, | ||
277 | 0, "SSP", dev); | ||
278 | if (ret) | ||
279 | goto out_region; | ||
280 | dev->irq = ssp->irq; | ||
281 | } else | ||
282 | dev->irq = NO_IRQ; | ||
283 | |||
284 | /* turn on SSP port clock */ | ||
285 | clk_enable(ssp->clk); | ||
286 | return 0; | ||
287 | |||
288 | out_region: | ||
289 | ssp_free(ssp); | ||
290 | return ret; | ||
291 | } | ||
292 | |||
293 | /** | ||
294 | * ssp_exit - undo the effects of ssp_init | ||
295 | * | ||
296 | * release and free resources for the SSP port. | ||
297 | */ | ||
298 | void ssp_exit(struct ssp_dev *dev) | ||
299 | { | ||
300 | struct ssp_device *ssp = dev->ssp; | ||
301 | |||
302 | ssp_disable(dev); | ||
303 | if (dev->irq != NO_IRQ) | ||
304 | free_irq(dev->irq, dev); | ||
305 | clk_disable(ssp->clk); | ||
306 | ssp_free(ssp); | ||
307 | } | ||
308 | #endif /* CONFIG_PXA_SSP_LEGACY */ | ||
309 | |||
310 | static DEFINE_MUTEX(ssp_lock); | 38 | static DEFINE_MUTEX(ssp_lock); |
311 | static LIST_HEAD(ssp_list); | 39 | static LIST_HEAD(ssp_list); |
312 | 40 | ||
@@ -491,20 +219,6 @@ static void __exit pxa_ssp_exit(void) | |||
491 | arch_initcall(pxa_ssp_init); | 219 | arch_initcall(pxa_ssp_init); |
492 | module_exit(pxa_ssp_exit); | 220 | module_exit(pxa_ssp_exit); |
493 | 221 | ||
494 | #ifdef CONFIG_PXA_SSP_LEGACY | ||
495 | EXPORT_SYMBOL(ssp_write_word); | ||
496 | EXPORT_SYMBOL(ssp_read_word); | ||
497 | EXPORT_SYMBOL(ssp_flush); | ||
498 | EXPORT_SYMBOL(ssp_enable); | ||
499 | EXPORT_SYMBOL(ssp_disable); | ||
500 | EXPORT_SYMBOL(ssp_save_state); | ||
501 | EXPORT_SYMBOL(ssp_restore_state); | ||
502 | EXPORT_SYMBOL(ssp_init); | ||
503 | EXPORT_SYMBOL(ssp_exit); | ||
504 | EXPORT_SYMBOL(ssp_config); | ||
505 | #endif | ||
506 | |||
507 | MODULE_DESCRIPTION("PXA SSP driver"); | 222 | MODULE_DESCRIPTION("PXA SSP driver"); |
508 | MODULE_AUTHOR("Liam Girdwood"); | 223 | MODULE_AUTHOR("Liam Girdwood"); |
509 | MODULE_LICENSE("GPL"); | 224 | MODULE_LICENSE("GPL"); |
510 | |||