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

/*
    comedi/drivers/ni_daq_dio24.c
    Driver for National Instruments PCMCIA DAQ-Card DIO-24
    Copyright (C) 2002 Daniel Vecino Castel <dvecino@able.es>

    PCMCIA crap at end of file 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.  All Rights Reserved.

    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_daq_dio24
Description: National Instruments PCMCIA DAQ-Card DIO-24
Author: Daniel Vecino Castel <dvecino@able.es>
Devices: [National Instruments] PCMCIA DAQ-Card DIO-24 (ni_daq_dio24)
Status: ?
Updated: Thu, 07 Nov 2002 21:53:06 -0800

This is just a wrapper around the 8255.o driver to properly handle
the PCMCIA interface.
*/

			    /* #define LABPC_DEBUG *//*  enable debugging messages */
#undef LABPC_DEBUG

#include <linux/interrupt.h>
#include <linux/slab.h>
#include "../comedidev.h"

#include <linux/ioport.h>

#include "8255.h"

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

static struct pcmcia_device *pcmcia_cur_dev = NULL;

#define DIO24_SIZE 4		/*  size of io region used by board */

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

enum dio24_bustype { pcmcia_bustype };

struct dio24_board_struct {
	const char *name;
	int device_id;		/*  device id for pcmcia board */
	enum dio24_bustype bustype;	/*  PCMCIA */
	int have_dio;		/*  have 8255 chip */
	/*  function pointers so we can use inb/outb or readb/writeb as appropriate */
	unsigned int (*read_byte) (unsigned int address);
	void (*write_byte) (unsigned int byte, unsigned int address);
};

static const struct dio24_board_struct dio24_boards[] = {
	{
	 .name = "daqcard-dio24",
	 .device_id = 0x475c,	/*  0x10b is manufacturer id, 0x475c is device id */
	 .bustype = pcmcia_bustype,
	 .have_dio = 1,
	 },
	{
	 .name = "ni_daq_dio24",
	 .device_id = 0x475c,	/*  0x10b is manufacturer id, 0x475c is device id */
	 .bustype = pcmcia_bustype,
	 .have_dio = 1,
	 },
};

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

struct dio24_private {

	int data;		/* number of data points left to be taken */
};

#define devpriv ((struct dio24_private *)dev->private)

static struct comedi_driver driver_dio24 = {
	.driver_name = "ni_daq_dio24",
	.module = THIS_MODULE,
	.attach = dio24_attach,
	.detach = dio24_detach,
	.num_names = ARRAY_SIZE(dio24_boards),
	.board_name = &dio24_boards[0].name,
	.offset = sizeof(struct dio24_board_struct),
};

static int dio24_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
	struct comedi_subdevice *s;
	unsigned long iobase = 0;
#ifdef incomplete
	unsigned int irq = 0;
#endif
	struct pcmcia_device *link;

	/* allocate and initialize dev->private */
	if (alloc_private(dev, sizeof(struct dio24_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;
#ifdef incomplete
		irq = link->irq;
#endif
		break;
	default:
		printk("bug! couldn't determine board type\n");
		return -EINVAL;
		break;
	}
	printk("comedi%d: ni_daq_dio24: %s, io 0x%lx", dev->minor,
	       thisboard->name, iobase);
#ifdef incomplete
	if (irq) {
		printk(", irq %u", irq);
	}
#endif

	printk("\n");

	if (iobase == 0) {
		printk("io base address is zero!\n");
		return -EINVAL;
	}

	dev->iobase = iobase;

#ifdef incomplete
	/* grab our IRQ */
	dev->irq = irq;
#endif

	dev->board_name = thisboard->name;

	if (alloc_subdevices(dev, 1) < 0)
		return -ENOMEM;

	/* 8255 dio */
	s = dev->subdevices + 0;
	subdev_8255_init(dev, s, NULL, dev->iobase);

	return 0;
};

static int dio24_detach(struct comedi_device *dev)
{
	printk("comedi%d: ni_daq_dio24: remove\n", dev->minor);

	if (dev->subdevices)
		subdev_8255_cleanup(dev, dev->subdevices + 0);

	if (thisboard->bustype != pcmcia_bustype && dev->iobase)
		release_region(dev->iobase, DIO24_SIZE);
	if (dev->irq)
		free_irq(dev->irq, dev);

	return 0;
};

/* PCMCIA crap -- watch your words! */

static void dio24_config(struct pcmcia_device *link);
static void dio24_release(struct pcmcia_device *link);
static int dio24_cs_suspend(struct pcmcia_device *p_dev);
static int dio24_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 dio24_cs_attach(struct pcmcia_device *);
static void dio24_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;
};

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

    dio24_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 dio24_cs_attach(struct pcmcia_device *link)
{
	struct local_info_t *local;

	printk(KERN_INFO "ni_daq_dio24: HOLA SOY YO - CS-attach!\n");

	dev_dbg(&link->dev, "dio24_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;

	dio24_config(link);

	return 0;
}				/* dio24_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 dio24_cs_detach(struct pcmcia_device *link)
{

	printk(KERN_INFO "ni_daq_dio24: HOLA SOY YO - cs-detach!\n");

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

	((struct local_info_t *)link->priv)->stop = 1;
	dio24_release(link);

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

}				/* dio24_cs_detach */

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

    dio24_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 dio24_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;

	/* 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 dio24_config(struct pcmcia_device *link)
{
	int ret;

	printk(KERN_INFO "ni_daq_dio24: HOLA SOY YO! - config\n");

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

	ret = pcmcia_loop_config(link, dio24_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:
	printk(KERN_INFO "Fallo");
	dio24_release(link);

}				/* dio24_config */

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

	pcmcia_disable_device(link);
}				/* dio24_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 dio24_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;
}				/* dio24_cs_suspend */

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

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

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

