[mirror_ubuntu-bionic-kernel.git] / drivers / parport / parport_cs.c

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

    A driver for PCMCIA parallel port adapters

    (specifically, for the Quatech SPP-100 EPP card: other cards will
    probably require driver tweaks)
    
    parport_cs.c 1.29 2002/10/11 06:57:41

    The contents of this file are subject to the Mozilla Public
    License Version 1.1 (the "License"); you may not use this file
    except in compliance with the License. You may obtain a copy of
    the License at http://www.mozilla.org/MPL/

    Software distributed under the License is distributed on an "AS
    IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
    implied. See the License for the specific language governing
    rights and limitations under the License.

    The initial developer of the original 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.

    Alternatively, the contents of this file may be used under the
    terms of the GNU General Public License version 2 (the "GPL"), in
    which case the provisions of the GPL are applicable instead of the
    above.  If you wish to allow the use of your version of this file
    only under the terms of the GPL and not to allow others to use
    your version of this file under the MPL, indicate your decision
    by deleting the provisions above and replace them with the notice
    and other provisions required by the GPL.  If you do not delete
    the provisions above, a recipient may use your version of this
    file under either the MPL or the GPL.
    
======================================================================*/

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/ptrace.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/ioport.h>
#include <linux/major.h>

#include <linux/parport.h>
#include <linux/parport_pc.h>

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

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

/* Module parameters */

MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
MODULE_DESCRIPTION("PCMCIA parallel port card driver");
MODULE_LICENSE("Dual MPL/GPL");

#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)

INT_MODULE_PARM(epp_mode, 1);

#ifdef PCMCIA_DEBUG
INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
static char *version =
"parport_cs.c 1.29 2002/10/11 06:57:41 (David Hinds)";
#else
#define DEBUG(n, args...)
#endif

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

#define FORCE_EPP_MODE	0x08

typedef struct parport_info_t {
    dev_link_t		link;
    int			ndev;
    dev_node_t		node;
    struct parport	*port;
} parport_info_t;

static dev_link_t *parport_attach(void);
static void parport_detach(struct pcmcia_device *p_dev);
static void parport_config(dev_link_t *link);
static void parport_cs_release(dev_link_t *);
static int parport_event(event_t event, int priority,
			 event_callback_args_t *args);

static dev_info_t dev_info = "parport_cs";

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

    parport_attach() creates an "instance" of the driver, allocating
    local data structures for one device.  The device is registered
    with Card Services.

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

static dev_link_t *parport_attach(void)
{
    parport_info_t *info;
    dev_link_t *link;
    client_reg_t client_reg;
    int ret;
    
    DEBUG(0, "parport_attach()\n");

    /* Create new parport device */
    info = kmalloc(sizeof(*info), GFP_KERNEL);
    if (!info) return NULL;
    memset(info, 0, sizeof(*info));
    link = &info->link; link->priv = info;

    link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
    link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
    link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
    link->irq.IRQInfo1 = IRQ_LEVEL_ID;
    link->conf.Attributes = CONF_ENABLE_IRQ;
    link->conf.Vcc = 50;
    link->conf.IntType = INT_MEMORY_AND_IO;
    
    /* Register with Card Services */
    link->next = NULL;
    client_reg.dev_info = &dev_info;
    client_reg.Version = 0x0210;
    client_reg.event_callback_args.client_data = link;
    ret = pcmcia_register_client(&link->handle, &client_reg);
    if (ret != CS_SUCCESS) {
	cs_error(link->handle, RegisterClient, ret);
	parport_detach(link->handle);
	return NULL;
    }
    
    return link;
} /* parport_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 parport_detach(struct pcmcia_device *p_dev)
{
    dev_link_t *link = dev_to_instance(p_dev);

    DEBUG(0, "parport_detach(0x%p)\n", link);

    if (link->state & DEV_CONFIG)
	parport_cs_release(link);

    kfree(link->priv);
} /* parport_detach */

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

    parport_config() is scheduled to run after a CARD_INSERTION event
    is received, to configure the PCMCIA socket, and to make the
    parport device available to the system.

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

