[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 void com20020_config(dev_link_t *link);
static void com20020_release(dev_link_t *link);
static int com20020_event(event_t event, int priority,
                       event_callback_args_t *args);

static dev_info_t dev_info = "com20020_cs";

static dev_link_t *com20020_attach(void);
static void com20020_detach(struct pcmcia_device *p_dev);

static dev_link_t *dev_list;

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

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 dev_link_t *com20020_attach(void)
{
    client_reg_t client_reg;
    dev_link_t *link;
    com20020_dev_t *info;
    struct net_device *dev;
    int ret;
    struct arcnet_local *lp;
    
    DEBUG(0, "com20020_attach()\n");

    /* Create new network device */
    link = kmalloc(sizeof(struct dev_link_t), GFP_KERNEL);
    if (!link)
	return NULL;

    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));
    memset(link, 0, sizeof(struct dev_link_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;

    link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
    link->io.NumPorts1 = 16;
    link->io.IOAddrLines = 16;
    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->conf.Present = PRESENT_OPTION;


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

    /* Register with Card Services */
    link->next = dev_list;
    dev_list = link;
    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 != 0) {
        cs_error(link->handle, RegisterClient, ret);
        com20020_detach(link->handle);
        return NULL;
    }

    return link;

fail_alloc_dev:
    kfree(info);
fail_alloc_info:
    kfree(link);
    return NULL;
} /* 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 *p_dev)
{
    dev_link_t *link = dev_to_instance(p_dev);
    struct com20020_dev_t *info = link->priv;
    dev_link_t **linkp;
    struct net_device *dev; 
    
    DEBUG(1,"detach...\n");

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

    /* Locate device structure */
    for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
        if (*linkp == link) break;
    if (*linkp == NULL)
        return;

    dev = info->dev;

    if (link->dev) {
	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");
    *linkp = link->next;
    if (link->priv)
    {
	dev = info->dev;
	if (dev)
	{
	    DEBUG(1,"kfree...\n");
	    free_netdev(dev);
	}
	DEBUG(1,"kfree2...\n");
	kfree(info);
    }
    DEBUG(1,"kfree3...\n");
    kfree(link);

} /* 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 void com20020_config(dev_link_t *link)
{
    struct arcnet_local *lp;
    client_handle_t handle;
    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;

    handle = link->handle;
    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(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;

    /* 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->handle, &link->io);
	    if (i == CS_SUCCESS)
		break;
	}
    }
    else
	i = pcmcia_request_io(link->handle, &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->handle, &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->handle, &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 = &info->node;
    link->state &= ~DEV_CONFIG_PENDING;
    SET_NETDEV_DEV(dev, &handle_to_dev(handle));

    i = com20020_found(dev, 0);	/* calls register_netdev */
    
    if (i != 0) {
	DEBUG(1,KERN_NOTICE "com20020_cs: com20020_found() failed\n");
	link->dev = 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;

cs_failed:
    cs_error(link->handle, last_fn, last_ret);
failed:
    DEBUG(1,"com20020_config failed...\n");
    com20020_release(link);
} /* 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(dev_link_t *link)
{

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

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

    pcmcia_release_configuration(link->handle);
    pcmcia_release_io(link->handle, &link->io);
    pcmcia_release_irq(link->handle, &link->irq);

    link->state &= ~(DEV_CONFIG | DEV_RELEASE_PENDING);
}

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

	link->state |= DEV_SUSPEND;
        if (link->state & DEV_CONFIG) {
		if (link->open) {
			netif_device_detach(dev);
		}
		pcmcia_release_configuration(link->handle);
        }

	return 0;
}

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

	link->state &= ~DEV_SUSPEND;
        if (link->state & DEV_CONFIG) {
		pcmcia_request_configuration(link->handle, &link->conf);
		if (link->open) {
			int ioaddr = dev->base_addr;
			struct arcnet_local *lp = dev->priv;
			ARCRESET;
		}
        }

	return 0;
}

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

    The card status event handler.  Mostly, this schedules other
    stuff to run after an event is received.  A CARD_REMOVAL event
    also sets some flags to discourage the net drivers from trying
    to talk to the card any more.

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

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

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

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",
	},
	.attach		= com20020_attach,
	.event		= com20020_event,
	.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);
	BUG_ON(dev_list != NULL);
}

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
121	static void com20020_config(dev_link_t *link);
122	static void com20020_release(dev_link_t *link);
123	static int com20020_event(event_t event, int priority,
124	event_callback_args_t *args);
125
126	static dev_info_t dev_info = "com20020_cs";
127
128	static dev_link_t *com20020_attach(void);
cc3b4866	129	static void com20020_detach(struct pcmcia_device *p_dev);
1da177e4 LT	130
	131	static dev_link_t *dev_list;
	132
	133	/====================================================================/
	134
	135	typedef struct com20020_dev_t {
	136	struct net_device *dev;
	137	dev_node_t node;
	138	} com20020_dev_t;
	139
	140	/*======================================================================
	141
	142	com20020_attach() creates an "instance" of the driver, allocating
	143	local data structures for one device. The device is registered
	144	with Card Services.
	145
	146	======================================================================*/
	147
	148	static dev_link_t *com20020_attach(void)
	149	{
	150	client_reg_t client_reg;
	151	dev_link_t *link;
	152	com20020_dev_t *info;
	153	struct net_device *dev;
	154	int ret;
	155	struct arcnet_local *lp;
	156
	157	DEBUG(0, "com20020_attach()\n");
	158
	159	/* Create new network device */
	160	link = kmalloc(sizeof(struct dev_link_t), GFP_KERNEL);
	161	if (!link)
	162	return NULL;
	163
	164	info = kmalloc(sizeof(struct com20020_dev_t), GFP_KERNEL);
	165	if (!info)
	166	goto fail_alloc_info;
	167
	168	dev = alloc_arcdev("");
	169	if (!dev)
	170	goto fail_alloc_dev;
	171
	172	memset(info, 0, sizeof(struct com20020_dev_t));
	173	memset(link, 0, sizeof(struct dev_link_t));
	174	lp = dev->priv;
	175	lp->timeout = timeout;
	176	lp->backplane = backplane;
	177	lp->clockp = clockp;
	178	lp->clockm = clockm & 3;
	179	lp->hw.owner = THIS_MODULE;
	180
	181	/* fill in our module parameters as defaults */
	182	dev->dev_addr[0] = node;
	183
	184	link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	185	link->io.NumPorts1 = 16;
	186	link->io.IOAddrLines = 16;
	187	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
	188	link->irq.IRQInfo1 = IRQ_LEVEL_ID;
	189	link->conf.Attributes = CONF_ENABLE_IRQ;
	190	link->conf.Vcc = 50;
	191	link->conf.IntType = INT_MEMORY_AND_IO;
	192	link->conf.Present = PRESENT_OPTION;
	193
194
195	link->irq.Instance = info->dev = dev;
196	link->priv = info;
197
198	/* Register with Card Services */
199	link->next = dev_list;
200	dev_list = link;
201	client_reg.dev_info = &dev_info;
1da177e4 LT	202	client_reg.Version = 0x0210;
	203	client_reg.event_callback_args.client_data = link;
	204	ret = pcmcia_register_client(&link->handle, &client_reg);
	205	if (ret != 0) {
	206	cs_error(link->handle, RegisterClient, ret);
cc3b4866	207	com20020_detach(link->handle);
1da177e4 LT	208	return NULL;
	209	}
	210
	211	return link;
	212
	213	fail_alloc_dev:
	214	kfree(info);
	215	fail_alloc_info:
	216	kfree(link);
	217	return NULL;
	218	} /* com20020_attach */
	219
	220	/*======================================================================
	221
	222	This deletes a driver "instance". The device is de-registered
	223	with Card Services. If it has been released, all local data
	224	structures are freed. Otherwise, the structures will be freed
	225	when the device is released.
	226
	227	======================================================================*/
	228
