[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.
*/

/*
   The dev_info variable is the "key" that is used to match up this
   device driver with appropriate cards, through the card configuration
   database.
*/

static const dev_info_t dev_info = "daqcard-1200";

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;
	link->conf.IntType = INT_MEMORY_AND_IO;

	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)
{
	win_req_t *req = priv_data;
	memreq_t map;

	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;
		p_dev->conf.Status = CCSR_AUDIO_ENA;
	}

	/* 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 ((cfg->mem.nwin > 0) || (dflt->mem.nwin > 0)) {
		cistpl_mem_t *mem =
			(cfg->mem.nwin) ? &cfg->mem : &dflt->mem;
		req->Attributes = WIN_DATA_WIDTH_16 | WIN_MEMORY_TYPE_CM;
		req->Attributes |= WIN_ENABLE;
		req->Base = mem->win[0].host_addr;
		req->Size = mem->win[0].len;
		if (req->Size < 0x1000)
			req->Size = 0x1000;
		req->AccessSpeed = 0;
		if (pcmcia_request_window(p_dev, req, &p_dev->win))
			return -ENODEV;
		map.Page = 0;
		map.CardOffset = mem->win[0].card_addr;
		if (pcmcia_map_mem_page(p_dev, p_dev->win, &map))
			return -ENODEV;
	}
	/* If we got this far, we're cool! */
	return 0;
}


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

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

	ret = pcmcia_loop_config(link, labpc_pcmcia_config_loop, &req);
	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]);
	if (link->win)
		printk(", mem 0x%06lx-0x%06lx", req.Base,
		       req.Base + req.Size - 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 = dev_info,
		},
};

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
	191	/*
	192	The dev_info variable is the "key" that is used to match up this
	193	device driver with appropriate cards, through the card configuration
	194	database.
	195	*/
	196
	197	static const dev_info_t dev_info = "daqcard-1200";
	198
e3f9f2c8	199	struct local_info_t {
124b13b2	200	struct pcmcia_device *link;
124b13b2 FMH	201	int stop;
124b13b2 FMH	202	struct bus_operations *bus;
e3f9f2c8	203	};
124b13b2 FMH	204
	205	/*======================================================================
	206
	207	labpc_cs_attach() creates an "instance" of the driver, allocating
	208	local data structures for one device. The device is registered
	209	with Card Services.
	210
	211	The dev_link structure is initialized, but we don't actually
	212	configure the card at this point -- we wait until we receive a
	213	card insertion event.
	214
	215	======================================================================*/
	216
	217	static int labpc_cs_attach(struct pcmcia_device *link)
	218	{
e3f9f2c8	219	struct local_info_t *local;
124b13b2	220
55a19b39	221	dev_dbg(&link->dev, "labpc_cs_attach()\n");
124b13b2 FMH	222
124b13b2 FMH	223	/* Allocate space for private device-specific data */
e3f9f2c8	224	local = kzalloc(sizeof(struct local_info_t), GFP_KERNEL);
124b13b2 FMH	225	if (!local)
	226	return -ENOMEM;
	227	local->link = link;
	228	link->priv = local;
	229
124b13b2 FMH	230	/*
	231	General socket configuration defaults can go here. In this
	232	client, we assume very little, and rely on the CIS for almost
	233	everything. In most clients, many details (i.e., number, sizes,
	234	and attributes of IO windows) are fixed by the nature of the
	235	device, and can be hard-wired here.
	236	*/
	237	link->conf.Attributes = 0;
	238	link->conf.IntType = INT_MEMORY_AND_IO;
	239
	240	pcmcia_cur_dev = link;
	241
	242	labpc_config(link);
	243
	244	return 0;
	245	} /* labpc_cs_attach */
	246
	247	/*======================================================================
	248
	249	This deletes a driver "instance". The device is de-registered
	250	with Card Services. If it has been released, all local data
	251	structures are freed. Otherwise, the structures will be freed
	252	when the device is released.
	253
	254	======================================================================*/
	255
	256	static void labpc_cs_detach(struct pcmcia_device *link)
	257	{
55a19b39	258	dev_dbg(&link->dev, "labpc_cs_detach\n");
124b13b2 FMH	259
	260	/*
	261	If the device is currently configured and active, we won't
	262	actually delete it yet. Instead, it is marked so that when
	263	the release() function is called, that will trigger a proper
	264	detach().
	265	*/
99bd8f22 JMC	266	((struct local_info_t *)link->priv)->stop = 1;
99bd8f22 JMC	267	labpc_release(link);
124b13b2	268
92c4bad7 BM	269	/* This points to the parent local_info_t struct (may be null) */
92c4bad7 BM	270	kfree(link->priv);
124b13b2 FMH	271
	272	} /* labpc_cs_detach */
	273
	274	/*======================================================================
	275
	276	labpc_config() is scheduled to run after a CARD_INSERTION event
	277	is received, to configure the PCMCIA socket, and to make the
	278	device available to the system.
	279
	280	======================================================================*/
	281
