[deliverable/linux.git] / drivers / net / pcmcia / com20020_cs.c

/*
 * Linux ARCnet driver - COM20020 PCMCIA support
 * 
 * Written 1994-1999 by Avery Pennarun,
 *    based on an ISA version by David Woodhouse.
 * Derived from ibmtr_cs.c by Steve Kipisz (pcmcia-cs 3.1.4)
 *    which was derived from pcnet_cs.c by David Hinds.
 * Some additional portions derived from skeleton.c by Donald Becker.
 *
 * Special thanks to Contemporary Controls, Inc. (www.ccontrols.com)
 *  for sponsoring the further development of this driver.
 *
 * **********************
 *
 * The original copyright of skeleton.c was as follows:
 *
 * skeleton.c Written 1993 by Donald Becker.
 * Copyright 1993 United States Government as represented by the
 * Director, National Security Agency.  This software may only be used
 * and distributed according to the terms of the GNU General Public License as
 * modified by SRC, incorporated herein by reference.
 * 
 * **********************
 * Changes:
 * Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 08/08/2000
 * - reorganize kmallocs in com20020_attach, checking all for failure
 *   and releasing the previous allocations if one fails
 * **********************
 * 
 * For more details, see drivers/net/arcnet.c
 *
 * **********************
 */
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/ptrace.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/arcdevice.h>
#include <linux/com20020.h>

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

#include <asm/io.h>
#include <asm/system.h>

#define VERSION "arcnet: COM20020 PCMCIA support loaded.\n"

#ifdef DEBUG

static void regdump(struct net_device *dev)
{
    int ioaddr = dev->base_addr;
    int count;
    
    printk("com20020 register dump:\n");
    for (count = ioaddr; count < ioaddr + 16; count++)
    {
	if (!(count % 16))
	    printk("\n%04X: ", count);
	printk("%02X ", inb(count));
    }
    printk("\n");
    
    printk("buffer0 dump:\n");
	/* set up the address register */
        count = 0;
	outb((count >> 8) | RDDATAflag | AUTOINCflag, _ADDR_HI);
	outb(count & 0xff, _ADDR_LO);
    
    for (count = 0; count < 256+32; count++)
    {
	if (!(count % 16))
	    printk("\n%04X: ", count);
	
	/* copy the data */
	printk("%02X ", inb(_MEMDATA));
    }
    printk("\n");
}

#else

static inline void regdump(struct net_device *dev) { }

#endif


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

/* Parameters that can be set with 'insmod' */

static int node;
static int timeout = 3;
static int backplane;
static int clockp;
static int clockm;

module_param(node, int, 0);
module_param(timeout, int, 0);
module_param(backplane, int, 0);
module_param(clockp, int, 0);
module_param(clockm, int, 0);

MODULE_LICENSE("GPL");

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

static int com20020_config(struct pcmcia_device *link);
static void com20020_release(struct pcmcia_device *link);

static void com20020_detach(struct pcmcia_device *p_dev);

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

typedef struct com20020_dev_t {
    struct net_device       *dev;
} com20020_dev_t;

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

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

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

