[deliverable/linux.git] / drivers / staging / comedi / drivers / 8255_pci.c

/*
 * COMEDI driver for generic PCI based 8255 digital i/o boards
 * Copyright (C) 2012 H Hartley Sweeten <hsweeten@visionengravers.com>
 *
 * Based on the tested adl_pci7296 driver written by:
 *	Jon Grierson <jd@renko.co.uk>
 * and the experimental cb_pcidio driver written by:
 *	Yoshiya Matsuzaka
 *
 * COMEDI - Linux Control and Measurement Device Interface
 * Copyright (C) 2000 David A. Schleef <ds@schleef.org>
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/*
Driver: 8255_pci
Description: Generic PCI based 8255 Digital I/O boards
Devices: (ADLink) PCI-7224 [adl_pci-7224] - 24 channels
	 (ADLink) PCI-7248 [adl_pci-7248] - 48 channels
	 (ADLink) PCI-7296 [adl_pci-7296] - 96 channels
	 (Measurement Computing) PCI-DIO24 [cb_pci-dio24] - 24 channels
	 (Measurement Computing) PCI-DIO24H [cb_pci-dio24h] - 24 channels
	 (Measurement Computing) PCI-DIO48H [cb_pci-dio48h] - 48 channels
	 (Measurement Computing) PCI-DIO96H [cb_pci-dio96h] - 96 channels
	 (National Instruments) PCI-DIO-96 [ni_pci-dio-96] - 96 channels
	 (National Instruments) PCI-DIO-96B [ni_pci-dio-96b] - 96 channels
	 (National Instruments) PXI-6508 [ni_pxi-6508] - 96 channels
	 (National Instruments) PCI-6503 [ni_pci-6503] - 24 channels
	 (National Instruments) PCI-6503B [ni_pci-6503b] - 24 channels
	 (National Instruments) PCI-6503X [ni_pci-6503x] - 24 channels
	 (National Instruments) PXI-6503 [ni_pxi-6503] - 24 channels
Author: H Hartley Sweeten <hsweeten@visionengravers.com>
Updated: Wed, 12 Sep 2012 11:52:01 -0700
Status: untested

Some of these boards also have an 8254 programmable timer/counter
chip. This chip is not currently supported by this driver.

Interrupt support for these boards is also not currently supported.

Configuration Options: not applicable, uses PCI auto config
*/

#include <linux/pci.h>

#include "../comedidev.h"

#include "8255.h"

enum pci_8255_boardid {
	BOARD_ADLINK_PCI7224,
	BOARD_ADLINK_PCI7248,
	BOARD_ADLINK_PCI7296,
	BOARD_CB_PCIDIO24,
	BOARD_CB_PCIDIO24H,
	BOARD_CB_PCIDIO48H,
	BOARD_CB_PCIDIO96H,
	BOARD_NI_PCIDIO96,
	BOARD_NI_PCIDIO96B,
	BOARD_NI_PXI6508,
	BOARD_NI_PCI6503,
	BOARD_NI_PCI6503B,
	BOARD_NI_PCI6503X,
	BOARD_NI_PXI_6503,
};

struct pci_8255_boardinfo {
	const char *name;
	int dio_badr;
	int is_mmio;
	int n_8255;
};

