[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->io.BasePort1;
		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->io.NumPorts1 = p_dev->io.NumPorts2 = 0;
	if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
		cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
		p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
		if (!(io->flags & CISTPL_IO_8BIT))
			p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
		if (!(io->flags & CISTPL_IO_16BIT))
			p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
		p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
		p_dev->io.BasePort1 = io->win[0].base;
		p_dev->io.NumPorts1 = io->win[0].len;
		if (io->nwin > 1) {
			p_dev->io.Attributes2 = p_dev->io.Attributes1;
			p_dev->io.BasePort2 = io->win[1].base;
			p_dev->io.NumPorts2 = io->win[1].len;
		}
		/* This reserves IO space but doesn't actually enable it */
		if (pcmcia_request_io(p_dev, &p_dev->io) != 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->io.NumPorts1)
		printk(", io 0x%04x-0x%04x", link->io.BasePort1,
		       link->io.BasePort1 + link->io.NumPorts1 - 1);
	if (link->io.NumPorts2)
		printk(" & 0x%04x-0x%04x", link->io.BasePort2,
		       link->io.BasePort2 + link->io.NumPorts2 - 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;
	145	iobase = link->io.BasePort1;
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
	303	/* IO window settings */
	304	p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0;
	305	if ((cfg->io.nwin > 0) \|\| (dflt->io.nwin > 0)) {
	306	cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
	307	p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
	308	if (!(io->flags & CISTPL_IO_8BIT))
	309	p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
	310	if (!(io->flags & CISTPL_IO_16BIT))
	311	p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	312	p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
	313	p_dev->io.BasePort1 = io->win[0].base;
	314	p_dev->io.NumPorts1 = io->win[0].len;
	315	if (io->nwin > 1) {
	316	p_dev->io.Attributes2 = p_dev->io.Attributes1;
	317	p_dev->io.BasePort2 = io->win[1].base;
	318	p_dev->io.NumPorts2 = io->win[1].len;
	319	}
	320	/* This reserves IO space but doesn't actually enable it */
	321	if (pcmcia_request_io(p_dev, &p_dev->io) != 0)
	322	return -ENODEV;
124b13b2	323	}
c3744138	324
55a19b39 DB	325	if ((cfg->mem.nwin > 0) \|\| (dflt->mem.nwin > 0)) {
	326	cistpl_mem_t *mem =
	327	(cfg->mem.nwin) ? &cfg->mem : &dflt->mem;
	328	req->Attributes = WIN_DATA_WIDTH_16 \| WIN_MEMORY_TYPE_CM;
	329	req->Attributes \|= WIN_ENABLE;
	330	req->Base = mem->win[0].host_addr;
	331	req->Size = mem->win[0].len;
	332	if (req->Size < 0x1000)
	333	req->Size = 0x1000;
	334	req->AccessSpeed = 0;
6838b03f	335	if (pcmcia_request_window(p_dev, req, &p_dev->win))
55a19b39 DB	336	return -ENODEV;
	337	map.Page = 0;
	338	map.CardOffset = mem->win[0].card_addr;
868575d1	339	if (pcmcia_map_mem_page(p_dev, p_dev->win, &map))
55a19b39	340	return -ENODEV;
124b13b2	341	}
55a19b39 DB	342	/* If we got this far, we're cool! */
	343	return 0;
	344	}
124b13b2	345
124b13b2	346
55a19b39 DB	347	static void labpc_config(struct pcmcia_device *link)
55a19b39 DB	348	{
55a19b39 DB	349	int ret;
55a19b39 DB	350	win_req_t req;
124b13b2	351
55a19b39	352	dev_dbg(&link->dev, "labpc_config\n");
124b13b2	353
55a19b39 DB	354	ret = pcmcia_loop_config(link, labpc_pcmcia_config_loop, &req);
	355	if (ret) {
	356	dev_warn(&link->dev, "no configuration found\n");
	357	goto failed;
124b13b2 FMH	358	}
124b13b2 FMH	359
eb14120f DB	360	if (!link->irq)
eb14120f DB	361	goto failed;
124b13b2 FMH	362
	363	/*
	364	This actually configures the PCMCIA socket -- setting up
	365	the I/O windows and the interrupt mapping, and putting the
	366	card and host interface into "Memory and IO" mode.
	367	*/
55a19b39 DB	368	ret = pcmcia_request_configuration(link, &link->conf);
	369	if (ret)
	370	goto failed;
124b13b2	371
124b13b2	372	/* Finally, report what we've done */
99bd8f22	373	dev_info(&link->dev, "index 0x%02x", link->conf.ConfigIndex);
124b13b2	374	if (link->conf.Attributes & CONF_ENABLE_IRQ)
eb14120f	375	printk(", irq %d", link->irq);
124b13b2 FMH	376	if (link->io.NumPorts1)
124b13b2 FMH	377	printk(", io 0x%04x-0x%04x", link->io.BasePort1,
0a85b6f0	378	link->io.BasePort1 + link->io.NumPorts1 - 1);
124b13b2 FMH	379	if (link->io.NumPorts2)
124b13b2 FMH	380	printk(" & 0x%04x-0x%04x", link->io.BasePort2,
0a85b6f0	381	link->io.BasePort2 + link->io.NumPorts2 - 1);
124b13b2 FMH	382	if (link->win)
124b13b2 FMH	383	printk(", mem 0x%06lx-0x%06lx", req.Base,
0a85b6f0	384	req.Base + req.Size - 1);
124b13b2 FMH	385	printk("\n");
	386
	387	return;
	388
55a19b39	389	failed:
124b13b2 FMH	390	labpc_release(link);
	391
	392	} /* labpc_config */
	393
	394	static void labpc_release(struct pcmcia_device *link)
	395	{
55a19b39	396	dev_dbg(&link->dev, "labpc_release\n");
124b13b2 FMH	397
	398	pcmcia_disable_device(link);
	399	} /* labpc_release */
	400
	401	/*======================================================================
	402
	403	The card status event handler. Mostly, this schedules other
	404	stuff to run after an event is received.
	405
	406	When a CARD_REMOVAL event is received, we immediately set a
	407	private flag to block future accesses to this device. All the
	408	functions that actually access the device should check this flag
	409	to make sure the card is still present.
	410
	411	======================================================================*/
	412
	413	static int labpc_cs_suspend(struct pcmcia_device *link)
	414	{
e3f9f2c8	415	struct local_info_t *local = link->priv;
124b13b2 FMH	416
	417	/* Mark the device as stopped, to block IO until later */
	418	local->stop = 1;
	419	return 0;
	420	} /* labpc_cs_suspend */
	421
	422	static int labpc_cs_resume(struct pcmcia_device *link)
	423	{
e3f9f2c8	424	struct local_info_t *local = link->priv;
124b13b2 FMH	425
	426	local->stop = 0;
	427	return 0;
	428	} /* labpc_cs_resume */
	429
	430	/====================================================================/
	431
	432	static struct pcmcia_device_id labpc_cs_ids[] = {
	433	/* N.B. These IDs should match those in labpc_cs_boards (ni_labpc.c) */
	434	PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0103), /* daqcard-1200 */
	435	PCMCIA_DEVICE_NULL
	436	};
	437
	438	MODULE_DEVICE_TABLE(pcmcia, labpc_cs_ids);