static int com20020_probe(struct pcmcia_device *p_dev)
{
    com20020_dev_t *info;
    struct net_device *dev;
    struct arcnet_local *lp;

    dev_dbg(&p_dev->dev, "com20020_attach()\n");

    /* Create new network device */
    info = kzalloc(sizeof(struct com20020_dev_t), GFP_KERNEL);
    if (!info)
	goto fail_alloc_info;

    dev = alloc_arcdev("");
    if (!dev)
	goto fail_alloc_dev;

    lp = netdev_priv(dev);
    lp->timeout = timeout;
    lp->backplane = backplane;
    lp->clockp = clockp;
    lp->clockm = clockm & 3;
    lp->hw.owner = THIS_MODULE;

    /* fill in our module parameters as defaults */
    dev->dev_addr[0] = node;

    p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
    p_dev->resource[0]->end = 16;
    p_dev->conf.Attributes = CONF_ENABLE_IRQ;
    p_dev->conf.IntType = INT_MEMORY_AND_IO;

    info->dev = dev;
    p_dev->priv = info;

    return com20020_config(p_dev);

fail_alloc_dev:
    kfree(info);
fail_alloc_info:
    return -ENOMEM;
} /* com20020_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 com20020_detach(struct pcmcia_device *link)
{
    struct com20020_dev_t *info = link->priv;
    struct net_device *dev = info->dev;

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

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

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

    unregister_netdev(dev);

    /*
     * this is necessary because we register our IRQ separately
     * from card services.
     */
    if (dev->irq)
	    free_irq(dev->irq, dev);

    com20020_release(link);

    /* Unlink device structure, free bits */
    dev_dbg(&link->dev, "unlinking...\n");
    if (link->priv)
    {
	dev = info->dev;
	if (dev)
	{
	    dev_dbg(&link->dev, "kfree...\n");
	    free_netdev(dev);
	}
	dev_dbg(&link->dev, "kfree2...\n");
	kfree(info);
    }

} /* com20020_detach */

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

    com20020_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 com20020_config(struct pcmcia_device *link)
{
    struct arcnet_local *lp;
    com20020_dev_t *info;
    struct net_device *dev;
    int i, ret;
    int ioaddr;

    info = link->priv;
    dev = info->dev;

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

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

    dev_dbg(&link->dev, "baseport1 is %Xh\n",
	    (unsigned int) link->resource[0]->start);

    i = -ENODEV;
    link->io_lines = 16;

    if (!link->resource[0]->start)
    {
	for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x10)
	{
	    link->resource[0]->start = ioaddr;
	    i = pcmcia_request_io(link);
	    if (i == 0)
		break;
	}
    }
    else
	i = pcmcia_request_io(link);
    
    if (i != 0)
    {
	dev_dbg(&link->dev, "requestIO failed totally!\n");
	goto failed;
    }
	
    ioaddr = dev->base_addr = link->resource[0]->start;
    dev_dbg(&link->dev, "got ioaddr %Xh\n", ioaddr);

    dev_dbg(&link->dev, "request IRQ %d\n",
	    link->irq);
    if (!link->irq)
    {
	dev_dbg(&link->dev, "requestIRQ failed totally!\n");
	goto failed;
    }

    dev->irq = link->irq;

    ret = pcmcia_request_configuration(link, &link->conf);
    if (ret)
	    goto failed;

    if (com20020_check(dev))
    {
	regdump(dev);
	goto failed;
    }
    
    lp = netdev_priv(dev);
    lp->card_name = "PCMCIA COM20020";
    lp->card_flags = ARC_CAN_10MBIT; /* pretend all of them can 10Mbit */

    SET_NETDEV_DEV(dev, &link->dev);

    i = com20020_found(dev, 0);	/* calls register_netdev */
    
    if (i != 0) {
	dev_printk(KERN_NOTICE, &link->dev,
		"com20020_cs: com20020_found() failed\n");
	goto failed;
    }

    dev_dbg(&link->dev,KERN_INFO "%s: port %#3lx, irq %d\n",
           dev->name, dev->base_addr, dev->irq);
    return 0;

failed:
    dev_dbg(&link->dev, "com20020_config failed...\n");
    com20020_release(link);
    return -ENODEV;
} /* com20020_config */

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

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

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

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

static int com20020_suspend(struct pcmcia_device *link)
{
	com20020_dev_t *info = link->priv;
	struct net_device *dev = info->dev;

	if (link->open)
		netif_device_detach(dev);

	return 0;
}

static int com20020_resume(struct pcmcia_device *link)
{
	com20020_dev_t *info = link->priv;
	struct net_device *dev = info->dev;

	if (link->open) {
		int ioaddr = dev->base_addr;
		struct arcnet_local *lp = netdev_priv(dev);
		ARCRESET;
	}

	return 0;
}

static struct pcmcia_device_id com20020_ids[] = {
	PCMCIA_DEVICE_PROD_ID12("Contemporary Control Systems, Inc.",
			"PCM20 Arcnet Adapter", 0x59991666, 0x95dfffaf),
	PCMCIA_DEVICE_PROD_ID12("SoHard AG",
			"SH ARC PCMCIA", 0xf8991729, 0x69dff0c7),
	PCMCIA_DEVICE_NULL
};
MODULE_DEVICE_TABLE(pcmcia, com20020_ids);

