[linux.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
    <[email protected]>.  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 <[email protected]>");
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 void parport_detach(struct pcmcia_device *p_dev);
static void parport_config(dev_link_t *link);
static void parport_cs_release(dev_link_t *);

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

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

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

static int parport_attach(struct pcmcia_device *p_dev)
{
    parport_info_t *info;
    dev_link_t *link;

    DEBUG(0, "parport_attach()\n");

    /* Create new parport device */
    info = kmalloc(sizeof(*info), GFP_KERNEL);
    if (!info) return -ENOMEM;
    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;

    link->handle = p_dev;
    p_dev->instance = link;

    link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
    parport_config(link);

    return 0;
} /* 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;
}

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",
	},
	.probe		= parport_attach,
	.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	<[email protected]>. 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 <[email protected]>");
	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
cc3b4866	90	static void parport_detach(struct pcmcia_device *p_dev);
1da177e4 LT	91	static void parport_config(dev_link_t *link);
1da177e4 LT	92	static void parport_cs_release(dev_link_t *);
1da177e4 LT	93
	94	/*======================================================================
	95
	96	parport_attach() creates an "instance" of the driver, allocating
	97	local data structures for one device. The device is registered
	98	with Card Services.
	99
	100	======================================================================*/
	101
f8cfa618	102	static int parport_attach(struct pcmcia_device *p_dev)
1da177e4 LT	103	{
	104	parport_info_t *info;
	105	dev_link_t *link;
f8cfa618	106
1da177e4 LT	107	DEBUG(0, "parport_attach()\n");
	108
	109	/* Create new parport device */
	110	info = kmalloc(sizeof(*info), GFP_KERNEL);
f8cfa618	111	if (!info) return -ENOMEM;
1da177e4 LT	112	memset(info, 0, sizeof(*info));
	113	link = &info->link; link->priv = info;
	114
	115	link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	116	link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
	117	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
	118	link->irq.IRQInfo1 = IRQ_LEVEL_ID;
	119	link->conf.Attributes = CONF_ENABLE_IRQ;
	120	link->conf.Vcc = 50;
	121	link->conf.IntType = INT_MEMORY_AND_IO;
f8cfa618 DB	122
	123	link->handle = p_dev;
	124	p_dev->instance = link;
	125
	126	link->state \|= DEV_PRESENT \| DEV_CONFIG_PENDING;
	127	parport_config(link);
	128
	129	return 0;
1da177e4 LT	130	} /* parport_attach */
	131
	132	/*======================================================================
	133
	134	This deletes a driver "instance". The device is de-registered
	135	with Card Services. If it has been released, all local data
	136	structures are freed. Otherwise, the structures will be freed
	137	when the device is released.
	138
	139	======================================================================*/
	140
cc3b4866	141	static void parport_detach(struct pcmcia_device *p_dev)
1da177e4	142	{
cc3b4866	143	dev_link_t *link = dev_to_instance(p_dev);
1da177e4 LT	144
1da177e4 LT	145	DEBUG(0, "parport_detach(0x%p)\n", link);
cc3b4866	146
1da177e4 LT	147	if (link->state & DEV_CONFIG)
1da177e4 LT	148	parport_cs_release(link);
cc3b4866	149
1da177e4	150	kfree(link->priv);
1da177e4 LT	151	} /* parport_detach */
	152
	153	/*======================================================================
	154
	155	parport_config() is scheduled to run after a CARD_INSERTION event
	156	is received, to configure the PCMCIA socket, and to make the
	157	parport device available to the system.
	158
	159	======================================================================*/
	160
	161	#define CS_CHECK(fn, ret) \
	162	do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
	163
	164	void parport_config(dev_link_t *link)
	165	{
	166	client_handle_t handle = link->handle;
	167	parport_info_t *info = link->priv;
	168	tuple_t tuple;
	169	u_short buf[128];
	170	cisparse_t parse;
	171	config_info_t conf;
	172	cistpl_cftable_entry_t *cfg = &parse.cftable_entry;
	173	cistpl_cftable_entry_t dflt = { 0 };
	174	struct parport *p;
	175	int last_ret, last_fn;
	176
	177	DEBUG(0, "parport_config(0x%p)\n", link);
	178
	179	tuple.TupleData = (cisdata_t *)buf;
	180	tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
	181	tuple.Attributes = 0;
	182	tuple.DesiredTuple = CISTPL_CONFIG;
	183	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
	184	CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
	185	CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
	186	link->conf.ConfigBase = parse.config.base;
	187	link->conf.Present = parse.config.rmask[0];
	188
	189	/* Configure card */
	190	link->state \|= DEV_CONFIG;
	191
	192	/* Not sure if this is right... look up the current Vcc */
	193	CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(handle, &conf));
	194
	195	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
	196	tuple.Attributes = 0;
	197	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
	198	while (1) {
	199	if (pcmcia_get_tuple_data(handle, &tuple) != 0 \|\|
	200	pcmcia_parse_tuple(handle, &tuple, &parse) != 0)
	201	goto next_entry;
	202
	203	if ((cfg->io.nwin > 0) \|\| (dflt.io.nwin > 0)) {
	204	cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
	205	link->conf.ConfigIndex = cfg->index;
	206	if (epp_mode)
	207	link->conf.ConfigIndex \|= FORCE_EPP_MODE;
	208	link->io.BasePort1 = io->win[0].base;
	209	link->io.NumPorts1 = io->win[0].len;
	210	link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
	211	if (io->nwin == 2) {
	212	link->io.BasePort2 = io->win[1].base;
	213	link->io.NumPorts2 = io->win[1].len;
	214	}
215	if (pcmcia_request_io(link->handle, &link->io) != 0)
216	goto next_entry;
217	/* If we've got this far, we're done */
218	break;
219	}
220
221	next_entry:
222	if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg;
223	CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple));
224	}
225
226	CS_CHECK(RequestIRQ, pcmcia_request_irq(handle, &link->irq));
227	CS_CHECK(RequestConfiguration, pcmcia_request_configuration(handle, &link->conf));
228
229	release_region(link->io.BasePort1, link->io.NumPorts1);
230	if (link->io.NumPorts2)
231	release_region(link->io.BasePort2, link->io.NumPorts2);
232	p = parport_pc_probe_port(link->io.BasePort1, link->io.BasePort2,
233	link->irq.AssignedIRQ, PARPORT_DMA_NONE,
234	NULL);
235	if (p == NULL) {
236	printk(KERN_NOTICE "parport_cs: parport_pc_probe_port() at "
237	"0x%3x, irq %u failed\n", link->io.BasePort1,
238	link->irq.AssignedIRQ);
239	goto failed;
240	}
241
242	p->modes \|= PARPORT_MODE_PCSPP;
243	if (epp_mode)
244	p->modes \|= PARPORT_MODE_TRISTATE \| PARPORT_MODE_EPP;
245	info->ndev = 1;
246	info->node.major = LP_MAJOR;
247	info->node.minor = p->number;
248	info->port = p;
249	strcpy(info->node.dev_name, p->name);
250	link->dev = &info->node;
251
252	link->state &= ~DEV_CONFIG_PENDING;
253	return;
254
255	cs_failed:
256	cs_error(link->handle, last_fn, last_ret);
257	failed:
258	parport_cs_release(link);
259	link->state &= ~DEV_CONFIG_PENDING;
260
261	} /* parport_config */
262
263	/*======================================================================
264
265	After a card is removed, parport_cs_release() will unregister the
266	device, and release the PCMCIA configuration. If the device is
267	still open, this will be postponed until it is closed.
268
269	======================================================================*/
270
271	void parport_cs_release(dev_link_t *link)
272	{
273	parport_info_t *info = link->priv;
274
275	DEBUG(0, "parport_release(0x%p)\n", link);
276
277	if (info->ndev) {
278	struct parport *p = info->port;
279	parport_pc_unregister_port(p);
280	request_region(link->io.BasePort1, link->io.NumPorts1,
281	info->node.dev_name);
282	if (link->io.NumPorts2)
283	request_region(link->io.BasePort2, link->io.NumPorts2,
284	info->node.dev_name);
285	}
286	info->ndev = 0;
287	link->dev = NULL;
288
289	pcmcia_release_configuration(link->handle);
290	pcmcia_release_io(link->handle, &link->io);
291	pcmcia_release_irq(link->handle, &link->irq);
292
293	link->state &= ~DEV_CONFIG;
294
295	} /* parport_cs_release */
296
98e4c28b DB	297	static int parport_suspend(struct pcmcia_device *dev)
	298	{
	299	dev_link_t *link = dev_to_instance(dev);
	300
	301	link->state \|= DEV_SUSPEND;
	302	if (link->state & DEV_CONFIG)
	303	pcmcia_release_configuration(link->handle);
	304
	305	return 0;
	306	}
	307
	308	static int parport_resume(struct pcmcia_device *dev)
	309	{
	310	dev_link_t *link = dev_to_instance(dev);
	311
	312	link->state &= ~DEV_SUSPEND;
	313	if (DEV_OK(link))
	314	pcmcia_request_configuration(link->handle, &link->conf);
	315
	316	return 0;
	317	}
	318
476835af DB	319	static struct pcmcia_device_id parport_ids[] = {
	320	PCMCIA_DEVICE_FUNC_ID(3),
	321	PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0003),
	322	PCMCIA_DEVICE_NULL
	323	};
	324	MODULE_DEVICE_TABLE(pcmcia, parport_ids);
	325
1da177e4 LT	326	static struct pcmcia_driver parport_cs_driver = {
	327	.owner = THIS_MODULE,
	328	.drv = {
	329	.name = "parport_cs",
	330	},
f8cfa618	331	.probe = parport_attach,
cc3b4866	332	.remove = parport_detach,
476835af	333	.id_table = parport_ids,
98e4c28b DB	334	.suspend = parport_suspend,
98e4c28b DB	335	.resume = parport_resume,
1da177e4 LT	336	};
	337
	338	static int __init init_parport_cs(void)
	339	{
	340	return pcmcia_register_driver(&parport_cs_driver);
	341	}
	342
	343	static void __exit exit_parport_cs(void)
	344	{
	345	pcmcia_unregister_driver(&parport_cs_driver);
1da177e4 LT	346	}
	347
	348	module_init(init_parport_cs);
	349	module_exit(exit_parport_cs);