6c7f8196 AK	439	MODULE_AUTHOR("Frank Mori Hess <fmhess@users.sourceforge.net>");
	440	MODULE_DESCRIPTION("Comedi driver for National Instruments Lab-PC");
	441	MODULE_LICENSE("GPL");
124b13b2 FMH	442
	443	struct pcmcia_driver labpc_cs_driver = {
	444	.probe = labpc_cs_attach,
	445	.remove = labpc_cs_detach,
	446	.suspend = labpc_cs_suspend,
	447	.resume = labpc_cs_resume,
	448	.id_table = labpc_cs_ids,
	449	.owner = THIS_MODULE,
	450	.drv = {
0a85b6f0	451	.name = dev_info,
124b13b2 FMH	452	},
	453	};
	454
	455	static int __init init_labpc_cs(void)
	456	{
124b13b2 FMH	457	pcmcia_register_driver(&labpc_cs_driver);
	458	return 0;
	459	}
	460
	461	static void __exit exit_labpc_cs(void)
	462	{
124b13b2 FMH	463	pcmcia_unregister_driver(&labpc_cs_driver);
	464	}
	465
	466	int __init labpc_init_module(void)
	467	{
	468	int ret;
	469
	470	ret = init_labpc_cs();
	471	if (ret < 0)
	472	return ret;
	473
	474	return comedi_driver_register(&driver_labpc_cs);
	475	}
	476
	477	void __exit labpc_exit_module(void)
	478	{
	479	exit_labpc_cs();
	480	comedi_driver_unregister(&driver_labpc_cs);
	481	}
	482
124b13b2 FMH	483	module_init(labpc_init_module);
124b13b2 FMH	484	module_exit(labpc_exit_module);