static struct pcmcia_driver com20020_cs_driver = {
	.owner		= THIS_MODULE,
	.drv		= {
		.name	= "com20020_cs",
	},
	.probe		= com20020_probe,
	.remove		= com20020_detach,
	.id_table	= com20020_ids,
	.suspend	= com20020_suspend,
	.resume		= com20020_resume,
};

static int __init init_com20020_cs(void)
{
	return pcmcia_register_driver(&com20020_cs_driver);
}

static void __exit exit_com20020_cs(void)
{
	pcmcia_unregister_driver(&com20020_cs_driver);
}

module_init(init_com20020_cs);
module_exit(exit_com20020_cs);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Linux ARCnet driver - COM20020 PCMCIA support
	3	*
	4	* Written 1994-1999 by Avery Pennarun,
	5	* based on an ISA version by David Woodhouse.
	6	* Derived from ibmtr_cs.c by Steve Kipisz (pcmcia-cs 3.1.4)
	7	* which was derived from pcnet_cs.c by David Hinds.
	8	* Some additional portions derived from skeleton.c by Donald Becker.
	9	*
	10	* Special thanks to Contemporary Controls, Inc. (www.ccontrols.com)
	11	* for sponsoring the further development of this driver.
	12	*
	13	* **********************
	14	*
	15	* The original copyright of skeleton.c was as follows:
	16	*
	17	* skeleton.c Written 1993 by Donald Becker.
	18	* Copyright 1993 United States Government as represented by the
	19	* Director, National Security Agency. This software may only be used
	20	* and distributed according to the terms of the GNU General Public License as
	21	* modified by SRC, incorporated herein by reference.
	22	*
	23	* **********************
	24	* Changes:
	25	* Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 08/08/2000
	26	* - reorganize kmallocs in com20020_attach, checking all for failure
	27	* and releasing the previous allocations if one fails
	28	* **********************
	29	*
	30	* For more details, see drivers/net/arcnet.c
	31	*
	32	* **********************
	33	*/
	34	#include <linux/kernel.h>
	35	#include <linux/init.h>
	36	#include <linux/ptrace.h>
	37	#include <linux/slab.h>
	38	#include <linux/string.h>
	39	#include <linux/timer.h>
	40	#include <linux/delay.h>
	41	#include <linux/module.h>
	42	#include <linux/netdevice.h>
	43	#include <linux/arcdevice.h>
	44	#include <linux/com20020.h>
	45
1da177e4 LT	46	#include <pcmcia/cs.h>
	47	#include <pcmcia/cistpl.h>
	48	#include <pcmcia/ds.h>
	49
	50	#include <asm/io.h>
	51	#include <asm/system.h>
	52
	53	#define VERSION "arcnet: COM20020 PCMCIA support loaded.\n"
	54
dd0fab5b	55	#ifdef DEBUG
1da177e4 LT	56
	57	static void regdump(struct net_device *dev)
	58	{
	59	int ioaddr = dev->base_addr;
	60	int count;
	61
	62	printk("com20020 register dump:\n");
	63	for (count = ioaddr; count < ioaddr + 16; count++)
	64	{
	65	if (!(count % 16))
	66	printk("\n%04X: ", count);
	67	printk("%02X ", inb(count));
	68	}
	69	printk("\n");
	70
	71	printk("buffer0 dump:\n");
	72	/* set up the address register */
	73	count = 0;
	74	outb((count >> 8) \| RDDATAflag \| AUTOINCflag, _ADDR_HI);
	75	outb(count & 0xff, _ADDR_LO);
	76
	77	for (count = 0; count < 256+32; count++)
	78	{
	79	if (!(count % 16))
	80	printk("\n%04X: ", count);
	81
	82	/* copy the data */
	83	printk("%02X ", inb(_MEMDATA));
	84	}
	85	printk("\n");
	86	}
	87
	88	#else
	89