#define CS_CHECK(fn, ret) \
do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)

void parport_config(dev_link_t *link)
{
    client_handle_t handle = link->handle;
    parport_info_t *info = link->priv;
    tuple_t tuple;
    u_short buf[128];
    cisparse_t parse;
    config_info_t conf;
    cistpl_cftable_entry_t *cfg = &parse.cftable_entry;
    cistpl_cftable_entry_t dflt = { 0 };
    struct parport *p;
    int last_ret, last_fn;
    
    DEBUG(0, "parport_config(0x%p)\n", link);
    
    tuple.TupleData = (cisdata_t *)buf;
    tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
    tuple.Attributes = 0;
    tuple.DesiredTuple = CISTPL_CONFIG;
    CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
    CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
    CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
    link->conf.ConfigBase = parse.config.base;
    link->conf.Present = parse.config.rmask[0];
    
    /* Configure card */
    link->state |= DEV_CONFIG;

    /* Not sure if this is right... look up the current Vcc */
    CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(handle, &conf));
    
    tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
    tuple.Attributes = 0;
    CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
    while (1) {
	if (pcmcia_get_tuple_data(handle, &tuple) != 0 ||
		pcmcia_parse_tuple(handle, &tuple, &parse) != 0)
	    goto next_entry;

	if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
	    cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
	    link->conf.ConfigIndex = cfg->index;
	    if (epp_mode)
		link->conf.ConfigIndex |= FORCE_EPP_MODE;
	    link->io.BasePort1 = io->win[0].base;
	    link->io.NumPorts1 = io->win[0].len;
	    link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
	    if (io->nwin == 2) {
		link->io.BasePort2 = io->win[1].base;
		link->io.NumPorts2 = io->win[1].len;
	    }
	    if (pcmcia_request_io(link->handle, &link->io) != 0)
		goto next_entry;
	    /* If we've got this far, we're done */
	    break;
	}
	
    next_entry:
	if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg;
	CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple));
    }
    
    CS_CHECK(RequestIRQ, pcmcia_request_irq(handle, &link->irq));
    CS_CHECK(RequestConfiguration, pcmcia_request_configuration(handle, &link->conf));

    release_region(link->io.BasePort1, link->io.NumPorts1);
    if (link->io.NumPorts2)
	release_region(link->io.BasePort2, link->io.NumPorts2);
    p = parport_pc_probe_port(link->io.BasePort1, link->io.BasePort2,
			      link->irq.AssignedIRQ, PARPORT_DMA_NONE,
			      NULL);
    if (p == NULL) {
	printk(KERN_NOTICE "parport_cs: parport_pc_probe_port() at "
	       "0x%3x, irq %u failed\n", link->io.BasePort1,
	       link->irq.AssignedIRQ);
	goto failed;
    }

    p->modes |= PARPORT_MODE_PCSPP;
    if (epp_mode)
	p->modes |= PARPORT_MODE_TRISTATE | PARPORT_MODE_EPP;
    info->ndev = 1;
    info->node.major = LP_MAJOR;
    info->node.minor = p->number;
    info->port = p;
    strcpy(info->node.dev_name, p->name);
    link->dev = &info->node;

    link->state &= ~DEV_CONFIG_PENDING;
    return;
    
cs_failed:
    cs_error(link->handle, last_fn, last_ret);
failed:
    parport_cs_release(link);
    link->state &= ~DEV_CONFIG_PENDING;

} /* parport_config */

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

    After a card is removed, parport_cs_release() will unregister the
    device, and release the PCMCIA configuration.  If the device is
    still open, this will be postponed until it is closed.
    
======================================================================*/

void parport_cs_release(dev_link_t *link)
{
    parport_info_t *info = link->priv;
    
    DEBUG(0, "parport_release(0x%p)\n", link);

    if (info->ndev) {
	struct parport *p = info->port;
	parport_pc_unregister_port(p);
	request_region(link->io.BasePort1, link->io.NumPorts1,
		       info->node.dev_name);
	if (link->io.NumPorts2)
	    request_region(link->io.BasePort2, link->io.NumPorts2,
			   info->node.dev_name);
    }
    info->ndev = 0;
    link->dev = NULL;
    
    pcmcia_release_configuration(link->handle);
    pcmcia_release_io(link->handle, &link->io);
    pcmcia_release_irq(link->handle, &link->irq);
    
    link->state &= ~DEV_CONFIG;

} /* parport_cs_release */