static struct pcmcia_device_id dio24_cs_ids[] = {
	/* N.B. These IDs should match those in dio24_boards */
	PCMCIA_DEVICE_MANF_CARD(0x010b, 0x475c),	/* daqcard-dio24 */
	PCMCIA_DEVICE_NULL
};

MODULE_DEVICE_TABLE(pcmcia, dio24_cs_ids);
MODULE_AUTHOR("Daniel Vecino Castel <dvecino@able.es>");
MODULE_DESCRIPTION("Comedi driver for National Instruments "
		   "PCMCIA DAQ-Card DIO-24");
MODULE_LICENSE("GPL");

struct pcmcia_driver dio24_cs_driver = {
	.probe = dio24_cs_attach,
	.remove = dio24_cs_detach,
	.suspend = dio24_cs_suspend,
	.resume = dio24_cs_resume,
	.id_table = dio24_cs_ids,
	.owner = THIS_MODULE,
	.drv = {
		.name = "ni_daq_dio24",
		},
};

static int __init init_dio24_cs(void)
{
	printk("ni_daq_dio24: HOLA SOY YO!\n");
	pcmcia_register_driver(&dio24_cs_driver);
	return 0;
}

static void __exit exit_dio24_cs(void)
{
	pcmcia_unregister_driver(&dio24_cs_driver);
}

int __init init_module(void)
{
	int ret;

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

	return comedi_driver_register(&driver_dio24);
}

void __exit cleanup_module(void)
{
	exit_dio24_cs();
	comedi_driver_unregister(&driver_dio24);
}
Commit	Line	Data
d1d3cb32 DVC	1	/*
	2	comedi/drivers/ni_daq_dio24.c
	3	Driver for National Instruments PCMCIA DAQ-Card DIO-24
	4	Copyright (C) 2002 Daniel Vecino Castel <dvecino@able.es>
	5
	6	PCMCIA crap at end of file 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. All Rights Reserved.
	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_daq_dio24
	30	Description: National Instruments PCMCIA DAQ-Card DIO-24
	31	Author: Daniel Vecino Castel <dvecino@able.es>
	32	Devices: [National Instruments] PCMCIA DAQ-Card DIO-24 (ni_daq_dio24)
	33	Status: ?
	34	Updated: Thu, 07 Nov 2002 21:53:06 -0800
	35
	36	This is just a wrapper around the 8255.o driver to properly handle
	37	the PCMCIA interface.
	38	*/
	39
0a85b6f0	40	/* #define LABPC_DEBUG // enable debugging messages */
d1d3cb32 DVC	41	#undef LABPC_DEBUG
d1d3cb32 DVC	42
25436dc9	43	#include <linux/interrupt.h>
5a0e3ad6	44	#include <linux/slab.h>
d1d3cb32 DVC	45	#include "../comedidev.h"
	46
	47	#include <linux/ioport.h>
d1d3cb32 DVC	48
	49	#include "8255.h"
	50
