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

/*
    comedi/drivers/ni_labpc_cs.c
    Driver for National Instruments daqcard-1200 boards
    Copyright (C) 2001, 2002, 2003 Frank Mori Hess <fmhess@users.sourceforge.net>

    PCMCIA crap is adapted from dummy_cs.c 1.31 2001/08/24 12:13:13
    from the pcmcia package.
    The initial developer of the pcmcia dummy_cs.c code is David A. Hinds
    <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
    are Copyright (C) 1999 David A. Hinds.

    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: ni_labpc_cs
Description: National Instruments Lab-PC (& compatibles)
Author: Frank Mori Hess <fmhess@users.sourceforge.net>
Devices: [National Instruments] DAQCard-1200 (daqcard-1200)
Status: works

Thanks go to Fredrik Lingvall for much testing and perseverance in
helping to debug daqcard-1200 support.

The 1200 series boards have onboard calibration dacs for correcting
analog input/output offsets and gains.  The proper settings for these
caldacs are stored on the board's eeprom.  To read the caldac values
from the eeprom and store them into a file that can be then be used by
comedilib, use the comedi_calibrate program.

Configuration options:
  none

The daqcard-1200 has quirky chanlist requirements
when scanning multiple channels.  Multiple channel scan
sequence must start at highest channel, then decrement down to
channel 0.  Chanlists consisting of all one channel
are also legal, and allow you to pace conversions in bursts.

*/

/*

NI manuals:
340988a (daqcard-1200)

*/

#undef LABPC_DEBUG  /* debugging messages */

#include "../comedidev.h"

#include <linux/delay.h>
#include <linux/slab.h>

#include "8253.h"
#include "8255.h"
#include "comedi_fc.h"
#include "ni_labpc.h"

#include <pcmcia/cistpl.h>
#include <pcmcia/cisreg.h>
#include <pcmcia/ds.h>

static struct pcmcia_device *pcmcia_cur_dev;

static int labpc_attach(struct comedi_device *dev, struct comedi_devconfig *it);

static const struct labpc_board_struct labpc_cs_boards[] = {
	{
	 .name = "daqcard-1200",
	 .device_id = 0x103,	/* 0x10b is manufacturer id,
				   0x103 is device id */
	 .ai_speed = 10000,
	 .bustype = pcmcia_bustype,
	 .register_layout = labpc_1200_layout,
	 .has_ao = 1,
	 .ai_range_table = &range_labpc_1200_ai,
	 .ai_range_code = labpc_1200_ai_gain_bits,
	 .ai_range_is_unipolar = labpc_1200_is_unipolar,
	 .ai_scan_up = 0,
	 .memory_mapped_io = 0,
	 },
	/* duplicate entry, to support using alternate name */
	{
	 .name = "ni_labpc_cs",
	 .device_id = 0x103,
	 .ai_speed = 10000,
	 .bustype = pcmcia_bustype,
	 .register_layout = labpc_1200_layout,
	 .has_ao = 1,
	 .ai_range_table = &range_labpc_1200_ai,
	 .ai_range_code = labpc_1200_ai_gain_bits,
	 .ai_range_is_unipolar = labpc_1200_is_unipolar,
	 .ai_scan_up = 0,
	 .memory_mapped_io = 0,
	 },
};

/*
 * Useful for shorthand access to the particular board structure
 */
#define thisboard ((const struct labpc_board_struct *)dev->board_ptr)

static struct comedi_driver driver_labpc_cs = {
	.driver_name = "ni_labpc_cs",
	.module = THIS_MODULE,
	.attach = &labpc_attach,
	.detach = &labpc_common_detach,
	.num_names = ARRAY_SIZE(labpc_cs_boards),
	.board_name = &labpc_cs_boards[0].name,
	.offset = sizeof(struct labpc_board_struct),
};

