git.oblomov.eu Git - linux-2.6/blob - arch/arm/mach-pxa/ssp.c

   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->node == &ssp_list)
 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