static int parport_suspend(struct pcmcia_device *dev)
{
	dev_link_t *link = dev_to_instance(dev);

	link->state |= DEV_SUSPEND;
	if (link->state & DEV_CONFIG)
		pcmcia_release_configuration(link->handle);

	return 0;
}

static int parport_resume(struct pcmcia_device *dev)
{
	dev_link_t *link = dev_to_instance(dev);

	link->state &= ~DEV_SUSPEND;
	if (DEV_OK(link))
		pcmcia_request_configuration(link->handle, &link->conf);

	return 0;
}

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

    The card status event handler.  Mostly, this schedules other
    stuff to run after an event is received.
    
======================================================================*/

int parport_event(event_t event, int priority,
		  event_callback_args_t *args)
{
    dev_link_t *link = args->client_data;

    DEBUG(1, "parport_event(0x%06x)\n", event);
    
    switch (event) {
    case CS_EVENT_CARD_INSERTION:
	link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
	parport_config(link);
	break;
    }
    return 0;
} /* parport_event */

static struct pcmcia_device_id parport_ids[] = {
	PCMCIA_DEVICE_FUNC_ID(3),
	PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0003),
	PCMCIA_DEVICE_NULL
};
MODULE_DEVICE_TABLE(pcmcia, parport_ids);

static struct pcmcia_driver parport_cs_driver = {
	.owner		= THIS_MODULE,
	.drv		= {
		.name	= "parport_cs",
	},
	.attach		= parport_attach,
	.event		= parport_event,
	.remove		= parport_detach,
	.id_table	= parport_ids,
	.suspend	= parport_suspend,
	.resume		= parport_resume,
};

static int __init init_parport_cs(void)
{
	return pcmcia_register_driver(&parport_cs_driver);
}

static void __exit exit_parport_cs(void)
{
	pcmcia_unregister_driver(&parport_cs_driver);
}

module_init(init_parport_cs);
module_exit(exit_parport_cs);
Commit	Line	Data
1da177e4 LT	1	/*======================================================================
	2
	3	A driver for PCMCIA parallel port adapters
	4
	5	(specifically, for the Quatech SPP-100 EPP card: other cards will
	6	probably require driver tweaks)
	7
	8	parport_cs.c 1.29 2002/10/11 06:57:41
	9
	10	The contents of this file are subject to the Mozilla Public
	11	License Version 1.1 (the "License"); you may not use this file
	12	except in compliance with the License. You may obtain a copy of
	13	the License at http://www.mozilla.org/MPL/
	14
	15	Software distributed under the License is distributed on an "AS
	16	IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
	17	implied. See the License for the specific language governing
	18	rights and limitations under the License.
	19
	20	The initial developer of the original code is David A. Hinds
	21	<dahinds@users.sourceforge.net>. Portions created by David A. Hinds
	22	are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
	23
	24	Alternatively, the contents of this file may be used under the
	25	terms of the GNU General Public License version 2 (the "GPL"), in
	26	which case the provisions of the GPL are applicable instead of the
	27	above. If you wish to allow the use of your version of this file
	28	only under the terms of the GPL and not to allow others to use
	29	your version of this file under the MPL, indicate your decision
	30	by deleting the provisions above and replace them with the notice
	31	and other provisions required by the GPL. If you do not delete
	32	the provisions above, a recipient may use your version of this
	33	file under either the MPL or the GPL.
	34
	35	======================================================================*/
	36
	37	#include <linux/kernel.h>
	38	#include <linux/module.h>
	39	#include <linux/init.h>
	40	#include <linux/sched.h>
	41	#include <linux/ptrace.h>
	42	#include <linux/slab.h>
	43	#include <linux/string.h>
	44	#include <linux/timer.h>
	45	#include <linux/ioport.h>
	46	#include <linux/major.h>
	47
	48	#include <linux/parport.h>
	49	#include <linux/parport_pc.h>
	50
