[deliverable/linux.git] / drivers / staging / comedi / drivers / cb_pcimdas.c

/*
    comedi/drivers/cb_pcimdas.c
    Comedi driver for Computer Boards PCIM-DAS1602/16

    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: cb_pcimdas
Description: Measurement Computing PCI Migration series boards
Devices: [ComputerBoards] PCIM-DAS1602/16 (cb_pcimdas)
Author: Richard Bytheway
Updated: Wed, 13 Nov 2002 12:34:56 +0000
Status: experimental

Written to support the PCIM-DAS1602/16 on a 2.4 series kernel.

Configuration Options:
    [0] - PCI bus number
    [1] - PCI slot number

Developed from cb_pcidas and skel by Richard Bytheway (mocelet@sucs.org).
Only supports DIO, AO and simple AI in it's present form.
No interrupts, multi channel or FIFO AI, although the card looks like it could support this.
See http://www.mccdaq.com/PDFs/Manuals/pcim-das1602-16.pdf for more details.
*/

#include <linux/pci.h>
#include <linux/delay.h>
#include <linux/interrupt.h>

#include "../comedidev.h"

#include "plx9052.h"
#include "8255.h"

/* #define CBPCIMDAS_DEBUG */
#undef CBPCIMDAS_DEBUG

/* Registers for the PCIM-DAS1602/16 */

/* sizes of io regions (bytes) */
#define BADR3_SIZE 16

/* DAC Offsets */
#define ADC_TRIG 0
#define DAC0_OFFSET 2
#define DAC1_OFFSET 4

/* AI and Counter Constants */
#define MUX_LIMITS 0
#define MAIN_CONN_DIO 1
#define ADC_STAT 2
#define ADC_CONV_STAT 3
#define ADC_INT 4
#define ADC_PACER 5
#define BURST_MODE 6
#define PROG_GAIN 7
#define CLK8254_1_DATA 8
#define CLK8254_2_DATA 9
#define CLK8254_3_DATA 10
#define CLK8254_CONTROL 11
#define USER_COUNTER 12
#define RESID_COUNT_H 13
#define RESID_COUNT_L 14

/*
 * this structure is for data unique to this hardware driver.  If
 * several hardware drivers keep similar information in this structure,
 * feel free to suggest moving the variable to the struct comedi_device
 * struct.
 */
struct cb_pcimdas_private {
	/* base addresses */
	unsigned long BADR3;

	/* Used for AO readback */
	unsigned int ao_readback[2];
};

/*
 * "instructions" read/write data in "one-shot" or "software-triggered"
 * mode.
 */
static int cb_pcimdas_ai_rinsn(struct comedi_device *dev,
			       struct comedi_subdevice *s,
			       struct comedi_insn *insn, unsigned int *data)
{
	struct cb_pcimdas_private *devpriv = dev->private;
	int n, i;
	unsigned int d;
	unsigned int busy;
	int chan = CR_CHAN(insn->chanspec);
	unsigned short chanlims;
	int maxchans;

	/*  only support sw initiated reads from a single channel */

	/* check channel number */
	if ((inb(devpriv->BADR3 + 2) & 0x20) == 0)	/* differential mode */
		maxchans = s->n_chan / 2;
	else
		maxchans = s->n_chan;

	if (chan > (maxchans - 1))
		return -ETIMEDOUT;	/* *** Wrong error code. Fixme. */

	/* configure for sw initiated read */
	d = inb(devpriv->BADR3 + 5);
	if ((d & 0x03) > 0) {	/* only reset if needed. */
		d = d & 0xfd;
		outb(d, devpriv->BADR3 + 5);
	}
	outb(0x01, devpriv->BADR3 + 6);	/* set bursting off, conversions on */
	outb(0x00, devpriv->BADR3 + 7);	/* set range to 10V. UP/BP is controlled by a switch on the board */

	/*
	 * write channel limits to multiplexer, set Low (bits 0-3) and
	 * High (bits 4-7) channels to chan.
	 */
	chanlims = chan | (chan << 4);
	outb(chanlims, devpriv->BADR3 + 0);