static const struct pci_8255_boardinfo pci_8255_boards[] = {
	[BOARD_ADLINK_PCI7224] = {
		.name		= "adl_pci-7224",
		.dio_badr	= 2,
		.n_8255		= 1,
	},
	[BOARD_ADLINK_PCI7248] = {
		.name		= "adl_pci-7248",
		.dio_badr	= 2,
		.n_8255		= 2,
	},
	[BOARD_ADLINK_PCI7296] = {
		.name		= "adl_pci-7296",
		.dio_badr	= 2,
		.n_8255		= 4,
	},
	[BOARD_CB_PCIDIO24] = {
		.name		= "cb_pci-dio24",
		.dio_badr	= 2,
		.n_8255		= 1,
	},
	[BOARD_CB_PCIDIO24H] = {
		.name		= "cb_pci-dio24h",
		.dio_badr	= 2,
		.n_8255		= 1,
	},
	[BOARD_CB_PCIDIO48H] = {
		.name		= "cb_pci-dio48h",
		.dio_badr	= 1,
		.n_8255		= 2,
	},
	[BOARD_CB_PCIDIO96H] = {
		.name		= "cb_pci-dio96h",
		.dio_badr	= 2,
		.n_8255		= 4,
	},
	[BOARD_NI_PCIDIO96] = {
		.name		= "ni_pci-dio-96",
		.dio_badr	= 1,
		.is_mmio	= 1,
		.n_8255		= 4,
	},
	[BOARD_NI_PCIDIO96B] = {
		.name		= "ni_pci-dio-96b",
		.dio_badr	= 1,
		.is_mmio	= 1,
		.n_8255		= 4,
	},
	[BOARD_NI_PXI6508] = {
		.name		= "ni_pxi-6508",
		.dio_badr	= 1,
		.is_mmio	= 1,
		.n_8255		= 4,
	},
	[BOARD_NI_PCI6503] = {
		.name		= "ni_pci-6503",
		.dio_badr	= 1,
		.is_mmio	= 1,
		.n_8255		= 1,
	},
	[BOARD_NI_PCI6503B] = {
		.name		= "ni_pci-6503b",
		.dio_badr	= 1,
		.is_mmio	= 1,
		.n_8255		= 1,
	},
	[BOARD_NI_PCI6503X] = {
		.name		= "ni_pci-6503x",
		.dio_badr	= 1,
		.is_mmio	= 1,
		.n_8255		= 1,
	},
	[BOARD_NI_PXI_6503] = {
		.name		= "ni_pxi-6503",
		.dio_badr	= 1,
		.is_mmio	= 1,
		.n_8255		= 1,
	},
};

struct pci_8255_private {
	void __iomem *mmio_base;
};

static int pci_8255_mmio(int dir, int port, int data, unsigned long iobase)
{
	void __iomem *mmio_base = (void __iomem *)iobase;

	if (dir) {
		writeb(data, mmio_base + port);
		return 0;
	} else {
		return readb(mmio_base  + port);
	}
}

static int pci_8255_auto_attach(struct comedi_device *dev,
				unsigned long context)
{
	struct pci_dev *pcidev = comedi_to_pci_dev(dev);
	const struct pci_8255_boardinfo *board = NULL;
	struct pci_8255_private *devpriv;
	struct comedi_subdevice *s;
	resource_size_t iobase;
	unsigned long len;
	int ret;
	int i;

	if (context < ARRAY_SIZE(pci_8255_boards))
		board = &pci_8255_boards[context];
	if (!board)
		return -ENODEV;
	dev->board_ptr = board;
	dev->board_name = board->name;

	devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
	if (!devpriv)
		return -ENOMEM;
	dev->private = devpriv;

	ret = comedi_pci_enable(dev);
	if (ret)
		return ret;
	iobase = pci_resource_start(pcidev, board->dio_badr);
	len = pci_resource_len(pcidev, board->dio_badr);

	if (board->is_mmio) {
		devpriv->mmio_base = ioremap(iobase, len);
		if (!devpriv->mmio_base)
			return -ENOMEM;
	}
	dev->iobase = iobase;

	/*
	 * One, two, or four subdevices are setup by this driver depending
	 * on the number of channels provided by the board. Each subdevice
	 * has 24 channels supported by the 8255 module.
	 */
	ret = comedi_alloc_subdevices(dev, board->n_8255);
	if (ret)
		return ret;

	for (i = 0; i < board->n_8255; i++) {
		s = &dev->subdevices[i];
		if (board->is_mmio) {
			iobase = (unsigned long)(devpriv->mmio_base + (i * 4));
			ret = subdev_8255_init(dev, s, pci_8255_mmio, iobase);
		} else {
			iobase = dev->iobase + (i * 4);
			ret = subdev_8255_init(dev, s, NULL, iobase);
		}
		if (ret)
			return ret;
	}

	dev_info(dev->class_dev, "%s attached (%d digital i/o channels)\n",
		dev->board_name, board->n_8255 * 24);

	return 0;
}