cc3b4866	229	static void com20020_detach(struct pcmcia_device *p_dev)
1da177e4	230	{
cc3b4866	231	dev_link_t *link = dev_to_instance(p_dev);
1da177e4 LT	232	struct com20020_dev_t *info = link->priv;
	233	dev_link_t **linkp;
	234	struct net_device *dev;
	235
	236	DEBUG(1,"detach...\n");
	237
	238	DEBUG(0, "com20020_detach(0x%p)\n", link);
	239
	240	/* Locate device structure */
	241	for (linkp = &dev_list; linkp; linkp = &(linkp)->next)
	242	if (*linkp == link) break;
	243	if (*linkp == NULL)
	244	return;
	245
	246	dev = info->dev;
	247
	248	if (link->dev) {
	249	DEBUG(1,"unregister...\n");
	250
	251	unregister_netdev(dev);
	252
	253	/*
	254	* this is necessary because we register our IRQ separately
	255	* from card services.
	256	*/
	257	if (dev->irq)
	258	free_irq(dev->irq, dev);
	259	}
	260
	261	if (link->state & DEV_CONFIG)
	262	com20020_release(link);
	263
1da177e4 LT	264	/* Unlink device structure, free bits */
	265	DEBUG(1,"unlinking...\n");
	266	*linkp = link->next;
	267	if (link->priv)
	268	{
	269	dev = info->dev;
	270	if (dev)
	271	{
	272	DEBUG(1,"kfree...\n");
	273	free_netdev(dev);
	274	}
	275	DEBUG(1,"kfree2...\n");
	276	kfree(info);
	277	}
	278	DEBUG(1,"kfree3...\n");
	279	kfree(link);
	280
	281	} /* com20020_detach */
	282
	283	/*======================================================================
	284
	285	com20020_config() is scheduled to run after a CARD_INSERTION event
	286	is received, to configure the PCMCIA socket, and to make the
	287	device available to the system.
	288
	289	======================================================================*/
	290
	291	#define CS_CHECK(fn, ret) \
	292	do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
	293
	294	static void com20020_config(dev_link_t *link)
	295	{
	296	struct arcnet_local *lp;
	297	client_handle_t handle;
	298	tuple_t tuple;
	299	cisparse_t parse;
	300	com20020_dev_t *info;
	301	struct net_device *dev;
	302	int i, last_ret, last_fn;
	303	u_char buf[64];
	304	int ioaddr;
	305
	306	handle = link->handle;
	307	info = link->priv;
	308	dev = info->dev;
	309
	310	DEBUG(1,"config...\n");
	311
	312	DEBUG(0, "com20020_config(0x%p)\n", link);
	313
	314	tuple.Attributes = 0;
	315	tuple.TupleData = buf;
	316	tuple.TupleDataMax = 64;
	317	tuple.TupleOffset = 0;
	318	tuple.DesiredTuple = CISTPL_CONFIG;
	319	CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
	320	CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
	321	CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
	322	link->conf.ConfigBase = parse.config.base;
	323
	324	/* Configure card */
	325	link->state \|= DEV_CONFIG;
	326
	327	DEBUG(1,"arcnet: baseport1 is %Xh\n", link->io.BasePort1);
328	i = !CS_SUCCESS;
329	if (!link->io.BasePort1)
330	{
331	for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x10)
332	{
333	link->io.BasePort1 = ioaddr;
334	i = pcmcia_request_io(link->handle, &link->io);
335	if (i == CS_SUCCESS)
336	break;
337	}
338	}
339	else
340	i = pcmcia_request_io(link->handle, &link->io);
341
342	if (i != CS_SUCCESS)
343	{
344	DEBUG(1,"arcnet: requestIO failed totally!\n");
345	goto failed;
346	}
347
348	ioaddr = dev->base_addr = link->io.BasePort1;
349	DEBUG(1,"arcnet: got ioaddr %Xh\n", ioaddr);
350
351	DEBUG(1,"arcnet: request IRQ %d (%Xh/%Xh)\n",
352	link->irq.AssignedIRQ,
353	link->irq.IRQInfo1, link->irq.IRQInfo2);
354	i = pcmcia_request_irq(link->handle, &link->irq);
355	if (i != CS_SUCCESS)
356	{
357	DEBUG(1,"arcnet: requestIRQ failed totally!\n");
358	goto failed;
359	}
360
361	dev->irq = link->irq.AssignedIRQ;
362
363	CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
364
365	if (com20020_check(dev))
366	{
367	regdump(dev);
368	goto failed;
369	}
370
371	lp = dev->priv;
372	lp->card_name = "PCMCIA COM20020";
373	lp->card_flags = ARC_CAN_10MBIT; /* pretend all of them can 10Mbit */
374
375	link->dev = &info->node;
376	link->state &= ~DEV_CONFIG_PENDING;
377	SET_NETDEV_DEV(dev, &handle_to_dev(handle));
378
379	i = com20020_found(dev, 0); /* calls register_netdev */
380
381	if (i != 0) {
382	DEBUG(1,KERN_NOTICE "com20020_cs: com20020_found() failed\n");
383	link->dev = NULL;
384	goto failed;
385	}
386
387	strcpy(info->node.dev_name, dev->name);
388
389	DEBUG(1,KERN_INFO "%s: port %#3lx, irq %d\n",
390	dev->name, dev->base_addr, dev->irq);
391	return;
392
393	cs_failed:
394	cs_error(link->handle, last_fn, last_ret);
395	failed:
396	DEBUG(1,"com20020_config failed...\n");
397	com20020_release(link);
398	} /* com20020_config */
399
400	/*======================================================================
401
402	After a card is removed, com20020_release() will unregister the net
403	device, and release the PCMCIA configuration. If the device is
404	still open, this will be postponed until it is closed.
405
406	======================================================================*/
407
408	static void com20020_release(dev_link_t *link)
409	{
410
411	DEBUG(1,"release...\n");
412
413	DEBUG(0, "com20020_release(0x%p)\n", link);
414
415	pcmcia_release_configuration(link->handle);
416	pcmcia_release_io(link->handle, &link->io);
417	pcmcia_release_irq(link->handle, &link->irq);
418
419	link->state &= ~(DEV_CONFIG \| DEV_RELEASE_PENDING);
420	}
421
98e4c28b DB	422	static int com20020_suspend(struct pcmcia_device *p_dev)
	423	{
	424	dev_link_t *link = dev_to_instance(p_dev);
	425	com20020_dev_t *info = link->priv;
	426	struct net_device *dev = info->dev;
	427
	428	link->state \|= DEV_SUSPEND;
	429	if (link->state & DEV_CONFIG) {
	430	if (link->open) {
	431	netif_device_detach(dev);
	432	}
	433	pcmcia_release_configuration(link->handle);
	434	}
	435
	436	return 0;
	437	}
	438
	439	static int com20020_resume(struct pcmcia_device *p_dev)
	440	{
	441	dev_link_t *link = dev_to_instance(p_dev);
	442	com20020_dev_t *info = link->priv;
	443	struct net_device *dev = info->dev;
	444
	445	link->state &= ~DEV_SUSPEND;
	446	if (link->state & DEV_CONFIG) {
	447	pcmcia_request_configuration(link->handle, &link->conf);
	448	if (link->open) {
	449	int ioaddr = dev->base_addr;
	450	struct arcnet_local *lp = dev->priv;
	451	ARCRESET;
	452	}
	453	}
	454
	455	return 0;
	456	}
	457