55a19b39 DB	282	static int labpc_pcmcia_config_loop(struct pcmcia_device *p_dev,
	283	cistpl_cftable_entry_t *cfg,
	284	cistpl_cftable_entry_t *dflt,
	285	unsigned int vcc,
	286	void *priv_data)
124b13b2	287	{
55a19b39	288	win_req_t *req = priv_data;
124b13b2	289	memreq_t map;
124b13b2	290
55a19b39 DB	291	if (cfg->index == 0)
55a19b39 DB	292	return -ENODEV;
124b13b2	293
55a19b39 DB	294	/* Does this card need audio output? */
	295	if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
	296	p_dev->conf.Attributes \|= CONF_ENABLE_SPKR;
	297	p_dev->conf.Status = CCSR_AUDIO_ENA;
124b13b2	298	}
c3744138	299
55a19b39	300	/* Do we need to allocate an interrupt? */
eb14120f	301	p_dev->conf.Attributes \|= CONF_ENABLE_IRQ \| CONF_ENABLE_PULSE_IRQ;
55a19b39 DB	302
55a19b39 DB	303	/* IO window settings */
90abdc3b	304	p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
55a19b39 DB	305	if ((cfg->io.nwin > 0) \|\| (dflt->io.nwin > 0)) {
55a19b39 DB	306	cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
90abdc3b DB	307	p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
	308	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	309	p_dev->resource[0]->flags \|=
	310	pcmcia_io_cfg_data_width(io->flags);
	311	p_dev->resource[0]->start = io->win[0].base;
	312	p_dev->resource[0]->end = io->win[0].len;
55a19b39	313	if (io->nwin > 1) {
90abdc3b DB	314	p_dev->resource[1]->flags = p_dev->resource[0]->flags;
	315	p_dev->resource[1]->start = io->win[1].base;
	316	p_dev->resource[1]->end = io->win[1].len;
55a19b39 DB	317	}
55a19b39 DB	318	/* This reserves IO space but doesn't actually enable it */
90abdc3b	319	if (pcmcia_request_io(p_dev) != 0)
55a19b39	320	return -ENODEV;
124b13b2	321	}
c3744138	322
55a19b39 DB	323	if ((cfg->mem.nwin > 0) \|\| (dflt->mem.nwin > 0)) {
	324	cistpl_mem_t *mem =
	325	(cfg->mem.nwin) ? &cfg->mem : &dflt->mem;
	326	req->Attributes = WIN_DATA_WIDTH_16 \| WIN_MEMORY_TYPE_CM;
	327	req->Attributes \|= WIN_ENABLE;
	328	req->Base = mem->win[0].host_addr;
	329	req->Size = mem->win[0].len;
	330	if (req->Size < 0x1000)
	331	req->Size = 0x1000;
	332	req->AccessSpeed = 0;
6838b03f	333	if (pcmcia_request_window(p_dev, req, &p_dev->win))
55a19b39 DB	334	return -ENODEV;
	335	map.Page = 0;
	336	map.CardOffset = mem->win[0].card_addr;
868575d1	337	if (pcmcia_map_mem_page(p_dev, p_dev->win, &map))
55a19b39	338	return -ENODEV;
124b13b2	339	}
55a19b39 DB	340	/* If we got this far, we're cool! */
	341	return 0;
	342	}