d1d3cb32 DVC	51	#include <pcmcia/cs.h>
	52	#include <pcmcia/cistpl.h>
	53	#include <pcmcia/cisreg.h>
	54	#include <pcmcia/ds.h>
	55
	56	static struct pcmcia_device *pcmcia_cur_dev = NULL;
	57
2696fb57	58	#define DIO24_SIZE 4 /* size of io region used by board */
d1d3cb32	59
da91b269 BP	60	static int dio24_attach(struct comedi_device dev, struct comedi_devconfig it);
da91b269 BP	61	static int dio24_detach(struct comedi_device *dev);
d1d3cb32 DVC	62
	63	enum dio24_bustype { pcmcia_bustype };
	64
cf4c8d1b	65	struct dio24_board_struct {
d1d3cb32	66	const char *name;
2696fb57 BP	67	int device_id; /* device id for pcmcia board */
	68	enum dio24_bustype bustype; /* PCMCIA */
	69	int have_dio; /* have 8255 chip */
	70	/* function pointers so we can use inb/outb or readb/writeb as appropriate */
d1d3cb32 DVC	71	unsigned int (*read_byte) (unsigned int address);
d1d3cb32 DVC	72	void (*write_byte) (unsigned int byte, unsigned int address);
cf4c8d1b	73	};
d1d3cb32	74
cf4c8d1b	75	static const struct dio24_board_struct dio24_boards[] = {
d1d3cb32	76	{
0a85b6f0 MT	77	.name = "daqcard-dio24",
	78	.device_id = 0x475c, /* 0x10b is manufacturer id, 0x475c is device id */
	79	.bustype = pcmcia_bustype,
	80	.have_dio = 1,
	81	},
d1d3cb32	82	{
0a85b6f0 MT	83	.name = "ni_daq_dio24",
	84	.device_id = 0x475c, /* 0x10b is manufacturer id, 0x475c is device id */
	85	.bustype = pcmcia_bustype,
	86	.have_dio = 1,
	87	},
d1d3cb32 DVC	88	};
	89
	90	/*
	91	* Useful for shorthand access to the particular board structure
	92	*/
cf4c8d1b	93	#define thisboard ((const struct dio24_board_struct *)dev->board_ptr)
d1d3cb32	94
344d23e9 BP	95	struct dio24_private {
344d23e9 BP	96
d1d3cb32	97	int data; /* number of data points left to be taken */
344d23e9 BP	98	};
344d23e9 BP	99
344d23e9	100	#define devpriv ((struct dio24_private *)dev->private)
d1d3cb32	101
139dfbdf	102	static struct comedi_driver driver_dio24 = {
68c3dbff BP	103	.driver_name = "ni_daq_dio24",
	104	.module = THIS_MODULE,
	105	.attach = dio24_attach,
	106	.detach = dio24_detach,
8629efa4	107	.num_names = ARRAY_SIZE(dio24_boards),
68c3dbff BP	108	.board_name = &dio24_boards[0].name,
68c3dbff BP	109	.offset = sizeof(struct dio24_board_struct),
d1d3cb32 DVC	110	};
d1d3cb32 DVC	111
da91b269	112	static int dio24_attach(struct comedi_device dev, struct comedi_devconfig it)
d1d3cb32	113	{
34c43922	114	struct comedi_subdevice *s;
d1d3cb32 DVC	115	unsigned long iobase = 0;
	116	#ifdef incomplete
	117	unsigned int irq = 0;
	118	#endif
	119	struct pcmcia_device *link;
	120
	121	/* allocate and initialize dev->private */
344d23e9	122	if (alloc_private(dev, sizeof(struct dio24_private)) < 0)
d1d3cb32 DVC	123	return -ENOMEM;
d1d3cb32 DVC	124
2696fb57	125	/* get base address, irq etc. based on bustype */
d1d3cb32 DVC	126	switch (thisboard->bustype) {
	127	case pcmcia_bustype:
	128	link = pcmcia_cur_dev; /* XXX hack */
	129	if (!link)
	130	return -EIO;
9a017a91	131	iobase = link->resource[0]->start;
d1d3cb32	132	#ifdef incomplete
eb14120f	133	irq = link->irq;
d1d3cb32 DVC	134	#endif
	135	break;
	136	default:
	137	printk("bug! couldn't determine board type\n");
	138	return -EINVAL;
	139	break;
	140	}
	141	printk("comedi%d: ni_daq_dio24: %s, io 0x%lx", dev->minor,
0a85b6f0	142	thisboard->name, iobase);
d1d3cb32 DVC	143	#ifdef incomplete
	144	if (irq) {
	145	printk(", irq %u", irq);
	146	}
	147	#endif
	148
	149	printk("\n");
	150
	151	if (iobase == 0) {
	152	printk("io base address is zero!\n");
	153	return -EINVAL;
	154	}
	155
	156	dev->iobase = iobase;
	157
	158	#ifdef incomplete
	159	/* grab our IRQ */
	160	dev->irq = irq;
	161	#endif
	162
	163	dev->board_name = thisboard->name;
	164
	165	if (alloc_subdevices(dev, 1) < 0)
	166	return -ENOMEM;
	167
	168	/* 8255 dio */
	169	s = dev->subdevices + 0;
	170	subdev_8255_init(dev, s, NULL, dev->iobase);
	171
	172	return 0;
	173	};
	174