static void pci_8255_detach(struct comedi_device *dev)
{
	const struct pci_8255_boardinfo *board = comedi_board(dev);
	struct pci_8255_private *devpriv = dev->private;
	struct comedi_subdevice *s;
	int i;

	if (!board || !devpriv)
		return;
	if (dev->subdevices) {
		for (i = 0; i < board->n_8255; i++) {
			s = &dev->subdevices[i];
			subdev_8255_cleanup(dev, s);
		}
	}
	if (devpriv->mmio_base)
		iounmap(devpriv->mmio_base);
	comedi_pci_disable(dev);
}

static struct comedi_driver pci_8255_driver = {
	.driver_name	= "8255_pci",
	.module		= THIS_MODULE,
	.auto_attach	= pci_8255_auto_attach,
	.detach		= pci_8255_detach,
};

static int pci_8255_pci_probe(struct pci_dev *dev,
			      const struct pci_device_id *id)
{
	return comedi_pci_auto_config(dev, &pci_8255_driver, id->driver_data);
}

static DEFINE_PCI_DEVICE_TABLE(pci_8255_pci_table) = {
	{ PCI_VDEVICE(ADLINK, 0x7224), BOARD_ADLINK_PCI7224 },
	{ PCI_VDEVICE(ADLINK, 0x7248), BOARD_ADLINK_PCI7248 },
	{ PCI_VDEVICE(ADLINK, 0x7296), BOARD_ADLINK_PCI7296 },
	{ PCI_VDEVICE(CB, 0x0028), BOARD_CB_PCIDIO24 },
	{ PCI_VDEVICE(CB, 0x0014), BOARD_CB_PCIDIO24H },
	{ PCI_VDEVICE(CB, 0x000b), BOARD_CB_PCIDIO48H },
	{ PCI_VDEVICE(CB, 0x0017), BOARD_CB_PCIDIO96H },
	{ PCI_VDEVICE(NI, 0x0160), BOARD_NI_PCIDIO96 },
	{ PCI_VDEVICE(NI, 0x1630), BOARD_NI_PCIDIO96B },
	{ PCI_VDEVICE(NI, 0x13c0), BOARD_NI_PXI6508 },
	{ PCI_VDEVICE(NI, 0x0400), BOARD_NI_PCI6503 },
	{ PCI_VDEVICE(NI, 0x1250), BOARD_NI_PCI6503B },
	{ PCI_VDEVICE(NI, 0x17d0), BOARD_NI_PCI6503X },
	{ PCI_VDEVICE(NI, 0x1800), BOARD_NI_PXI_6503 },
	{ 0 }
};
MODULE_DEVICE_TABLE(pci, pci_8255_pci_table);

static struct pci_driver pci_8255_pci_driver = {
	.name		= "8255_pci",
	.id_table	= pci_8255_pci_table,
	.probe		= pci_8255_pci_probe,
	.remove		= comedi_pci_auto_unconfig,
};
module_comedi_pci_driver(pci_8255_driver, pci_8255_pci_driver);

MODULE_DESCRIPTION("COMEDI - Generic PCI based 8255 Digital I/O boards");
MODULE_AUTHOR("Comedi http://www.comedi.org");
MODULE_LICENSE("GPL");
Commit	Line	Data
bb71f8b3	1	/*
f7c22868 HS	2	* COMEDI driver for generic PCI based 8255 digital i/o boards
	3	* Copyright (C) 2012 H Hartley Sweeten <hsweeten@visionengravers.com>
	4	*
	5	* Based on the tested adl_pci7296 driver written by:
	6	* Jon Grierson <jd@renko.co.uk>
df1a3f87 HS	7	* and the experimental cb_pcidio driver written by:
df1a3f87 HS	8	* Yoshiya Matsuzaka
32bb1544 HS	9	*
	10	* COMEDI - Linux Control and Measurement Device Interface
	11	* Copyright (C) 2000 David A. Schleef <ds@schleef.org>
	12	*
	13	* This program is free software; you can redistribute it and/or modify
	14	* it under the terms of the GNU General Public License as published by
	15	* the Free Software Foundation; either version 2 of the License, or
	16	* (at your option) any later version.
	17	*
	18	* This program is distributed in the hope that it will be useful,
	19	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	21	* GNU General Public License for more details.
	22	*
	23	* You should have received a copy of the GNU General Public License
	24	* along with this program; if not, write to the Free Software
	25	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	26	*/
