[GitHub/mt8127/android_kernel_alcatel_ttab.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->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
    p_dev->io.NumPorts1 = 16;
    p_dev->io.IOAddrLines = 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", link->io.BasePort1);
    i = -ENODEV;
    if (!link->io.BasePort1)
    {
	for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x10)
	{
	    link->io.BasePort1 = ioaddr;
	    i = pcmcia_request_io(link, &link->io);
	    if (i == 0)
		break;
	}
    }
    else
	i = pcmcia_request_io(link, &link->io);
    
    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
fd238232 DB	161	p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	162	p_dev->io.NumPorts1 = 16;
	163	p_dev->io.IOAddrLines = 16;
fd238232 DB	164	p_dev->conf.Attributes = CONF_ENABLE_IRQ;
fd238232 DB	165	p_dev->conf.IntType = INT_MEMORY_AND_IO;
1da177e4	166
5fa9167a	167	info->dev = dev;
fd238232	168	p_dev->priv = info;
1da177e4	169
15b99ac1	170	return com20020_config(p_dev);
1da177e4 LT	171
	172	fail_alloc_dev:
	173	kfree(info);
	174	fail_alloc_info:
f8cfa618	175	return -ENOMEM;
1da177e4 LT	176	} /* com20020_attach */
	177
	178	/*======================================================================
	179
	180	This deletes a driver "instance". The device is de-registered
	181	with Card Services. If it has been released, all local data
	182	structures are freed. Otherwise, the structures will be freed
	183	when the device is released.
	184
	185	======================================================================*/
	186
fba395ee	187	static void com20020_detach(struct pcmcia_device *link)
1da177e4 LT	188	{
1da177e4 LT	189	struct com20020_dev_t *info = link->priv;
b4635811 DB	190	struct net_device *dev = info->dev;
b4635811 DB	191
dd0fab5b	192	dev_dbg(&link->dev, "detach...\n");
1da177e4	193
dd0fab5b	194	dev_dbg(&link->dev, "com20020_detach\n");
1da177e4	195
c7c2fa07	196	dev_dbg(&link->dev, "unregister...\n");
1da177e4	197
c7c2fa07	198	unregister_netdev(dev);
b4635811	199
c7c2fa07 DB	200	/*
	201	* this is necessary because we register our IRQ separately
	202	* from card services.
	203	*/
	204	if (dev->irq)
1da177e4	205	free_irq(dev->irq, dev);
1da177e4	206
e2d40963	207	com20020_release(link);
1da177e4	208
1da177e4	209	/* Unlink device structure, free bits */
dd0fab5b	210	dev_dbg(&link->dev, "unlinking...\n");
1da177e4 LT	211	if (link->priv)
	212	{
	213	dev = info->dev;
	214	if (dev)
	215	{
dd0fab5b	216	dev_dbg(&link->dev, "kfree...\n");
1da177e4 LT	217	free_netdev(dev);
1da177e4 LT	218	}
dd0fab5b	219	dev_dbg(&link->dev, "kfree2...\n");
1da177e4 LT	220	kfree(info);
1da177e4 LT	221	}
1da177e4 LT	222
	223	} /* com20020_detach */
	224
	225	/*======================================================================
	226
	227	com20020_config() is scheduled to run after a CARD_INSERTION event
	228	is received, to configure the PCMCIA socket, and to make the
	229	device available to the system.
	230
	231	======================================================================*/
	232
15b99ac1	233	static int com20020_config(struct pcmcia_device *link)
1da177e4 LT	234	{
1da177e4 LT	235	struct arcnet_local *lp;
1da177e4 LT	236	com20020_dev_t *info;
1da177e4 LT	237	struct net_device *dev;
dd0fab5b	238	int i, ret;
1da177e4 LT	239	int ioaddr;
1da177e4 LT	240
1da177e4 LT	241	info = link->priv;
	242	dev = info->dev;
	243
dd0fab5b	244	dev_dbg(&link->dev, "config...\n");
1da177e4	245
dd0fab5b	246	dev_dbg(&link->dev, "com20020_config\n");
1da177e4	247
dd0fab5b	248	dev_dbg(&link->dev, "baseport1 is %Xh\n", link->io.BasePort1);
4c89e88b	249	i = -ENODEV;
1da177e4 LT	250	if (!link->io.BasePort1)
	251	{
	252	for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x10)
	253	{
	254	link->io.BasePort1 = ioaddr;
fba395ee	255	i = pcmcia_request_io(link, &link->io);
4c89e88b	256	if (i == 0)
1da177e4 LT	257	break;
	258	}
	259	}
	260	else
fba395ee	261	i = pcmcia_request_io(link, &link->io);
1da177e4	262
4c89e88b	263	if (i != 0)
1da177e4	264	{
dd0fab5b	265	dev_dbg(&link->dev, "requestIO failed totally!\n");
1da177e4 LT	266	goto failed;
	267	}
	268