1da177e4 LT	90	static inline void regdump(struct net_device *dev) { }
	91
	92	#endif
	93
	94
	95	/====================================================================/
	96
	97	/* Parameters that can be set with 'insmod' */
	98
	99	static int node;
	100	static int timeout = 3;
	101	static int backplane;
	102	static int clockp;
	103	static int clockm;
	104
	105	module_param(node, int, 0);
	106	module_param(timeout, int, 0);
	107	module_param(backplane, int, 0);
	108	module_param(clockp, int, 0);
	109	module_param(clockm, int, 0);
	110
	111	MODULE_LICENSE("GPL");
	112
	113	/====================================================================/
	114
15b99ac1	115	static int com20020_config(struct pcmcia_device *link);
fba395ee	116	static void com20020_release(struct pcmcia_device *link);
1da177e4	117
cc3b4866	118	static void com20020_detach(struct pcmcia_device *p_dev);
1da177e4	119
1da177e4 LT	120	/====================================================================/
	121
	122	typedef struct com20020_dev_t {
	123	struct net_device *dev;
1da177e4 LT	124	} com20020_dev_t;
	125
	126	/*======================================================================
	127
	128	com20020_attach() creates an "instance" of the driver, allocating
	129	local data structures for one device. The device is registered
	130	with Card Services.
	131
	132	======================================================================*/
	133
15b99ac1	134	static int com20020_probe(struct pcmcia_device *p_dev)
1da177e4	135	{
1da177e4 LT	136	com20020_dev_t *info;
1da177e4 LT	137	struct net_device *dev;
1da177e4	138	struct arcnet_local *lp;
f8cfa618	139
dd0fab5b	140	dev_dbg(&p_dev->dev, "com20020_attach()\n");
1da177e4 LT	141
1da177e4 LT	142	/* Create new network device */
dd00cc48	143	info = kzalloc(sizeof(struct com20020_dev_t), GFP_KERNEL);
1da177e4 LT	144	if (!info)
	145	goto fail_alloc_info;
	146
	147	dev = alloc_arcdev("");
	148	if (!dev)
	149	goto fail_alloc_dev;
	150
4cf1653a	151	lp = netdev_priv(dev);
1da177e4 LT	152	lp->timeout = timeout;
	153	lp->backplane = backplane;
	154	lp->clockp = clockp;
	155	lp->clockm = clockm & 3;
	156	lp->hw.owner = THIS_MODULE;
	157
	158	/* fill in our module parameters as defaults */
	159	dev->dev_addr[0] = node;
	160
90abdc3b DB	161	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_8;
90abdc3b DB	162	p_dev->resource[0]->end = 16;
fd238232 DB	163	p_dev->conf.Attributes = CONF_ENABLE_IRQ;
fd238232 DB	164	p_dev->conf.IntType = INT_MEMORY_AND_IO;
1da177e4	165
5fa9167a	166	info->dev = dev;
fd238232	167	p_dev->priv = info;
1da177e4	168
15b99ac1	169	return com20020_config(p_dev);
1da177e4 LT	170
	171	fail_alloc_dev:
	172	kfree(info);
	173	fail_alloc_info:
f8cfa618	174	return -ENOMEM;
1da177e4 LT	175	} /* com20020_attach */
	176
	177	/*======================================================================
	178
	179	This deletes a driver "instance". The device is de-registered
	180	with Card Services. If it has been released, all local data
	181	structures are freed. Otherwise, the structures will be freed
	182	when the device is released.
	183
	184	======================================================================*/
	185