	/* convert n samples */
	for (n = 0; n < insn->n; n++) {
		/* trigger conversion */
		outw(0, dev->iobase + 0);

#define TIMEOUT 1000		/* typically takes 5 loops on a lightly loaded Pentium 100MHz, */
		/* this is likely to be 100 loops on a 2GHz machine, so set 1000 as the limit. */

		/* wait for conversion to end */
		for (i = 0; i < TIMEOUT; i++) {
			busy = inb(devpriv->BADR3 + 2) & 0x80;
			if (!busy)
				break;
		}
		if (i == TIMEOUT) {
			printk("timeout\n");
			return -ETIMEDOUT;
		}
		/* read data */
		data[n] = inw(dev->iobase + 0);
	}

	/* return the number of samples read/written */
	return n;
}

static int cb_pcimdas_ao_winsn(struct comedi_device *dev,
			       struct comedi_subdevice *s,
			       struct comedi_insn *insn, unsigned int *data)
{
	struct cb_pcimdas_private *devpriv = dev->private;
	int i;
	int chan = CR_CHAN(insn->chanspec);

	/* Writing a list of values to an AO channel is probably not
	 * very useful, but that's how the interface is defined. */
	for (i = 0; i < insn->n; i++) {
		switch (chan) {
		case 0:
			outw(data[i] & 0x0FFF, dev->iobase + DAC0_OFFSET);
			break;
		case 1:
			outw(data[i] & 0x0FFF, dev->iobase + DAC1_OFFSET);
			break;
		default:
			return -1;
		}
		devpriv->ao_readback[chan] = data[i];
	}

	/* return the number of samples read/written */
	return i;
}

/* AO subdevices should have a read insn as well as a write insn.
 * Usually this means copying a value stored in devpriv. */
static int cb_pcimdas_ao_rinsn(struct comedi_device *dev,
			       struct comedi_subdevice *s,
			       struct comedi_insn *insn, unsigned int *data)
{
	struct cb_pcimdas_private *devpriv = dev->private;
	int i;
	int chan = CR_CHAN(insn->chanspec);

	for (i = 0; i < insn->n; i++)
		data[i] = devpriv->ao_readback[chan];

	return i;
}

static int cb_pcimdas_auto_attach(struct comedi_device *dev,
					    unsigned long context_unused)
{
	struct pci_dev *pcidev = comedi_to_pci_dev(dev);
	struct cb_pcimdas_private *devpriv;
	struct comedi_subdevice *s;
	unsigned long iobase_8255;
	int ret;

	dev->board_name = dev->driver->driver_name;

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

	ret = comedi_pci_enable(dev);
	if (ret)
		return ret;

	dev->iobase = pci_resource_start(pcidev, 2);
	devpriv->BADR3 = pci_resource_start(pcidev, 3);
	iobase_8255 = pci_resource_start(pcidev, 4);

/* Dont support IRQ yet */
/*  get irq */
/* if(request_irq(pcidev->irq, cb_pcimdas_interrupt, IRQF_SHARED, "cb_pcimdas", dev )) */
/* { */
/* printk(" unable to allocate irq %u\n", pcidev->irq); */
/* return -EINVAL; */
/* } */
/* dev->irq = pcidev->irq; */

	ret = comedi_alloc_subdevices(dev, 3);
	if (ret)
		return ret;

	s = &dev->subdevices[0];
	/* dev->read_subdev=s; */
	/*  analog input subdevice */
	s->type = COMEDI_SUBD_AI;
	s->subdev_flags = SDF_READABLE | SDF_GROUND;
	s->n_chan = 16;
	s->maxdata = 0xffff;
	s->range_table = &range_unknown;
	s->len_chanlist = 1;	/*  This is the maximum chanlist length that */
	/*  the board can handle */
	s->insn_read = cb_pcimdas_ai_rinsn;

	s = &dev->subdevices[1];
	/*  analog output subdevice */
	s->type = COMEDI_SUBD_AO;
	s->subdev_flags = SDF_WRITABLE;
	s->n_chan = 2;
	s->maxdata = 0xfff;
	/* ranges are hardware settable, but not software readable. */
	s->range_table = &range_unknown;
	s->insn_write = &cb_pcimdas_ao_winsn;
	s->insn_read = &cb_pcimdas_ao_rinsn;

	s = &dev->subdevices[2];
	/* digital i/o subdevice */
	subdev_8255_init(dev, s, NULL, iobase_8255);

	dev_info(dev->class_dev, "%s attached\n", dev->board_name);

	return 0;
}