9a017a91	269	ioaddr = dev->base_addr = link->resource[0]->start;
dd0fab5b	270	dev_dbg(&link->dev, "got ioaddr %Xh\n", ioaddr);
1da177e4	271
5fa9167a	272	dev_dbg(&link->dev, "request IRQ %d\n",
eb14120f DB	273	link->irq);
eb14120f DB	274	if (!link->irq)
1da177e4	275	{
dd0fab5b	276	dev_dbg(&link->dev, "requestIRQ failed totally!\n");
1da177e4 LT	277	goto failed;
	278	}
	279
eb14120f	280	dev->irq = link->irq;
1da177e4	281
dd0fab5b DB	282	ret = pcmcia_request_configuration(link, &link->conf);
	283	if (ret)
	284	goto failed;
1da177e4 LT	285
	286	if (com20020_check(dev))
	287	{
	288	regdump(dev);
	289	goto failed;
	290	}
	291
4cf1653a	292	lp = netdev_priv(dev);
1da177e4 LT	293	lp->card_name = "PCMCIA COM20020";
	294	lp->card_flags = ARC_CAN_10MBIT; /* pretend all of them can 10Mbit */
	295
dd2e5a15	296	SET_NETDEV_DEV(dev, &link->dev);
1da177e4 LT	297
	298	i = com20020_found(dev, 0); /* calls register_netdev */
	299
	300	if (i != 0) {
dd0fab5b DB	301	dev_printk(KERN_NOTICE, &link->dev,
dd0fab5b DB	302	"com20020_cs: com20020_found() failed\n");
1da177e4 LT	303	goto failed;
	304	}
	305
dd0fab5b	306	dev_dbg(&link->dev,KERN_INFO "%s: port %#3lx, irq %d\n",
1da177e4	307	dev->name, dev->base_addr, dev->irq);
15b99ac1	308	return 0;
1da177e4	309
1da177e4	310	failed:
dd0fab5b	311	dev_dbg(&link->dev, "com20020_config failed...\n");
1da177e4	312	com20020_release(link);
15b99ac1	313	return -ENODEV;
1da177e4 LT	314	} /* com20020_config */
	315
	316	/*======================================================================
	317
	318	After a card is removed, com20020_release() will unregister the net
	319	device, and release the PCMCIA configuration. If the device is
	320	still open, this will be postponed until it is closed.
	321
	322	======================================================================*/
	323
fba395ee	324	static void com20020_release(struct pcmcia_device *link)
1da177e4	325	{
dd0fab5b	326	dev_dbg(&link->dev, "com20020_release\n");
fba395ee	327	pcmcia_disable_device(link);
1da177e4 LT	328	}
1da177e4 LT	329
fba395ee	330	static int com20020_suspend(struct pcmcia_device *link)
98e4c28b	331	{
98e4c28b DB	332	com20020_dev_t *info = link->priv;
	333	struct net_device *dev = info->dev;
	334
e2d40963	335	if (link->open)
8661bb5b	336	netif_device_detach(dev);
98e4c28b DB	337
	338	return 0;
	339	}
	340
fba395ee	341	static int com20020_resume(struct pcmcia_device *link)
98e4c28b	342	{
98e4c28b DB	343	com20020_dev_t *info = link->priv;
	344	struct net_device *dev = info->dev;
	345
e2d40963	346	if (link->open) {
8661bb5b	347	int ioaddr = dev->base_addr;
4cf1653a	348	struct arcnet_local *lp = netdev_priv(dev);
8661bb5b DB	349	ARCRESET;
8661bb5b DB	350	}
98e4c28b DB	351
	352	return 0;
	353	}
	354
7fb22bb4	355	static struct pcmcia_device_id com20020_ids[] = {
6bb1c39a MS	356	PCMCIA_DEVICE_PROD_ID12("Contemporary Control Systems, Inc.",
	357	"PCM20 Arcnet Adapter", 0x59991666, 0x95dfffaf),
	358	PCMCIA_DEVICE_PROD_ID12("SoHard AG",
	359	"SH ARC PCMCIA", 0xf8991729, 0x69dff0c7),
7fb22bb4 DB	360	PCMCIA_DEVICE_NULL
	361	};
	362	MODULE_DEVICE_TABLE(pcmcia, com20020_ids);
1da177e4 LT	363
	364	static struct pcmcia_driver com20020_cs_driver = {
	365	.owner = THIS_MODULE,
	366	.drv = {
	367	.name = "com20020_cs",
	368	},
15b99ac1	369	.probe = com20020_probe,
cc3b4866	370	.remove = com20020_detach,
7fb22bb4	371	.id_table = com20020_ids,
98e4c28b DB	372	.suspend = com20020_suspend,
98e4c28b DB	373	.resume = com20020_resume,
1da177e4 LT	374	};
	375
	376	static int __init init_com20020_cs(void)
	377	{
	378	return pcmcia_register_driver(&com20020_cs_driver);
	379	}
	380
	381	static void __exit exit_com20020_cs(void)
	382	{
	383	pcmcia_unregister_driver(&com20020_cs_driver);
1da177e4 LT	384	}
	385
	386	module_init(init_com20020_cs);
	387	module_exit(exit_com20020_cs);