fba395ee	186	static void com20020_detach(struct pcmcia_device *link)
1da177e4 LT	187	{
1da177e4 LT	188	struct com20020_dev_t *info = link->priv;
b4635811 DB	189	struct net_device *dev = info->dev;
b4635811 DB	190
dd0fab5b	191	dev_dbg(&link->dev, "detach...\n");
1da177e4	192
dd0fab5b	193	dev_dbg(&link->dev, "com20020_detach\n");
1da177e4	194
c7c2fa07	195	dev_dbg(&link->dev, "unregister...\n");
1da177e4	196
c7c2fa07	197	unregister_netdev(dev);
b4635811	198
c7c2fa07 DB	199	/*
	200	* this is necessary because we register our IRQ separately
	201	* from card services.
	202	*/
	203	if (dev->irq)
1da177e4	204	free_irq(dev->irq, dev);
1da177e4	205
e2d40963	206	com20020_release(link);
1da177e4	207
1da177e4	208	/* Unlink device structure, free bits */
dd0fab5b	209	dev_dbg(&link->dev, "unlinking...\n");
1da177e4 LT	210	if (link->priv)
	211	{
	212	dev = info->dev;
	213	if (dev)
	214	{
dd0fab5b	215	dev_dbg(&link->dev, "kfree...\n");
1da177e4 LT	216	free_netdev(dev);
1da177e4 LT	217	}
dd0fab5b	218	dev_dbg(&link->dev, "kfree2...\n");
1da177e4 LT	219	kfree(info);
1da177e4 LT	220	}
1da177e4 LT	221
	222	} /* com20020_detach */
	223
	224	/*======================================================================
	225
	226	com20020_config() is scheduled to run after a CARD_INSERTION event
	227	is received, to configure the PCMCIA socket, and to make the
	228	device available to the system.
	229
	230	======================================================================*/
	231
15b99ac1	232	static int com20020_config(struct pcmcia_device *link)
1da177e4 LT	233	{
1da177e4 LT	234	struct arcnet_local *lp;
1da177e4 LT	235	com20020_dev_t *info;
1da177e4 LT	236	struct net_device *dev;
dd0fab5b	237	int i, ret;
1da177e4 LT	238	int ioaddr;
1da177e4 LT	239
1da177e4 LT	240	info = link->priv;
	241	dev = info->dev;
	242
dd0fab5b	243	dev_dbg(&link->dev, "config...\n");
1da177e4	244
dd0fab5b	245	dev_dbg(&link->dev, "com20020_config\n");
1da177e4	246
90abdc3b DB	247	dev_dbg(&link->dev, "baseport1 is %Xh\n",
	248	(unsigned int) link->resource[0]->start);
	249
4c89e88b	250	i = -ENODEV;
90abdc3b DB	251	link->io_lines = 16;
	252
	253	if (!link->resource[0]->start)
1da177e4 LT	254	{
	255	for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x10)
	256	{
90abdc3b DB	257	link->resource[0]->start = ioaddr;
90abdc3b DB	258	i = pcmcia_request_io(link);
4c89e88b	259	if (i == 0)
1da177e4 LT	260	break;
	261	}
	262	}
	263	else
90abdc3b	264	i = pcmcia_request_io(link);
1da177e4	265
4c89e88b	266	if (i != 0)
1da177e4	267	{
dd0fab5b	268	dev_dbg(&link->dev, "requestIO failed totally!\n");
1da177e4 LT	269	goto failed;
	270	}
	271
9a017a91	272	ioaddr = dev->base_addr = link->resource[0]->start;
dd0fab5b	273	dev_dbg(&link->dev, "got ioaddr %Xh\n", ioaddr);
1da177e4	274
5fa9167a	275	dev_dbg(&link->dev, "request IRQ %d\n",
eb14120f DB	276	link->irq);
eb14120f DB	277	if (!link->irq)
1da177e4	278	{
dd0fab5b	279	dev_dbg(&link->dev, "requestIRQ failed totally!\n");
1da177e4 LT	280	goto failed;
	281	}
	282
eb14120f	283	dev->irq = link->irq;
1da177e4	284
dd0fab5b DB	285	ret = pcmcia_request_configuration(link, &link->conf);
	286	if (ret)
	287	goto failed;
1da177e4 LT	288
	289	if (com20020_check(dev))
	290	{
	291	regdump(dev);
	292	goto failed;
	293	}
	294
4cf1653a	295	lp = netdev_priv(dev);
1da177e4 LT	296	lp->card_name = "PCMCIA COM20020";
	297	lp->card_flags = ARC_CAN_10MBIT; /* pretend all of them can 10Mbit */
	298
