SAFE public projects git trees. - safe/jmp/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
  19 #include <linux/module.h>
  20 #include <linux/kernel.h>
  21 #include <linux/sched.h>
  22 #include <linux/slab.h>
  23 #include <linux/errno.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/ioport.h>
  26 #include <linux/init.h>
  27 #include <linux/mutex.h>
  28 #include <linux/clk.h>
  29 #include <linux/err.h>
  30 #include <linux/platform_device.h>
  31 #include <linux/io.h>
  32
  33 #include <asm/irq.h>
  34 #include <mach/hardware.h>
  35 #include <mach/ssp.h>
  36 #include <mach/regs-ssp.h>
  37
  38 static DEFINE_MUTEX(ssp_lock);
  39 static LIST_HEAD(ssp_list);
  40
  41 struct ssp_device *ssp_request(int port, const char *label)
  42 {
  43         struct ssp_device *ssp = NULL;
  44
  45         mutex_lock(&ssp_lock);
  46
  47         list_for_each_entry(ssp, &ssp_list, node) {
  48                 if (ssp->port_id == port && ssp->use_count == 0) {
  49                         ssp->use_count++;
  50                         ssp->label = label;
  51                         break;
  52                 }
  53         }
  54
  55         mutex_unlock(&ssp_lock);
  56
  57         if (&ssp->node == &ssp_list)
  58                 return NULL;
  59
  60         return ssp;
  61 }
  62 EXPORT_SYMBOL(ssp_request);
  63
  64 void ssp_free(struct ssp_device *ssp)
  65 {
  66         mutex_lock(&ssp_lock);
  67         if (ssp->use_count) {
  68                 ssp->use_count--;
  69                 ssp->label = NULL;
  70         } else
  71                 dev_err(&ssp->pdev->dev, "device already free\n");
  72         mutex_unlock(&ssp_lock);
  73 }
  74 EXPORT_SYMBOL(ssp_free);
  75
  76 static int __devinit ssp_probe(struct platform_device *pdev)
  77 {
  78         const struct platform_device_id *id = platform_get_device_id(pdev);
  79         struct resource *res;
  80         struct ssp_device *ssp;
  81         int ret = 0;
  82
  83         ssp = kzalloc(sizeof(struct ssp_device), GFP_KERNEL);
  84         if (ssp == NULL) {
  85                 dev_err(&pdev->dev, "failed to allocate memory");
  86                 return -ENOMEM;
  87         }
  88         ssp->pdev = pdev;
  89
  90         ssp->clk = clk_get(&pdev->dev, NULL);
  91         if (IS_ERR(ssp->clk)) {
  92                 ret = PTR_ERR(ssp->clk);
  93                 goto err_free;
  94         }
  95
  96         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  97         if (res == NULL) {
  98                 dev_err(&pdev->dev, "no memory resource defined\n");
  99                 ret = -ENODEV;
 100                 goto err_free_clk;
 101         }
 102
 103         res = request_mem_region(res->start, res->end - res->start + 1,
 104                         pdev->name);
 105         if (res == NULL) {
 106                 dev_err(&pdev->dev, "failed to request memory resource\n");
 107                 ret = -EBUSY;
 108                 goto err_free_clk;
 109         }
 110
 111         ssp->phys_base = res->start;
 112
 113         ssp->mmio_base = ioremap(res->start, res->end - res->start + 1);
 114         if (ssp->mmio_base == NULL) {
 115                 dev_err(&pdev->dev, "failed to ioremap() registers\n");
 116                 ret = -ENODEV;
 117                 goto err_free_mem;
 118         }
 119
 120         ssp->irq = platform_get_irq(pdev, 0);
 121         if (ssp->irq < 0) {
 122                 dev_err(&pdev->dev, "no IRQ resource defined\n");
 123                 ret = -ENODEV;
 124                 goto err_free_io;
 125         }
 126
 127         res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
 128         if (res == NULL) {
 129                 dev_err(&pdev->dev, "no SSP RX DRCMR defined\n");
 130                 ret = -ENODEV;
 131                 goto err_free_io;
 132         }
 133         ssp->drcmr_rx = res->start;
 134
 135         res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
 136         if (res == NULL) {
 137                 dev_err(&pdev->dev, "no SSP TX DRCMR defined\n");
 138                 ret = -ENODEV;
 139                 goto err_free_io;
 140         }
 141         ssp->drcmr_tx = res->start;
 142
 143         /* PXA2xx/3xx SSP ports starts from 1 and the internal pdev->id
 144          * starts from 0, do a translation here
 145          */
 146         ssp->port_id = pdev->id + 1;
 147         ssp->use_count = 0;
 148         ssp->type = (int)id->driver_data;
 149
 150         mutex_lock(&ssp_lock);
 151         list_add(&ssp->node, &ssp_list);
 152         mutex_unlock(&ssp_lock);
 153
 154         platform_set_drvdata(pdev, ssp);
 155         return 0;
 156
 157 err_free_io:
 158         iounmap(ssp->mmio_base);
 159 err_free_mem:
 160         release_mem_region(res->start, res->end - res->start + 1);
 161 err_free_clk:
 162         clk_put(ssp->clk);
 163 err_free:
 164         kfree(ssp);
 165         return ret;
 166 }
 167
 168 static int __devexit ssp_remove(struct platform_device *pdev)
 169 {
 170         struct resource *res;
 171         struct ssp_device *ssp;
 172
 173         ssp = platform_get_drvdata(pdev);
 174         if (ssp == NULL)
 175                 return -ENODEV;
 176
 177         iounmap(ssp->mmio_base);
 178
 179         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 180         release_mem_region(res->start, res->end - res->start + 1);
 181
 182         clk_put(ssp->clk);
 183
 184         mutex_lock(&ssp_lock);
 185         list_del(&ssp->node);
 186         mutex_unlock(&ssp_lock);
 187
 188         kfree(ssp);
 189         return 0;
 190 }
 191
 192 static const struct platform_device_id ssp_id_table[] = {
 193         { "pxa25x-ssp",         PXA25x_SSP },
 194         { "pxa25x-nssp",        PXA25x_NSSP },
 195         { "pxa27x-ssp",         PXA27x_SSP },
 196         { },
 197 };
 198
 199 static struct platform_driver ssp_driver = {
 200         .probe          = ssp_probe,
 201         .remove         = __devexit_p(ssp_remove),
 202         .driver         = {
 203                 .owner  = THIS_MODULE,
 204                 .name   = "pxa2xx-ssp",
 205         },
 206         .id_table       = ssp_id_table,
 207 };
 208
 209 static int __init pxa_ssp_init(void)
 210 {
 211         return platform_driver_register(&ssp_driver);
 212 }
 213
 214 static void __exit pxa_ssp_exit(void)
 215 {
 216         platform_driver_unregister(&ssp_driver);
 217 }
 218
 219 arch_initcall(pxa_ssp_init);
 220 module_exit(pxa_ssp_exit);
 221
 222 MODULE_DESCRIPTION("PXA SSP driver");
 223 MODULE_AUTHOR("Liam Girdwood");
 224 MODULE_LICENSE("GPL");