1/*
  2 * Janz CMOD-IO MODULbus Carrier Board PCI Driver
  3 *
  4 * Copyright (c) 2010 Ira W. Snyder <iws@ovro.caltech.edu>
  5 *
  6 * Lots of inspiration and code was copied from drivers/mfd/sm501.c
  7 *
  8 * This program is free software; you can redistribute it and/or modify it
  9 * under the terms of the GNU General Public License as published by the
 10 * Free Software Foundation; either version 2 of the License, or (at your
 11 * option) any later version.
 12 */
 13
 14#include <linux/kernel.h>
 15#include <linux/module.h>
 16#include <linux/init.h>
 17#include <linux/pci.h>
 18#include <linux/interrupt.h>
 19#include <linux/delay.h>
 20#include <linux/platform_device.h>
 21#include <linux/slab.h>
 22#include <linux/mfd/core.h>
 23
 24#include <linux/mfd/janz.h>
 25
 26#define DRV_NAME "janz-cmodio"
 27
 28/* Size of each MODULbus module in PCI BAR4 */
 29#define CMODIO_MODULBUS_SIZE	0x200
 30
 31/* Maximum number of MODULbus modules on a CMOD-IO carrier board */
 32#define CMODIO_MAX_MODULES	4
 33
 34/* Module Parameters */
 35static unsigned int num_modules = CMODIO_MAX_MODULES;
 36static char *modules[CMODIO_MAX_MODULES] = {
 37	"empty", "empty", "empty", "empty",
 38};
 39
 40module_param_array(modules, charp, &num_modules, S_IRUGO);
 41MODULE_PARM_DESC(modules, "MODULbus modules attached to the carrier board");
 42
 43/* Unique Device Id */
 44static unsigned int cmodio_id;
 45
 46struct cmodio_device {
 47	/* Parent PCI device */
 48	struct pci_dev *pdev;
 49
 50	/* PLX control registers */
 51	struct janz_cmodio_onboard_regs __iomem *ctrl;
 52
 53	/* hex switch position */
 54	u8 hex;
 55
 56	/* mfd-core API */
 57	struct mfd_cell cells[CMODIO_MAX_MODULES];
 58	struct resource resources[3 * CMODIO_MAX_MODULES];
 59	struct janz_platform_data pdata[CMODIO_MAX_MODULES];
 60};
 61
 62/*
 63 * Subdevices using the mfd-core API
 64 */
 65
 66static int __devinit cmodio_setup_subdevice(struct cmodio_device *priv,
 67					    char *name, unsigned int devno,
 68					    unsigned int modno)
 69{
 70	struct janz_platform_data *pdata;
 71	struct mfd_cell *cell;
 72	struct resource *res;
 73	struct pci_dev *pci;
 74
 75	pci = priv->pdev;
 76	cell = &priv->cells[devno];
 77	res = &priv->resources[devno * 3];
 78	pdata = &priv->pdata[devno];
 79
 80	cell->name = name;
 81	cell->resources = res;
 82	cell->num_resources = 3;
 83
 84	/* Setup the subdevice ID -- must be unique */
 85	cell->id = cmodio_id++;
 86
 87	/* Add platform data */
 88	pdata->modno = modno;
 89	cell->platform_data = pdata;
 90	cell->pdata_size = sizeof(*pdata);
 91
 92	/* MODULbus registers -- PCI BAR3 is big-endian MODULbus access */
 93	res->flags = IORESOURCE_MEM;
 94	res->parent = &pci->resource[3];
 95	res->start = pci->resource[3].start + (CMODIO_MODULBUS_SIZE * modno);
 96	res->end = res->start + CMODIO_MODULBUS_SIZE - 1;
 97	res++;
 98
 99	/* PLX Control Registers -- PCI BAR4 is interrupt and other registers */
100	res->flags = IORESOURCE_MEM;
101	res->parent = &pci->resource[4];
102	res->start = pci->resource[4].start;
103	res->end = pci->resource[4].end;
104	res++;
105
106	/*
107	 * IRQ
108	 *
109	 * The start and end fields are used as an offset to the irq_base
110	 * parameter passed into the mfd_add_devices() function call. All
111	 * devices share the same IRQ.
112	 */
113	res->flags = IORESOURCE_IRQ;
114	res->parent = NULL;
115	res->start = 0;
116	res->end = 0;
117	res++;
118
119	return 0;
120}
121
122/* Probe each submodule using kernel parameters */
123static int __devinit cmodio_probe_submodules(struct cmodio_device *priv)
124{
125	struct pci_dev *pdev = priv->pdev;
126	unsigned int num_probed = 0;
127	char *name;
128	int i;
129
130	for (i = 0; i < num_modules; i++) {
131		name = modules[i];
132		if (!strcmp(name, "") || !strcmp(name, "empty"))
133			continue;
134
135		dev_dbg(&priv->pdev->dev, "MODULbus %d: name %s\n", i, name);
136		cmodio_setup_subdevice(priv, name, num_probed, i);
137		num_probed++;
138	}
139
140	/* print an error message if no modules were probed */
141	if (num_probed == 0) {
142		dev_err(&priv->pdev->dev, "no MODULbus modules specified, "
143					  "please set the ``modules'' kernel "
144					  "parameter according to your "
145					  "hardware configuration\n");
146		return -ENODEV;
147	}
148
149	return mfd_add_devices(&pdev->dev, 0, priv->cells,
150			       num_probed, NULL, pdev->irq);
151}
152
153/*
154 * SYSFS Attributes
155 */
156
157static ssize_t mbus_show(struct device *dev, struct device_attribute *attr,
158			 char *buf)
159{
160	struct cmodio_device *priv = dev_get_drvdata(dev);
161
162	return snprintf(buf, PAGE_SIZE, "%x\n", priv->hex);
163}
164
165static DEVICE_ATTR(modulbus_number, S_IRUGO, mbus_show, NULL);
166
167static struct attribute *cmodio_sysfs_attrs[] = {
168	&dev_attr_modulbus_number.attr,
169	NULL,
170};
171
172static const struct attribute_group cmodio_sysfs_attr_group = {
173	.attrs = cmodio_sysfs_attrs,
174};
175
176/*
177 * PCI Driver
178 */
179
180static int __devinit cmodio_pci_probe(struct pci_dev *dev,
181				      const struct pci_device_id *id)
182{
183	struct cmodio_device *priv;
184	int ret;
185
186	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
187	if (!priv) {
188		dev_err(&dev->dev, "unable to allocate private data\n");
189		ret = -ENOMEM;
190		goto out_return;
191	}
192
193	pci_set_drvdata(dev, priv);
194	priv->pdev = dev;
195
196	/* Hardware Initialization */
197	ret = pci_enable_device(dev);
198	if (ret) {
199		dev_err(&dev->dev, "unable to enable device\n");
200		goto out_free_priv;
201	}
202
203	pci_set_master(dev);
204	ret = pci_request_regions(dev, DRV_NAME);
205	if (ret) {
206		dev_err(&dev->dev, "unable to request regions\n");
207		goto out_pci_disable_device;
208	}
209
210	/* Onboard configuration registers */
211	priv->ctrl = pci_ioremap_bar(dev, 4);
212	if (!priv->ctrl) {
213		dev_err(&dev->dev, "unable to remap onboard regs\n");
214		ret = -ENOMEM;
215		goto out_pci_release_regions;
216	}
217
218	/* Read the hex switch on the carrier board */
219	priv->hex = ioread8(&priv->ctrl->int_enable);
220
221	/* Add the MODULbus number (hex switch value) to the device's sysfs */
222	ret = sysfs_create_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
223	if (ret) {
224		dev_err(&dev->dev, "unable to create sysfs attributes\n");
225		goto out_unmap_ctrl;
226	}
227
228	/*
229	 * Disable all interrupt lines, each submodule will enable its
230	 * own interrupt line if needed
231	 */
232	iowrite8(0xf, &priv->ctrl->int_disable);
233
234	/* Register drivers for all submodules */
235	ret = cmodio_probe_submodules(priv);
236	if (ret) {
237		dev_err(&dev->dev, "unable to probe submodules\n");
238		goto out_sysfs_remove_group;
239	}
240
241	return 0;
242
243out_sysfs_remove_group:
244	sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
245out_unmap_ctrl:
246	iounmap(priv->ctrl);
247out_pci_release_regions:
248	pci_release_regions(dev);
249out_pci_disable_device:
250	pci_disable_device(dev);
251out_free_priv:
252	kfree(priv);
253out_return:
254	return ret;
255}
256
257static void __devexit cmodio_pci_remove(struct pci_dev *dev)
258{
259	struct cmodio_device *priv = pci_get_drvdata(dev);
260
261	mfd_remove_devices(&dev->dev);
262	sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
263	iounmap(priv->ctrl);
264	pci_release_regions(dev);
265	pci_disable_device(dev);
266	kfree(priv);
267}
268
269#define PCI_VENDOR_ID_JANZ		0x13c3
270
271/* The list of devices that this module will support */
272static DEFINE_PCI_DEVICE_TABLE(cmodio_pci_ids) = {
273	{ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_JANZ, 0x0101 },
274	{ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_JANZ, 0x0100 },
275	{ 0, }
276};
277MODULE_DEVICE_TABLE(pci, cmodio_pci_ids);
278
279static struct pci_driver cmodio_pci_driver = {
280	.name     = DRV_NAME,
281	.id_table = cmodio_pci_ids,
282	.probe    = cmodio_pci_probe,
283	.remove   = __devexit_p(cmodio_pci_remove),
284};
285
286module_pci_driver(cmodio_pci_driver);
287
288MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");
289MODULE_DESCRIPTION("Janz CMOD-IO PCI MODULbus Carrier Board Driver");
290MODULE_LICENSE("GPL");