1da177e4 LT	458	/*======================================================================
	459
	460	The card status event handler. Mostly, this schedules other
	461	stuff to run after an event is received. A CARD_REMOVAL event
	462	also sets some flags to discourage the net drivers from trying
	463	to talk to the card any more.
	464
	465	======================================================================*/
	466
	467	static int com20020_event(event_t event, int priority,
	468	event_callback_args_t *args)
	469	{
	470	dev_link_t *link = args->client_data;
1da177e4 LT	471
	472	DEBUG(1, "com20020_event(0x%06x)\n", event);
	473
	474	switch (event) {
1da177e4 LT	475	case CS_EVENT_CARD_INSERTION:
	476	link->state \|= DEV_PRESENT;
	477	com20020_config(link);
	478	break;
1da177e4 LT	479	}
	480	return 0;
	481	} /* com20020_event */
	482
7fb22bb4 DB	483	static struct pcmcia_device_id com20020_ids[] = {
	484	PCMCIA_DEVICE_PROD_ID12("Contemporary Control Systems, Inc.", "PCM20 Arcnet Adapter", 0x59991666, 0x95dfffaf),
	485	PCMCIA_DEVICE_NULL
	486	};
	487	MODULE_DEVICE_TABLE(pcmcia, com20020_ids);
1da177e4 LT	488
	489	static struct pcmcia_driver com20020_cs_driver = {
	490	.owner = THIS_MODULE,
	491	.drv = {
	492	.name = "com20020_cs",
	493	},
	494	.attach = com20020_attach,
1e212f36	495	.event = com20020_event,
cc3b4866	496	.remove = com20020_detach,
7fb22bb4	497	.id_table = com20020_ids,
98e4c28b DB	498	.suspend = com20020_suspend,
98e4c28b DB	499	.resume = com20020_resume,
1da177e4 LT	500	};
	501
	502	static int __init init_com20020_cs(void)
	503	{
	504	return pcmcia_register_driver(&com20020_cs_driver);
	505	}
	506
	507	static void __exit exit_com20020_cs(void)
	508	{
	509	pcmcia_unregister_driver(&com20020_cs_driver);
	510	BUG_ON(dev_list != NULL);
	511	}
	512
	513	module_init(init_com20020_cs);
	514	module_exit(exit_com20020_cs);