static int labpc_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
	unsigned long iobase = 0;
	unsigned int irq = 0;
	struct pcmcia_device *link;

	/* allocate and initialize dev->private */
	if (alloc_private(dev, sizeof(struct labpc_private)) < 0)
		return -ENOMEM;

	/*  get base address, irq etc. based on bustype */
	switch (thisboard->bustype) {
	case pcmcia_bustype:
		link = pcmcia_cur_dev;	/* XXX hack */
		if (!link)
			return -EIO;
		iobase = link->resource[0]->start;
		irq = link->irq;
		break;
	default:
		printk("bug! couldn't determine board type\n");
		return -EINVAL;
		break;
	}
	return labpc_common_attach(dev, iobase, irq, 0);
}

/*====================================================================*/

/*
   The event() function is this driver's Card Services event handler.
   It will be called by Card Services when an appropriate card status
   event is received.  The config() and release() entry points are
   used to configure or release a socket, in response to card
   insertion and ejection events.  They are invoked from the dummy
   event handler.

   Kernel version 2.6.16 upwards uses suspend() and resume() functions
   instead of an event() function.
*/

static void labpc_config(struct pcmcia_device *link);
static void labpc_release(struct pcmcia_device *link);
static int labpc_cs_suspend(struct pcmcia_device *p_dev);
static int labpc_cs_resume(struct pcmcia_device *p_dev);

/*
   The attach() and detach() entry points are used to create and destroy
   "instances" of the driver, where each instance represents everything
   needed to manage one actual PCMCIA card.
*/

static int labpc_cs_attach(struct pcmcia_device *);
static void labpc_cs_detach(struct pcmcia_device *);

/*
   You'll also need to prototype all the functions that will actually
   be used to talk to your device.  See 'memory_cs' for a good example
   of a fully self-sufficient driver; the other drivers rely more or
   less on other parts of the kernel.
*/

struct local_info_t {
	struct pcmcia_device *link;
	int stop;
	struct bus_operations *bus;
};

/*======================================================================

    labpc_cs_attach() creates an "instance" of the driver, allocating
    local data structures for one device.  The device is registered
    with Card Services.

    The dev_link structure is initialized, but we don't actually
    configure the card at this point -- we wait until we receive a
    card insertion event.

======================================================================*/

static int labpc_cs_attach(struct pcmcia_device *link)
{
	struct local_info_t *local;

	dev_dbg(&link->dev, "labpc_cs_attach()\n");

	/* Allocate space for private device-specific data */
	local = kzalloc(sizeof(struct local_info_t), GFP_KERNEL);
	if (!local)
		return -ENOMEM;
	local->link = link;
	link->priv = local;

	pcmcia_cur_dev = link;

	labpc_config(link);

	return 0;
}				/* labpc_cs_attach */

/*======================================================================

    This deletes a driver "instance".  The device is de-registered
    with Card Services.  If it has been released, all local data
    structures are freed.  Otherwise, the structures will be freed
    when the device is released.

======================================================================*/

static void labpc_cs_detach(struct pcmcia_device *link)
{
	dev_dbg(&link->dev, "labpc_cs_detach\n");

	/*
	   If the device is currently configured and active, we won't
	   actually delete it yet.  Instead, it is marked so that when
	   the release() function is called, that will trigger a proper
	   detach().
	 */
	((struct local_info_t *)link->priv)->stop = 1;
	labpc_release(link);

	/* This points to the parent local_info_t struct (may be null) */
	kfree(link->priv);

}				/* labpc_cs_detach */

/*======================================================================

    labpc_config() is scheduled to run after a CARD_INSERTION event
    is received, to configure the PCMCIA socket, and to make the
    device available to the system.

======================================================================*/

static int labpc_pcmcia_config_loop(struct pcmcia_device *p_dev,
				void *priv_data)
{
	if (p_dev->config_index == 0)
		return -EINVAL;

	return pcmcia_request_io(p_dev);
}


