[linux-2.6-block.git] / drivers / mfd / janz-cmodio.c

/*
 * Janz CMOD-IO MODULbus Carrier Board PCI Driver
 *
 * Copyright (c) 2010 Ira W. Snyder <iws@ovro.caltech.edu>
 *
 * Lots of inspiration and code was copied from drivers/mfd/sm501.c
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/mfd/core.h>

#include <linux/mfd/janz.h>

#define DRV_NAME "janz-cmodio"

/* Size of each MODULbus module in PCI BAR4 */
#define CMODIO_MODULBUS_SIZE	0x200

/* Maximum number of MODULbus modules on a CMOD-IO carrier board */
#define CMODIO_MAX_MODULES	4

/* Module Parameters */
static unsigned int num_modules = CMODIO_MAX_MODULES;
static char *modules[CMODIO_MAX_MODULES] = {
	"empty", "empty", "empty", "empty",
};

module_param_array(modules, charp, &num_modules, S_IRUGO);
MODULE_PARM_DESC(modules, "MODULbus modules attached to the carrier board");

/* Unique Device Id */
static unsigned int cmodio_id;

struct cmodio_device {
	/* Parent PCI device */
	struct pci_dev *pdev;

	/* PLX control registers */
	struct janz_cmodio_onboard_regs __iomem *ctrl;

	/* hex switch position */
	u8 hex;

	/* mfd-core API */
	struct mfd_cell cells[CMODIO_MAX_MODULES];
	struct resource resources[3 * CMODIO_MAX_MODULES];
	struct janz_platform_data pdata[CMODIO_MAX_MODULES];
};

/*
 * Subdevices using the mfd-core API
 */

static int cmodio_setup_subdevice(struct cmodio_device *priv,
					    char *name, unsigned int devno,
					    unsigned int modno)
{
	struct janz_platform_data *pdata;
	struct mfd_cell *cell;
	struct resource *res;
	struct pci_dev *pci;

	pci = priv->pdev;
	cell = &priv->cells[devno];
	res = &priv->resources[devno * 3];
	pdata = &priv->pdata[devno];

	cell->name = name;
	cell->resources = res;
	cell->num_resources = 3;

	/* Setup the subdevice ID -- must be unique */
	cell->id = cmodio_id++;

	/* Add platform data */
	pdata->modno = modno;
	cell->platform_data = pdata;
	cell->pdata_size = sizeof(*pdata);

	/* MODULbus registers -- PCI BAR3 is big-endian MODULbus access */
	res->flags = IORESOURCE_MEM;
	res->parent = &pci->resource[3];
	res->start = pci->resource[3].start + (CMODIO_MODULBUS_SIZE * modno);
	res->end = res->start + CMODIO_MODULBUS_SIZE - 1;
	res++;

	/* PLX Control Registers -- PCI BAR4 is interrupt and other registers */
	res->flags = IORESOURCE_MEM;
	res->parent = &pci->resource[4];
	res->start = pci->resource[4].start;
	res->end = pci->resource[4].end;
	res++;

	/*
	 * IRQ
	 *
	 * The start and end fields are used as an offset to the irq_base
	 * parameter passed into the mfd_add_devices() function call. All
	 * devices share the same IRQ.
	 */
	res->flags = IORESOURCE_IRQ;
	res->parent = NULL;
	res->start = 0;
	res->end = 0;
	res++;

	return 0;
}

/* Probe each submodule using kernel parameters */
static int cmodio_probe_submodules(struct cmodio_device *priv)
{
	struct pci_dev *pdev = priv->pdev;
	unsigned int num_probed = 0;
	char *name;
	int i;

	for (i = 0; i < num_modules; i++) {
		name = modules[i];
		if (!strcmp(name, "") || !strcmp(name, "empty"))
			continue;

		dev_dbg(&priv->pdev->dev, "MODULbus %d: name %s\n", i, name);
		cmodio_setup_subdevice(priv, name, num_probed, i);
		num_probed++;
	}

	/* print an error message if no modules were probed */
	if (num_probed == 0) {
		dev_err(&priv->pdev->dev, "no MODULbus modules specified, "
					  "please set the ``modules'' kernel "
					  "parameter according to your "
					  "hardware configuration\n");
		return -ENODEV;
	}

	return mfd_add_devices(&pdev->dev, 0, priv->cells,
			       num_probed, NULL, pdev->irq, NULL);
}

