drivers/spi/spi-pxa2xx-platform.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 #include <linux/acpi.h>
   4 #include <linux/clk.h>
   5 #include <linux/device.h>
   6 #include <linux/err.h>
   7 #include <linux/init.h>
   8 #include <linux/mod_devicetable.h>
   9 #include <linux/platform_device.h>
  10 #include <linux/pm_runtime.h>
  11 #include <linux/property.h>
  12 #include <linux/types.h>
  13
  14 #include "spi-pxa2xx.h"
  15
  16 static bool pxa2xx_spi_idma_filter(struct dma_chan *chan, void *param)
  17 {
  18         return param == chan->device->dev;
  19 }
  20
  21 static int
  22 pxa2xx_spi_init_ssp(struct platform_device *pdev, struct ssp_device *ssp, enum pxa_ssp_type type)
  23 {
  24         struct device *dev = &pdev->dev;
  25         struct resource *res;
  26         int status;
  27         u64 uid;
  28
  29         ssp->mmio_base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
  30         if (IS_ERR(ssp->mmio_base))
  31                 return PTR_ERR(ssp->mmio_base);
  32
  33         ssp->phys_base = res->start;
  34
  35         ssp->clk = devm_clk_get(dev, NULL);
  36         if (IS_ERR(ssp->clk))
  37                 return PTR_ERR(ssp->clk);
  38
  39         ssp->irq = platform_get_irq(pdev, 0);
  40         if (ssp->irq < 0)
  41                 return ssp->irq;
  42
  43         ssp->type = type;
  44         ssp->dev = dev;
  45
  46         status = acpi_dev_uid_to_integer(ACPI_COMPANION(dev), &uid);
  47         if (status)
  48                 ssp->port_id = -1;
  49         else
  50                 ssp->port_id = uid;
  51
  52         return 0;
  53 }
  54
  55 static void pxa2xx_spi_ssp_release(void *ssp)
  56 {
  57         pxa_ssp_free(ssp);
  58 }
  59
  60 static struct ssp_device *pxa2xx_spi_ssp_request(struct platform_device *pdev)
  61 {
  62         struct ssp_device *ssp;
  63         int status;
  64
  65         ssp = pxa_ssp_request(pdev->id, pdev->name);
  66         if (!ssp)
  67                 return NULL;
  68
  69         status = devm_add_action_or_reset(&pdev->dev, pxa2xx_spi_ssp_release, ssp);
  70         if (status)
  71                 return ERR_PTR(status);
  72
  73         return ssp;
  74 }
  75
  76 static struct pxa2xx_spi_controller *
  77 pxa2xx_spi_init_pdata(struct platform_device *pdev)
  78 {
  79         struct pxa2xx_spi_controller *pdata;
  80         struct device *dev = &pdev->dev;
  81         struct device *parent = dev->parent;
  82         const void *match = device_get_match_data(dev);
  83         enum pxa_ssp_type type = SSP_UNDEFINED;
  84         struct ssp_device *ssp;
  85         bool is_lpss_priv;
  86         u32 num_cs = 1;
  87         int status;
  88
  89         ssp = pxa2xx_spi_ssp_request(pdev);
  90         if (IS_ERR(ssp))
  91                 return ERR_CAST(ssp);
  92         if (ssp) {
  93                 type = ssp->type;
  94         } else if (match) {
  95                 type = (enum pxa_ssp_type)(uintptr_t)match;
  96         } else {
  97                 u32 value;
  98
  99                 status = device_property_read_u32(dev, "intel,spi-pxa2xx-type", &value);
 100                 if (status)
 101                         return ERR_PTR(status);
 102
 103                 type = (enum pxa_ssp_type)value;
 104         }
 105
 106         /* Validate the SSP type correctness */
 107         if (!(type > SSP_UNDEFINED && type < SSP_MAX))
 108                 return ERR_PTR(-EINVAL);
 109
 110         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 111         if (!pdata)
 112                 return ERR_PTR(-ENOMEM);
 113
 114         /* Platforms with iDMA 64-bit */
 115         is_lpss_priv = platform_get_resource_byname(pdev, IORESOURCE_MEM, "lpss_priv");
 116         if (is_lpss_priv) {
 117                 pdata->tx_param = parent;
 118                 pdata->rx_param = parent;
 119                 pdata->dma_filter = pxa2xx_spi_idma_filter;
 120         }
 121
 122         /* Read number of chip select pins, if provided */
 123         device_property_read_u32(dev, "num-cs", &num_cs);
 124
 125         pdata->num_chipselect = num_cs;
 126         pdata->is_target = device_property_read_bool(dev, "spi-slave");
 127         pdata->enable_dma = true;
 128         pdata->dma_burst_size = 1;
 129
 130         /* If SSP has been already enumerated, use it */
 131         if (ssp)
 132                 return pdata;
 133
 134         status = pxa2xx_spi_init_ssp(pdev, &pdata->ssp, type);
 135         if (status)
 136                 return ERR_PTR(status);
 137
 138         return pdata;
 139 }
 140
 141 static int pxa2xx_spi_platform_probe(struct platform_device *pdev)
 142 {
 143         struct pxa2xx_spi_controller *platform_info;
 144         struct device *dev = &pdev->dev;
 145         struct ssp_device *ssp;
 146         int ret;
 147
 148         platform_info = dev_get_platdata(dev);
 149         if (!platform_info) {
 150                 platform_info = pxa2xx_spi_init_pdata(pdev);
 151                 if (IS_ERR(platform_info))
 152                         return dev_err_probe(dev, PTR_ERR(platform_info), "missing platform data\n");
 153         }
 154
 155         ssp = pxa2xx_spi_ssp_request(pdev);
 156         if (IS_ERR(ssp))
 157                 return PTR_ERR(ssp);
 158         if (!ssp)
 159                 ssp = &platform_info->ssp;
 160
 161         pm_runtime_set_autosuspend_delay(dev, 50);
 162         pm_runtime_use_autosuspend(dev);
 163         pm_runtime_set_active(dev);
 164         pm_runtime_enable(dev);
 165
 166         ret = pxa2xx_spi_probe(dev, ssp, platform_info);
 167         if (ret)
 168                 pm_runtime_disable(dev);
 169
 170         return ret;
 171 }
 172
 173 static void pxa2xx_spi_platform_remove(struct platform_device *pdev)
 174 {
 175         struct device *dev = &pdev->dev;
 176
 177         pm_runtime_get_sync(dev);
 178
 179         pxa2xx_spi_remove(dev);
 180
 181         pm_runtime_put_noidle(dev);
 182         pm_runtime_disable(dev);
 183 }
 184
 185 static const struct acpi_device_id pxa2xx_spi_acpi_match[] = {
 186         { "80860F0E" },
 187         { "8086228E" },
 188         { "INT33C0" },
 189         { "INT33C1" },
 190         { "INT3430" },
 191         { "INT3431" },
 192         {}
 193 };
 194 MODULE_DEVICE_TABLE(acpi, pxa2xx_spi_acpi_match);
 195
 196 static const struct of_device_id pxa2xx_spi_of_match[] = {
 197         { .compatible = "marvell,mmp2-ssp", .data = (void *)MMP2_SSP },
 198         {}
 199 };
 200 MODULE_DEVICE_TABLE(of, pxa2xx_spi_of_match);
 201
 202 static struct platform_driver driver = {
 203         .driver = {
 204                 .name   = "pxa2xx-spi",
 205                 .pm     = pm_ptr(&pxa2xx_spi_pm_ops),
 206                 .acpi_match_table = pxa2xx_spi_acpi_match,
 207                 .of_match_table = pxa2xx_spi_of_match,
 208         },
 209         .probe = pxa2xx_spi_platform_probe,
 210         .remove = pxa2xx_spi_platform_remove,
 211 };
 212
 213 static int __init pxa2xx_spi_init(void)
 214 {
 215         return platform_driver_register(&driver);
 216 }
 217 subsys_initcall(pxa2xx_spi_init);
 218
 219 static void __exit pxa2xx_spi_exit(void)
 220 {
 221         platform_driver_unregister(&driver);
 222 }
 223 module_exit(pxa2xx_spi_exit);
 224
 225 MODULE_AUTHOR("Stephen Street");
 226 MODULE_DESCRIPTION("PXA2xx SSP SPI Controller platform driver");
 227 MODULE_LICENSE("GPL");
 228 MODULE_IMPORT_NS("SPI_PXA2xx");
 229 MODULE_ALIAS("platform:pxa2xx-spi");
 230 MODULE_SOFTDEP("pre: dw_dmac");