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 = NO_IRQ;
 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         if (dev->irq != NO_IRQ)
 310                 free_irq(dev->irq, dev);
 311         clk_disable(ssp->clk);
 312         ssp_free(ssp);
 313 }
 314
 315 static DEFINE_MUTEX(ssp_lock);
 316 static LIST_HEAD(ssp_list);
 317
 318 struct ssp_device *ssp_request(int port, const char *label)
 319 {
 320         struct ssp_device *ssp = NULL;
 321
 322         mutex_lock(&ssp_lock);
 323
 324         list_for_each_entry(ssp, &ssp_list, node) {
 325                 if (ssp->port_id == port && ssp->use_count == 0) {
 326                         ssp->use_count++;
 327                         ssp->label = label;
 328                         break;
 329                 }
 330         }
 331
 332         mutex_unlock(&ssp_lock);
 333
 334         if (ssp->port_id != port)
 335                 return NULL;
 336
 337         return ssp;
 338 }
 339 EXPORT_SYMBOL(ssp_request);
 340
 341 void ssp_free(struct ssp_device *ssp)
 342 {
 343         mutex_lock(&ssp_lock);
 344         if (ssp->use_count) {
 345                 ssp->use_count--;
 346                 ssp->label = NULL;
 347         } else
 348                 dev_err(&ssp->pdev->dev, "device already free\n");
 349         mutex_unlock(&ssp_lock);
 350 }
 351 EXPORT_SYMBOL(ssp_free);
 352
 353 static int __devinit ssp_probe(struct platform_device *pdev, int type)
 354 {
 355         struct resource *res;
 356         struct ssp_device *ssp;
 357         int ret = 0;
 358
 359         ssp = kzalloc(sizeof(struct ssp_device), GFP_KERNEL);
 360         if (ssp == NULL) {
 361                 dev_err(&pdev->dev, "failed to allocate memory");
 362                 return -ENOMEM;
 363         }
 364         ssp->pdev = pdev;
 365
 366         ssp->clk = clk_get(&pdev->dev, "SSPCLK");
 367         if (IS_ERR(ssp->clk)) {
 368                 ret = PTR_ERR(ssp->clk);
 369                 goto err_free;
 370         }
 371
 372         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 373         if (res == NULL) {
 374                 dev_err(&pdev->dev, "no memory resource defined\n");
 375                 ret = -ENODEV;
 376                 goto err_free_clk;
 377         }
 378
 379         res = request_mem_region(res->start, res->end - res->start + 1,
 380                         pdev->name);
 381         if (res == NULL) {
 382                 dev_err(&pdev->dev, "failed to request memory resource\n");
 383                 ret = -EBUSY;
 384                 goto err_free_clk;
 385         }
 386
 387         ssp->phys_base = res->start;
 388
 389         ssp->mmio_base = ioremap(res->start, res->end - res->start + 1);
 390         if (ssp->mmio_base == NULL) {
 391                 dev_err(&pdev->dev, "failed to ioremap() registers\n");
 392                 ret = -ENODEV;
 393                 goto err_free_mem;
 394         }
 395
 396         ssp->irq = platform_get_irq(pdev, 0);
 397         if (ssp->irq < 0) {
 398                 dev_err(&pdev->dev, "no IRQ resource defined\n");
 399                 ret = -ENODEV;
 400                 goto err_free_io;
 401         }
 402
 403         res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
 404         if (res == NULL) {
 405                 dev_err(&pdev->dev, "no SSP RX DRCMR defined\n");
 406                 ret = -ENODEV;
 407                 goto err_free_io;
 408         }
 409         ssp->drcmr_rx = res->start;
 410
 411         res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
 412         if (res == NULL) {
 413                 dev_err(&pdev->dev, "no SSP TX DRCMR defined\n");
 414                 ret = -ENODEV;
 415                 goto err_free_io;
 416         }
 417         ssp->drcmr_tx = res->start;
 418
 419         /* PXA2xx/3xx SSP ports starts from 1 and the internal pdev->id
 420          * starts from 0, do a translation here
 421          */
 422         ssp->port_id = pdev->id + 1;
 423         ssp->use_count = 0;
 424         ssp->type = type;
 425
 426         mutex_lock(&ssp_lock);
 427         list_add(&ssp->node, &ssp_list);
 428         mutex_unlock(&ssp_lock);
 429
 430         platform_set_drvdata(pdev, ssp);
 431         return 0;
 432
 433 err_free_io:
 434         iounmap(ssp->mmio_base);
 435 err_free_mem:
 436         release_mem_region(res->start, res->end - res->start + 1);
 437 err_free_clk:
 438         clk_put(ssp->clk);
 439 err_free:
 440         kfree(ssp);
 441         return ret;
 442 }
 443
 444 static int __devexit ssp_remove(struct platform_device *pdev)
 445 {
 446         struct resource *res;
 447         struct ssp_device *ssp;
 448
 449         ssp = platform_get_drvdata(pdev);
 450         if (ssp == NULL)
 451                 return -ENODEV;
 452
 453         iounmap(ssp->mmio_base);
 454
 455         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 456         release_mem_region(res->start, res->end - res->start + 1);
 457
 458         clk_put(ssp->clk);
 459
 460         mutex_lock(&ssp_lock);
 461         list_del(&ssp->node);
 462         mutex_unlock(&ssp_lock);
 463
 464         kfree(ssp);
 465         return 0;
 466 }
 467
 468 static int __devinit pxa25x_ssp_probe(struct platform_device *pdev)
 469 {
 470         return ssp_probe(pdev, PXA25x_SSP);
 471 }
 472
 473 static int __devinit pxa25x_nssp_probe(struct platform_device *pdev)
 474 {
 475         return ssp_probe(pdev, PXA25x_NSSP);
 476 }
 477
 478 static int __devinit pxa27x_ssp_probe(struct platform_device *pdev)
 479 {
 480         return ssp_probe(pdev, PXA27x_SSP);
 481 }
 482
 483 static struct platform_driver pxa25x_ssp_driver = {
 484         .driver         = {
 485                 .name   = "pxa25x-ssp",
 486         },
 487         .probe          = pxa25x_ssp_probe,
 488         .remove         = __devexit_p(ssp_remove),
 489 };
 490
 491 static struct platform_driver pxa25x_nssp_driver = {
 492         .driver         = {
 493                 .name   = "pxa25x-nssp",
 494         },
 495         .probe          = pxa25x_nssp_probe,
 496         .remove         = __devexit_p(ssp_remove),
 497 };
 498
 499 static struct platform_driver pxa27x_ssp_driver = {
 500         .driver         = {
 501                 .name   = "pxa27x-ssp",
 502         },
 503         .probe          = pxa27x_ssp_probe,
 504         .remove         = __devexit_p(ssp_remove),
 505 };
 506
 507 static int __init pxa_ssp_init(void)
 508 {
 509         int ret = 0;
 510
 511         ret = platform_driver_register(&pxa25x_ssp_driver);
 512         if (ret) {
 513                 printk(KERN_ERR "failed to register pxa25x_ssp_driver");
 514                 return ret;
 515         }
 516
 517         ret = platform_driver_register(&pxa25x_nssp_driver);
 518         if (ret) {
 519                 printk(KERN_ERR "failed to register pxa25x_nssp_driver");
 520                 return ret;
 521         }
 522
 523         ret = platform_driver_register(&pxa27x_ssp_driver);
 524         if (ret) {
 525                 printk(KERN_ERR "failed to register pxa27x_ssp_driver");
 526                 return ret;
 527         }
 528
 529         return ret;
 530 }
 531
 532 static void __exit pxa_ssp_exit(void)
 533 {
 534         platform_driver_unregister(&pxa25x_ssp_driver);
 535         platform_driver_unregister(&pxa25x_nssp_driver);
 536         platform_driver_unregister(&pxa27x_ssp_driver);
 537 }
 538
 539 arch_initcall(pxa_ssp_init);
 540 module_exit(pxa_ssp_exit);
 541
 542 EXPORT_SYMBOL(ssp_write_word);
 543 EXPORT_SYMBOL(ssp_read_word);
 544 EXPORT_SYMBOL(ssp_flush);
 545 EXPORT_SYMBOL(ssp_enable);
 546 EXPORT_SYMBOL(ssp_disable);
 547 EXPORT_SYMBOL(ssp_save_state);
 548 EXPORT_SYMBOL(ssp_restore_state);
 549 EXPORT_SYMBOL(ssp_init);
 550 EXPORT_SYMBOL(ssp_exit);
 551 EXPORT_SYMBOL(ssp_config);
 552
 553 MODULE_DESCRIPTION("PXA SSP driver");
 554 MODULE_AUTHOR("Liam Girdwood");
 555 MODULE_LICENSE("GPL");
 556