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