da91b269	175	static int dio24_detach(struct comedi_device *dev)
d1d3cb32 DVC	176	{
	177	printk("comedi%d: ni_daq_dio24: remove\n", dev->minor);
	178
	179	if (dev->subdevices)
	180	subdev_8255_cleanup(dev, dev->subdevices + 0);
	181
	182	if (thisboard->bustype != pcmcia_bustype && dev->iobase)
	183	release_region(dev->iobase, DIO24_SIZE);
	184	if (dev->irq)
5f74ea14	185	free_irq(dev->irq, dev);
d1d3cb32 DVC	186
	187	return 0;
	188	};
	189
55a19b39	190	/* PCMCIA crap -- watch your words! */
d1d3cb32 DVC	191
	192	static void dio24_config(struct pcmcia_device *link);
	193	static void dio24_release(struct pcmcia_device *link);
	194	static int dio24_cs_suspend(struct pcmcia_device *p_dev);
	195	static int dio24_cs_resume(struct pcmcia_device *p_dev);
	196
	197	/*
	198	The attach() and detach() entry points are used to create and destroy
	199	"instances" of the driver, where each instance represents everything
	200	needed to manage one actual PCMCIA card.
	201	*/
	202
	203	static int dio24_cs_attach(struct pcmcia_device *);
	204	static void dio24_cs_detach(struct pcmcia_device *);
	205
	206	/*
	207	You'll also need to prototype all the functions that will actually
	208	be used to talk to your device. See 'memory_cs' for a good example
	209	of a fully self-sufficient driver; the other drivers rely more or
	210	less on other parts of the kernel.
	211	*/
	212
2ec9f875	213	struct local_info_t {
d1d3cb32	214	struct pcmcia_device *link;
d1d3cb32 DVC	215	int stop;
d1d3cb32 DVC	216	struct bus_operations *bus;
2ec9f875	217	};
d1d3cb32 DVC	218
	219	/*======================================================================
	220
	221	dio24_cs_attach() creates an "instance" of the driver, allocating
	222	local data structures for one device. The device is registered
	223	with Card Services.
	224
	225	The dev_link structure is initialized, but we don't actually
	226	configure the card at this point -- we wait until we receive a
	227	card insertion event.
	228
	229	======================================================================*/
	230
	231	static int dio24_cs_attach(struct pcmcia_device *link)
	232	{
2ec9f875	233	struct local_info_t *local;
d1d3cb32 DVC	234
	235	printk(KERN_INFO "ni_daq_dio24: HOLA SOY YO - CS-attach!\n");
	236
55a19b39	237	dev_dbg(&link->dev, "dio24_cs_attach()\n");
d1d3cb32 DVC	238
d1d3cb32 DVC	239	/* Allocate space for private device-specific data */
2ec9f875	240	local = kzalloc(sizeof(struct local_info_t), GFP_KERNEL);
d1d3cb32 DVC	241	if (!local)
	242	return -ENOMEM;
	243	local->link = link;
	244	link->priv = local;
	245
d1d3cb32 DVC	246	/*
	247	General socket configuration defaults can go here. In this
	248	client, we assume very little, and rely on the CIS for almost
	249	everything. In most clients, many details (i.e., number, sizes,
	250	and attributes of IO windows) are fixed by the nature of the
	251	device, and can be hard-wired here.
	252	*/
	253	link->conf.Attributes = 0;
d1d3cb32 DVC	254
	255	pcmcia_cur_dev = link;
	256
	257	dio24_config(link);
	258
	259	return 0;
	260	} /* dio24_cs_attach */
	261
	262	/*======================================================================
	263
	264	This deletes a driver "instance". The device is de-registered
	265	with Card Services. If it has been released, all local data
	266	structures are freed. Otherwise, the structures will be freed
	267	when the device is released.
	268
	269	======================================================================*/
	270
	271	static void dio24_cs_detach(struct pcmcia_device *link)
	272	{
	273
	274	printk(KERN_INFO "ni_daq_dio24: HOLA SOY YO - cs-detach!\n");
	275
55a19b39	276	dev_dbg(&link->dev, "dio24_cs_detach\n");
d1d3cb32	277
78950591 JMC	278	((struct local_info_t *)link->priv)->stop = 1;
78950591 JMC	279	dio24_release(link);
d1d3cb32 DVC	280
d1d3cb32 DVC	281	/* This points to the parent local_info_t struct */
f25bd6bf	282	kfree(link->priv);
d1d3cb32 DVC	283
	284	} /* dio24_cs_detach */
	285
	286	/*======================================================================
	287
	288	dio24_config() is scheduled to run after a CARD_INSERTION event
	289	is received, to configure the PCMCIA socket, and to make the
	290	device available to the system.
	291
	292	======================================================================*/
	293
