[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_types.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 PCMCIA_DEBUG

static int pc_debug = PCMCIA_DEBUG;
module_param(pc_debug, int, 0);
#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)

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

#define DEBUG(n, args...) do { } while (0)
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;
    dev_node_t          node;
} 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;

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

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

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

    memset(info, 0, sizeof(struct com20020_dev_t));
    lp = dev->priv;
    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->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
    p_dev->irq.IRQInfo1 = IRQ_LEVEL_ID;
    p_dev->conf.Attributes = CONF_ENABLE_IRQ;
    p_dev->conf.IntType = INT_MEMORY_AND_IO;
    p_dev->conf.Present = PRESENT_OPTION;

    p_dev->irq.Instance = info->dev = dev;
    p_dev->priv = info;

    p_dev->state |= DEV_PRESENT;
    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;

    DEBUG(1,"detach...\n");

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

    if (link->dev_node) {
	DEBUG(1,"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);
    }

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

    /* Unlink device structure, free bits */
    DEBUG(1,"unlinking...\n");
    if (link->priv)
    {
	dev = info->dev;
	if (dev)
	{
	    DEBUG(1,"kfree...\n");
	    free_netdev(dev);
	}
	DEBUG(1,"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.

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

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

static int com20020_config(struct pcmcia_device *link)
{
    struct arcnet_local *lp;
    tuple_t tuple;
    cisparse_t parse;
    com20020_dev_t *info;
    struct net_device *dev;
    int i, last_ret, last_fn;
    u_char buf[64];
    int ioaddr;

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

    DEBUG(1,"config...\n");

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

    tuple.Attributes = 0;
    tuple.TupleData = buf;
    tuple.TupleDataMax = 64;
    tuple.TupleOffset = 0;
    tuple.DesiredTuple = CISTPL_CONFIG;
    CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
    CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
    CS_CHECK(ParseTuple, pcmcia_parse_tuple(link, &tuple, &parse));
    link->conf.ConfigBase = parse.config.base;

    /* Configure card */
    link->state |= DEV_CONFIG;

    DEBUG(1,"arcnet: baseport1 is %Xh\n", link->io.BasePort1);
    i = !CS_SUCCESS;
    if (!link->io.BasePort1)
    {
	for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x10)
	{
	    link->io.BasePort1 = ioaddr;
	    i = pcmcia_request_io(link, &link->io);
	    if (i == CS_SUCCESS)
		break;
	}
    }
    else
	i = pcmcia_request_io(link, &link->io);
    
    if (i != CS_SUCCESS)
    {
	DEBUG(1,"arcnet: requestIO failed totally!\n");
	goto failed;
    }
	
    ioaddr = dev->base_addr = link->io.BasePort1;
    DEBUG(1,"arcnet: got ioaddr %Xh\n", ioaddr);

    DEBUG(1,"arcnet: request IRQ %d (%Xh/%Xh)\n",
	   link->irq.AssignedIRQ,
	   link->irq.IRQInfo1, link->irq.IRQInfo2);
    i = pcmcia_request_irq(link, &link->irq);
    if (i != CS_SUCCESS)
    {
	DEBUG(1,"arcnet: requestIRQ failed totally!\n");
	goto failed;
    }

    dev->irq = link->irq.AssignedIRQ;

    CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));

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

    link->dev_node = &info->node;
    link->state &= ~DEV_CONFIG_PENDING;
    SET_NETDEV_DEV(dev, &handle_to_dev(link));

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

    strcpy(info->node.dev_name, dev->name);

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

cs_failed:
    cs_error(link, last_fn, last_ret);
failed:
    DEBUG(1,"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)
{
	DEBUG(0, "com20020_release(0x%p)\n", link);
	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->state & DEV_CONFIG) && (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->state & DEV_CONFIG) && (link->open)) {
		int ioaddr = dev->base_addr;
		struct arcnet_local *lp = dev->priv;
		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_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_types.h>
	47	#include <pcmcia/cs.h>
	48	#include <pcmcia/cistpl.h>
	49	#include <pcmcia/ds.h>
	50
	51	#include <asm/io.h>
	52	#include <asm/system.h>
	53
	54	#define VERSION "arcnet: COM20020 PCMCIA support loaded.\n"
	55
	56	#ifdef PCMCIA_DEBUG
	57
	58	static int pc_debug = PCMCIA_DEBUG;
	59	module_param(pc_debug, int, 0);
	60	#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
	61
	62	static void regdump(struct net_device *dev)
	63	{
	64	int ioaddr = dev->base_addr;
	65	int count;
	66
	67	printk("com20020 register dump:\n");
	68	for (count = ioaddr; count < ioaddr + 16; count++)
	69	{
	70	if (!(count % 16))
	71	printk("\n%04X: ", count);
	72	printk("%02X ", inb(count));
	73	}
	74	printk("\n");
	75
	76	printk("buffer0 dump:\n");
	77	/* set up the address register */
	78	count = 0;
	79	outb((count >> 8) \| RDDATAflag \| AUTOINCflag, _ADDR_HI);
	80	outb(count & 0xff, _ADDR_LO);
	81
	82	for (count = 0; count < 256+32; count++)
	83	{
	84	if (!(count % 16))
	85	printk("\n%04X: ", count);
	86
	87	/* copy the data */
	88	printk("%02X ", inb(_MEMDATA));
	89	}
	90	printk("\n");
	91	}
	92
	93	#else
	94
	95	#define DEBUG(n, args...) do { } while (0)
	96	static inline void regdump(struct net_device *dev) { }
	97
	98	#endif
	99
	100
	101	/====================================================================/
	102
	103	/* Parameters that can be set with 'insmod' */
	104
	105	static int node;
	106	static int timeout = 3;
	107	static int backplane;
	108	static int clockp;
	109	static int clockm;
110
111	module_param(node, int, 0);
112	module_param(timeout, int, 0);
113	module_param(backplane, int, 0);
114	module_param(clockp, int, 0);
115	module_param(clockm, int, 0);
116
117	MODULE_LICENSE("GPL");
118
119	/====================================================================/
120
15b99ac1	121	static int com20020_config(struct pcmcia_device *link);
fba395ee	122	static void com20020_release(struct pcmcia_device *link);
1da177e4	123
cc3b4866	124	static void com20020_detach(struct pcmcia_device *p_dev);
1da177e4	125
1da177e4 LT	126	/====================================================================/
	127
	128	typedef struct com20020_dev_t {
	129	struct net_device *dev;
	130	dev_node_t node;
	131	} com20020_dev_t;
	132
	133	/*======================================================================
	134
	135	com20020_attach() creates an "instance" of the driver, allocating
	136	local data structures for one device. The device is registered
	137	with Card Services.
	138
	139	======================================================================*/
	140
15b99ac1	141	static int com20020_probe(struct pcmcia_device *p_dev)
1da177e4	142	{
1da177e4 LT	143	com20020_dev_t *info;
1da177e4 LT	144	struct net_device *dev;
1da177e4	145	struct arcnet_local *lp;
f8cfa618	146
1da177e4 LT	147	DEBUG(0, "com20020_attach()\n");
	148
	149	/* Create new network device */
1da177e4 LT	150	info = kmalloc(sizeof(struct com20020_dev_t), GFP_KERNEL);
	151	if (!info)
	152	goto fail_alloc_info;
	153
	154	dev = alloc_arcdev("");
	155	if (!dev)
	156	goto fail_alloc_dev;
	157
	158	memset(info, 0, sizeof(struct com20020_dev_t));
1da177e4 LT	159	lp = dev->priv;
	160	lp->timeout = timeout;
	161	lp->backplane = backplane;
	162	lp->clockp = clockp;
	163	lp->clockm = clockm & 3;
	164	lp->hw.owner = THIS_MODULE;
	165
	166	/* fill in our module parameters as defaults */
	167	dev->dev_addr[0] = node;
	168
fd238232 DB	169	p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	170	p_dev->io.NumPorts1 = 16;
	171	p_dev->io.IOAddrLines = 16;
	172	p_dev->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
	173	p_dev->irq.IRQInfo1 = IRQ_LEVEL_ID;
	174	p_dev->conf.Attributes = CONF_ENABLE_IRQ;
	175	p_dev->conf.IntType = INT_MEMORY_AND_IO;
	176	p_dev->conf.Present = PRESENT_OPTION;
1da177e4	177
fd238232 DB	178	p_dev->irq.Instance = info->dev = dev;
fd238232 DB	179	p_dev->priv = info;
1da177e4	180
fd238232	181	p_dev->state \|= DEV_PRESENT;
15b99ac1	182	return com20020_config(p_dev);
1da177e4 LT	183
	184	fail_alloc_dev:
	185	kfree(info);
	186	fail_alloc_info:
f8cfa618	187	return -ENOMEM;
1da177e4 LT	188	} /* com20020_attach */
	189
	190	/*======================================================================
	191
	192	This deletes a driver "instance". The device is de-registered
	193	with Card Services. If it has been released, all local data
	194	structures are freed. Otherwise, the structures will be freed
	195	when the device is released.
	196
	197	======================================================================*/
	198
fba395ee	199	static void com20020_detach(struct pcmcia_device *link)
1da177e4 LT	200	{
1da177e4 LT	201	struct com20020_dev_t *info = link->priv;
b4635811 DB	202	struct net_device *dev = info->dev;
b4635811 DB	203
1da177e4 LT	204	DEBUG(1,"detach...\n");
	205
	206	DEBUG(0, "com20020_detach(0x%p)\n", link);
	207
fd238232	208	if (link->dev_node) {
1da177e4 LT	209	DEBUG(1,"unregister...\n");
	210
	211	unregister_netdev(dev);
b4635811	212
1da177e4 LT	213	/*
	214	* this is necessary because we register our IRQ separately
	215	* from card services.
	216	*/
	217	if (dev->irq)
	218	free_irq(dev->irq, dev);
	219	}
	220
	221	if (link->state & DEV_CONFIG)
	222	com20020_release(link);
	223
1da177e4 LT	224	/* Unlink device structure, free bits */
1da177e4 LT	225	DEBUG(1,"unlinking...\n");
1da177e4 LT	226	if (link->priv)
	227	{
	228	dev = info->dev;
	229	if (dev)
	230	{
	231	DEBUG(1,"kfree...\n");
	232	free_netdev(dev);
	233	}
	234	DEBUG(1,"kfree2...\n");
	235	kfree(info);
	236	}
1da177e4 LT	237
	238	} /* com20020_detach */
	239
	240	/*======================================================================
	241
	242	com20020_config() is scheduled to run after a CARD_INSERTION event
	243	is received, to configure the PCMCIA socket, and to make the
	244	device available to the system.
	245
	246	======================================================================*/
	247
	248	#define CS_CHECK(fn, ret) \
	249	do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
	250
15b99ac1	251	static int com20020_config(struct pcmcia_device *link)
1da177e4 LT	252	{
1da177e4 LT	253	struct arcnet_local *lp;
1da177e4 LT	254	tuple_t tuple;
	255	cisparse_t parse;
	256	com20020_dev_t *info;
	257	struct net_device *dev;
	258	int i, last_ret, last_fn;
	259	u_char buf[64];
	260	int ioaddr;
	261
1da177e4 LT	262	info = link->priv;
	263	dev = info->dev;
	264
	265	DEBUG(1,"config...\n");
	266
	267	DEBUG(0, "com20020_config(0x%p)\n", link);
	268
	269	tuple.Attributes = 0;
	270	tuple.TupleData = buf;
	271	tuple.TupleDataMax = 64;
	272	tuple.TupleOffset = 0;
	273	tuple.DesiredTuple = CISTPL_CONFIG;
fba395ee DB	274	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
	275	CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
	276	CS_CHECK(ParseTuple, pcmcia_parse_tuple(link, &tuple, &parse));
1da177e4 LT	277	link->conf.ConfigBase = parse.config.base;
	278
	279	/* Configure card */
	280	link->state \|= DEV_CONFIG;
	281
	282	DEBUG(1,"arcnet: baseport1 is %Xh\n", link->io.BasePort1);
	283	i = !CS_SUCCESS;
	284	if (!link->io.BasePort1)
	285	{
	286	for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x10)
	287	{
	288	link->io.BasePort1 = ioaddr;
fba395ee	289	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	290	if (i == CS_SUCCESS)
	291	break;
	292	}
	293	}
	294	else
fba395ee	295	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	296
	297	if (i != CS_SUCCESS)
	298	{
	299	DEBUG(1,"arcnet: requestIO failed totally!\n");
	300	goto failed;
	301	}
	302
	303	ioaddr = dev->base_addr = link->io.BasePort1;
	304	DEBUG(1,"arcnet: got ioaddr %Xh\n", ioaddr);
	305
	306	DEBUG(1,"arcnet: request IRQ %d (%Xh/%Xh)\n",
	307	link->irq.AssignedIRQ,
	308	link->irq.IRQInfo1, link->irq.IRQInfo2);
fba395ee	309	i = pcmcia_request_irq(link, &link->irq);
1da177e4 LT	310	if (i != CS_SUCCESS)
	311	{
	312	DEBUG(1,"arcnet: requestIRQ failed totally!\n");
	313	goto failed;
	314	}
	315
	316	dev->irq = link->irq.AssignedIRQ;
	317
fba395ee	318	CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
1da177e4 LT	319
	320	if (com20020_check(dev))
	321	{
	322	regdump(dev);
	323	goto failed;
	324	}
	325
	326	lp = dev->priv;
	327	lp->card_name = "PCMCIA COM20020";
	328	lp->card_flags = ARC_CAN_10MBIT; /* pretend all of them can 10Mbit */
	329
fd238232	330	link->dev_node = &info->node;
1da177e4	331	link->state &= ~DEV_CONFIG_PENDING;
fba395ee	332	SET_NETDEV_DEV(dev, &handle_to_dev(link));
1da177e4 LT	333
	334	i = com20020_found(dev, 0); /* calls register_netdev */
	335
	336	if (i != 0) {
	337	DEBUG(1,KERN_NOTICE "com20020_cs: com20020_found() failed\n");
fd238232	338	link->dev_node = NULL;
1da177e4 LT	339	goto failed;
	340	}
	341
	342	strcpy(info->node.dev_name, dev->name);
	343
	344	DEBUG(1,KERN_INFO "%s: port %#3lx, irq %d\n",
	345	dev->name, dev->base_addr, dev->irq);
15b99ac1	346	return 0;
1da177e4 LT	347
1da177e4 LT	348	cs_failed:
fba395ee	349	cs_error(link, last_fn, last_ret);
1da177e4 LT	350	failed:
	351	DEBUG(1,"com20020_config failed...\n");
	352	com20020_release(link);
15b99ac1	353	return -ENODEV;
1da177e4 LT	354	} /* com20020_config */
	355
	356	/*======================================================================
	357
	358	After a card is removed, com20020_release() will unregister the net
	359	device, and release the PCMCIA configuration. If the device is
	360	still open, this will be postponed until it is closed.
	361
	362	======================================================================*/
	363
fba395ee	364	static void com20020_release(struct pcmcia_device *link)
1da177e4	365	{
5f2a71fc	366	DEBUG(0, "com20020_release(0x%p)\n", link);
fba395ee	367	pcmcia_disable_device(link);
1da177e4 LT	368	}
1da177e4 LT	369
fba395ee	370	static int com20020_suspend(struct pcmcia_device *link)
98e4c28b	371	{
98e4c28b DB	372	com20020_dev_t *info = link->priv;
	373	struct net_device *dev = info->dev;
	374
8661bb5b DB	375	if ((link->state & DEV_CONFIG) && (link->open))
8661bb5b DB	376	netif_device_detach(dev);
98e4c28b DB	377
	378	return 0;
	379	}
	380
fba395ee	381	static int com20020_resume(struct pcmcia_device *link)
98e4c28b	382	{
98e4c28b DB	383	com20020_dev_t *info = link->priv;
	384	struct net_device *dev = info->dev;
	385
8661bb5b DB	386	if ((link->state & DEV_CONFIG) && (link->open)) {
	387	int ioaddr = dev->base_addr;
	388	struct arcnet_local *lp = dev->priv;
	389	ARCRESET;
	390	}
98e4c28b DB	391
	392	return 0;
	393	}
	394
7fb22bb4 DB	395	static struct pcmcia_device_id com20020_ids[] = {
	396	PCMCIA_DEVICE_PROD_ID12("Contemporary Control Systems, Inc.", "PCM20 Arcnet Adapter", 0x59991666, 0x95dfffaf),
	397	PCMCIA_DEVICE_NULL
	398	};
	399	MODULE_DEVICE_TABLE(pcmcia, com20020_ids);
1da177e4 LT	400
	401	static struct pcmcia_driver com20020_cs_driver = {
	402	.owner = THIS_MODULE,
	403	.drv = {
	404	.name = "com20020_cs",
	405	},
15b99ac1	406	.probe = com20020_probe,
cc3b4866	407	.remove = com20020_detach,
7fb22bb4	408	.id_table = com20020_ids,
98e4c28b DB	409	.suspend = com20020_suspend,
98e4c28b DB	410	.resume = com20020_resume,
1da177e4 LT	411	};
	412
	413	static int __init init_com20020_cs(void)
	414	{
	415	return pcmcia_register_driver(&com20020_cs_driver);
	416	}
	417
	418	static void __exit exit_com20020_cs(void)
	419	{
	420	pcmcia_unregister_driver(&com20020_cs_driver);
1da177e4 LT	421	}
	422
	423	module_init(init_com20020_cs);
	424	module_exit(exit_com20020_cs);