static void cb_pcimdas_detach(struct comedi_device *dev)
{
	if (dev->irq)
		free_irq(dev->irq, dev);
	comedi_pci_disable(dev);
}

static struct comedi_driver cb_pcimdas_driver = {
	.driver_name	= "cb_pcimdas",
	.module		= THIS_MODULE,
	.auto_attach	= cb_pcimdas_auto_attach,
	.detach		= cb_pcimdas_detach,
};

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

static DEFINE_PCI_DEVICE_TABLE(cb_pcimdas_pci_table) = {
	{ PCI_DEVICE(PCI_VENDOR_ID_CB, 0x0056) },
	{ 0 }
};
MODULE_DEVICE_TABLE(pci, cb_pcimdas_pci_table);

static struct pci_driver cb_pcimdas_pci_driver = {
	.name		= "cb_pcimdas",
	.id_table	= cb_pcimdas_pci_table,
	.probe		= cb_pcimdas_pci_probe,
	.remove		= comedi_pci_auto_unconfig,
};
module_comedi_pci_driver(cb_pcimdas_driver, cb_pcimdas_pci_driver);

MODULE_AUTHOR("Comedi http://www.comedi.org");
MODULE_DESCRIPTION("Comedi low-level driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
f4bd8abb RB	1	/*
	2	comedi/drivers/cb_pcimdas.c
	3	Comedi driver for Computer Boards PCIM-DAS1602/16
	4
	5	COMEDI - Linux Control and Measurement Device Interface
	6	Copyright (C) 2000 David A. Schleef <ds@schleef.org>
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	21
	22	*/
	23	/*
	24	Driver: cb_pcimdas
	25	Description: Measurement Computing PCI Migration series boards
	26	Devices: [ComputerBoards] PCIM-DAS1602/16 (cb_pcimdas)
	27	Author: Richard Bytheway
	28	Updated: Wed, 13 Nov 2002 12:34:56 +0000
	29	Status: experimental
	30
	31	Written to support the PCIM-DAS1602/16 on a 2.4 series kernel.
	32
	33	Configuration Options:
	34	[0] - PCI bus number
	35	[1] - PCI slot number
	36
	37	Developed from cb_pcidas and skel by Richard Bytheway (mocelet@sucs.org).
	38	Only supports DIO, AO and simple AI in it's present form.
	39	No interrupts, multi channel or FIFO AI, although the card looks like it could support this.
631dd1a8	40	See http://www.mccdaq.com/PDFs/Manuals/pcim-das1602-16.pdf for more details.
f4bd8abb RB	41	*/
f4bd8abb RB	42
33782dd5	43	#include <linux/pci.h>
f4bd8abb	44	#include <linux/delay.h>
25436dc9	45	#include <linux/interrupt.h>
f4bd8abb	46
33782dd5 HS	47	#include "../comedidev.h"
33782dd5 HS	48
f4bd8abb RB	49	#include "plx9052.h"
	50	#include "8255.h"
	51
6eef3af5	52	/* #define CBPCIMDAS_DEBUG */
f4bd8abb RB	53	#undef CBPCIMDAS_DEBUG
	54
	55	/* Registers for the PCIM-DAS1602/16 */
	56
6eef3af5	57	/* sizes of io regions (bytes) */
f4bd8abb	58	#define BADR3_SIZE 16
f4bd8abb	59
6eef3af5	60	/* DAC Offsets */
f4bd8abb RB	61	#define ADC_TRIG 0
	62	#define DAC0_OFFSET 2
	63	#define DAC1_OFFSET 4
	64
6eef3af5	65	/* AI and Counter Constants */
f4bd8abb RB	66	#define MUX_LIMITS 0
	67	#define MAIN_CONN_DIO 1
	68	#define ADC_STAT 2
	69	#define ADC_CONV_STAT 3
	70	#define ADC_INT 4
	71	#define ADC_PACER 5
	72	#define BURST_MODE 6
	73	#define PROG_GAIN 7
	74	#define CLK8254_1_DATA 8
	75	#define CLK8254_2_DATA 9
	76	#define CLK8254_3_DATA 10
	77	#define CLK8254_CONTROL 11
	78	#define USER_COUNTER 12
	79	#define RESID_COUNT_H 13
	80	#define RESID_COUNT_L 14
	81
190908ba RKM	82	/*
	83	* this structure is for data unique to this hardware driver. If
	84	* several hardware drivers keep similar information in this structure,
	85	* feel free to suggest moving the variable to the struct comedi_device
	86	* struct.
	87	*/
b90c76fd	88	struct cb_pcimdas_private {
6eef3af5	89	/* base addresses */
f4bd8abb	90	unsigned long BADR3;
f4bd8abb RB	91
f4bd8abb RB	92	/* Used for AO readback */
790c5541	93	unsigned int ao_readback[2];
b90c76fd	94	};
f4bd8abb	95
2682b2dc HS	96	/*
	97	* "instructions" read/write data in "one-shot" or "software-triggered"
	98	* mode.
	99	*/
0a85b6f0 MT	100	static int cb_pcimdas_ai_rinsn(struct comedi_device *dev,
0a85b6f0 MT	101	struct comedi_subdevice *s,
2682b2dc HS	102	struct comedi_insn insn, unsigned int data)
2682b2dc HS	103	{
2682b2dc HS	104	struct cb_pcimdas_private *devpriv = dev->private;
	105	int n, i;
	106	unsigned int d;
	107	unsigned int busy;
	108	int chan = CR_CHAN(insn->chanspec);
	109	unsigned short chanlims;
	110	int maxchans;
	111
	112	/* only support sw initiated reads from a single channel */
	113
	114	/* check channel number */
	115	if ((inb(devpriv->BADR3 + 2) & 0x20) == 0) /* differential mode */
0f904604	116	maxchans = s->n_chan / 2;
2682b2dc	117	else
0f904604	118	maxchans = s->n_chan;
2682b2dc HS	119
	120	if (chan > (maxchans - 1))
	121	return -ETIMEDOUT; /* *** Wrong error code. Fixme. */
	122
	123	/* configure for sw initiated read */
	124	d = inb(devpriv->BADR3 + 5);
	125	if ((d & 0x03) > 0) { /* only reset if needed. */
	126	d = d & 0xfd;
	127	outb(d, devpriv->BADR3 + 5);
	128	}
	129	outb(0x01, devpriv->BADR3 + 6); /* set bursting off, conversions on */
	130	outb(0x00, devpriv->BADR3 + 7); /* set range to 10V. UP/BP is controlled by a switch on the board */
	131
	132	/*
	133	* write channel limits to multiplexer, set Low (bits 0-3) and
	134	* High (bits 4-7) channels to chan.
	135	*/
	136	chanlims = chan \| (chan << 4);
	137	outb(chanlims, devpriv->BADR3 + 0);
	138
	139	/* convert n samples */
	140	for (n = 0; n < insn->n; n++) {
	141	/* trigger conversion */
	142	outw(0, dev->iobase + 0);
	143
	144	#define TIMEOUT 1000 /* typically takes 5 loops on a lightly loaded Pentium 100MHz, */
	145	/* this is likely to be 100 loops on a 2GHz machine, so set 1000 as the limit. */
	146
	147	/* wait for conversion to end */
	148	for (i = 0; i < TIMEOUT; i++) {
	149	busy = inb(devpriv->BADR3 + 2) & 0x80;
	150	if (!busy)
	151	break;
	152	}
	153	if (i == TIMEOUT) {
	154	printk("timeout\n");
	155	return -ETIMEDOUT;
	156	}
	157	/* read data */
0f904604	158	data[n] = inw(dev->iobase + 0);
2682b2dc HS	159	}
	160
	161	/* return the number of samples read/written */
	162	return n;
	163	}
	164
0a85b6f0 MT	165	static int cb_pcimdas_ao_winsn(struct comedi_device *dev,
0a85b6f0 MT	166	struct comedi_subdevice *s,
2682b2dc HS	167	struct comedi_insn insn, unsigned int data)
	168	{
	169	struct cb_pcimdas_private *devpriv = dev->private;
	170	int i;
	171	int chan = CR_CHAN(insn->chanspec);
	172
	173	/* Writing a list of values to an AO channel is probably not
	174	* very useful, but that's how the interface is defined. */
	175	for (i = 0; i < insn->n; i++) {
	176	switch (chan) {
	177	case 0:
	178	outw(data[i] & 0x0FFF, dev->iobase + DAC0_OFFSET);
	179	break;
	180	case 1:
	181	outw(data[i] & 0x0FFF, dev->iobase + DAC1_OFFSET);
	182	break;
	183	default:
	184	return -1;
	185	}
	186	devpriv->ao_readback[chan] = data[i];
	187	}
	188
	189	/* return the number of samples read/written */
	190	return i;
	191	}
	192
	193	/* AO subdevices should have a read insn as well as a write insn.
	194	* Usually this means copying a value stored in devpriv. */
0a85b6f0 MT	195	static int cb_pcimdas_ao_rinsn(struct comedi_device *dev,
0a85b6f0 MT	196	struct comedi_subdevice *s,
2682b2dc HS	197	struct comedi_insn insn, unsigned int data)
	198	{
	199	struct cb_pcimdas_private *devpriv = dev->private;
	200	int i;
	201	int chan = CR_CHAN(insn->chanspec);
	202
	203	for (i = 0; i < insn->n; i++)
	204	data[i] = devpriv->ao_readback[chan];
	205
	206	return i;
	207	}
f4bd8abb	208
a690b7e5	209	static int cb_pcimdas_auto_attach(struct comedi_device *dev,
750af5e5	210	unsigned long context_unused)
46a4ff0d	211	{
750af5e5	212	struct pci_dev *pcidev = comedi_to_pci_dev(dev);
5f7cab0a	213	struct cb_pcimdas_private *devpriv;
46a4ff0d	214	struct comedi_subdevice *s;
8e2f2384	215	unsigned long iobase_8255;
46a4ff0d	216	int ret;
f4bd8abb	217
0f904604	218	dev->board_name = dev->driver->driver_name;
2d069fbe	219
c34fa261 HS	220	devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
	221	if (!devpriv)
	222	return -ENOMEM;
	223	dev->private = devpriv;
46a4ff0d	224
818f569f	225	ret = comedi_pci_enable(dev);
2d069fbe HS	226	if (ret)
2d069fbe HS	227	return ret;
f4bd8abb	228
16dd84f5 HS	229	dev->iobase = pci_resource_start(pcidev, 2);
	230	devpriv->BADR3 = pci_resource_start(pcidev, 3);
	231	iobase_8255 = pci_resource_start(pcidev, 4);
f4bd8abb	232
6eef3af5 BP	233	/* Dont support IRQ yet */
6eef3af5 BP	234	/* get irq */
16dd84f5	235	/* if(request_irq(pcidev->irq, cb_pcimdas_interrupt, IRQF_SHARED, "cb_pcimdas", dev )) */
6eef3af5	236	/* { */
16dd84f5	237	/* printk(" unable to allocate irq %u\n", pcidev->irq); */
6eef3af5 BP	238	/* return -EINVAL; */
6eef3af5 BP	239	/* } */
16dd84f5	240	/* dev->irq = pcidev->irq; */
f4bd8abb	241
8b6c5694 HS	242	ret = comedi_alloc_subdevices(dev, 3);
	243	if (ret)
	244	return ret;
f4bd8abb	245
13201d88	246	s = &dev->subdevices[0];
6eef3af5 BP	247	/* dev->read_subdev=s; */
6eef3af5 BP	248	/* analog input subdevice */
f4bd8abb RB	249	s->type = COMEDI_SUBD_AI;
f4bd8abb RB	250	s->subdev_flags = SDF_READABLE \| SDF_GROUND;
0f904604 HS	251	s->n_chan = 16;
0f904604 HS	252	s->maxdata = 0xffff;
f4bd8abb	253	s->range_table = &range_unknown;
6eef3af5 BP	254	s->len_chanlist = 1; /* This is the maximum chanlist length that */
6eef3af5 BP	255	/* the board can handle */
f4bd8abb RB	256	s->insn_read = cb_pcimdas_ai_rinsn;
f4bd8abb RB	257
13201d88	258	s = &dev->subdevices[1];
6eef3af5	259	/* analog output subdevice */
f4bd8abb RB	260	s->type = COMEDI_SUBD_AO;
f4bd8abb RB	261	s->subdev_flags = SDF_WRITABLE;
0f904604 HS	262	s->n_chan = 2;
0f904604 HS	263	s->maxdata = 0xfff;
190908ba RKM	264	/* ranges are hardware settable, but not software readable. */
190908ba RKM	265	s->range_table = &range_unknown;
f4bd8abb RB	266	s->insn_write = &cb_pcimdas_ao_winsn;
	267	s->insn_read = &cb_pcimdas_ao_rinsn;
	268
13201d88	269	s = &dev->subdevices[2];
f4bd8abb	270	/* digital i/o subdevice */
0f904604	271	subdev_8255_init(dev, s, NULL, iobase_8255);
f4bd8abb	272
2d069fbe HS	273	dev_info(dev->class_dev, "%s attached\n", dev->board_name);
	274
	275	return 0;
f4bd8abb RB	276	}
f4bd8abb RB	277
484ecc95	278	static void cb_pcimdas_detach(struct comedi_device *dev)
f4bd8abb	279	{
f4bd8abb	280	if (dev->irq)
5f74ea14	281	free_irq(dev->irq, dev);
7f072f54	282	comedi_pci_disable(dev);
f4bd8abb RB	283	}
f4bd8abb RB	284
0835145d HS	285	static struct comedi_driver cb_pcimdas_driver = {
	286	.driver_name = "cb_pcimdas",
	287	.module = THIS_MODULE,
750af5e5	288	.auto_attach = cb_pcimdas_auto_attach,
0835145d HS	289	.detach = cb_pcimdas_detach,
	290	};
	291
a690b7e5	292	static int cb_pcimdas_pci_probe(struct pci_dev *dev,
b8f4ac23	293	const struct pci_device_id *id)
727b286b	294	{
b8f4ac23 HS	295	return comedi_pci_auto_config(dev, &cb_pcimdas_driver,
b8f4ac23 HS	296	id->driver_data);
727b286b AT	297	}
727b286b AT	298
0835145d	299	static DEFINE_PCI_DEVICE_TABLE(cb_pcimdas_pci_table) = {
cb3e9d86	300	{ PCI_DEVICE(PCI_VENDOR_ID_CB, 0x0056) },
0835145d	301	{ 0 }
727b286b	302	};
0835145d	303	MODULE_DEVICE_TABLE(pci, cb_pcimdas_pci_table);
727b286b	304
0835145d HS	305	static struct pci_driver cb_pcimdas_pci_driver = {
	306	.name = "cb_pcimdas",
	307	.id_table = cb_pcimdas_pci_table,
	308	.probe = cb_pcimdas_pci_probe,
9901a4d7	309	.remove = comedi_pci_auto_unconfig,
0835145d HS	310	};
0835145d HS	311	module_comedi_pci_driver(cb_pcimdas_driver, cb_pcimdas_pci_driver);
90f703d3 AT	312
	313	MODULE_AUTHOR("Comedi http://www.comedi.org");
	314	MODULE_DESCRIPTION("Comedi low-level driver");
	315	MODULE_LICENSE("GPL");