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