static void labpc_config(struct pcmcia_device *link)
{
	int ret;

	dev_dbg(&link->dev, "labpc_config\n");

	link->config_flags |= CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ |
		CONF_AUTO_AUDIO | CONF_AUTO_SET_IO;

	ret = pcmcia_loop_config(link, labpc_pcmcia_config_loop, NULL);
	if (ret) {
		dev_warn(&link->dev, "no configuration found\n");
		goto failed;
	}

	if (!link->irq)
		goto failed;

	/*
	   This actually configures the PCMCIA socket -- setting up
	   the I/O windows and the interrupt mapping, and putting the
	   card and host interface into "Memory and IO" mode.
	 */
	ret = pcmcia_enable_device(link);
	if (ret)
		goto failed;

	return;

failed:
	labpc_release(link);

}				/* labpc_config */

static void labpc_release(struct pcmcia_device *link)
{
	dev_dbg(&link->dev, "labpc_release\n");

	pcmcia_disable_device(link);
}				/* labpc_release */

/*======================================================================

    The card status event handler.  Mostly, this schedules other
    stuff to run after an event is received.

    When a CARD_REMOVAL event is received, we immediately set a
    private flag to block future accesses to this device.  All the
    functions that actually access the device should check this flag
    to make sure the card is still present.

======================================================================*/

static int labpc_cs_suspend(struct pcmcia_device *link)
{
	struct local_info_t *local = link->priv;

	/* Mark the device as stopped, to block IO until later */
	local->stop = 1;
	return 0;
}				/* labpc_cs_suspend */

static int labpc_cs_resume(struct pcmcia_device *link)
{
	struct local_info_t *local = link->priv;

	local->stop = 0;
	return 0;
}				/* labpc_cs_resume */

/*====================================================================*/

static struct pcmcia_device_id labpc_cs_ids[] = {
	/* N.B. These IDs should match those in labpc_cs_boards (ni_labpc.c) */
	PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0103),	/* daqcard-1200 */
	PCMCIA_DEVICE_NULL
};

MODULE_DEVICE_TABLE(pcmcia, labpc_cs_ids);
MODULE_AUTHOR("Frank Mori Hess <fmhess@users.sourceforge.net>");
MODULE_DESCRIPTION("Comedi driver for National Instruments Lab-PC");
MODULE_LICENSE("GPL");

struct pcmcia_driver labpc_cs_driver = {
	.probe = labpc_cs_attach,
	.remove = labpc_cs_detach,
	.suspend = labpc_cs_suspend,
	.resume = labpc_cs_resume,
	.id_table = labpc_cs_ids,
	.owner = THIS_MODULE,
	.name = "daqcard-1200",
};

static int __init init_labpc_cs(void)
{
	pcmcia_register_driver(&labpc_cs_driver);
	return 0;
}

static void __exit exit_labpc_cs(void)
{
	pcmcia_unregister_driver(&labpc_cs_driver);
}

int __init labpc_init_module(void)
{
	int ret;

	ret = init_labpc_cs();
	if (ret < 0)
		return ret;

	return comedi_driver_register(&driver_labpc_cs);
}

void __exit labpc_exit_module(void)
{
	exit_labpc_cs();
	comedi_driver_unregister(&driver_labpc_cs);
}

