[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/cs.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;

	/*
	   General socket configuration defaults can go here.  In this
	   client, we assume very little, and rely on the CIS for almost
	   everything.  In most clients, many details (i.e., number, sizes,
	   and attributes of IO windows) are fixed by the nature of the
	   device, and can be hard-wired here.
	 */
	link->conf.Attributes = 0;

	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,
				cistpl_cftable_entry_t *cfg,
				cistpl_cftable_entry_t *dflt,
				unsigned int vcc,
				void *priv_data)
{
	if (cfg->index == 0)
		return -ENODEV;

	/* Does this card need audio output? */
	if (cfg->flags & CISTPL_CFTABLE_AUDIO)
		p_dev->conf.Attributes |= CONF_ENABLE_SPKR;

	/* Do we need to allocate an interrupt? */
	p_dev->conf.Attributes |= CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ;

	/* IO window settings */
	p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
	if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
		cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
		p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
		p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
		p_dev->resource[0]->flags |=
			pcmcia_io_cfg_data_width(io->flags);
		p_dev->resource[0]->start = io->win[0].base;
		p_dev->resource[0]->end = io->win[0].len;
		if (io->nwin > 1) {
			p_dev->resource[1]->flags = p_dev->resource[0]->flags;
			p_dev->resource[1]->start = io->win[1].base;
			p_dev->resource[1]->end = io->win[1].len;
		}
		/* This reserves IO space but doesn't actually enable it */
		if (pcmcia_request_io(p_dev) != 0)
			return -ENODEV;
	}

	/* If we got this far, we're cool! */
	return 0;
}


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

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

	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_request_configuration(link, &link->conf);
	if (ret)
		goto failed;

	/* Finally, report what we've done */
	dev_info(&link->dev, "index 0x%02x", link->conf.ConfigIndex);
	if (link->conf.Attributes & CONF_ENABLE_IRQ)
		printk(", irq %d", link->irq);
	if (link->resource[0])
		printk(" & %pR", link->resource[0]);
	if (link->resource[1])
		printk(" & %pR", link->resource[1]);
	printk("\n");

	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,
	.drv = {
		.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/cs.h>
	75	#include <pcmcia/cistpl.h>
	76	#include <pcmcia/cisreg.h>
	77	#include <pcmcia/ds.h>
	78
96233181	79	static struct pcmcia_device *pcmcia_cur_dev;
124b13b2	80
da91b269	81	static int labpc_attach(struct comedi_device dev, struct comedi_devconfig it);
124b13b2	82
9ad00740	83	static const struct labpc_board_struct labpc_cs_boards[] = {
124b13b2	84	{
0a85b6f0	85	.name = "daqcard-1200",
63a4eca5 BM	86	.device_id = 0x103, /* 0x10b is manufacturer id,
63a4eca5 BM	87	0x103 is device id */
0a85b6f0 MT	88	.ai_speed = 10000,
	89	.bustype = pcmcia_bustype,
	90	.register_layout = labpc_1200_layout,
	91	.has_ao = 1,
	92	.ai_range_table = &range_labpc_1200_ai,
	93	.ai_range_code = labpc_1200_ai_gain_bits,
	94	.ai_range_is_unipolar = labpc_1200_is_unipolar,
	95	.ai_scan_up = 0,
	96	.memory_mapped_io = 0,
	97	},
124b13b2 FMH	98	/* duplicate entry, to support using alternate name */
124b13b2 FMH	99	{
0a85b6f0 MT	100	.name = "ni_labpc_cs",
	101	.device_id = 0x103,
	102	.ai_speed = 10000,
	103	.bustype = pcmcia_bustype,
	104	.register_layout = labpc_1200_layout,
	105	.has_ao = 1,
	106	.ai_range_table = &range_labpc_1200_ai,
	107	.ai_range_code = labpc_1200_ai_gain_bits,
	108	.ai_range_is_unipolar = labpc_1200_is_unipolar,
	109	.ai_scan_up = 0,
	110	.memory_mapped_io = 0,
	111	},
124b13b2 FMH	112	};
	113
	114	/*
	115	* Useful for shorthand access to the particular board structure
	116	*/
9ad00740	117	#define thisboard ((const struct labpc_board_struct *)dev->board_ptr)
124b13b2	118
139dfbdf	119	static struct comedi_driver driver_labpc_cs = {
124b13b2 FMH	120	.driver_name = "ni_labpc_cs",
	121	.module = THIS_MODULE,
	122	.attach = &labpc_attach,
	123	.detach = &labpc_common_detach,
8629efa4	124	.num_names = ARRAY_SIZE(labpc_cs_boards),
124b13b2	125	.board_name = &labpc_cs_boards[0].name,
9ad00740	126	.offset = sizeof(struct labpc_board_struct),
124b13b2 FMH	127	};
124b13b2 FMH	128
da91b269	129	static int labpc_attach(struct comedi_device dev, struct comedi_devconfig it)
124b13b2 FMH	130	{
	131	unsigned long iobase = 0;
	132	unsigned int irq = 0;
	133	struct pcmcia_device *link;
	134
	135	/* allocate and initialize dev->private */
0a4eb4b6	136	if (alloc_private(dev, sizeof(struct labpc_private)) < 0)
124b13b2 FMH	137	return -ENOMEM;
124b13b2 FMH	138
2696fb57	139	/* get base address, irq etc. based on bustype */
124b13b2 FMH	140	switch (thisboard->bustype) {
	141	case pcmcia_bustype:
	142	link = pcmcia_cur_dev; /* XXX hack */
	143	if (!link)
	144	return -EIO;
9a017a91	145	iobase = link->resource[0]->start;
eb14120f	146	irq = link->irq;
124b13b2 FMH	147	break;
	148	default:
	149	printk("bug! couldn't determine board type\n");
	150	return -EINVAL;
	151	break;
	152	}
	153	return labpc_common_attach(dev, iobase, irq, 0);
	154	}
	155
124b13b2 FMH	156	/====================================================================/
	157
	158	/*
	159	The event() function is this driver's Card Services event handler.
	160	It will be called by Card Services when an appropriate card status
	161	event is received. The config() and release() entry points are
	162	used to configure or release a socket, in response to card
	163	insertion and ejection events. They are invoked from the dummy
	164	event handler.
	165
	166	Kernel version 2.6.16 upwards uses suspend() and resume() functions
	167	instead of an event() function.
	168	*/
	169
	170	static void labpc_config(struct pcmcia_device *link);
	171	static void labpc_release(struct pcmcia_device *link);
	172	static int labpc_cs_suspend(struct pcmcia_device *p_dev);
	173	static int labpc_cs_resume(struct pcmcia_device *p_dev);
	174
	175	/*
	176	The attach() and detach() entry points are used to create and destroy
	177	"instances" of the driver, where each instance represents everything
	178	needed to manage one actual PCMCIA card.
	179	*/
	180
	181	static int labpc_cs_attach(struct pcmcia_device *);
	182	static void labpc_cs_detach(struct pcmcia_device *);
	183
	184	/*
	185	You'll also need to prototype all the functions that will actually
	186	be used to talk to your device. See 'memory_cs' for a good example
	187	of a fully self-sufficient driver; the other drivers rely more or
	188	less on other parts of the kernel.
	189	*/
	190
e3f9f2c8	191	struct local_info_t {
124b13b2	192	struct pcmcia_device *link;
124b13b2 FMH	193	int stop;
124b13b2 FMH	194	struct bus_operations *bus;
e3f9f2c8	195	};
124b13b2 FMH	196
	197	/*======================================================================
	198
	199	labpc_cs_attach() creates an "instance" of the driver, allocating
	200	local data structures for one device. The device is registered
	201	with Card Services.
	202
	203	The dev_link structure is initialized, but we don't actually
	204	configure the card at this point -- we wait until we receive a
	205	card insertion event.
	206
	207	======================================================================*/
	208
	209	static int labpc_cs_attach(struct pcmcia_device *link)
	210	{
e3f9f2c8	211	struct local_info_t *local;
124b13b2	212
55a19b39	213	dev_dbg(&link->dev, "labpc_cs_attach()\n");
124b13b2 FMH	214
124b13b2 FMH	215	/* Allocate space for private device-specific data */
e3f9f2c8	216	local = kzalloc(sizeof(struct local_info_t), GFP_KERNEL);
124b13b2 FMH	217	if (!local)
	218	return -ENOMEM;
	219	local->link = link;
	220	link->priv = local;
	221
124b13b2 FMH	222	/*
	223	General socket configuration defaults can go here. In this
	224	client, we assume very little, and rely on the CIS for almost
	225	everything. In most clients, many details (i.e., number, sizes,
	226	and attributes of IO windows) are fixed by the nature of the
	227	device, and can be hard-wired here.
	228	*/
	229	link->conf.Attributes = 0;
124b13b2 FMH	230
	231	pcmcia_cur_dev = link;
	232
	233	labpc_config(link);
	234
	235	return 0;
	236	} /* labpc_cs_attach */
	237
	238	/*======================================================================
	239
	240	This deletes a driver "instance". The device is de-registered
	241	with Card Services. If it has been released, all local data
	242	structures are freed. Otherwise, the structures will be freed
	243	when the device is released.
	244
	245	======================================================================*/
	246
	247	static void labpc_cs_detach(struct pcmcia_device *link)
	248	{
55a19b39	249	dev_dbg(&link->dev, "labpc_cs_detach\n");
124b13b2 FMH	250
	251	/*
	252	If the device is currently configured and active, we won't
	253	actually delete it yet. Instead, it is marked so that when
	254	the release() function is called, that will trigger a proper
	255	detach().
	256	*/
99bd8f22 JMC	257	((struct local_info_t *)link->priv)->stop = 1;
99bd8f22 JMC	258	labpc_release(link);
124b13b2	259
92c4bad7 BM	260	/* This points to the parent local_info_t struct (may be null) */
92c4bad7 BM	261	kfree(link->priv);
124b13b2 FMH	262
	263	} /* labpc_cs_detach */
	264
	265	/*======================================================================
	266
	267	labpc_config() is scheduled to run after a CARD_INSERTION event
	268	is received, to configure the PCMCIA socket, and to make the
	269	device available to the system.
	270
	271	======================================================================*/
	272
55a19b39 DB	273	static int labpc_pcmcia_config_loop(struct pcmcia_device *p_dev,
	274	cistpl_cftable_entry_t *cfg,
	275	cistpl_cftable_entry_t *dflt,
	276	unsigned int vcc,
	277	void *priv_data)
124b13b2	278	{
55a19b39 DB	279	if (cfg->index == 0)
55a19b39 DB	280	return -ENODEV;
124b13b2	281
55a19b39	282	/* Does this card need audio output? */
fc301101	283	if (cfg->flags & CISTPL_CFTABLE_AUDIO)
55a19b39	284	p_dev->conf.Attributes \|= CONF_ENABLE_SPKR;
c3744138	285
55a19b39	286	/* Do we need to allocate an interrupt? */
eb14120f	287	p_dev->conf.Attributes \|= CONF_ENABLE_IRQ \| CONF_ENABLE_PULSE_IRQ;
55a19b39 DB	288
55a19b39 DB	289	/* IO window settings */
90abdc3b	290	p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
55a19b39 DB	291	if ((cfg->io.nwin > 0) \|\| (dflt->io.nwin > 0)) {
55a19b39 DB	292	cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
90abdc3b DB	293	p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
	294	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	295	p_dev->resource[0]->flags \|=
	296	pcmcia_io_cfg_data_width(io->flags);
	297	p_dev->resource[0]->start = io->win[0].base;
	298	p_dev->resource[0]->end = io->win[0].len;
55a19b39	299	if (io->nwin > 1) {
90abdc3b DB	300	p_dev->resource[1]->flags = p_dev->resource[0]->flags;
	301	p_dev->resource[1]->start = io->win[1].base;
	302	p_dev->resource[1]->end = io->win[1].len;
55a19b39 DB	303	}
55a19b39 DB	304	/* This reserves IO space but doesn't actually enable it */
90abdc3b	305	if (pcmcia_request_io(p_dev) != 0)
55a19b39	306	return -ENODEV;
124b13b2	307	}
c3744138	308
55a19b39 DB	309	/* If we got this far, we're cool! */
	310	return 0;
	311	}
124b13b2	312
124b13b2	313
55a19b39 DB	314	static void labpc_config(struct pcmcia_device *link)
55a19b39 DB	315	{
55a19b39	316	int ret;
124b13b2	317
55a19b39	318	dev_dbg(&link->dev, "labpc_config\n");
124b13b2	319
0f52e86d	320	ret = pcmcia_loop_config(link, labpc_pcmcia_config_loop, NULL);
55a19b39 DB	321	if (ret) {
	322	dev_warn(&link->dev, "no configuration found\n");
	323	goto failed;
124b13b2 FMH	324	}
124b13b2 FMH	325
eb14120f DB	326	if (!link->irq)
eb14120f DB	327	goto failed;
124b13b2 FMH	328
	329	/*
	330	This actually configures the PCMCIA socket -- setting up
	331	the I/O windows and the interrupt mapping, and putting the
	332	card and host interface into "Memory and IO" mode.
	333	*/
55a19b39 DB	334	ret = pcmcia_request_configuration(link, &link->conf);
	335	if (ret)
	336	goto failed;
124b13b2	337
124b13b2	338	/* Finally, report what we've done */
99bd8f22	339	dev_info(&link->dev, "index 0x%02x", link->conf.ConfigIndex);
124b13b2	340	if (link->conf.Attributes & CONF_ENABLE_IRQ)
eb14120f	341	printk(", irq %d", link->irq);
9a017a91 DB	342	if (link->resource[0])
	343	printk(" & %pR", link->resource[0]);
	344	if (link->resource[1])
	345	printk(" & %pR", link->resource[1]);
124b13b2 FMH	346	printk("\n");
	347
	348	return;
	349
55a19b39	350	failed:
124b13b2 FMH	351	labpc_release(link);
	352
	353	} /* labpc_config */
	354
	355	static void labpc_release(struct pcmcia_device *link)
	356	{
55a19b39	357	dev_dbg(&link->dev, "labpc_release\n");
124b13b2 FMH	358
	359	pcmcia_disable_device(link);
	360	} /* labpc_release */
	361
	362	/*======================================================================
	363
	364	The card status event handler. Mostly, this schedules other
	365	stuff to run after an event is received.
	366
	367	When a CARD_REMOVAL event is received, we immediately set a
	368	private flag to block future accesses to this device. All the
	369	functions that actually access the device should check this flag
	370	to make sure the card is still present.
	371
	372	======================================================================*/
	373
	374	static int labpc_cs_suspend(struct pcmcia_device *link)
	375	{
e3f9f2c8	376	struct local_info_t *local = link->priv;
124b13b2 FMH	377
	378	/* Mark the device as stopped, to block IO until later */
	379	local->stop = 1;
	380	return 0;
	381	} /* labpc_cs_suspend */
	382
	383	static int labpc_cs_resume(struct pcmcia_device *link)
	384	{
e3f9f2c8	385	struct local_info_t *local = link->priv;
124b13b2 FMH	386
	387	local->stop = 0;
	388	return 0;
	389	} /* labpc_cs_resume */
	390
	391	/====================================================================/
	392
	393	static struct pcmcia_device_id labpc_cs_ids[] = {
	394	/* N.B. These IDs should match those in labpc_cs_boards (ni_labpc.c) */
	395	PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0103), /* daqcard-1200 */
	396	PCMCIA_DEVICE_NULL
	397	};
	398
	399	MODULE_DEVICE_TABLE(pcmcia, labpc_cs_ids);