124b13b2	343
124b13b2	344
55a19b39 DB	345	static void labpc_config(struct pcmcia_device *link)
55a19b39 DB	346	{
55a19b39 DB	347	int ret;
55a19b39 DB	348	win_req_t req;
124b13b2	349
55a19b39	350	dev_dbg(&link->dev, "labpc_config\n");
124b13b2	351
55a19b39 DB	352	ret = pcmcia_loop_config(link, labpc_pcmcia_config_loop, &req);
	353	if (ret) {
	354	dev_warn(&link->dev, "no configuration found\n");
	355	goto failed;
124b13b2 FMH	356	}
124b13b2 FMH	357
eb14120f DB	358	if (!link->irq)
eb14120f DB	359	goto failed;
124b13b2 FMH	360
	361	/*
	362	This actually configures the PCMCIA socket -- setting up
	363	the I/O windows and the interrupt mapping, and putting the
	364	card and host interface into "Memory and IO" mode.
	365	*/
55a19b39 DB	366	ret = pcmcia_request_configuration(link, &link->conf);
	367	if (ret)
	368	goto failed;
124b13b2	369
124b13b2	370	/* Finally, report what we've done */
99bd8f22	371	dev_info(&link->dev, "index 0x%02x", link->conf.ConfigIndex);
124b13b2	372	if (link->conf.Attributes & CONF_ENABLE_IRQ)
eb14120f	373	printk(", irq %d", link->irq);
9a017a91 DB	374	if (link->resource[0])
	375	printk(" & %pR", link->resource[0]);
	376	if (link->resource[1])
	377	printk(" & %pR", link->resource[1]);
124b13b2 FMH	378	if (link->win)
124b13b2 FMH	379	printk(", mem 0x%06lx-0x%06lx", req.Base,
0a85b6f0	380	req.Base + req.Size - 1);
124b13b2 FMH	381	printk("\n");
	382
	383	return;
	384
55a19b39	385	failed:
124b13b2 FMH	386	labpc_release(link);
	387
	388	} /* labpc_config */
	389
	390	static void labpc_release(struct pcmcia_device *link)
	391	{
55a19b39	392	dev_dbg(&link->dev, "labpc_release\n");
124b13b2 FMH	393
	394	pcmcia_disable_device(link);
	395	} /* labpc_release */
	396
	397	/*======================================================================
	398
	399	The card status event handler. Mostly, this schedules other
	400	stuff to run after an event is received.
	401
	402	When a CARD_REMOVAL event is received, we immediately set a
	403	private flag to block future accesses to this device. All the
	404	functions that actually access the device should check this flag
	405	to make sure the card is still present.
	406
	407	======================================================================*/
	408
	409	static int labpc_cs_suspend(struct pcmcia_device *link)
	410	{
e3f9f2c8	411	struct local_info_t *local = link->priv;
124b13b2 FMH	412
	413	/* Mark the device as stopped, to block IO until later */
	414	local->stop = 1;
	415	return 0;
	416	} /* labpc_cs_suspend */
	417
	418	static int labpc_cs_resume(struct pcmcia_device *link)
	419	{
e3f9f2c8	420	struct local_info_t *local = link->priv;
124b13b2 FMH	421
	422	local->stop = 0;
	423	return 0;
	424	} /* labpc_cs_resume */
	425
	426	/====================================================================/
	427
	428	static struct pcmcia_device_id labpc_cs_ids[] = {
	429	/* N.B. These IDs should match those in labpc_cs_boards (ni_labpc.c) */
	430	PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0103), /* daqcard-1200 */
	431	PCMCIA_DEVICE_NULL
	432	};
	433
	434	MODULE_DEVICE_TABLE(pcmcia, labpc_cs_ids);
6c7f8196 AK	435	MODULE_AUTHOR("Frank Mori Hess <fmhess@users.sourceforge.net>");
	436	MODULE_DESCRIPTION("Comedi driver for National Instruments Lab-PC");
	437	MODULE_LICENSE("GPL");
124b13b2 FMH	438
	439	struct pcmcia_driver labpc_cs_driver = {
	440	.probe = labpc_cs_attach,
	441	.remove = labpc_cs_detach,
	442	.suspend = labpc_cs_suspend,
	443	.resume = labpc_cs_resume,
	444	.id_table = labpc_cs_ids,
	445	.owner = THIS_MODULE,
	446	.drv = {
0a85b6f0	447	.name = dev_info,
124b13b2 FMH	448	},
	449	};
	450
	451	static int __init init_labpc_cs(void)
	452	{
124b13b2 FMH	453	pcmcia_register_driver(&labpc_cs_driver);
	454	return 0;
	455	}
	456
	457	static void __exit exit_labpc_cs(void)
	458	{
124b13b2 FMH	459	pcmcia_unregister_driver(&labpc_cs_driver);
	460	}
	461
	462	int __init labpc_init_module(void)
	463	{
	464	int ret;
	465
	466	ret = init_labpc_cs();
	467	if (ret < 0)
	468	return ret;
	469
	470	return comedi_driver_register(&driver_labpc_cs);
	471	}
	472
	473	void __exit labpc_exit_module(void)
	474	{
	475	exit_labpc_cs();
	476	comedi_driver_unregister(&driver_labpc_cs);
	477	}
	478
124b13b2 FMH	479	module_init(labpc_init_module);
124b13b2 FMH	480	module_exit(labpc_exit_module);