1da177e4 LT	51	#include <pcmcia/cs_types.h>
	52	#include <pcmcia/cs.h>
	53	#include <pcmcia/cistpl.h>
	54	#include <pcmcia/ds.h>
	55	#include <pcmcia/cisreg.h>
	56	#include <pcmcia/ciscode.h>
	57
	58	/====================================================================/
	59
	60	/* Module parameters */
	61
	62	MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
	63	MODULE_DESCRIPTION("PCMCIA parallel port card driver");
	64	MODULE_LICENSE("Dual MPL/GPL");
	65
	66	#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
	67
	68	INT_MODULE_PARM(epp_mode, 1);
	69
	70	#ifdef PCMCIA_DEBUG
	71	INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
	72	#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
	73	static char *version =
	74	"parport_cs.c 1.29 2002/10/11 06:57:41 (David Hinds)";
	75	#else
	76	#define DEBUG(n, args...)
	77	#endif
	78
	79	/====================================================================/
	80
	81	#define FORCE_EPP_MODE 0x08
	82
	83	typedef struct parport_info_t {
	84	dev_link_t link;
	85	int ndev;
	86	dev_node_t node;
	87	struct parport *port;
	88	} parport_info_t;
	89
	90	static dev_link_t *parport_attach(void);
cc3b4866	91	static void parport_detach(struct pcmcia_device *p_dev);
1da177e4 LT	92	static void parport_config(dev_link_t *link);
	93	static void parport_cs_release(dev_link_t *);
	94	static int parport_event(event_t event, int priority,
	95	event_callback_args_t *args);
	96
	97	static dev_info_t dev_info = "parport_cs";
1da177e4 LT	98
	99	/*======================================================================
	100
	101	parport_attach() creates an "instance" of the driver, allocating
	102	local data structures for one device. The device is registered
	103	with Card Services.
	104
	105	======================================================================*/
	106
	107	static dev_link_t *parport_attach(void)
	108	{
	109	parport_info_t *info;
	110	dev_link_t *link;
	111	client_reg_t client_reg;
	112	int ret;
	113
	114	DEBUG(0, "parport_attach()\n");
	115
	116	/* Create new parport device */
	117	info = kmalloc(sizeof(*info), GFP_KERNEL);
	118	if (!info) return NULL;
	119	memset(info, 0, sizeof(*info));
	120	link = &info->link; link->priv = info;
	121
	122	link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	123	link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
	124	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
	125	link->irq.IRQInfo1 = IRQ_LEVEL_ID;
	126	link->conf.Attributes = CONF_ENABLE_IRQ;
	127	link->conf.Vcc = 50;
	128	link->conf.IntType = INT_MEMORY_AND_IO;
	129
	130	/* Register with Card Services */
b4635811	131	link->next = NULL;
1da177e4	132	client_reg.dev_info = &dev_info;
1da177e4 LT	133	client_reg.Version = 0x0210;
	134	client_reg.event_callback_args.client_data = link;
	135	ret = pcmcia_register_client(&link->handle, &client_reg);
	136	if (ret != CS_SUCCESS) {
	137	cs_error(link->handle, RegisterClient, ret);
cc3b4866	138	parport_detach(link->handle);
1da177e4 LT	139	return NULL;
	140	}
	141
	142	return link;
	143	} /* parport_attach */
	144
	145	/*======================================================================
	146
	147	This deletes a driver "instance". The device is de-registered
	148	with Card Services. If it has been released, all local data
	149	structures are freed. Otherwise, the structures will be freed
	150	when the device is released.
	151
	152	======================================================================*/
	153