/*
 * SYSFS Attributes
 */

static ssize_t mbus_show(struct device *dev, struct device_attribute *attr,
			 char *buf)
{
	struct cmodio_device *priv = dev_get_drvdata(dev);

	return snprintf(buf, PAGE_SIZE, "%x\n", priv->hex);
}

static DEVICE_ATTR(modulbus_number, S_IRUGO, mbus_show, NULL);

static struct attribute *cmodio_sysfs_attrs[] = {
	&dev_attr_modulbus_number.attr,
	NULL,
};

static const struct attribute_group cmodio_sysfs_attr_group = {
	.attrs = cmodio_sysfs_attrs,
};

/*
 * PCI Driver
 */

static int cmodio_pci_probe(struct pci_dev *dev,
				      const struct pci_device_id *id)
{
	struct cmodio_device *priv;
	int ret;

	priv = devm_kzalloc(&dev->dev, sizeof(*priv), GFP_KERNEL);
	if (!priv) {
		dev_err(&dev->dev, "unable to allocate private data\n");
		return -ENOMEM;
	}

	pci_set_drvdata(dev, priv);
	priv->pdev = dev;

	/* Hardware Initialization */
	ret = pci_enable_device(dev);
	if (ret) {
		dev_err(&dev->dev, "unable to enable device\n");
		return ret;
	}

	pci_set_master(dev);
	ret = pci_request_regions(dev, DRV_NAME);
	if (ret) {
		dev_err(&dev->dev, "unable to request regions\n");
		goto out_pci_disable_device;
	}

	/* Onboard configuration registers */
	priv->ctrl = pci_ioremap_bar(dev, 4);
	if (!priv->ctrl) {
		dev_err(&dev->dev, "unable to remap onboard regs\n");
		ret = -ENOMEM;
		goto out_pci_release_regions;
	}

	/* Read the hex switch on the carrier board */
	priv->hex = ioread8(&priv->ctrl->int_enable);

	/* Add the MODULbus number (hex switch value) to the device's sysfs */
	ret = sysfs_create_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
	if (ret) {
		dev_err(&dev->dev, "unable to create sysfs attributes\n");
		goto out_unmap_ctrl;
	}

	/*
	 * Disable all interrupt lines, each submodule will enable its
	 * own interrupt line if needed
	 */
	iowrite8(0xf, &priv->ctrl->int_disable);

	/* Register drivers for all submodules */
	ret = cmodio_probe_submodules(priv);
	if (ret) {
		dev_err(&dev->dev, "unable to probe submodules\n");
		goto out_sysfs_remove_group;
	}

	return 0;

out_sysfs_remove_group:
	sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
out_unmap_ctrl:
	iounmap(priv->ctrl);
out_pci_release_regions:
	pci_release_regions(dev);
out_pci_disable_device:
	pci_disable_device(dev);

	return ret;
}

static void cmodio_pci_remove(struct pci_dev *dev)
{
	struct cmodio_device *priv = pci_get_drvdata(dev);

	mfd_remove_devices(&dev->dev);
	sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
	iounmap(priv->ctrl);
	pci_release_regions(dev);
	pci_disable_device(dev);
}

#define PCI_VENDOR_ID_JANZ		0x13c3

/* The list of devices that this module will support */
static const struct pci_device_id cmodio_pci_ids[] = {
	{ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_JANZ, 0x0101 },
	{ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_JANZ, 0x0100 },
	{ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_JANZ, 0x0201 },
	{ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_JANZ, 0x0202 },
	{ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_JANZ, 0x0201 },
	{ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_JANZ, 0x0202 },
	{ 0, }
};
MODULE_DEVICE_TABLE(pci, cmodio_pci_ids);

static struct pci_driver cmodio_pci_driver = {
	.name     = DRV_NAME,
	.id_table = cmodio_pci_ids,
	.probe    = cmodio_pci_probe,
	.remove   = cmodio_pci_remove,
};

module_pci_driver(cmodio_pci_driver);

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