55a19b39 DB	294	static int dio24_pcmcia_config_loop(struct pcmcia_device *p_dev,
	295	cistpl_cftable_entry_t *cfg,
	296	cistpl_cftable_entry_t *dflt,
	297	unsigned int vcc,
	298	void *priv_data)
d1d3cb32	299	{
55a19b39 DB	300	if (cfg->index == 0)
55a19b39 DB	301	return -ENODEV;
c3744138	302
55a19b39	303	/* Does this card need audio output? */
fc301101	304	if (cfg->flags & CISTPL_CFTABLE_AUDIO)
55a19b39	305	p_dev->conf.Attributes \|= CONF_ENABLE_SPKR;
c3744138	306
55a19b39	307	/* Do we need to allocate an interrupt? */
eb14120f	308	p_dev->conf.Attributes \|= CONF_ENABLE_IRQ;
55a19b39 DB	309
55a19b39 DB	310	/* IO window settings */
90abdc3b	311	p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
55a19b39 DB	312	if ((cfg->io.nwin > 0) \|\| (dflt->io.nwin > 0)) {
55a19b39 DB	313	cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
90abdc3b DB	314	p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
	315	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	316	p_dev->resource[0]->flags \|=
	317	pcmcia_io_cfg_data_width(io->flags);
	318	p_dev->resource[0]->start = io->win[0].base;
	319	p_dev->resource[0]->end = io->win[0].len;
55a19b39	320	if (io->nwin > 1) {
90abdc3b DB	321	p_dev->resource[1]->flags = p_dev->resource[0]->flags;
	322	p_dev->resource[1]->start = io->win[1].base;
	323	p_dev->resource[1]->end = io->win[1].len;
55a19b39 DB	324	}
55a19b39 DB	325	/* This reserves IO space but doesn't actually enable it */
90abdc3b	326	if (pcmcia_request_io(p_dev) != 0)
55a19b39	327	return -ENODEV;
d1d3cb32	328	}
c3744138	329
55a19b39 DB	330	/* If we got this far, we're cool! */
	331	return 0;
	332	}
