drivers/spi/dw_spi_mmio.c

   1 /*
   2  * dw_spi_mmio.c - Memory-mapped interface driver for DW SPI Core
   3  *
   4  * Copyright (c) 2010, Octasic semiconductor.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/clk.h>
  12 #include <linux/err.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/slab.h>
  16 #include <linux/spi/spi.h>
  17 #include <linux/scatterlist.h>
  18
  19 #include "dw_spi.h"
  20
  21 #define DRIVER_NAME "dw_spi_mmio"
  22
  23 struct dw_spi_mmio {
  24         struct dw_spi  dws;
  25         struct clk     *clk;
  26 };
  27
  28 static int __devinit dw_spi_mmio_probe(struct platform_device *pdev)
  29 {
  30         struct dw_spi_mmio *dwsmmio;
  31         struct dw_spi *dws;
  32         struct resource *mem, *ioarea;
  33         int ret;
  34
  35         dwsmmio = kzalloc(sizeof(struct dw_spi_mmio), GFP_KERNEL);
  36         if (!dwsmmio) {
  37                 ret = -ENOMEM;
  38                 goto err_end;
  39         }
  40
  41         dws = &dwsmmio->dws;
  42
  43         /* Get basic io resource and map it */
  44         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  45         if (!mem) {
  46                 dev_err(&pdev->dev, "no mem resource?\n");
  47                 ret = -EINVAL;
  48                 goto err_kfree;
  49         }
  50
  51         ioarea = request_mem_region(mem->start, resource_size(mem),
  52                         pdev->name);
  53         if (!ioarea) {
  54                 dev_err(&pdev->dev, "SPI region already claimed\n");
  55                 ret = -EBUSY;
  56                 goto err_kfree;
  57         }
  58
  59         dws->regs = ioremap_nocache(mem->start, resource_size(mem));
  60         if (!dws->regs) {
  61                 dev_err(&pdev->dev, "SPI region already mapped\n");
  62                 ret = -ENOMEM;
  63                 goto err_release_reg;
  64         }
  65
  66         dws->irq = platform_get_irq(pdev, 0);
  67         if (dws->irq < 0) {
  68                 dev_err(&pdev->dev, "no irq resource?\n");
  69                 ret = dws->irq; /* -ENXIO */
  70                 goto err_unmap;
  71         }
  72
  73         dwsmmio->clk = clk_get(&pdev->dev, NULL);
  74         if (IS_ERR(dwsmmio->clk)) {
  75                 ret = PTR_ERR(dwsmmio->clk);
  76                 goto err_irq;
  77         }
  78         clk_enable(dwsmmio->clk);
  79
  80         dws->parent_dev = &pdev->dev;
  81         dws->bus_num = 0;
  82         dws->num_cs = 4;
  83         dws->max_freq = clk_get_rate(dwsmmio->clk);
  84
  85         ret = dw_spi_add_host(dws);
  86         if (ret)
  87                 goto err_clk;
  88
  89         platform_set_drvdata(pdev, dwsmmio);
  90         return 0;
  91
  92 err_clk:
  93         clk_disable(dwsmmio->clk);
  94         clk_put(dwsmmio->clk);
  95         dwsmmio->clk = NULL;
  96 err_irq:
  97         free_irq(dws->irq, dws);
  98 err_unmap:
  99         iounmap(dws->regs);
 100 err_release_reg:
 101         release_mem_region(mem->start, resource_size(mem));
 102 err_kfree:
 103         kfree(dwsmmio);
 104 err_end:
 105         return ret;
 106 }
 107
 108 static int __devexit dw_spi_mmio_remove(struct platform_device *pdev)
 109 {
 110         struct dw_spi_mmio *dwsmmio = platform_get_drvdata(pdev);
 111         struct resource *mem;
 112
 113         platform_set_drvdata(pdev, NULL);
 114
 115         clk_disable(dwsmmio->clk);
 116         clk_put(dwsmmio->clk);
 117         dwsmmio->clk = NULL;
 118
 119         free_irq(dwsmmio->dws.irq, &dwsmmio->dws);
 120         dw_spi_remove_host(&dwsmmio->dws);
 121         iounmap(dwsmmio->dws.regs);
 122         kfree(dwsmmio);
 123
 124         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 125         release_mem_region(mem->start, resource_size(mem));
 126         return 0;
 127 }
 128
 129 static struct platform_driver dw_spi_mmio_driver = {
 130         .remove         = __devexit_p(dw_spi_mmio_remove),
 131         .driver         = {
 132                 .name   = DRIVER_NAME,
 133                 .owner  = THIS_MODULE,
 134         },
 135 };
 136
 137 static int __init dw_spi_mmio_init(void)
 138 {
 139         return platform_driver_probe(&dw_spi_mmio_driver, dw_spi_mmio_probe);
 140 }
 141 module_init(dw_spi_mmio_init);
 142
 143 static void __exit dw_spi_mmio_exit(void)
 144 {
 145         platform_driver_unregister(&dw_spi_mmio_driver);
 146 }
 147 module_exit(dw_spi_mmio_exit);
 148
 149 MODULE_AUTHOR("Jean-Hugues Deschenes <[email protected]>");
 150 MODULE_DESCRIPTION("Memory-mapped I/O interface driver for DW SPI Core");
 151 MODULE_LICENSE("GPL v2");