module_init(labpc_init_module);
module_exit(labpc_exit_module);
Commit	Line	Data
124b13b2 FMH	1	/*
	2	comedi/drivers/ni_labpc_cs.c
	3	Driver for National Instruments daqcard-1200 boards
	4	Copyright (C) 2001, 2002, 2003 Frank Mori Hess <fmhess@users.sourceforge.net>
	5
	6	PCMCIA crap is adapted from dummy_cs.c 1.31 2001/08/24 12:13:13
	7	from the pcmcia package.
	8	The initial developer of the pcmcia dummy_cs.c code is David A. Hinds
	9	<dahinds@users.sourceforge.net>. Portions created by David A. Hinds
	10	are Copyright (C) 1999 David A. Hinds.
	11
	12	This program is free software; you can redistribute it and/or modify
	13	it under the terms of the GNU General Public License as published by
	14	the Free Software Foundation; either version 2 of the License, or
	15	(at your option) any later version.
	16
	17	This program is distributed in the hope that it will be useful,
	18	but WITHOUT ANY WARRANTY; without even the implied warranty of
	19	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	20	GNU General Public License for more details.
	21
	22	You should have received a copy of the GNU General Public License
	23	along with this program; if not, write to the Free Software
	24	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	25
	26	************************************************************************
	27	*/
	28	/*
	29	Driver: ni_labpc_cs
	30	Description: National Instruments Lab-PC (& compatibles)
	31	Author: Frank Mori Hess <fmhess@users.sourceforge.net>
	32	Devices: [National Instruments] DAQCard-1200 (daqcard-1200)
	33	Status: works
	34
	35	Thanks go to Fredrik Lingvall for much testing and perseverance in
	36	helping to debug daqcard-1200 support.
	37
	38	The 1200 series boards have onboard calibration dacs for correcting
	39	analog input/output offsets and gains. The proper settings for these
	40	caldacs are stored on the board's eeprom. To read the caldac values
	41	from the eeprom and store them into a file that can be then be used by
	42	comedilib, use the comedi_calibrate program.
	43
	44	Configuration options:
	45	none
	46
	47	The daqcard-1200 has quirky chanlist requirements
	48	when scanning multiple channels. Multiple channel scan
	49	sequence must start at highest channel, then decrement down to
	50	channel 0. Chanlists consisting of all one channel
	51	are also legal, and allow you to pace conversions in bursts.
	52
	53	*/
	54
	55	/*
	56
	57	NI manuals:
	58	340988a (daqcard-1200)
	59
	60	*/
	61
b79eb4c1	62	#undef LABPC_DEBUG /* debugging messages */
124b13b2 FMH	63
	64	#include "../comedidev.h"
	65
	66	#include <linux/delay.h>
5a0e3ad6	67	#include <linux/slab.h>
124b13b2 FMH	68
	69	#include "8253.h"
	70	#include "8255.h"
	71	#include "comedi_fc.h"
	72	#include "ni_labpc.h"
	73
124b13b2 FMH	74	#include <pcmcia/cistpl.h>
	75	#include <pcmcia/cisreg.h>
	76	#include <pcmcia/ds.h>
	77
96233181	78	static struct pcmcia_device *pcmcia_cur_dev;
124b13b2	79
da91b269	80	static int labpc_attach(struct comedi_device dev, struct comedi_devconfig it);
124b13b2	81
9ad00740	82	static const struct labpc_board_struct labpc_cs_boards[] = {
124b13b2	83	{
0a85b6f0	84	.name = "daqcard-1200",
63a4eca5 BM	85	.device_id = 0x103, /* 0x10b is manufacturer id,
63a4eca5 BM	86	0x103 is device id */
0a85b6f0 MT	87	.ai_speed = 10000,
	88	.bustype = pcmcia_bustype,
	89	.register_layout = labpc_1200_layout,
	90	.has_ao = 1,
	91	.ai_range_table = &range_labpc_1200_ai,
	92	.ai_range_code = labpc_1200_ai_gain_bits,
	93	.ai_range_is_unipolar = labpc_1200_is_unipolar,
	94	.ai_scan_up = 0,
	95	.memory_mapped_io = 0,
	96	},
124b13b2 FMH	97	/* duplicate entry, to support using alternate name */
124b13b2 FMH	98	{
0a85b6f0 MT	99	.name = "ni_labpc_cs",
	100	.device_id = 0x103,
	101	.ai_speed = 10000,
	102	.bustype = pcmcia_bustype,
	103	.register_layout = labpc_1200_layout,
	104	.has_ao = 1,
	105	.ai_range_table = &range_labpc_1200_ai,
	106	.ai_range_code = labpc_1200_ai_gain_bits,
	107	.ai_range_is_unipolar = labpc_1200_is_unipolar,
	108	.ai_scan_up = 0,
	109	.memory_mapped_io = 0,
	110	},
124b13b2 FMH	111	};
	112
	113	/*
	114	* Useful for shorthand access to the particular board structure
	115	*/
