1 /*
2 * linux/arch/arm/mach-pxa/ssp.c
3 *
4 * based on linux/arch/arm/mach-sa1100/ssp.c by Russell King
5 *
6 * Copyright (C) 2003 Russell King.
7 * Copyright (C) 2003 Wolfson Microelectronics PLC
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 *
13 * PXA2xx SSP driver. This provides the generic core for simple
14 * IO-based SSP applications and allows easy port setup for DMA access.
15 *
16 * Author: Liam Girdwood <liam.girdwood@wolfsonmicro.com>
17 *
18 * Revision history:
19 * 22nd Aug 2003 Initial version.
20 * 20th Dec 2004 Added ssp_config for changing port config without
21 * closing the port.
22 * 4th Aug 2005 Added option to disable irq handler registration and
23 * cleaned up irq and clock detection.
24 */
25
26 #include <linux/module.h>
27 #include <linux/kernel.h>
28 #include <linux/sched.h>
29 #include <linux/slab.h>
30 #include <linux/errno.h>
31 #include <linux/interrupt.h>
32 #include <linux/ioport.h>
33 #include <linux/init.h>
34 #include <linux/mutex.h>
35 #include <linux/clk.h>
36 #include <linux/err.h>
37 #include <linux/platform_device.h>
38
39 #include <asm/io.h>
40 #include <asm/irq.h>
41 #include <asm/hardware.h>
42 #include <asm/arch/ssp.h>
43 #include <asm/arch/pxa-regs.h>
44 #include <asm/arch/regs-ssp.h>
45
46 #define TIMEOUT 100000
47
48 static irqreturn_t ssp_interrupt(int irq, void *dev_id)
49 {
50 struct ssp_dev *dev = dev_id;
51 struct ssp_device *ssp = dev->ssp;
52 unsigned int status;
53
54 status = __raw_readl(ssp->mmio_base + SSSR);
55 __raw_writel(status, ssp->mmio_base + SSSR);
56
57 if (status & SSSR_ROR)
58 printk(KERN_WARNING "SSP(%d): receiver overrun\n", dev->port);
59
60 if (status & SSSR_TUR)
61 printk(KERN_WARNING "SSP(%d): transmitter underrun\n", dev->port);
62
63 if (status & SSSR_BCE)
64 printk(KERN_WARNING "SSP(%d): bit count error\n", dev->port);
65
66 return IRQ_HANDLED;
67 }
68
69 /**
70 * ssp_write_word - write a word to the SSP port
71 * @data: 32-bit, MSB justified data to write.
72 *
73 * Wait for a free entry in the SSP transmit FIFO, and write a data
74 * word to the SSP port.
75 *
76 * The caller is expected to perform the necessary locking.
77 *
78 * Returns:
79 * %-ETIMEDOUT timeout occurred
80 * 0 success
81 */
82 int ssp_write_word(struct ssp_dev *dev, u32 data)
83 {
84 struct ssp_device *ssp = dev->ssp;
85 int timeout = TIMEOUT;
86
87 while (!(__raw_readl(ssp->mmio_base + SSSR) & SSSR_TNF)) {
88 if (!--timeout)
89 return -ETIMEDOUT;
90 cpu_relax();
91 }
92
93 __raw_writel(data, ssp->mmio_base + SSDR);
94
95 return 0;
96 }
97
98 /**
99 * ssp_read_word - read a word from the SSP port
100 *
101 * Wait for a data word in the SSP receive FIFO, and return the
102 * received data. Data is LSB justified.
103 *
104 * Note: Currently, if data is not expected to be received, this
105 * function will wait for ever.
106 *
107 * The caller is expected to perform the necessary locking.
108 *
109 * Returns:
110 * %-ETIMEDOUT timeout occurred
111 * 32-bit data success
112 */
113 int ssp_read_word(struct ssp_dev *dev, u32 *data)
114 {
115 struct ssp_device *ssp = dev->ssp;
116 int timeout = TIMEOUT;
117
118 while (!(__raw_readl(ssp->mmio_base + SSSR) & SSSR_RNE)) {
119 if (!--timeout)
120 return -ETIMEDOUT;
121 cpu_relax();
122 }
123
124 *data = __raw_readl(ssp->mmio_base + SSDR);
125 return 0;
126 }
127
128 /**
129 * ssp_flush - flush the transmit and receive FIFOs
130 *
131 * Wait for the SSP to idle, and ensure that the receive FIFO
132 * is empty.
133 *
134 * The caller is expected to perform the necessary locking.
135 */
136 int ssp_flush(struct ssp_dev *dev)
137 {
138 struct ssp_device *ssp = dev->ssp;
139 int timeout = TIMEOUT * 2;
140
141 /* ensure TX FIFO is empty instead of not full */
142 if (cpu_is_pxa3xx()) {
143 while (__raw_readl(ssp->mmio_base + SSSR) & 0xf00) {
144 if (!--timeout)
145 return -ETIMEDOUT;
146 cpu_relax();
147 }
148 timeout = TIMEOUT * 2;
149 }
150
151 do {
152 while (__raw_readl(ssp->mmio_base + SSSR) & SSSR_RNE) {
153 if (!--timeout)
154 return -ETIMEDOUT;
155 (void)__raw_readl(ssp->mmio_base + SSDR);
156 }
157 if (!--timeout)
158 return -ETIMEDOUT;
159 } while (__raw_readl(ssp->mmio_base + SSSR) & SSSR_BSY);
160
161 return 0;
162 }
163
164 /**
165 * ssp_enable - enable the SSP port
166 *
167 * Turn on the SSP port.
168 */
169 void ssp_enable(struct ssp_dev *dev)
170 {
171 struct ssp_device *ssp = dev->ssp;
172 uint32_t sscr0;
173
174 sscr0 = __raw_readl(ssp->mmio_base + SSCR0);
175 sscr0 |= SSCR0_SSE;
176 __raw_writel(sscr0, ssp->mmio_base + SSCR0);
177 }
178
179 /**
180 * ssp_disable - shut down the SSP port
181 *
182 * Turn off the SSP port, optionally powering it down.
183 */
184 void ssp_disable(struct ssp_dev *dev)
185 {
186 struct ssp_device *ssp = dev->ssp;
187 uint32_t sscr0;
188
189 sscr0 = __raw_readl(ssp->mmio_base + SSCR0);
190 sscr0 &= ~SSCR0_SSE;
191 __raw_writel(sscr0, ssp->mmio_base + SSCR0);
192 }
193
194 /**
195 * ssp_save_state - save the SSP configuration
196 * @ssp: pointer to structure to save SSP configuration
197 *
198 * Save the configured SSP state for suspend.
199 */
200 void ssp_save_state(struct ssp_dev *dev, struct ssp_state *state)
201 {
202 struct ssp_device *ssp = dev->ssp;
203
204 state->cr0 = __raw_readl(ssp->mmio_base + SSCR0);
205 state->cr1 = __raw_readl(ssp->mmio_base + SSCR1);
206 state->to = __raw_readl(ssp->mmio_base + SSTO);
207 state->psp = __raw_readl(ssp->mmio_base + SSPSP);
208
209 ssp_disable(dev);
210 }
211
212 /**
213 * ssp_restore_state - restore a previously saved SSP configuration
214 * @ssp: pointer to configuration saved by ssp_save_state
215 *
216 * Restore the SSP configuration saved previously by ssp_save_state.
217 */
218 void ssp_restore_state(struct ssp_dev *dev, struct ssp_state *state)
219 {
220 struct ssp_device *ssp = dev->ssp;
221 uint32_t sssr = SSSR_ROR | SSSR_TUR | SSSR_BCE;
222
223 __raw_writel(sssr, ssp->mmio_base + SSSR);
224
225 __raw_writel(state->cr0 & ~SSCR0_SSE, ssp->mmio_base + SSCR0);
226 __raw_writel(state->cr1, ssp->mmio_base + SSCR1);
227 __raw_writel(state->to, ssp->mmio_base + SSTO);
228 __raw_writel(state->psp, ssp->mmio_base + SSPSP);
229 __raw_writel(state->cr0, ssp->mmio_base + SSCR0);
230 }
231
232 /**
233 * ssp_config - configure SSP port settings
234 * @mode: port operating mode
235 * @flags: port config flags
236 * @psp_flags: port PSP config flags
237 * @speed: port speed
238 *
239 * Port MUST be disabled by ssp_disable before making any config changes.
240 */
241 int ssp_config(struct ssp_dev *dev, u32 mode, u32 flags, u32 psp_flags, u32 speed)
242 {
243 struct ssp_device *ssp = dev->ssp;
244
245 dev->mode = mode;
246 dev->flags = flags;
247 dev->psp_flags = psp_flags;
248 dev->speed = speed;
249
250 /* set up port type, speed, port settings */
251 __raw_writel((dev->speed | dev->mode), ssp->mmio_base + SSCR0);
252 __raw_writel(dev->flags, ssp->mmio_base + SSCR1);
253 __raw_writel(dev->psp_flags, ssp->mmio_base + SSPSP);
254
255 return 0;
256 }
257
258 /**
259 * ssp_init - setup the SSP port
260 *
261 * initialise and claim resources for the SSP port.
262 *
263 * Returns:
264 * %-ENODEV if the SSP port is unavailable
265 * %-EBUSY if the resources are already in use
266 * %0 on success
267 */
268 int ssp_init(struct ssp_dev *dev, u32 port, u32 init_flags)
269 {
270 struct ssp_device *ssp;
271 int ret;
272
273 ssp = ssp_request(port, "SSP");
274 if (ssp == NULL)
275 return -ENODEV;
276
277 dev->ssp = ssp;
278 dev->port = port;
279
280 /* do we need to get irq */
281 if (!(init_flags & SSP_NO_IRQ)) {
282 ret = request_irq(ssp->irq, ssp_interrupt,
283 0, "SSP", dev);
284 if (ret)
285 goto out_region;
286 dev->irq = ssp->irq;
287 } else
288 dev->irq = 0;
289
290 /* turn on SSP port clock */
291 clk_enable(ssp->clk);
292 return 0;
293
294 out_region:
295 ssp_free(ssp);
296 return ret;
297 }
298
299 /**
300 * ssp_exit - undo the effects of ssp_init
301 *
302 * release and free resources for the SSP port.
303 */
304 void ssp_exit(struct ssp_dev *dev)
305 {
306 struct ssp_device *ssp = dev->ssp;
307
308 ssp_disable(dev);
309 free_irq(dev->irq, dev);
310 clk_disable(ssp->clk);
311 ssp_free(ssp);
312 }
313
314 static DEFINE_MUTEX(ssp_lock);
315 static LIST_HEAD(ssp_list);
316
317 struct ssp_device *ssp_request(int port, const char *label)
318 {
319 struct ssp_device *ssp = NULL;
320
321 mutex_lock(&ssp_lock);
322
323 list_for_each_entry(ssp, &ssp_list, node) {
324 if (ssp->port_id == port && ssp->use_count == 0) {
325 ssp->use_count++;
326 ssp->label = label;
327 break;
328 }
329 }
330
331 mutex_unlock(&ssp_lock);
332
333 if (ssp->port_id != port)
334 return NULL;
335
336 return ssp;
337 }
338 EXPORT_SYMBOL(ssp_request);
339
340 void ssp_free(struct ssp_device *ssp)
341 {
342 mutex_lock(&ssp_lock);
343 if (ssp->use_count) {
344 ssp->use_count--;
345 ssp->label = NULL;
346 } else
347 dev_err(&ssp->pdev->dev, "device already free\n");
348 mutex_unlock(&ssp_lock);
349 }
350 EXPORT_SYMBOL(ssp_free);
351
352 static int __devinit ssp_probe(struct platform_device *pdev, int type)
353 {
354 struct resource *res;
355 struct ssp_device *ssp;
356 int ret = 0;
357
358 ssp = kzalloc(sizeof(struct ssp_device), GFP_KERNEL);
359 if (ssp == NULL) {
360 dev_err(&pdev->dev, "failed to allocate memory");
361 return -ENOMEM;
362 }
363
364 ssp->clk = clk_get(&pdev->dev, "SSPCLK");
365 if (IS_ERR(ssp->clk)) {
366 ret = PTR_ERR(ssp->clk);
367 goto err_free;
368 }
369
370 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
371 if (res == NULL) {
372 dev_err(&pdev->dev, "no memory resource defined\n");
373 ret = -ENODEV;
374 goto err_free_clk;
375 }
376
377 res = request_mem_region(res->start, res->end - res->start + 1,
378 pdev->name);
379 if (res == NULL) {
380 dev_err(&pdev->dev, "failed to request memory resource\n");
381 ret = -EBUSY;
382 goto err_free_clk;
383 }
384
385 ssp->phys_base = res->start;
386
387 ssp->mmio_base = ioremap(res->start, res->end - res->start + 1);
388 if (ssp->mmio_base == NULL) {
389 dev_err(&pdev->dev, "failed to ioremap() registers\n");
390 ret = -ENODEV;
391 goto err_free_mem;
392 }
393
394 ssp->irq = platform_get_irq(pdev, 0);
395 if (ssp->irq < 0) {
396 dev_err(&pdev->dev, "no IRQ resource defined\n");
397 ret = -ENODEV;
398 goto err_free_io;
399 }
400
401 res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
402 if (res == NULL) {
403 dev_err(&pdev->dev, "no SSP RX DRCMR defined\n");
404 ret = -ENODEV;
405 goto err_free_io;
406 }
407 ssp->drcmr_rx = res->start;
408
409 res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
410 if (res == NULL) {
411 dev_err(&pdev->dev, "no SSP TX DRCMR defined\n");
412 ret = -ENODEV;
413 goto err_free_io;
414 }
415 ssp->drcmr_tx = res->start;
416
417 /* PXA2xx/3xx SSP ports starts from 1 and the internal pdev->id
418 * starts from 0, do a translation here
419 */
420 ssp->port_id = pdev->id + 1;
421 ssp->use_count = 0;
422 ssp->type = type;
423
424 mutex_lock(&ssp_lock);
425 list_add(&ssp->node, &ssp_list);
426 mutex_unlock(&ssp_lock);
427
428 platform_set_drvdata(pdev, ssp);
429 return 0;
430
431 err_free_io:
432 iounmap(ssp->mmio_base);
433 err_free_mem:
434 release_mem_region(res->start, res->end - res->start + 1);
435 err_free_clk:
436 clk_put(ssp->clk);
437 err_free:
438 kfree(ssp);
439 return ret;
440 }
441
442 static int __devexit ssp_remove(struct platform_device *pdev)
443 {
444 struct resource *res;
445 struct ssp_device *ssp;
446
447 ssp = platform_get_drvdata(pdev);
448 if (ssp == NULL)
449 return -ENODEV;
450
451 iounmap(ssp->mmio_base);
452
453 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
454 release_mem_region(res->start, res->end - res->start + 1);
455
456 clk_put(ssp->clk);
457
458 mutex_lock(&ssp_lock);
459 list_del(&ssp->node);
460 mutex_unlock(&ssp_lock);
461
462 kfree(ssp);
463 return 0;
464 }
465
466 static int __devinit pxa25x_ssp_probe(struct platform_device *pdev)
467 {
468 return ssp_probe(pdev, PXA25x_SSP);
469 }
470
471 static int __devinit pxa25x_nssp_probe(struct platform_device *pdev)
472 {
473 return ssp_probe(pdev, PXA25x_NSSP);
474 }
475
476 static int __devinit pxa27x_ssp_probe(struct platform_device *pdev)
477 {
478 return ssp_probe(pdev, PXA27x_SSP);
479 }
480
481 static struct platform_driver pxa25x_ssp_driver = {
482 .driver = {
483 .name = "pxa25x-ssp",
484 },
485 .probe = pxa25x_ssp_probe,
486 .remove = __devexit_p(ssp_remove),
487 };
488
489 static struct platform_driver pxa25x_nssp_driver = {
490 .driver = {
491 .name = "pxa25x-nssp",
492 },
493 .probe = pxa25x_nssp_probe,
494 .remove = __devexit_p(ssp_remove),
495 };
496
497 static struct platform_driver pxa27x_ssp_driver = {
498 .driver = {
499 .name = "pxa27x-ssp",
500 },
501 .probe = pxa27x_ssp_probe,
502 .remove = __devexit_p(ssp_remove),
503 };
504
505 static int __init pxa_ssp_init(void)
506 {
507 int ret = 0;
508
509 ret = platform_driver_register(&pxa25x_ssp_driver);
510 if (ret) {
511 printk(KERN_ERR "failed to register pxa25x_ssp_driver");
512 return ret;
513 }
514
515 ret = platform_driver_register(&pxa25x_nssp_driver);
516 if (ret) {
517 printk(KERN_ERR "failed to register pxa25x_nssp_driver");
518 return ret;
519 }
520
521 ret = platform_driver_register(&pxa27x_ssp_driver);
522 if (ret) {
523 printk(KERN_ERR "failed to register pxa27x_ssp_driver");
524 return ret;
525 }
526
527 return ret;
528 }
529
530 static void __exit pxa_ssp_exit(void)
531 {
532 platform_driver_unregister(&pxa25x_ssp_driver);
533 platform_driver_unregister(&pxa25x_nssp_driver);
534 platform_driver_unregister(&pxa27x_ssp_driver);
535 }
536
537 arch_initcall(pxa_ssp_init);
538 module_exit(pxa_ssp_exit);
539
540 EXPORT_SYMBOL(ssp_write_word);
541 EXPORT_SYMBOL(ssp_read_word);
542 EXPORT_SYMBOL(ssp_flush);
543 EXPORT_SYMBOL(ssp_enable);
544 EXPORT_SYMBOL(ssp_disable);
545 EXPORT_SYMBOL(ssp_save_state);
546 EXPORT_SYMBOL(ssp_restore_state);
547 EXPORT_SYMBOL(ssp_init);
548 EXPORT_SYMBOL(ssp_exit);
549 EXPORT_SYMBOL(ssp_config);
550
551 MODULE_DESCRIPTION("PXA SSP driver");
552 MODULE_AUTHOR("Liam Girdwood");
553 MODULE_LICENSE("GPL");
554
555
|
This page was automatically generated by the
LXR engine.
|