bb71f8b3	27
bb71f8b3	28	/*
f7c22868 HS	29	Driver: 8255_pci
	30	Description: Generic PCI based 8255 Digital I/O boards
	31	Devices: (ADLink) PCI-7224 [adl_pci-7224] - 24 channels
	32	(ADLink) PCI-7248 [adl_pci-7248] - 48 channels
	33	(ADLink) PCI-7296 [adl_pci-7296] - 96 channels
df1a3f87 HS	34	(Measurement Computing) PCI-DIO24 [cb_pci-dio24] - 24 channels
	35	(Measurement Computing) PCI-DIO24H [cb_pci-dio24h] - 24 channels
	36	(Measurement Computing) PCI-DIO48H [cb_pci-dio48h] - 48 channels
606b0470	37	(Measurement Computing) PCI-DIO96H [cb_pci-dio96h] - 96 channels
b37c1aee HS	38	(National Instruments) PCI-DIO-96 [ni_pci-dio-96] - 96 channels
	39	(National Instruments) PCI-DIO-96B [ni_pci-dio-96b] - 96 channels
	40	(National Instruments) PXI-6508 [ni_pxi-6508] - 96 channels
	41	(National Instruments) PCI-6503 [ni_pci-6503] - 24 channels
	42	(National Instruments) PCI-6503B [ni_pci-6503b] - 24 channels
	43	(National Instruments) PCI-6503X [ni_pci-6503x] - 24 channels
	44	(National Instruments) PXI-6503 [ni_pxi-6503] - 24 channels
f7c22868 HS	45	Author: H Hartley Sweeten <hsweeten@visionengravers.com>
	46	Updated: Wed, 12 Sep 2012 11:52:01 -0700
	47	Status: untested
	48
	49	Some of these boards also have an 8254 programmable timer/counter
	50	chip. This chip is not currently supported by this driver.
32bb1544 HS	51
	52	Interrupt support for these boards is also not currently supported.
	53
f7c22868	54	Configuration Options: not applicable, uses PCI auto config
bb71f8b3 JG	55	*/
bb71f8b3 JG	56
33782dd5 HS	57	#include <linux/pci.h>
33782dd5 HS	58
bb71f8b3	59	#include "../comedidev.h"
bb71f8b3	60
bb71f8b3	61	#include "8255.h"
bb71f8b3	62
af48bd8c HS	63	enum pci_8255_boardid {
	64	BOARD_ADLINK_PCI7224,
	65	BOARD_ADLINK_PCI7248,
	66	BOARD_ADLINK_PCI7296,
	67	BOARD_CB_PCIDIO24,
	68	BOARD_CB_PCIDIO24H,
	69	BOARD_CB_PCIDIO48H,
	70	BOARD_CB_PCIDIO96H,
	71	BOARD_NI_PCIDIO96,
	72	BOARD_NI_PCIDIO96B,
	73	BOARD_NI_PXI6508,
	74	BOARD_NI_PCI6503,
	75	BOARD_NI_PCI6503B,
	76	BOARD_NI_PCI6503X,
	77	BOARD_NI_PXI_6503,
	78	};