9ad00740	116	#define thisboard ((const struct labpc_board_struct *)dev->board_ptr)
124b13b2	117
139dfbdf	118	static struct comedi_driver driver_labpc_cs = {
124b13b2 FMH	119	.driver_name = "ni_labpc_cs",
	120	.module = THIS_MODULE,
	121	.attach = &labpc_attach,
	122	.detach = &labpc_common_detach,
8629efa4	123	.num_names = ARRAY_SIZE(labpc_cs_boards),
124b13b2	124	.board_name = &labpc_cs_boards[0].name,
9ad00740	125	.offset = sizeof(struct labpc_board_struct),
124b13b2 FMH	126	};
124b13b2 FMH	127
da91b269	128	static int labpc_attach(struct comedi_device dev, struct comedi_devconfig it)
124b13b2 FMH	129	{
	130	unsigned long iobase = 0;
	131	unsigned int irq = 0;
	132	struct pcmcia_device *link;
	133
	134	/* allocate and initialize dev->private */
0a4eb4b6	135	if (alloc_private(dev, sizeof(struct labpc_private)) < 0)
124b13b2 FMH	136	return -ENOMEM;
124b13b2 FMH	137
2696fb57	138	/* get base address, irq etc. based on bustype */
124b13b2 FMH	139	switch (thisboard->bustype) {
	140	case pcmcia_bustype:
	141	link = pcmcia_cur_dev; /* XXX hack */
	142	if (!link)
	143	return -EIO;
9a017a91	144	iobase = link->resource[0]->start;
eb14120f	145	irq = link->irq;
124b13b2 FMH	146	break;
	147	default:
	148	printk("bug! couldn't determine board type\n");
	149	return -EINVAL;
	150	break;
	151	}
	152	return labpc_common_attach(dev, iobase, irq, 0);
	153	}
	154
124b13b2 FMH	155	/====================================================================/
	156
	157	/*
	158	The event() function is this driver's Card Services event handler.
	159	It will be called by Card Services when an appropriate card status
	160	event is received. The config() and release() entry points are
	161	used to configure or release a socket, in response to card
	162	insertion and ejection events. They are invoked from the dummy
	163	event handler.
	164
	165	Kernel version 2.6.16 upwards uses suspend() and resume() functions
	166	instead of an event() function.
	167	*/
	168
	169	static void labpc_config(struct pcmcia_device *link);
	170	static void labpc_release(struct pcmcia_device *link);
	171	static int labpc_cs_suspend(struct pcmcia_device *p_dev);
	172	static int labpc_cs_resume(struct pcmcia_device *p_dev);
	173
	174	/*
	175	The attach() and detach() entry points are used to create and destroy
	176	"instances" of the driver, where each instance represents everything
	177	needed to manage one actual PCMCIA card.
	178	*/
	179
	180	static int labpc_cs_attach(struct pcmcia_device *);
	181	static void labpc_cs_detach(struct pcmcia_device *);
	182
	183	/*
	184	You'll also need to prototype all the functions that will actually
	185	be used to talk to your device. See 'memory_cs' for a good example
	186	of a fully self-sufficient driver; the other drivers rely more or
	187	less on other parts of the kernel.
	188	*/
	189