d1d3cb32	333
55a19b39 DB	334	static void dio24_config(struct pcmcia_device *link)
55a19b39 DB	335	{
55a19b39	336	int ret;
d1d3cb32	337
55a19b39	338	printk(KERN_INFO "ni_daq_dio24: HOLA SOY YO! - config\n");
d1d3cb32	339
55a19b39	340	dev_dbg(&link->dev, "dio24_config\n");
c3744138	341
0f52e86d	342	ret = pcmcia_loop_config(link, dio24_pcmcia_config_loop, NULL);
55a19b39 DB	343	if (ret) {
	344	dev_warn(&link->dev, "no configuration found\n");
	345	goto failed;
d1d3cb32 DVC	346	}
d1d3cb32 DVC	347
eb14120f DB	348	if (!link->irq)
eb14120f DB	349	goto failed;
d1d3cb32 DVC	350
	351	/*
	352	This actually configures the PCMCIA socket -- setting up
	353	the I/O windows and the interrupt mapping, and putting the
	354	card and host interface into "Memory and IO" mode.
	355	*/
55a19b39 DB	356	ret = pcmcia_request_configuration(link, &link->conf);
	357	if (ret)
	358	goto failed;
d1d3cb32	359
d1d3cb32	360	/* Finally, report what we've done */
78950591	361	dev_info(&link->dev, "index 0x%02x", link->conf.ConfigIndex);
d1d3cb32	362	if (link->conf.Attributes & CONF_ENABLE_IRQ)
eb14120f	363	printk(", irq %d", link->irq);
9a017a91 DB	364	if (link->resource[0])
	365	printk(" & %pR", link->resource[0]);
	366	if (link->resource[1])
	367	printk(" & %pR", link->resource[1]);
d1d3cb32 DVC	368	printk("\n");
	369
	370	return;
	371
55a19b39	372	failed:
d1d3cb32 DVC	373	printk(KERN_INFO "Fallo");
	374	dio24_release(link);
	375
	376	} /* dio24_config */
	377
	378	static void dio24_release(struct pcmcia_device *link)
	379	{
55a19b39	380	dev_dbg(&link->dev, "dio24_release\n");
d1d3cb32 DVC	381
	382	pcmcia_disable_device(link);
	383	} /* dio24_release */
	384
	385	/*======================================================================
	386
	387	The card status event handler. Mostly, this schedules other
	388	stuff to run after an event is received.
	389
	390	When a CARD_REMOVAL event is received, we immediately set a
	391	private flag to block future accesses to this device. All the
	392	functions that actually access the device should check this flag
	393	to make sure the card is still present.
	394
	395	======================================================================*/
	396
	397	static int dio24_cs_suspend(struct pcmcia_device *link)
	398	{
2ec9f875	399	struct local_info_t *local = link->priv;
d1d3cb32 DVC	400
	401	/* Mark the device as stopped, to block IO until later */
	402	local->stop = 1;
	403	return 0;
	404	} /* dio24_cs_suspend */
	405
	406	static int dio24_cs_resume(struct pcmcia_device *link)
	407	{
2ec9f875	408	struct local_info_t *local = link->priv;
d1d3cb32 DVC	409
	410	local->stop = 0;
	411	return 0;
	412	} /* dio24_cs_resume */
	413
	414	/====================================================================/
	415
	416	static struct pcmcia_device_id dio24_cs_ids[] = {
	417	/* N.B. These IDs should match those in dio24_boards */
	418	PCMCIA_DEVICE_MANF_CARD(0x010b, 0x475c), /* daqcard-dio24 */
	419	PCMCIA_DEVICE_NULL
	420	};
	421
	422	MODULE_DEVICE_TABLE(pcmcia, dio24_cs_ids);
6c7f8196 AK	423	MODULE_AUTHOR("Daniel Vecino Castel <dvecino@able.es>");
	424	MODULE_DESCRIPTION("Comedi driver for National Instruments "
	425	"PCMCIA DAQ-Card DIO-24");
	426	MODULE_LICENSE("GPL");
d1d3cb32 DVC	427
	428	struct pcmcia_driver dio24_cs_driver = {
	429	.probe = dio24_cs_attach,
	430	.remove = dio24_cs_detach,
	431	.suspend = dio24_cs_suspend,
	432	.resume = dio24_cs_resume,
	433	.id_table = dio24_cs_ids,
	434	.owner = THIS_MODULE,
	435	.drv = {
1685e633	436	.name = "ni_daq_dio24",
d1d3cb32 DVC	437	},
	438	};
	439
	440	static int __init init_dio24_cs(void)
	441	{
	442	printk("ni_daq_dio24: HOLA SOY YO!\n");
d1d3cb32 DVC	443	pcmcia_register_driver(&dio24_cs_driver);
	444	return 0;
	445	}
	446
	447	static void __exit exit_dio24_cs(void)
	448	{
d1d3cb32 DVC	449	pcmcia_unregister_driver(&dio24_cs_driver);
	450	}
	451
	452	int __init init_module(void)
	453	{
	454	int ret;
	455
	456	ret = init_dio24_cs();
	457	if (ret < 0)
	458	return ret;
	459
	460	return comedi_driver_register(&driver_dio24);
	461	}
	462
	463	void __exit cleanup_module(void)
	464	{
	465	exit_dio24_cs();
	466	comedi_driver_unregister(&driver_dio24);
	467	}