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/spi/pxa2xx_spi.h>
  9
 10struct ce4100_info {
 11	struct ssp_device ssp;
 12	struct platform_device *spi_pdev;
 13};
 14
 15static DEFINE_MUTEX(ssp_lock);
 16static LIST_HEAD(ssp_list);
 17
 18struct ssp_device *pxa_ssp_request(int port, const char *label)
 19{
 20	struct ssp_device *ssp = NULL;
 21
 22	mutex_lock(&ssp_lock);
 23
 24	list_for_each_entry(ssp, &ssp_list, node) {
 25		if (ssp->port_id == port && ssp->use_count == 0) {
 26			ssp->use_count++;
 27			ssp->label = label;
 28			break;
 29		}
 30	}
 31
 32	mutex_unlock(&ssp_lock);
 33
 34	if (&ssp->node == &ssp_list)
 35		return NULL;
 36
 37	return ssp;
 38}
 39EXPORT_SYMBOL_GPL(pxa_ssp_request);
 40
 41void pxa_ssp_free(struct ssp_device *ssp)
 42{
 43	mutex_lock(&ssp_lock);
 44	if (ssp->use_count) {
 45		ssp->use_count--;
 46		ssp->label = NULL;
 47	} else
 48		dev_err(&ssp->pdev->dev, "device already free\n");
 49	mutex_unlock(&ssp_lock);
 50}
 51EXPORT_SYMBOL_GPL(pxa_ssp_free);
 52
 53static int __devinit ce4100_spi_probe(struct pci_dev *dev,
 54		const struct pci_device_id *ent)
 55{
 56	int ret;
 57	resource_size_t phys_beg;
 58	resource_size_t phys_len;
 59	struct ce4100_info *spi_info;
 60	struct platform_device *pdev;
 61	struct pxa2xx_spi_master spi_pdata;
 62	struct ssp_device *ssp;
 63
 64	ret = pci_enable_device(dev);
 65	if (ret)
 66		return ret;
 67
 68	phys_beg = pci_resource_start(dev, 0);
 69	phys_len = pci_resource_len(dev, 0);
 70
 71	if (!request_mem_region(phys_beg, phys_len,
 72				"CE4100 SPI")) {
 73		dev_err(&dev->dev, "Can't request register space.\n");
 74		ret = -EBUSY;
 75		return ret;
 76	}
 77
 78	pdev = platform_device_alloc("pxa2xx-spi", dev->devfn);
 79	spi_info = kzalloc(sizeof(*spi_info), GFP_KERNEL);
 80	if (!pdev || !spi_info ) {
 81		ret = -ENOMEM;
 82		goto err_nomem;
 83	}
 84	memset(&spi_pdata, 0, sizeof(spi_pdata));
 85	spi_pdata.num_chipselect = dev->devfn;
 86
 87	ret = platform_device_add_data(pdev, &spi_pdata, sizeof(spi_pdata));
 88	if (ret)
 89		goto err_nomem;
 90
 91	pdev->dev.parent = &dev->dev;
 92	pdev->dev.of_node = dev->dev.of_node;
 93	ssp = &spi_info->ssp;
 94	ssp->phys_base = pci_resource_start(dev, 0);
 95	ssp->mmio_base = ioremap(phys_beg, phys_len);
 96	if (!ssp->mmio_base) {
 97		dev_err(&pdev->dev, "failed to ioremap() registers\n");
 98		ret = -EIO;
 99		goto err_nomem;
100	}
101	ssp->irq = dev->irq;
102	ssp->port_id = pdev->id;
103	ssp->type = PXA25x_SSP;
104
105	mutex_lock(&ssp_lock);
106	list_add(&ssp->node, &ssp_list);
107	mutex_unlock(&ssp_lock);
108
109	pci_set_drvdata(dev, spi_info);
110
111	ret = platform_device_add(pdev);
112	if (ret)
113		goto err_dev_add;
114
115	return ret;
116
117err_dev_add:
118	pci_set_drvdata(dev, NULL);
119	mutex_lock(&ssp_lock);
120	list_del(&ssp->node);
121	mutex_unlock(&ssp_lock);
122	iounmap(ssp->mmio_base);
123
124err_nomem:
125	release_mem_region(phys_beg, phys_len);
126	platform_device_put(pdev);
127	kfree(spi_info);
128	return ret;
129}
130
131static void __devexit ce4100_spi_remove(struct pci_dev *dev)
132{
133	struct ce4100_info *spi_info;
134	struct ssp_device *ssp;
135
136	spi_info = pci_get_drvdata(dev);
137	ssp = &spi_info->ssp;
138	platform_device_unregister(spi_info->spi_pdev);
139
140	iounmap(ssp->mmio_base);
141	release_mem_region(pci_resource_start(dev, 0),
142			pci_resource_len(dev, 0));
143
144	mutex_lock(&ssp_lock);
145	list_del(&ssp->node);
146	mutex_unlock(&ssp_lock);
147
148	pci_set_drvdata(dev, NULL);
149	pci_disable_device(dev);
150	kfree(spi_info);
151}
152
153static struct pci_device_id ce4100_spi_devices[] __devinitdata = {
154	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2e6a) },
155	{ },
156};
157MODULE_DEVICE_TABLE(pci, ce4100_spi_devices);
158
159static struct pci_driver ce4100_spi_driver = {
160	.name           = "ce4100_spi",
161	.id_table       = ce4100_spi_devices,
162	.probe          = ce4100_spi_probe,
163	.remove         = __devexit_p(ce4100_spi_remove),
164};
165
166static int __init ce4100_spi_init(void)
167{
168	return pci_register_driver(&ce4100_spi_driver);
169}
170module_init(ce4100_spi_init);
171
172static void __exit ce4100_spi_exit(void)
173{
174	pci_unregister_driver(&ce4100_spi_driver);
175}
176module_exit(ce4100_spi_exit);
177
178MODULE_DESCRIPTION("CE4100 PCI-SPI glue code for PXA's driver");
179MODULE_LICENSE("GPL v2");
180MODULE_AUTHOR("Sebastian Andrzej Siewior <bigeasy@linutronix.de>");

  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
 11struct ce4100_info {
 12	struct ssp_device ssp;
 13	struct platform_device *spi_pdev;
 14};
 15
 16static DEFINE_MUTEX(ssp_lock);
 17static LIST_HEAD(ssp_list);
 18
 19struct ssp_device *pxa_ssp_request(int port, const char *label)
 20{
 21	struct ssp_device *ssp = NULL;
 22
 23	mutex_lock(&ssp_lock);
 24
 25	list_for_each_entry(ssp, &ssp_list, node) {
 26		if (ssp->port_id == port && ssp->use_count == 0) {
 27			ssp->use_count++;
 28			ssp->label = label;
 29			break;
 30		}
 31	}
 32
 33	mutex_unlock(&ssp_lock);
 34
 35	if (&ssp->node == &ssp_list)
 36		return NULL;
 37
 38	return ssp;
 39}
 40EXPORT_SYMBOL_GPL(pxa_ssp_request);
 41
 42void pxa_ssp_free(struct ssp_device *ssp)
 43{
 44	mutex_lock(&ssp_lock);
 45	if (ssp->use_count) {
 46		ssp->use_count--;
 47		ssp->label = NULL;
 48	} else
 49		dev_err(&ssp->pdev->dev, "device already free\n");
 50	mutex_unlock(&ssp_lock);
 51}
 52EXPORT_SYMBOL_GPL(pxa_ssp_free);
 53
 54static int __devinit ce4100_spi_probe(struct pci_dev *dev,
 55		const struct pci_device_id *ent)
 56{
 57	int ret;
 58	resource_size_t phys_beg;
 59	resource_size_t phys_len;
 60	struct ce4100_info *spi_info;
 61	struct platform_device *pdev;
 62	struct pxa2xx_spi_master spi_pdata;
 63	struct ssp_device *ssp;
 64
 65	ret = pci_enable_device(dev);
 66	if (ret)
 67		return ret;
 68
 69	phys_beg = pci_resource_start(dev, 0);
 70	phys_len = pci_resource_len(dev, 0);
 71
 72	if (!request_mem_region(phys_beg, phys_len,
 73				"CE4100 SPI")) {
 74		dev_err(&dev->dev, "Can't request register space.\n");
 75		ret = -EBUSY;
 76		return ret;
 77	}
 78
 79	pdev = platform_device_alloc("pxa2xx-spi", dev->devfn);
 80	spi_info = kzalloc(sizeof(*spi_info), GFP_KERNEL);
 81	if (!pdev || !spi_info ) {
 82		ret = -ENOMEM;
 83		goto err_nomem;
 84	}
 85	memset(&spi_pdata, 0, sizeof(spi_pdata));
 86	spi_pdata.num_chipselect = dev->devfn;
 87
 88	ret = platform_device_add_data(pdev, &spi_pdata, sizeof(spi_pdata));
 89	if (ret)
 90		goto err_nomem;
 91
 92	pdev->dev.parent = &dev->dev;
 93	pdev->dev.of_node = dev->dev.of_node;
 94	ssp = &spi_info->ssp;
 95	ssp->phys_base = pci_resource_start(dev, 0);
 96	ssp->mmio_base = ioremap(phys_beg, phys_len);
 97	if (!ssp->mmio_base) {
 98		dev_err(&pdev->dev, "failed to ioremap() registers\n");
 99		ret = -EIO;
100		goto err_nomem;
101	}
102	ssp->irq = dev->irq;
103	ssp->port_id = pdev->id;
104	ssp->type = PXA25x_SSP;
105
106	mutex_lock(&ssp_lock);
107	list_add(&ssp->node, &ssp_list);
108	mutex_unlock(&ssp_lock);
109
110	pci_set_drvdata(dev, spi_info);
111
112	ret = platform_device_add(pdev);
113	if (ret)
114		goto err_dev_add;
115
116	return ret;
117
118err_dev_add:
119	pci_set_drvdata(dev, NULL);
120	mutex_lock(&ssp_lock);
121	list_del(&ssp->node);
122	mutex_unlock(&ssp_lock);
123	iounmap(ssp->mmio_base);
124
125err_nomem:
126	release_mem_region(phys_beg, phys_len);
127	platform_device_put(pdev);
128	kfree(spi_info);
129	return ret;
130}
131
132static void __devexit ce4100_spi_remove(struct pci_dev *dev)
133{
134	struct ce4100_info *spi_info;
135	struct ssp_device *ssp;
136
137	spi_info = pci_get_drvdata(dev);
138	ssp = &spi_info->ssp;
139	platform_device_unregister(spi_info->spi_pdev);
140
141	iounmap(ssp->mmio_base);
142	release_mem_region(pci_resource_start(dev, 0),
143			pci_resource_len(dev, 0));
144
145	mutex_lock(&ssp_lock);
146	list_del(&ssp->node);
147	mutex_unlock(&ssp_lock);
148
149	pci_set_drvdata(dev, NULL);
150	pci_disable_device(dev);
151	kfree(spi_info);
152}
153
154static DEFINE_PCI_DEVICE_TABLE(ce4100_spi_devices) = {
155	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2e6a) },
156	{ },
157};
158MODULE_DEVICE_TABLE(pci, ce4100_spi_devices);
159
160static struct pci_driver ce4100_spi_driver = {
161	.name           = "ce4100_spi",
162	.id_table       = ce4100_spi_devices,
163	.probe          = ce4100_spi_probe,
164	.remove         = __devexit_p(ce4100_spi_remove),
165};
166
167module_pci_driver(ce4100_spi_driver);
 
 
 
 
 
 
 
 
 
 
168
169MODULE_DESCRIPTION("CE4100 PCI-SPI glue code for PXA's driver");
170MODULE_LICENSE("GPL v2");
171MODULE_AUTHOR("Sebastian Andrzej Siewior <bigeasy@linutronix.de>");