dd2e5a15	299	SET_NETDEV_DEV(dev, &link->dev);
1da177e4 LT	300
	301	i = com20020_found(dev, 0); /* calls register_netdev */
	302
	303	if (i != 0) {
dd0fab5b DB	304	dev_printk(KERN_NOTICE, &link->dev,
dd0fab5b DB	305	"com20020_cs: com20020_found() failed\n");
1da177e4 LT	306	goto failed;
	307	}
	308
dd0fab5b	309	dev_dbg(&link->dev,KERN_INFO "%s: port %#3lx, irq %d\n",
1da177e4	310	dev->name, dev->base_addr, dev->irq);
15b99ac1	311	return 0;
1da177e4	312
1da177e4	313	failed:
dd0fab5b	314	dev_dbg(&link->dev, "com20020_config failed...\n");
1da177e4	315	com20020_release(link);
15b99ac1	316	return -ENODEV;
1da177e4 LT	317	} /* com20020_config */
	318
	319	/*======================================================================
	320
	321	After a card is removed, com20020_release() will unregister the net
	322	device, and release the PCMCIA configuration. If the device is
	323	still open, this will be postponed until it is closed.
	324
	325	======================================================================*/
	326
fba395ee	327	static void com20020_release(struct pcmcia_device *link)
1da177e4	328	{
dd0fab5b	329	dev_dbg(&link->dev, "com20020_release\n");
fba395ee	330	pcmcia_disable_device(link);
1da177e4 LT	331	}
1da177e4 LT	332
fba395ee	333	static int com20020_suspend(struct pcmcia_device *link)
98e4c28b	334	{
98e4c28b DB	335	com20020_dev_t *info = link->priv;
	336	struct net_device *dev = info->dev;
	337
e2d40963	338	if (link->open)
8661bb5b	339	netif_device_detach(dev);
98e4c28b DB	340
	341	return 0;
	342	}
	343
fba395ee	344	static int com20020_resume(struct pcmcia_device *link)
98e4c28b	345	{
98e4c28b DB	346	com20020_dev_t *info = link->priv;
	347	struct net_device *dev = info->dev;
	348
e2d40963	349	if (link->open) {
8661bb5b	350	int ioaddr = dev->base_addr;
4cf1653a	351	struct arcnet_local *lp = netdev_priv(dev);
8661bb5b DB	352	ARCRESET;
8661bb5b DB	353	}
98e4c28b DB	354
	355	return 0;
	356	}
	357
7fb22bb4	358	static struct pcmcia_device_id com20020_ids[] = {
6bb1c39a MS	359	PCMCIA_DEVICE_PROD_ID12("Contemporary Control Systems, Inc.",
	360	"PCM20 Arcnet Adapter", 0x59991666, 0x95dfffaf),
	361	PCMCIA_DEVICE_PROD_ID12("SoHard AG",
	362	"SH ARC PCMCIA", 0xf8991729, 0x69dff0c7),
7fb22bb4 DB	363	PCMCIA_DEVICE_NULL
	364	};
	365	MODULE_DEVICE_TABLE(pcmcia, com20020_ids);
1da177e4 LT	366
	367	static struct pcmcia_driver com20020_cs_driver = {
	368	.owner = THIS_MODULE,
	369	.drv = {
	370	.name = "com20020_cs",
	371	},
15b99ac1	372	.probe = com20020_probe,
cc3b4866	373	.remove = com20020_detach,
7fb22bb4	374	.id_table = com20020_ids,
98e4c28b DB	375	.suspend = com20020_suspend,
98e4c28b DB	376	.resume = com20020_resume,
1da177e4 LT	377	};
	378
	379	static int __init init_com20020_cs(void)
	380	{
	381	return pcmcia_register_driver(&com20020_cs_driver);
	382	}
	383
	384	static void __exit exit_com20020_cs(void)
	385	{
	386	pcmcia_unregister_driver(&com20020_cs_driver);
1da177e4 LT	387	}
	388
	389	module_init(init_com20020_cs);
	390	module_exit(exit_com20020_cs);