cc3b4866	154	static void parport_detach(struct pcmcia_device *p_dev)
1da177e4	155	{
cc3b4866	156	dev_link_t *link = dev_to_instance(p_dev);
1da177e4 LT	157
1da177e4 LT	158	DEBUG(0, "parport_detach(0x%p)\n", link);
cc3b4866	159
1da177e4 LT	160	if (link->state & DEV_CONFIG)
1da177e4 LT	161	parport_cs_release(link);
cc3b4866	162
1da177e4	163	kfree(link->priv);
1da177e4 LT	164	} /* parport_detach */
	165
	166	/*======================================================================
	167
	168	parport_config() is scheduled to run after a CARD_INSERTION event
	169	is received, to configure the PCMCIA socket, and to make the
	170	parport device available to the system.
	171
	172	======================================================================*/
	173
	174	#define CS_CHECK(fn, ret) \
	175	do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
	176
	177	void parport_config(dev_link_t *link)
	178	{
	179	client_handle_t handle = link->handle;
	180	parport_info_t *info = link->priv;
	181	tuple_t tuple;
	182	u_short buf[128];
	183	cisparse_t parse;
	184	config_info_t conf;
	185	cistpl_cftable_entry_t *cfg = &parse.cftable_entry;
	186	cistpl_cftable_entry_t dflt = { 0 };
	187	struct parport *p;
	188	int last_ret, last_fn;
	189
	190	DEBUG(0, "parport_config(0x%p)\n", link);
	191
	192	tuple.TupleData = (cisdata_t *)buf;
	193	tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
	194	tuple.Attributes = 0;
	195	tuple.DesiredTuple = CISTPL_CONFIG;
	196	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
	197	CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
	198	CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
	199	link->conf.ConfigBase = parse.config.base;
	200	link->conf.Present = parse.config.rmask[0];
	201
	202	/* Configure card */
	203	link->state \|= DEV_CONFIG;
	204
	205	/* Not sure if this is right... look up the current Vcc */
	206	CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(handle, &conf));
	207
	208	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
	209	tuple.Attributes = 0;
	210	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
	211	while (1) {
	212	if (pcmcia_get_tuple_data(handle, &tuple) != 0 \|\|
	213	pcmcia_parse_tuple(handle, &tuple, &parse) != 0)
	214	goto next_entry;
	215
	216	if ((cfg->io.nwin > 0) \|\| (dflt.io.nwin > 0)) {
	217	cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
	218	link->conf.ConfigIndex = cfg->index;
	219	if (epp_mode)
	220	link->conf.ConfigIndex \|= FORCE_EPP_MODE;
	221	link->io.BasePort1 = io->win[0].base;
	222	link->io.NumPorts1 = io->win[0].len;
	223	link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
	224	if (io->nwin == 2) {
	225	link->io.BasePort2 = io->win[1].base;
	226	link->io.NumPorts2 = io->win[1].len;
	227	}
228	if (pcmcia_request_io(link->handle, &link->io) != 0)
229	goto next_entry;
230	/* If we've got this far, we're done */
231	break;
232	}
233
234	next_entry:
235	if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg;
236	CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple));
237	}
238
239	CS_CHECK(RequestIRQ, pcmcia_request_irq(handle, &link->irq));
240	CS_CHECK(RequestConfiguration, pcmcia_request_configuration(handle, &link->conf));
241
242	release_region(link->io.BasePort1, link->io.NumPorts1);
243	if (link->io.NumPorts2)
244	release_region(link->io.BasePort2, link->io.NumPorts2);
245	p = parport_pc_probe_port(link->io.BasePort1, link->io.BasePort2,
246	link->irq.AssignedIRQ, PARPORT_DMA_NONE,
247	NULL);
248	if (p == NULL) {
249	printk(KERN_NOTICE "parport_cs: parport_pc_probe_port() at "
250	"0x%3x, irq %u failed\n", link->io.BasePort1,
251	link->irq.AssignedIRQ);
252	goto failed;
253	}
254
255	p->modes \|= PARPORT_MODE_PCSPP;
256	if (epp_mode)
257	p->modes \|= PARPORT_MODE_TRISTATE \| PARPORT_MODE_EPP;
258	info->ndev = 1;
259	info->node.major = LP_MAJOR;
260	info->node.minor = p->number;
261	info->port = p;
262	strcpy(info->node.dev_name, p->name);
263	link->dev = &info->node;
264
265	link->state &= ~DEV_CONFIG_PENDING;
266	return;
267
268	cs_failed:
269	cs_error(link->handle, last_fn, last_ret);
270	failed:
271	parport_cs_release(link);
272	link->state &= ~DEV_CONFIG_PENDING;
273
274	} /* parport_config */
275
276	/*======================================================================
277
278	After a card is removed, parport_cs_release() will unregister the
279	device, and release the PCMCIA configuration. If the device is
280	still open, this will be postponed until it is closed.
281
282	======================================================================*/
283
284	void parport_cs_release(dev_link_t *link)
285	{
286	parport_info_t *info = link->priv;
287
288	DEBUG(0, "parport_release(0x%p)\n", link);
289
290	if (info->ndev) {
291	struct parport *p = info->port;
292	parport_pc_unregister_port(p);
293	request_region(link->io.BasePort1, link->io.NumPorts1,
294	info->node.dev_name);
295	if (link->io.NumPorts2)
296	request_region(link->io.BasePort2, link->io.NumPorts2,
297	info->node.dev_name);
298	}
299	info->ndev = 0;
300	link->dev = NULL;
301
302	pcmcia_release_configuration(link->handle);
303	pcmcia_release_io(link->handle, &link->io);
304	pcmcia_release_irq(link->handle, &link->irq);
305
306	link->state &= ~DEV_CONFIG;
307
308	} /* parport_cs_release */
309
98e4c28b DB	310	static int parport_suspend(struct pcmcia_device *dev)
	311	{
	312	dev_link_t *link = dev_to_instance(dev);
	313
	314	link->state \|= DEV_SUSPEND;
	315	if (link->state & DEV_CONFIG)
	316	pcmcia_release_configuration(link->handle);
	317
	318	return 0;
	319	}
	320
	321	static int parport_resume(struct pcmcia_device *dev)
	322	{
	323	dev_link_t *link = dev_to_instance(dev);
	324
	325	link->state &= ~DEV_SUSPEND;
	326	if (DEV_OK(link))
	327	pcmcia_request_configuration(link->handle, &link->conf);
	328
	329	return 0;
	330	}
	331