b37c1aee	79
f7c22868	80	struct pci_8255_boardinfo {
32bb1544	81	const char *name;
df1a3f87	82	int dio_badr;
77f17d37	83	int is_mmio;
f7c22868	84	int n_8255;
32bb1544	85	};
bb71f8b3	86
f7c22868	87	static const struct pci_8255_boardinfo pci_8255_boards[] = {
af48bd8c	88	[BOARD_ADLINK_PCI7224] = {
f7c22868	89	.name = "adl_pci-7224",
df1a3f87	90	.dio_badr = 2,
f7c22868	91	.n_8255 = 1,
af48bd8c HS	92	},
af48bd8c HS	93	[BOARD_ADLINK_PCI7248] = {
f7c22868	94	.name = "adl_pci-7248",
df1a3f87	95	.dio_badr = 2,
f7c22868	96	.n_8255 = 2,
af48bd8c HS	97	},
af48bd8c HS	98	[BOARD_ADLINK_PCI7296] = {
f7c22868	99	.name = "adl_pci-7296",
df1a3f87	100	.dio_badr = 2,
f7c22868	101	.n_8255 = 4,
af48bd8c HS	102	},
af48bd8c HS	103	[BOARD_CB_PCIDIO24] = {
df1a3f87	104	.name = "cb_pci-dio24",
df1a3f87 HS	105	.dio_badr = 2,
df1a3f87 HS	106	.n_8255 = 1,
af48bd8c HS	107	},
af48bd8c HS	108	[BOARD_CB_PCIDIO24H] = {
df1a3f87	109	.name = "cb_pci-dio24h",
df1a3f87 HS	110	.dio_badr = 2,
df1a3f87 HS	111	.n_8255 = 1,
af48bd8c HS	112	},
af48bd8c HS	113	[BOARD_CB_PCIDIO48H] = {
df1a3f87	114	.name = "cb_pci-dio48h",
df1a3f87 HS	115	.dio_badr = 1,
df1a3f87 HS	116	.n_8255 = 2,
af48bd8c HS	117	},
af48bd8c HS	118	[BOARD_CB_PCIDIO96H] = {
606b0470	119	.name = "cb_pci-dio96h",
606b0470 HS	120	.dio_badr = 2,
606b0470 HS	121	.n_8255 = 4,
af48bd8c HS	122	},
af48bd8c HS	123	[BOARD_NI_PCIDIO96] = {
b37c1aee	124	.name = "ni_pci-dio-96",
b37c1aee HS	125	.dio_badr = 1,
	126	.is_mmio = 1,
	127	.n_8255 = 4,
af48bd8c HS	128	},
af48bd8c HS	129	[BOARD_NI_PCIDIO96B] = {
b37c1aee	130	.name = "ni_pci-dio-96b",
b37c1aee HS	131	.dio_badr = 1,
	132	.is_mmio = 1,
	133	.n_8255 = 4,
af48bd8c HS	134	},
af48bd8c HS	135	[BOARD_NI_PXI6508] = {
b37c1aee	136	.name = "ni_pxi-6508",
b37c1aee HS	137	.dio_badr = 1,
	138	.is_mmio = 1,
	139	.n_8255 = 4,
af48bd8c HS	140	},
af48bd8c HS	141	[BOARD_NI_PCI6503] = {
b37c1aee	142	.name = "ni_pci-6503",
b37c1aee HS	143	.dio_badr = 1,
	144	.is_mmio = 1,
	145	.n_8255 = 1,
af48bd8c HS	146	},
af48bd8c HS	147	[BOARD_NI_PCI6503B] = {
b37c1aee	148	.name = "ni_pci-6503b",
b37c1aee HS	149	.dio_badr = 1,
	150	.is_mmio = 1,
	151	.n_8255 = 1,
af48bd8c HS	152	},
af48bd8c HS	153	[BOARD_NI_PCI6503X] = {
b37c1aee	154	.name = "ni_pci-6503x",
b37c1aee HS	155	.dio_badr = 1,
	156	.is_mmio = 1,
	157	.n_8255 = 1,
af48bd8c HS	158	},
af48bd8c HS	159	[BOARD_NI_PXI_6503] = {
b37c1aee	160	.name = "ni_pxi-6503",
b37c1aee HS	161	.dio_badr = 1,
	162	.is_mmio = 1,
	163	.n_8255 = 1,
32bb1544 HS	164	},
32bb1544 HS	165	};
bb71f8b3	166
77f17d37 HS	167	struct pci_8255_private {
	168	void __iomem *mmio_base;
	169	};
	170
	171	static int pci_8255_mmio(int dir, int port, int data, unsigned long iobase)
	172	{
	173	void __iomem mmio_base = (void __iomem )iobase;
	174
	175	if (dir) {
	176	writeb(data, mmio_base + port);
	177	return 0;
	178	} else {
	179	return readb(mmio_base + port);
	180	}
	181	}
	182
