[GitHub/mt8127/android_kernel_alcatel_ttab.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/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;

	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->config_flags |= CONF_ENABLE_SPKR;

	/* Do we need to allocate an interrupt? */
	p_dev->config_flags |= 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_enable_device(link);
	if (ret)
		goto failed;

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