drivers/mmc/host/sdhci-spear.c

   1 /*
   2  * drivers/mmc/host/sdhci-spear.c
   3  *
   4  * Support of SDHCI platform devices for spear soc family
   5  *
   6  * Copyright (C) 2010 ST Microelectronics
   7  * Viresh Kumar<viresh.kumar@st.com>
   8  *
   9  * Inspired by sdhci-pltfm.c
  10  *
  11  * This file is licensed under the terms of the GNU General Public
  12  * License version 2. This program is licensed "as is" without any
  13  * warranty of any kind, whether express or implied.
  14  */
  15
  16 #include <linux/clk.h>
  17 #include <linux/delay.h>
  18 #include <linux/gpio.h>
  19 #include <linux/highmem.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/irq.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/slab.h>
  24 #include <linux/mmc/host.h>
  25 #include <linux/mmc/sdhci-spear.h>
  26 #include <linux/io.h>
  27 #include "sdhci.h"
  28
  29 struct spear_sdhci {
  30         struct clk *clk;
  31         struct sdhci_plat_data *data;
  32 };
  33
  34 /* sdhci ops */
  35 static struct sdhci_ops sdhci_pltfm_ops = {
  36         /* Nothing to do for now. */
  37 };
  38
  39 /* gpio card detection interrupt handler */
  40 static irqreturn_t sdhci_gpio_irq(int irq, void *dev_id)
  41 {
  42         struct platform_device *pdev = dev_id;
  43         struct sdhci_host *host = platform_get_drvdata(pdev);
  44         struct spear_sdhci *sdhci = dev_get_platdata(&pdev->dev);
  45         unsigned long gpio_irq_type;
  46         int val;
  47
  48         val = gpio_get_value(sdhci->data->card_int_gpio);
  49
  50         /* val == 1 -> card removed, val == 0 -> card inserted */
  51         /* if card removed - set irq for low level, else vice versa */
  52         gpio_irq_type = val ? IRQF_TRIGGER_LOW : IRQF_TRIGGER_HIGH;
  53         irq_set_irq_type(irq, gpio_irq_type);
  54
  55         if (sdhci->data->card_power_gpio >= 0) {
  56                 if (!sdhci->data->power_always_enb) {
  57                         /* if card inserted, give power, otherwise remove it */
  58                         val = sdhci->data->power_active_high ? !val : val ;
  59                         gpio_set_value(sdhci->data->card_power_gpio, val);
  60                 }
  61         }
  62
  63         /* inform sdhci driver about card insertion/removal */
  64         tasklet_schedule(&host->card_tasklet);
  65
  66         return IRQ_HANDLED;
  67 }
  68
  69 static int __devinit sdhci_probe(struct platform_device *pdev)
  70 {
  71         struct sdhci_host *host;
  72         struct resource *iomem;
  73         struct spear_sdhci *sdhci;
  74         int ret;
  75
  76         BUG_ON(pdev == NULL);
  77
  78         iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  79         if (!iomem) {
  80                 ret = -ENOMEM;
  81                 dev_dbg(&pdev->dev, "memory resource not defined\n");
  82                 goto err;
  83         }
  84
  85         if (!request_mem_region(iomem->start, resource_size(iomem),
  86                                 "spear-sdhci")) {
  87                 ret = -EBUSY;
  88                 dev_dbg(&pdev->dev, "cannot request region\n");
  89                 goto err;
  90         }
  91
  92         sdhci = kzalloc(sizeof(*sdhci), GFP_KERNEL);
  93         if (!sdhci) {
  94                 ret = -ENOMEM;
  95                 dev_dbg(&pdev->dev, "cannot allocate memory for sdhci\n");
  96                 goto err_kzalloc;
  97         }
  98
  99         /* clk enable */
 100         sdhci->clk = clk_get(&pdev->dev, NULL);
 101         if (IS_ERR(sdhci->clk)) {
 102                 ret = PTR_ERR(sdhci->clk);
 103                 dev_dbg(&pdev->dev, "Error getting clock\n");
 104                 goto err_clk_get;
 105         }
 106
 107         ret = clk_enable(sdhci->clk);
 108         if (ret) {
 109                 dev_dbg(&pdev->dev, "Error enabling clock\n");
 110                 goto err_clk_enb;
 111         }
 112
 113         /* overwrite platform_data */
 114         sdhci->data = dev_get_platdata(&pdev->dev);
 115         pdev->dev.platform_data = sdhci;
 116
 117         if (pdev->dev.parent)
 118                 host = sdhci_alloc_host(pdev->dev.parent, 0);
 119         else
 120                 host = sdhci_alloc_host(&pdev->dev, 0);
 121
 122         if (IS_ERR(host)) {
 123                 ret = PTR_ERR(host);
 124                 dev_dbg(&pdev->dev, "error allocating host\n");
 125                 goto err_alloc_host;
 126         }
 127
 128         host->hw_name = "sdhci";
 129         host->ops = &sdhci_pltfm_ops;
 130         host->irq = platform_get_irq(pdev, 0);
 131         host->quirks = SDHCI_QUIRK_BROKEN_ADMA;
 132
 133         host->ioaddr = ioremap(iomem->start, resource_size(iomem));
 134         if (!host->ioaddr) {
 135                 ret = -ENOMEM;
 136                 dev_dbg(&pdev->dev, "failed to remap registers\n");
 137                 goto err_ioremap;
 138         }
 139
 140         ret = sdhci_add_host(host);
 141         if (ret) {
 142                 dev_dbg(&pdev->dev, "error adding host\n");
 143                 goto err_add_host;
 144         }
 145
 146         platform_set_drvdata(pdev, host);
 147
 148         /*
 149          * It is optional to use GPIOs for sdhci Power control & sdhci card
 150          * interrupt detection. If sdhci->data is NULL, then use original sdhci
 151          * lines otherwise GPIO lines.
 152          * If GPIO is selected for power control, then power should be disabled
 153          * after card removal and should be enabled when card insertion
 154          * interrupt occurs
 155          */
 156         if (!sdhci->data)
 157                 return 0;
 158
 159         if (sdhci->data->card_power_gpio >= 0) {
 160                 int val = 0;
 161
 162                 ret = gpio_request(sdhci->data->card_power_gpio, "sdhci");
 163                 if (ret < 0) {
 164                         dev_dbg(&pdev->dev, "gpio request fail: %d\n",
 165                                         sdhci->data->card_power_gpio);
 166                         goto err_pgpio_request;
 167                 }
 168
 169                 if (sdhci->data->power_always_enb)
 170                         val = sdhci->data->power_active_high;
 171                 else
 172                         val = !sdhci->data->power_active_high;
 173
 174                 ret = gpio_direction_output(sdhci->data->card_power_gpio, val);
 175                 if (ret) {
 176                         dev_dbg(&pdev->dev, "gpio set direction fail: %d\n",
 177                                         sdhci->data->card_power_gpio);
 178                         goto err_pgpio_direction;
 179                 }
 180         }
 181
 182         if (sdhci->data->card_int_gpio >= 0) {
 183                 ret = gpio_request(sdhci->data->card_int_gpio, "sdhci");
 184                 if (ret < 0) {
 185                         dev_dbg(&pdev->dev, "gpio request fail: %d\n",
 186                                         sdhci->data->card_int_gpio);
 187                         goto err_igpio_request;
 188                 }
 189
 190                 ret = gpio_direction_input(sdhci->data->card_int_gpio);
 191                 if (ret) {
 192                         dev_dbg(&pdev->dev, "gpio set direction fail: %d\n",
 193                                         sdhci->data->card_int_gpio);
 194                         goto err_igpio_direction;
 195                 }
 196                 ret = request_irq(gpio_to_irq(sdhci->data->card_int_gpio),
 197                                 sdhci_gpio_irq, IRQF_TRIGGER_LOW,
 198                                 mmc_hostname(host->mmc), pdev);
 199                 if (ret) {
 200                         dev_dbg(&pdev->dev, "gpio request irq fail: %d\n",
 201                                         sdhci->data->card_int_gpio);
 202                         goto err_igpio_request_irq;
 203                 }
 204
 205         }
 206
 207         return 0;
 208
 209 err_igpio_request_irq:
 210 err_igpio_direction:
 211         if (sdhci->data->card_int_gpio >= 0)
 212                 gpio_free(sdhci->data->card_int_gpio);
 213 err_igpio_request:
 214 err_pgpio_direction:
 215         if (sdhci->data->card_power_gpio >= 0)
 216                 gpio_free(sdhci->data->card_power_gpio);
 217 err_pgpio_request:
 218         platform_set_drvdata(pdev, NULL);
 219         sdhci_remove_host(host, 1);
 220 err_add_host:
 221         iounmap(host->ioaddr);
 222 err_ioremap:
 223         sdhci_free_host(host);
 224 err_alloc_host:
 225         clk_disable(sdhci->clk);
 226 err_clk_enb:
 227         clk_put(sdhci->clk);
 228 err_clk_get:
 229         kfree(sdhci);
 230 err_kzalloc:
 231         release_mem_region(iomem->start, resource_size(iomem));
 232 err:
 233         dev_err(&pdev->dev, "spear-sdhci probe failed: %d\n", ret);
 234         return ret;
 235 }
 236
 237 static int __devexit sdhci_remove(struct platform_device *pdev)
 238 {
 239         struct sdhci_host *host = platform_get_drvdata(pdev);
 240         struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 241         struct spear_sdhci *sdhci = dev_get_platdata(&pdev->dev);
 242         int dead;
 243         u32 scratch;
 244
 245         if (sdhci->data) {
 246                 if (sdhci->data->card_int_gpio >= 0) {
 247                         free_irq(gpio_to_irq(sdhci->data->card_int_gpio), pdev);
 248                         gpio_free(sdhci->data->card_int_gpio);
 249                 }
 250
 251                 if (sdhci->data->card_power_gpio >= 0)
 252                         gpio_free(sdhci->data->card_power_gpio);
 253         }
 254
 255         platform_set_drvdata(pdev, NULL);
 256         dead = 0;
 257         scratch = readl(host->ioaddr + SDHCI_INT_STATUS);
 258         if (scratch == (u32)-1)
 259                 dead = 1;
 260
 261         sdhci_remove_host(host, dead);
 262         iounmap(host->ioaddr);
 263         sdhci_free_host(host);
 264         clk_disable(sdhci->clk);
 265         clk_put(sdhci->clk);
 266         kfree(sdhci);
 267         if (iomem)
 268                 release_mem_region(iomem->start, resource_size(iomem));
 269
 270         return 0;
 271 }
 272
 273 static struct platform_driver sdhci_driver = {
 274         .driver = {
 275                 .name   = "sdhci",
 276                 .owner  = THIS_MODULE,
 277         },
 278         .probe          = sdhci_probe,
 279         .remove         = __devexit_p(sdhci_remove),
 280 };
 281
 282 static int __init sdhci_init(void)
 283 {
 284         return platform_driver_register(&sdhci_driver);
 285 }
 286 module_init(sdhci_init);
 287
 288 static void __exit sdhci_exit(void)
 289 {
 290         platform_driver_unregister(&sdhci_driver);
 291 }
 292 module_exit(sdhci_exit);
 293
 294 MODULE_DESCRIPTION("SPEAr Secure Digital Host Controller Interface driver");
 295 MODULE_AUTHOR("Viresh Kumar <viresh.kumar@st.com>");
 296 MODULE_LICENSE("GPL v2");