a690b7e5	183	static int pci_8255_auto_attach(struct comedi_device *dev,
af48bd8c	184	unsigned long context)
bb71f8b3	185	{
750af5e5	186	struct pci_dev *pcidev = comedi_to_pci_dev(dev);
af48bd8c	187	const struct pci_8255_boardinfo *board = NULL;
77f17d37	188	struct pci_8255_private *devpriv;
34c43922	189	struct comedi_subdevice *s;
77f17d37 HS	190	resource_size_t iobase;
77f17d37 HS	191	unsigned long len;
bb71f8b3	192	int ret;
32bb1544	193	int i;
bb71f8b3	194
af48bd8c HS	195	if (context < ARRAY_SIZE(pci_8255_boards))
af48bd8c HS	196	board = &pci_8255_boards[context];
32bb1544 HS	197	if (!board)
	198	return -ENODEV;
	199	dev->board_ptr = board;
	200	dev->board_name = board->name;
bb71f8b3	201
c34fa261 HS	202	devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
	203	if (!devpriv)
	204	return -ENOMEM;
	205	dev->private = devpriv;
77f17d37	206
818f569f	207	ret = comedi_pci_enable(dev);
8b6c5694 HS	208	if (ret)
8b6c5694 HS	209	return ret;
77f17d37 HS	210	iobase = pci_resource_start(pcidev, board->dio_badr);
	211	len = pci_resource_len(pcidev, board->dio_badr);
	212
	213	if (board->is_mmio) {
	214	devpriv->mmio_base = ioremap(iobase, len);
	215	if (!devpriv->mmio_base)
	216	return -ENOMEM;
	217	}
	218	dev->iobase = iobase;
262ea0d4	219
32bb1544 HS	220	/*
	221	* One, two, or four subdevices are setup by this driver depending
	222	* on the number of channels provided by the board. Each subdevice
	223	* has 24 channels supported by the 8255 module.
	224	*/
f7c22868	225	ret = comedi_alloc_subdevices(dev, board->n_8255);
32bb1544	226	if (ret)
262ea0d4 HS	227	return ret;
262ea0d4 HS	228
f7c22868	229	for (i = 0; i < board->n_8255; i++) {
630b713b	230	s = &dev->subdevices[i];
77f17d37 HS	231	if (board->is_mmio) {
	232	iobase = (unsigned long)(devpriv->mmio_base + (i * 4));
	233	ret = subdev_8255_init(dev, s, pci_8255_mmio, iobase);
	234	} else {
	235	iobase = dev->iobase + (i * 4);
	236	ret = subdev_8255_init(dev, s, NULL, iobase);
	237	}
32bb1544 HS	238	if (ret)
	239	return ret;
	240	}
262ea0d4	241
32bb1544	242	dev_info(dev->class_dev, "%s attached (%d digital i/o channels)\n",
f7c22868	243	dev->board_name, board->n_8255 * 24);
262ea0d4 HS	244
262ea0d4 HS	245	return 0;
bb71f8b3 JG	246	}
bb71f8b3 JG	247
f7c22868	248	static void pci_8255_detach(struct comedi_device *dev)
bb71f8b3	249	{
f7c22868	250	const struct pci_8255_boardinfo *board = comedi_board(dev);
77f17d37	251	struct pci_8255_private *devpriv = dev->private;
32bb1544 HS	252	struct comedi_subdevice *s;
32bb1544 HS	253	int i;
caeb2490	254
f4dd2367 IA	255	if (!board \|\| !devpriv)
f4dd2367 IA	256	return;
32bb1544	257	if (dev->subdevices) {
f7c22868	258	for (i = 0; i < board->n_8255; i++) {
630b713b	259	s = &dev->subdevices[i];
32bb1544 HS	260	subdev_8255_cleanup(dev, s);
	261	}
	262	}
7f072f54 HS	263	if (devpriv->mmio_base)
	264	iounmap(devpriv->mmio_base);
	265	comedi_pci_disable(dev);
bb71f8b3 JG	266	}
bb71f8b3 JG	267
f7c22868 HS	268	static struct comedi_driver pci_8255_driver = {
f7c22868 HS	269	.driver_name = "8255_pci",
db0eaeed	270	.module = THIS_MODULE,
750af5e5	271	.auto_attach = pci_8255_auto_attach,
f7c22868	272	.detach = pci_8255_detach,
db0eaeed HS	273	};
db0eaeed HS	274
a690b7e5	275	static int pci_8255_pci_probe(struct pci_dev *dev,
b8f4ac23	276	const struct pci_device_id *id)
727b286b	277	{
b8f4ac23	278	return comedi_pci_auto_config(dev, &pci_8255_driver, id->driver_data);
727b286b AT	279	}
727b286b AT	280
f7c22868	281	static DEFINE_PCI_DEVICE_TABLE(pci_8255_pci_table) = {
af48bd8c HS	282	{ PCI_VDEVICE(ADLINK, 0x7224), BOARD_ADLINK_PCI7224 },
	283	{ PCI_VDEVICE(ADLINK, 0x7248), BOARD_ADLINK_PCI7248 },
	284	{ PCI_VDEVICE(ADLINK, 0x7296), BOARD_ADLINK_PCI7296 },
	285	{ PCI_VDEVICE(CB, 0x0028), BOARD_CB_PCIDIO24 },
	286	{ PCI_VDEVICE(CB, 0x0014), BOARD_CB_PCIDIO24H },
	287	{ PCI_VDEVICE(CB, 0x000b), BOARD_CB_PCIDIO48H },
	288	{ PCI_VDEVICE(CB, 0x0017), BOARD_CB_PCIDIO96H },
	289	{ PCI_VDEVICE(NI, 0x0160), BOARD_NI_PCIDIO96 },
	290	{ PCI_VDEVICE(NI, 0x1630), BOARD_NI_PCIDIO96B },
	291	{ PCI_VDEVICE(NI, 0x13c0), BOARD_NI_PXI6508 },
	292	{ PCI_VDEVICE(NI, 0x0400), BOARD_NI_PCI6503 },
	293	{ PCI_VDEVICE(NI, 0x1250), BOARD_NI_PCI6503B },
	294	{ PCI_VDEVICE(NI, 0x17d0), BOARD_NI_PCI6503X },
	295	{ PCI_VDEVICE(NI, 0x1800), BOARD_NI_PXI_6503 },
75e6301b	296	{ 0 }
db0eaeed	297	};
f7c22868	298	MODULE_DEVICE_TABLE(pci, pci_8255_pci_table);
db0eaeed	299
f7c22868 HS	300	static struct pci_driver pci_8255_pci_driver = {
	301	.name = "8255_pci",
	302	.id_table = pci_8255_pci_table,
	303	.probe = pci_8255_pci_probe,
9901a4d7	304	.remove = comedi_pci_auto_unconfig,
727b286b	305	};
f7c22868	306	module_comedi_pci_driver(pci_8255_driver, pci_8255_pci_driver);
90f703d3	307
f7c22868	308	MODULE_DESCRIPTION("COMEDI - Generic PCI based 8255 Digital I/O boards");
90f703d3	309	MODULE_AUTHOR("Comedi http://www.comedi.org");
90f703d3	310	MODULE_LICENSE("GPL");