Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/drivers/spi/spi-pxa2xx-pci.c

  1 /*
  2  * CE4100's SPI device is more or less the same one as found on PXA
  3  *
  4  * Copyright (C) 2016, Intel Corporation
  5  */
  6 #include <linux/clk-provider.h>
  7 #include <linux/module.h>
  8 #include <linux/of_device.h>
  9 #include <linux/pci.h>
 10 #include <linux/platform_device.h>
 11 #include <linux/spi/pxa2xx_spi.h>
 12 
 13 #include <linux/dmaengine.h>
 14 #include <linux/platform_data/dma-dw.h>
 15 
 16 enum {
 17         PORT_QUARK_X1000,
 18         PORT_BYT,
 19         PORT_MRFLD,
 20         PORT_BSW0,
 21         PORT_BSW1,
 22         PORT_BSW2,
 23         PORT_CE4100,
 24         PORT_LPT,
 25 };
 26 
 27 struct pxa_spi_info {
 28         enum pxa_ssp_type type;
 29         int port_id;
 30         int num_chipselect;
 31         unsigned long max_clk_rate;
 32 
 33         /* DMA channel request parameters */
 34         bool (*dma_filter)(struct dma_chan *chan, void *param);
 35         void *tx_param;
 36         void *rx_param;
 37 
 38         int (*setup)(struct pci_dev *pdev, struct pxa_spi_info *c);
 39 };
 40 
 41 static struct dw_dma_slave byt_tx_param = { .dst_id = 0 };
 42 static struct dw_dma_slave byt_rx_param = { .src_id = 1 };
 43 
 44 static struct dw_dma_slave bsw0_tx_param = { .dst_id = 0 };
 45 static struct dw_dma_slave bsw0_rx_param = { .src_id = 1 };
 46 static struct dw_dma_slave bsw1_tx_param = { .dst_id = 6 };
 47 static struct dw_dma_slave bsw1_rx_param = { .src_id = 7 };
 48 static struct dw_dma_slave bsw2_tx_param = { .dst_id = 8 };
 49 static struct dw_dma_slave bsw2_rx_param = { .src_id = 9 };
 50 
 51 static struct dw_dma_slave lpt_tx_param = { .dst_id = 0 };
 52 static struct dw_dma_slave lpt_rx_param = { .src_id = 1 };
 53 
 54 static bool lpss_dma_filter(struct dma_chan *chan, void *param)
 55 {
 56         struct dw_dma_slave *dws = param;
 57 
 58         if (dws->dma_dev != chan->device->dev)
 59                 return false;
 60 
 61         chan->private = dws;
 62         return true;
 63 }
 64 
 65 static int lpss_spi_setup(struct pci_dev *dev, struct pxa_spi_info *c)
 66 {
 67         struct pci_dev *dma_dev;
 68 
 69         c->num_chipselect = 1;
 70         c->max_clk_rate = 50000000;
 71 
 72         dma_dev = pci_get_slot(dev->bus, PCI_DEVFN(PCI_SLOT(dev->devfn), 0));
 73 
 74         if (c->tx_param) {
 75                 struct dw_dma_slave *slave = c->tx_param;
 76 
 77                 slave->dma_dev = &dma_dev->dev;
 78                 slave->m_master = 0;
 79                 slave->p_master = 1;
 80         }
 81 
 82         if (c->rx_param) {
 83                 struct dw_dma_slave *slave = c->rx_param;
 84 
 85                 slave->dma_dev = &dma_dev->dev;
 86                 slave->m_master = 0;
 87                 slave->p_master = 1;
 88         }
 89 
 90         c->dma_filter = lpss_dma_filter;
 91         return 0;
 92 }
 93 
 94 static int mrfld_spi_setup(struct pci_dev *dev, struct pxa_spi_info *c)
 95 {
 96         switch (PCI_FUNC(dev->devfn)) {
 97         case 0:
 98                 c->port_id = 3;
 99                 c->num_chipselect = 1;
100                 break;
101         case 1:
102                 c->port_id = 5;
103                 c->num_chipselect = 4;
104                 break;
105         case 2:
106                 c->port_id = 6;
107                 c->num_chipselect = 1;
108                 break;
109         default:
110                 return -ENODEV;
111         }
112         return 0;
113 }
114 
115 static struct pxa_spi_info spi_info_configs[] = {
116         [PORT_CE4100] = {
117                 .type = PXA25x_SSP,
118                 .port_id =  -1,
119                 .num_chipselect = -1,
120                 .max_clk_rate = 3686400,
121         },
122         [PORT_BYT] = {
123                 .type = LPSS_BYT_SSP,
124                 .port_id = 0,
125                 .setup = lpss_spi_setup,
126                 .tx_param = &byt_tx_param,
127                 .rx_param = &byt_rx_param,
128         },
129         [PORT_BSW0] = {
130                 .type = LPSS_BSW_SSP,
131                 .port_id = 0,
132                 .setup = lpss_spi_setup,
133                 .tx_param = &bsw0_tx_param,
134                 .rx_param = &bsw0_rx_param,
135         },
136         [PORT_BSW1] = {
137                 .type = LPSS_BSW_SSP,
138                 .port_id = 1,
139                 .setup = lpss_spi_setup,
140                 .tx_param = &bsw1_tx_param,
141                 .rx_param = &bsw1_rx_param,
142         },
143         [PORT_BSW2] = {
144                 .type = LPSS_BSW_SSP,
145                 .port_id = 2,
146                 .setup = lpss_spi_setup,
147                 .tx_param = &bsw2_tx_param,
148                 .rx_param = &bsw2_rx_param,
149         },
150         [PORT_MRFLD] = {
151                 .type = PXA27x_SSP,
152                 .max_clk_rate = 25000000,
153                 .setup = mrfld_spi_setup,
154         },
155         [PORT_QUARK_X1000] = {
156                 .type = QUARK_X1000_SSP,
157                 .port_id = -1,
158                 .num_chipselect = 1,
159                 .max_clk_rate = 50000000,
160         },
161         [PORT_LPT] = {
162                 .type = LPSS_LPT_SSP,
163                 .port_id = 0,
164                 .setup = lpss_spi_setup,
165                 .tx_param = &lpt_tx_param,
166                 .rx_param = &lpt_rx_param,
167         },
168 };
169 
170 static int pxa2xx_spi_pci_probe(struct pci_dev *dev,
171                 const struct pci_device_id *ent)
172 {
173         struct platform_device_info pi;
174         int ret;
175         struct platform_device *pdev;
176         struct pxa2xx_spi_master spi_pdata;
177         struct ssp_device *ssp;
178         struct pxa_spi_info *c;
179         char buf[40];
180 
181         ret = pcim_enable_device(dev);
182         if (ret)
183                 return ret;
184 
185         ret = pcim_iomap_regions(dev, 1 << 0, "PXA2xx SPI");
186         if (ret)
187                 return ret;
188 
189         c = &spi_info_configs[ent->driver_data];
190         if (c->setup) {
191                 ret = c->setup(dev, c);
192                 if (ret)
193                         return ret;
194         }
195 
196         memset(&spi_pdata, 0, sizeof(spi_pdata));
197         spi_pdata.num_chipselect = (c->num_chipselect > 0) ? c->num_chipselect : dev->devfn;
198         spi_pdata.dma_filter = c->dma_filter;
199         spi_pdata.tx_param = c->tx_param;
200         spi_pdata.rx_param = c->rx_param;
201         spi_pdata.enable_dma = c->rx_param && c->tx_param;
202 
203         ssp = &spi_pdata.ssp;
204         ssp->phys_base = pci_resource_start(dev, 0);
205         ssp->mmio_base = pcim_iomap_table(dev)[0];
206         ssp->irq = dev->irq;
207         ssp->port_id = (c->port_id >= 0) ? c->port_id : dev->devfn;
208         ssp->type = c->type;
209 
210         snprintf(buf, sizeof(buf), "pxa2xx-spi.%d", ssp->port_id);
211         ssp->clk = clk_register_fixed_rate(&dev->dev, buf , NULL, 0,
212                                            c->max_clk_rate);
213          if (IS_ERR(ssp->clk))
214                 return PTR_ERR(ssp->clk);
215 
216         memset(&pi, 0, sizeof(pi));
217         pi.fwnode = dev->dev.fwnode;
218         pi.parent = &dev->dev;
219         pi.name = "pxa2xx-spi";
220         pi.id = ssp->port_id;
221         pi.data = &spi_pdata;
222         pi.size_data = sizeof(spi_pdata);
223 
224         pdev = platform_device_register_full(&pi);
225         if (IS_ERR(pdev)) {
226                 clk_unregister(ssp->clk);
227                 return PTR_ERR(pdev);
228         }
229 
230         pci_set_drvdata(dev, pdev);
231 
232         return 0;
233 }
234 
235 static void pxa2xx_spi_pci_remove(struct pci_dev *dev)
236 {
237         struct platform_device *pdev = pci_get_drvdata(dev);
238         struct pxa2xx_spi_master *spi_pdata;
239 
240         spi_pdata = dev_get_platdata(&pdev->dev);
241 
242         platform_device_unregister(pdev);
243         clk_unregister(spi_pdata->ssp.clk);
244 }
245 
246 static const struct pci_device_id pxa2xx_spi_pci_devices[] = {
247         { PCI_VDEVICE(INTEL, 0x0935), PORT_QUARK_X1000 },
248         { PCI_VDEVICE(INTEL, 0x0f0e), PORT_BYT },
249         { PCI_VDEVICE(INTEL, 0x1194), PORT_MRFLD },
250         { PCI_VDEVICE(INTEL, 0x228e), PORT_BSW0 },
251         { PCI_VDEVICE(INTEL, 0x2290), PORT_BSW1 },
252         { PCI_VDEVICE(INTEL, 0x22ac), PORT_BSW2 },
253         { PCI_VDEVICE(INTEL, 0x2e6a), PORT_CE4100 },
254         { PCI_VDEVICE(INTEL, 0x9ce6), PORT_LPT },
255         { },
256 };
257 MODULE_DEVICE_TABLE(pci, pxa2xx_spi_pci_devices);
258 
259 static struct pci_driver pxa2xx_spi_pci_driver = {
260         .name           = "pxa2xx_spi_pci",
261         .id_table       = pxa2xx_spi_pci_devices,
262         .probe          = pxa2xx_spi_pci_probe,
263         .remove         = pxa2xx_spi_pci_remove,
264 };
265 
266 module_pci_driver(pxa2xx_spi_pci_driver);
267 
268 MODULE_DESCRIPTION("CE4100/LPSS PCI-SPI glue code for PXA's driver");
269 MODULE_LICENSE("GPL v2");
270 MODULE_AUTHOR("Sebastian Andrzej Siewior <bigeasy@linutronix.de>");
271 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us