1da177e4 LT	332	/*======================================================================
	333
	334	The card status event handler. Mostly, this schedules other
	335	stuff to run after an event is received.
	336
	337	======================================================================*/
	338
	339	int parport_event(event_t event, int priority,
	340	event_callback_args_t *args)
	341	{
	342	dev_link_t *link = args->client_data;
	343
	344	DEBUG(1, "parport_event(0x%06x)\n", event);
	345
	346	switch (event) {
1da177e4 LT	347	case CS_EVENT_CARD_INSERTION:
	348	link->state \|= DEV_PRESENT \| DEV_CONFIG_PENDING;
	349	parport_config(link);
	350	break;
1da177e4 LT	351	}
	352	return 0;
	353	} /* parport_event */
	354
476835af DB	355	static struct pcmcia_device_id parport_ids[] = {
	356	PCMCIA_DEVICE_FUNC_ID(3),
	357	PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0003),
	358	PCMCIA_DEVICE_NULL
	359	};
	360	MODULE_DEVICE_TABLE(pcmcia, parport_ids);
	361
1da177e4 LT	362	static struct pcmcia_driver parport_cs_driver = {
	363	.owner = THIS_MODULE,
	364	.drv = {
	365	.name = "parport_cs",
	366	},
	367	.attach = parport_attach,
1e212f36	368	.event = parport_event,
cc3b4866	369	.remove = parport_detach,
476835af	370	.id_table = parport_ids,
98e4c28b DB	371	.suspend = parport_suspend,
98e4c28b DB	372	.resume = parport_resume,
1da177e4 LT	373	};
	374
	375	static int __init init_parport_cs(void)
	376	{
	377	return pcmcia_register_driver(&parport_cs_driver);
	378	}
	379
	380	static void __exit exit_parport_cs(void)
	381	{
	382	pcmcia_unregister_driver(&parport_cs_driver);
1da177e4 LT	383	}
	384
	385	module_init(init_parport_cs);
	386	module_exit(exit_parport_cs);