blob: 4954da907d429f954e792d64c88e6884830356af [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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.
Liam Girdwoodb216c012005-11-10 17:45:39 +000022 * 4th Aug 2005 Added option to disable irq handler registration and
23 * cleaned up irq and clock detection.
Linus Torvalds1da177e2005-04-16 15:20:36 -070024 */
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>
Arjan van de Ven00431702006-01-12 18:42:23 +000034#include <linux/mutex.h>
eric miao88286452007-12-06 17:56:42 +080035#include <linux/clk.h>
36#include <linux/err.h>
37#include <linux/platform_device.h>
38
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#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>
eric miao0aea1fd2007-11-21 16:57:12 +080044#include <asm/arch/regs-ssp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Paul Sokolovsky8f1bf872006-08-27 12:54:56 +010046#define TIMEOUT 100000
47
Linus Torvalds0cd61b62006-10-06 10:53:39 -070048static irqreturn_t ssp_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -070049{
50 struct ssp_dev *dev = (struct ssp_dev*) dev_id;
eric miao3dcb00e2007-11-30 18:26:56 +080051 struct ssp_device *ssp = dev->ssp;
52 unsigned int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
eric miao3dcb00e2007-11-30 18:26:56 +080054 status = __raw_readl(ssp->mmio_base + SSSR);
55 __raw_writel(status, ssp->mmio_base + SSSR);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
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:
Paul Sokolovsky8f1bf872006-08-27 12:54:56 +010079 * %-ETIMEDOUT timeout occurred
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 * 0 success
81 */
82int ssp_write_word(struct ssp_dev *dev, u32 data)
83{
eric miao3dcb00e2007-11-30 18:26:56 +080084 struct ssp_device *ssp = dev->ssp;
Paul Sokolovsky8f1bf872006-08-27 12:54:56 +010085 int timeout = TIMEOUT;
86
eric miao3dcb00e2007-11-30 18:26:56 +080087 while (!(__raw_readl(ssp->mmio_base + SSSR) & SSSR_TNF)) {
Paul Sokolovsky8f1bf872006-08-27 12:54:56 +010088 if (!--timeout)
89 return -ETIMEDOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 cpu_relax();
Paul Sokolovsky8f1bf872006-08-27 12:54:56 +010091 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
eric miao3dcb00e2007-11-30 18:26:56 +080093 __raw_writel(data, ssp->mmio_base + SSDR);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
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:
Paul Sokolovsky8f1bf872006-08-27 12:54:56 +0100110 * %-ETIMEDOUT timeout occurred
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 * 32-bit data success
112 */
Paul Sokolovsky8f1bf872006-08-27 12:54:56 +0100113int ssp_read_word(struct ssp_dev *dev, u32 *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114{
eric miao3dcb00e2007-11-30 18:26:56 +0800115 struct ssp_device *ssp = dev->ssp;
Paul Sokolovsky8f1bf872006-08-27 12:54:56 +0100116 int timeout = TIMEOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
eric miao3dcb00e2007-11-30 18:26:56 +0800118 while (!(__raw_readl(ssp->mmio_base + SSSR) & SSSR_RNE)) {
Paul Sokolovsky8f1bf872006-08-27 12:54:56 +0100119 if (!--timeout)
120 return -ETIMEDOUT;
121 cpu_relax();
122 }
123
eric miao3dcb00e2007-11-30 18:26:56 +0800124 *data = __raw_readl(ssp->mmio_base + SSDR);
Paul Sokolovsky8f1bf872006-08-27 12:54:56 +0100125 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126}
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 */
Paul Sokolovsky8f1bf872006-08-27 12:54:56 +0100136int ssp_flush(struct ssp_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137{
eric miao3dcb00e2007-11-30 18:26:56 +0800138 struct ssp_device *ssp = dev->ssp;
Paul Sokolovsky8f1bf872006-08-27 12:54:56 +0100139 int timeout = TIMEOUT * 2;
140
eric miao732ce162007-11-23 14:55:59 +0800141 /* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 do {
eric miao3dcb00e2007-11-30 18:26:56 +0800152 while (__raw_readl(ssp->mmio_base + SSSR) & SSSR_RNE) {
Paul Sokolovsky8f1bf872006-08-27 12:54:56 +0100153 if (!--timeout)
154 return -ETIMEDOUT;
eric miao3dcb00e2007-11-30 18:26:56 +0800155 (void)__raw_readl(ssp->mmio_base + SSDR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 }
Paul Sokolovsky8f1bf872006-08-27 12:54:56 +0100157 if (!--timeout)
158 return -ETIMEDOUT;
eric miao3dcb00e2007-11-30 18:26:56 +0800159 } while (__raw_readl(ssp->mmio_base + SSSR) & SSSR_BSY);
Paul Sokolovsky8f1bf872006-08-27 12:54:56 +0100160
161 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162}
163
164/**
165 * ssp_enable - enable the SSP port
166 *
167 * Turn on the SSP port.
168 */
169void ssp_enable(struct ssp_dev *dev)
170{
eric miao3dcb00e2007-11-30 18:26:56 +0800171 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177}
178
179/**
180 * ssp_disable - shut down the SSP port
181 *
182 * Turn off the SSP port, optionally powering it down.
183 */
184void ssp_disable(struct ssp_dev *dev)
185{
eric miao3dcb00e2007-11-30 18:26:56 +0800186 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192}
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 */
eric miao3dcb00e2007-11-30 18:26:56 +0800200void ssp_save_state(struct ssp_dev *dev, struct ssp_state *state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201{
eric miao3dcb00e2007-11-30 18:26:56 +0800202 struct ssp_device *ssp = dev->ssp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
eric miao3dcb00e2007-11-30 18:26:56 +0800204 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210}
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 */
eric miao3dcb00e2007-11-30 18:26:56 +0800218void ssp_restore_state(struct ssp_dev *dev, struct ssp_state *state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
eric miao3dcb00e2007-11-30 18:26:56 +0800220 struct ssp_device *ssp = dev->ssp;
221 uint32_t sssr = SSSR_ROR | SSSR_TUR | SSSR_BCE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
eric miao3dcb00e2007-11-30 18:26:56 +0800223 __raw_writel(sssr, ssp->mmio_base + SSSR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
eric miao3dcb00e2007-11-30 18:26:56 +0800225 __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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230}
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 */
241int ssp_config(struct ssp_dev *dev, u32 mode, u32 flags, u32 psp_flags, u32 speed)
242{
eric miao3dcb00e2007-11-30 18:26:56 +0800243 struct ssp_device *ssp = dev->ssp;
244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 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 */
eric miao3dcb00e2007-11-30 18:26:56 +0800251 __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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
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 */
Liam Girdwoodb216c012005-11-10 17:45:39 +0000268int ssp_init(struct ssp_dev *dev, u32 port, u32 init_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269{
eric miao88286452007-12-06 17:56:42 +0800270 struct ssp_device *ssp;
Liam Girdwoodb216c012005-11-10 17:45:39 +0000271 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
eric miao88286452007-12-06 17:56:42 +0800273 ssp = ssp_request(port, "SSP");
274 if (ssp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 return -ENODEV;
276
eric miao88286452007-12-06 17:56:42 +0800277 dev->ssp = ssp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 dev->port = port;
279
Liam Girdwoodb216c012005-11-10 17:45:39 +0000280 /* do we need to get irq */
281 if (!(init_flags & SSP_NO_IRQ)) {
eric miao88286452007-12-06 17:56:42 +0800282 ret = request_irq(ssp->irq, ssp_interrupt,
Liam Girdwoodb216c012005-11-10 17:45:39 +0000283 0, "SSP", dev);
284 if (ret)
285 goto out_region;
eric miao88286452007-12-06 17:56:42 +0800286 dev->irq = ssp->irq;
Liam Girdwoodb216c012005-11-10 17:45:39 +0000287 } else
288 dev->irq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
290 /* turn on SSP port clock */
eric miao88286452007-12-06 17:56:42 +0800291 clk_enable(ssp->clk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 return 0;
293
294out_region:
eric miao88286452007-12-06 17:56:42 +0800295 ssp_free(ssp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 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 */
304void ssp_exit(struct ssp_dev *dev)
305{
eric miao88286452007-12-06 17:56:42 +0800306 struct ssp_device *ssp = dev->ssp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
eric miao3dcb00e2007-11-30 18:26:56 +0800308 ssp_disable(dev);
eric miao88286452007-12-06 17:56:42 +0800309 free_irq(dev->irq, dev);
310 clk_disable(ssp->clk);
311 ssp_free(ssp);
312}
313
314static DEFINE_MUTEX(ssp_lock);
315static LIST_HEAD(ssp_list);
316
317struct 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 }
330
eric miao88286452007-12-06 17:56:42 +0800331 mutex_unlock(&ssp_lock);
332
333 if (ssp->port_id != port)
334 return NULL;
335
336 return ssp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337}
eric miao88286452007-12-06 17:56:42 +0800338EXPORT_SYMBOL(ssp_request);
339
340void 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}
350EXPORT_SYMBOL(ssp_free);
351
352static 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
431err_free_io:
432 iounmap(ssp->mmio_base);
433err_free_mem:
434 release_mem_region(res->start, res->end - res->start + 1);
435err_free_clk:
436 clk_put(ssp->clk);
437err_free:
438 kfree(ssp);
439 return ret;
440}
441
442static 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
466static int __devinit pxa25x_ssp_probe(struct platform_device *pdev)
467{
468 return ssp_probe(pdev, PXA25x_SSP);
469}
470
471static int __devinit pxa25x_nssp_probe(struct platform_device *pdev)
472{
473 return ssp_probe(pdev, PXA25x_NSSP);
474}
475
476static int __devinit pxa27x_ssp_probe(struct platform_device *pdev)
477{
478 return ssp_probe(pdev, PXA27x_SSP);
479}
480
481static 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
489static 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
497static 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
505static 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
530static 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
Russell Kingcae05542007-12-10 15:35:54 +0000537arch_initcall(pxa_ssp_init);
eric miao88286452007-12-06 17:56:42 +0800538module_exit(pxa_ssp_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
540EXPORT_SYMBOL(ssp_write_word);
541EXPORT_SYMBOL(ssp_read_word);
542EXPORT_SYMBOL(ssp_flush);
543EXPORT_SYMBOL(ssp_enable);
544EXPORT_SYMBOL(ssp_disable);
545EXPORT_SYMBOL(ssp_save_state);
546EXPORT_SYMBOL(ssp_restore_state);
547EXPORT_SYMBOL(ssp_init);
548EXPORT_SYMBOL(ssp_exit);
549EXPORT_SYMBOL(ssp_config);
550
551MODULE_DESCRIPTION("PXA SSP driver");
552MODULE_AUTHOR("Liam Girdwood");
553MODULE_LICENSE("GPL");
554