drivers/spi/spi-dw-mmio.c

   1 /*
   2  * 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 #include <linux/module.h>
  19 #include <linux/of.h>
  20 #include <linux/of_gpio.h>
  21 #include <linux/of_platform.h>
  22 #include <linux/property.h>
  23
  24 #include "spi-dw.h"
  25
  26 #define DRIVER_NAME "dw_spi_mmio"
  27
  28 struct dw_spi_mmio {
  29         struct dw_spi  dws;
  30         struct clk     *clk;
  31 };
  32
  33 static int dw_spi_mmio_probe(struct platform_device *pdev)
  34 {
  35         struct dw_spi_mmio *dwsmmio;
  36         struct dw_spi *dws;
  37         struct resource *mem;
  38         int ret;
  39         int num_cs;
  40
  41         dwsmmio = devm_kzalloc(&pdev->dev, sizeof(struct dw_spi_mmio),
  42                         GFP_KERNEL);
  43         if (!dwsmmio)
  44                 return -ENOMEM;
  45
  46         dws = &dwsmmio->dws;
  47
  48         /* Get basic io resource and map it */
  49         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  50         if (!mem) {
  51                 dev_err(&pdev->dev, "no mem resource?\n");
  52                 return -EINVAL;
  53         }
  54
  55         dws->regs = devm_ioremap_resource(&pdev->dev, mem);
  56         if (IS_ERR(dws->regs)) {
  57                 dev_err(&pdev->dev, "SPI region map failed\n");
  58                 return PTR_ERR(dws->regs);
  59         }
  60
  61         dws->irq = platform_get_irq(pdev, 0);
  62         if (dws->irq < 0) {
  63                 dev_err(&pdev->dev, "no irq resource?\n");
  64                 return dws->irq; /* -ENXIO */
  65         }
  66
  67         dwsmmio->clk = devm_clk_get(&pdev->dev, NULL);
  68         if (IS_ERR(dwsmmio->clk))
  69                 return PTR_ERR(dwsmmio->clk);
  70         ret = clk_prepare_enable(dwsmmio->clk);
  71         if (ret)
  72                 return ret;
  73
  74         dws->bus_num = pdev->id;
  75
  76         dws->max_freq = clk_get_rate(dwsmmio->clk);
  77
  78         device_property_read_u32(&pdev->dev, "reg-io-width", &dws->reg_io_width);
  79
  80         num_cs = 4;
  81
  82         device_property_read_u32(&pdev->dev, "num-cs", &num_cs);
  83
  84         dws->num_cs = num_cs;
  85
  86         if (pdev->dev.of_node) {
  87                 int i;
  88
  89                 for (i = 0; i < dws->num_cs; i++) {
  90                         int cs_gpio = of_get_named_gpio(pdev->dev.of_node,
  91                                         "cs-gpios", i);
  92
  93                         if (cs_gpio == -EPROBE_DEFER) {
  94                                 ret = cs_gpio;
  95                                 goto out;
  96                         }
  97
  98                         if (gpio_is_valid(cs_gpio)) {
  99                                 ret = devm_gpio_request(&pdev->dev, cs_gpio,
 100                                                 dev_name(&pdev->dev));
 101                                 if (ret)
 102                                         goto out;
 103                         }
 104                 }
 105         }
 106
 107         ret = dw_spi_add_host(&pdev->dev, dws);
 108         if (ret)
 109                 goto out;
 110
 111         platform_set_drvdata(pdev, dwsmmio);
 112         return 0;
 113
 114 out:
 115         clk_disable_unprepare(dwsmmio->clk);
 116         return ret;
 117 }
 118
 119 static int dw_spi_mmio_remove(struct platform_device *pdev)
 120 {
 121         struct dw_spi_mmio *dwsmmio = platform_get_drvdata(pdev);
 122
 123         dw_spi_remove_host(&dwsmmio->dws);
 124         clk_disable_unprepare(dwsmmio->clk);
 125
 126         return 0;
 127 }
 128
 129 static const struct of_device_id dw_spi_mmio_of_match[] = {
 130         { .compatible = "snps,dw-apb-ssi", },
 131         { /* end of table */}
 132 };
 133 MODULE_DEVICE_TABLE(of, dw_spi_mmio_of_match);
 134
 135 static struct platform_driver dw_spi_mmio_driver = {
 136         .probe          = dw_spi_mmio_probe,
 137         .remove         = dw_spi_mmio_remove,
 138         .driver         = {
 139                 .name   = DRIVER_NAME,
 140                 .of_match_table = dw_spi_mmio_of_match,
 141         },
 142 };
 143 module_platform_driver(dw_spi_mmio_driver);
 144
 145 MODULE_AUTHOR("Jean-Hugues Deschenes <jean-hugues.deschenes@octasic.com>");
 146 MODULE_DESCRIPTION("Memory-mapped I/O interface driver for DW SPI Core");
 147 MODULE_LICENSE("GPL v2");