e3f9f2c8	190	struct local_info_t {
124b13b2	191	struct pcmcia_device *link;
124b13b2 FMH	192	int stop;
124b13b2 FMH	193	struct bus_operations *bus;
e3f9f2c8	194	};
124b13b2 FMH	195
	196	/*======================================================================
	197
	198	labpc_cs_attach() creates an "instance" of the driver, allocating
	199	local data structures for one device. The device is registered
	200	with Card Services.
	201
	202	The dev_link structure is initialized, but we don't actually
	203	configure the card at this point -- we wait until we receive a
	204	card insertion event.
	205
	206	======================================================================*/
	207
	208	static int labpc_cs_attach(struct pcmcia_device *link)
	209	{
e3f9f2c8	210	struct local_info_t *local;
124b13b2	211
55a19b39	212	dev_dbg(&link->dev, "labpc_cs_attach()\n");
124b13b2 FMH	213
124b13b2 FMH	214	/* Allocate space for private device-specific data */
e3f9f2c8	215	local = kzalloc(sizeof(struct local_info_t), GFP_KERNEL);
124b13b2 FMH	216	if (!local)
	217	return -ENOMEM;
	218	local->link = link;
	219	link->priv = local;
	220
124b13b2 FMH	221	pcmcia_cur_dev = link;
	222
	223	labpc_config(link);
	224
	225	return 0;
	226	} /* labpc_cs_attach */
	227
	228	/*======================================================================
	229
	230	This deletes a driver "instance". The device is de-registered
	231	with Card Services. If it has been released, all local data
	232	structures are freed. Otherwise, the structures will be freed
	233	when the device is released.
	234
	235	======================================================================*/
	236
	237	static void labpc_cs_detach(struct pcmcia_device *link)
	238	{
55a19b39	239	dev_dbg(&link->dev, "labpc_cs_detach\n");
124b13b2 FMH	240
	241	/*
	242	If the device is currently configured and active, we won't
	243	actually delete it yet. Instead, it is marked so that when
	244	the release() function is called, that will trigger a proper
	245	detach().
	246	*/
99bd8f22 JMC	247	((struct local_info_t *)link->priv)->stop = 1;
99bd8f22 JMC	248	labpc_release(link);
124b13b2	249
92c4bad7 BM	250	/* This points to the parent local_info_t struct (may be null) */
92c4bad7 BM	251	kfree(link->priv);
124b13b2 FMH	252
	253	} /* labpc_cs_detach */
	254
	255	/*======================================================================
	256
	257	labpc_config() is scheduled to run after a CARD_INSERTION event
	258	is received, to configure the PCMCIA socket, and to make the
	259	device available to the system.
	260
	261	======================================================================*/
	262