6c7f8196 AK	400	MODULE_AUTHOR("Frank Mori Hess <fmhess@users.sourceforge.net>");
	401	MODULE_DESCRIPTION("Comedi driver for National Instruments Lab-PC");
	402	MODULE_LICENSE("GPL");
124b13b2 FMH	403
	404	struct pcmcia_driver labpc_cs_driver = {
	405	.probe = labpc_cs_attach,
	406	.remove = labpc_cs_detach,
	407	.suspend = labpc_cs_suspend,
	408	.resume = labpc_cs_resume,
	409	.id_table = labpc_cs_ids,
	410	.owner = THIS_MODULE,
	411	.drv = {
1685e633	412	.name = "daqcard-1200",
124b13b2 FMH	413	},
	414	};
	415
	416	static int __init init_labpc_cs(void)
	417	{
124b13b2 FMH	418	pcmcia_register_driver(&labpc_cs_driver);
	419	return 0;
	420	}
	421
	422	static void __exit exit_labpc_cs(void)
	423	{
124b13b2 FMH	424	pcmcia_unregister_driver(&labpc_cs_driver);
	425	}
	426
	427	int __init labpc_init_module(void)
	428	{
	429	int ret;
	430
	431	ret = init_labpc_cs();
	432	if (ret < 0)
	433	return ret;
	434
	435	return comedi_driver_register(&driver_labpc_cs);
	436	}
	437
	438	void __exit labpc_exit_module(void)
	439	{
	440	exit_labpc_cs();
	441	comedi_driver_unregister(&driver_labpc_cs);
	442	}
	443
124b13b2 FMH	444	module_init(labpc_init_module);
124b13b2 FMH	445	module_exit(labpc_exit_module);