55a19b39	263	static int labpc_pcmcia_config_loop(struct pcmcia_device *p_dev,
55a19b39	264	void *priv_data)
124b13b2	265	{
00990e7c DB	266	if (p_dev->config_index == 0)
00990e7c DB	267	return -EINVAL;
c3744138	268
00990e7c	269	return pcmcia_request_io(p_dev);
55a19b39	270	}
124b13b2	271
124b13b2	272
55a19b39 DB	273	static void labpc_config(struct pcmcia_device *link)
55a19b39 DB	274	{
55a19b39	275	int ret;
124b13b2	276
55a19b39	277	dev_dbg(&link->dev, "labpc_config\n");
124b13b2	278
440eed43	279	link->config_flags \|= CONF_ENABLE_IRQ \| CONF_ENABLE_PULSE_IRQ \|
00990e7c	280	CONF_AUTO_AUDIO \| CONF_AUTO_SET_IO;
440eed43	281
0f52e86d	282	ret = pcmcia_loop_config(link, labpc_pcmcia_config_loop, NULL);
55a19b39 DB	283	if (ret) {
	284	dev_warn(&link->dev, "no configuration found\n");
	285	goto failed;
124b13b2 FMH	286	}
124b13b2 FMH	287
eb14120f DB	288	if (!link->irq)
eb14120f DB	289	goto failed;
124b13b2 FMH	290
	291	/*
	292	This actually configures the PCMCIA socket -- setting up
	293	the I/O windows and the interrupt mapping, and putting the
	294	card and host interface into "Memory and IO" mode.
	295	*/
1ac71e5a	296	ret = pcmcia_enable_device(link);
55a19b39 DB	297	if (ret)
55a19b39 DB	298	goto failed;
124b13b2	299
124b13b2 FMH	300	return;
124b13b2 FMH	301
55a19b39	302	failed:
124b13b2 FMH	303	labpc_release(link);
	304
	305	} /* labpc_config */
	306
	307	static void labpc_release(struct pcmcia_device *link)
	308	{
55a19b39	309	dev_dbg(&link->dev, "labpc_release\n");
124b13b2 FMH	310
	311	pcmcia_disable_device(link);
	312	} /* labpc_release */
	313
	314	/*======================================================================
	315
	316	The card status event handler. Mostly, this schedules other
	317	stuff to run after an event is received.
	318
	319	When a CARD_REMOVAL event is received, we immediately set a
	320	private flag to block future accesses to this device. All the
	321	functions that actually access the device should check this flag
	322	to make sure the card is still present.
	323
	324	======================================================================*/
	325
	326	static int labpc_cs_suspend(struct pcmcia_device *link)
	327	{
e3f9f2c8	328	struct local_info_t *local = link->priv;
124b13b2 FMH	329
	330	/* Mark the device as stopped, to block IO until later */
	331	local->stop = 1;
	332	return 0;
	333	} /* labpc_cs_suspend */
	334
	335	static int labpc_cs_resume(struct pcmcia_device *link)
	336	{
e3f9f2c8	337	struct local_info_t *local = link->priv;
124b13b2 FMH	338
	339	local->stop = 0;
	340	return 0;
	341	} /* labpc_cs_resume */
	342
	343	/====================================================================/
	344
	345	static struct pcmcia_device_id labpc_cs_ids[] = {
	346	/* N.B. These IDs should match those in labpc_cs_boards (ni_labpc.c) */
	347	PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0103), /* daqcard-1200 */
	348	PCMCIA_DEVICE_NULL
	349	};
	350
	351	MODULE_DEVICE_TABLE(pcmcia, labpc_cs_ids);
6c7f8196 AK	352	MODULE_AUTHOR("Frank Mori Hess <fmhess@users.sourceforge.net>");
	353	MODULE_DESCRIPTION("Comedi driver for National Instruments Lab-PC");
	354	MODULE_LICENSE("GPL");
124b13b2 FMH	355
	356	struct pcmcia_driver labpc_cs_driver = {
	357	.probe = labpc_cs_attach,
	358	.remove = labpc_cs_detach,
	359	.suspend = labpc_cs_suspend,
	360	.resume = labpc_cs_resume,
	361	.id_table = labpc_cs_ids,
	362	.owner = THIS_MODULE,
2e9b981a	363	.name = "daqcard-1200",
124b13b2 FMH	364	};
	365
	366	static int __init init_labpc_cs(void)
	367	{
124b13b2 FMH	368	pcmcia_register_driver(&labpc_cs_driver);
	369	return 0;
	370	}
	371
	372	static void __exit exit_labpc_cs(void)
	373	{
124b13b2 FMH	374	pcmcia_unregister_driver(&labpc_cs_driver);
	375	}
	376
	377	int __init labpc_init_module(void)
	378	{
	379	int ret;
	380
	381	ret = init_labpc_cs();
	382	if (ret < 0)
	383	return ret;
	384
	385	return comedi_driver_register(&driver_labpc_cs);
	386	}
	387
	388	void __exit labpc_exit_module(void)
	389	{
	390	exit_labpc_cs();
	391	comedi_driver_unregister(&driver_labpc_cs);
	392	}
	393
124b13b2 FMH	394	module_init(labpc_init_module);
124b13b2 FMH	395	module_exit(labpc_exit_module);