[deliverable/linux.git] / drivers / isdn / hisax / elsa_cs.c

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

    An elsa_cs PCMCIA client driver

    This driver is for the Elsa PCM ISDN Cards, i.e. the MicroLink


    The contents of this file are subject to the Mozilla Public
    License Version 1.1 (the "License"); you may not use this file
    except in compliance with the License. You may obtain a copy of
    the License at http://www.mozilla.org/MPL/

    Software distributed under the License is distributed on an "AS
    IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
    implied. See the License for the specific language governing
    rights and limitations under the License.

    The initial developer of the original code is David A. Hinds
    <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
    are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.

    Modifications from dummy_cs.c are Copyright (C) 1999-2001 Klaus
    Lichtenwalder <Lichtenwalder@ACM.org>. All Rights Reserved.

    Alternatively, the contents of this file may be used under the
    terms of the GNU General Public License version 2 (the "GPL"), in
    which case the provisions of the GPL are applicable instead of the
    above.  If you wish to allow the use of your version of this file
    only under the terms of the GPL and not to allow others to use
    your version of this file under the MPL, indicate your decision
    by deleting the provisions above and replace them with the notice
    and other provisions required by the GPL.  If you do not delete
    the provisions above, a recipient may use your version of this
    file under either the MPL or the GPL.

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

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/ptrace.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/ioport.h>
#include <asm/io.h>
#include <asm/system.h>

#include <pcmcia/cs_types.h>
#include <pcmcia/cs.h>
#include <pcmcia/cistpl.h>
#include <pcmcia/cisreg.h>
#include <pcmcia/ds.h>
#include "hisax_cfg.h"

MODULE_DESCRIPTION("ISDN4Linux: PCMCIA client driver for Elsa PCM cards");
MODULE_AUTHOR("Klaus Lichtenwalder");
MODULE_LICENSE("Dual MPL/GPL");

/*
   All the PCMCIA modules use PCMCIA_DEBUG to control debugging.  If
   you do not define PCMCIA_DEBUG at all, all the debug code will be
   left out.  If you compile with PCMCIA_DEBUG=0, the debug code will
   be present but disabled -- but it can then be enabled for specific
   modules at load time with a 'pc_debug=#' option to insmod.
*/

#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 char *version =
"elsa_cs.c $Revision: 1.2.2.4 $ $Date: 2004/01/25 15:07:06 $ (K.Lichtenwalder)";
#else
#define DEBUG(n, args...)
#endif

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

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

static int protocol = 2;        /* EURO-ISDN Default */
module_param(protocol, int, 0);

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

/*
   The event() function is this driver's Card Services event handler.
   It will be called by Card Services when an appropriate card status
   event is received.  The config() and release() entry points are
   used to configure or release a socket, in response to card insertion
   and ejection events.  They are invoked from the elsa_cs event
   handler.
*/

static int elsa_cs_config(struct pcmcia_device *link);
static void elsa_cs_release(struct pcmcia_device *link);

/*
   The attach() and detach() entry points are used to create and destroy
   "instances" of the driver, where each instance represents everything
   needed to manage one actual PCMCIA card.
*/

static void elsa_cs_detach(struct pcmcia_device *p_dev);

/*
   A driver needs to provide a dev_node_t structure for each device
   on a card.  In some cases, there is only one device per card (for
   example, ethernet cards, modems).  In other cases, there may be
   many actual or logical devices (SCSI adapters, memory cards with
   multiple partitions).  The dev_node_t structures need to be kept
   in a linked list starting at the 'dev' field of a struct pcmcia_device
   structure.  We allocate them in the card's private data structure,
   because they generally shouldn't be allocated dynamically.
   In this case, we also provide a flag to indicate if a device is
   "stopped" due to a power management event, or card ejection.  The
   device IO routines can use a flag like this to throttle IO to a
   card that is not ready to accept it.
*/

typedef struct local_info_t {
	struct pcmcia_device	*p_dev;
    dev_node_t          node;
    int                 busy;
    int			cardnr;
} local_info_t;

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

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

    The dev_link structure is initialized, but we don't actually
    configure the card at this point -- we wait until we receive a
    card insertion event.

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

static int elsa_cs_probe(struct pcmcia_device *link)
{
    local_info_t *local;

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

    /* Allocate space for private device-specific data */
    local = kmalloc(sizeof(local_info_t), GFP_KERNEL);
    if (!local) return -ENOMEM;
    memset(local, 0, sizeof(local_info_t));

    local->p_dev = link;
    link->priv = local;

    local->cardnr = -1;

    /* Interrupt setup */
    link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
    link->irq.IRQInfo1 = IRQ_LEVEL_ID|IRQ_SHARE_ID;
    link->irq.Handler = NULL;

    /*
      General socket configuration defaults can go here.  In this
      client, we assume very little, and rely on the CIS for almost
      everything.  In most clients, many details (i.e., number, sizes,
      and attributes of IO windows) are fixed by the nature of the
      device, and can be hard-wired here.
    */
    link->io.NumPorts1 = 8;
    link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
    link->io.IOAddrLines = 3;

    link->conf.Attributes = CONF_ENABLE_IRQ;
    link->conf.IntType = INT_MEMORY_AND_IO;

    link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
    return elsa_cs_config(link);
} /* elsa_cs_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 elsa_cs_detach(struct pcmcia_device *link)
{
    local_info_t *info = link->priv;

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

    if (link->state & DEV_CONFIG) {
	    info->busy = 1;
	    elsa_cs_release(link);
    }

    kfree(info);

} /* elsa_cs_detach */

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

    elsa_cs_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 get_tuple(struct pcmcia_device *handle, tuple_t *tuple,
                     cisparse_t *parse)
{
    int i = pcmcia_get_tuple_data(handle, tuple);
    if (i != CS_SUCCESS) return i;
    return pcmcia_parse_tuple(handle, tuple, parse);
}

static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple,
                     cisparse_t *parse)
{
    int i = pcmcia_get_first_tuple(handle, tuple);
    if (i != CS_SUCCESS) return i;
    return get_tuple(handle, tuple, parse);
}

static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple,
                     cisparse_t *parse)
{
    int i = pcmcia_get_next_tuple(handle, tuple);
    if (i != CS_SUCCESS) return i;
    return get_tuple(handle, tuple, parse);
}

static int elsa_cs_config(struct pcmcia_device *link)
{
    tuple_t tuple;
    cisparse_t parse;
    local_info_t *dev;
    int i, j, last_fn;
    u_short buf[128];
    cistpl_cftable_entry_t *cf = &parse.cftable_entry;
    IsdnCard_t icard;

    DEBUG(0, "elsa_config(0x%p)\n", link);
    dev = link->priv;

    /*
       This reads the card's CONFIG tuple to find its configuration
       registers.
    */
    tuple.DesiredTuple = CISTPL_CONFIG;
    tuple.TupleData = (cisdata_t *)buf;
    tuple.TupleDataMax = 255;
    tuple.TupleOffset = 0;
    tuple.Attributes = 0;
    i = first_tuple(link, &tuple, &parse);
    if (i != CS_SUCCESS) {
        last_fn = ParseTuple;
	goto cs_failed;
    }
    link->conf.ConfigBase = parse.config.base;
    link->conf.Present = parse.config.rmask[0];

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

    tuple.TupleData = (cisdata_t *)buf;
    tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
    tuple.Attributes = 0;
    tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
    i = first_tuple(link, &tuple, &parse);
    while (i == CS_SUCCESS) {
        if ( (cf->io.nwin > 0) && cf->io.win[0].base) {
            printk(KERN_INFO "(elsa_cs: looks like the 96 model)\n");
            link->conf.ConfigIndex = cf->index;
            link->io.BasePort1 = cf->io.win[0].base;
            i = pcmcia_request_io(link, &link->io);
            if (i == CS_SUCCESS) break;
        } else {
          printk(KERN_INFO "(elsa_cs: looks like the 97 model)\n");
          link->conf.ConfigIndex = cf->index;
          for (i = 0, j = 0x2f0; j > 0x100; j -= 0x10) {
            link->io.BasePort1 = j;
            i = pcmcia_request_io(link, &link->io);
            if (i == CS_SUCCESS) break;
          }
          break;
        }
        i = next_tuple(link, &tuple, &parse);
    }

    if (i != CS_SUCCESS) {
	last_fn = RequestIO;
	goto cs_failed;
    }

    i = pcmcia_request_irq(link, &link->irq);
    if (i != CS_SUCCESS) {
        link->irq.AssignedIRQ = 0;
	last_fn = RequestIRQ;
        goto cs_failed;
    }

    i = pcmcia_request_configuration(link, &link->conf);
    if (i != CS_SUCCESS) {
      last_fn = RequestConfiguration;
      goto cs_failed;
    }

    /* At this point, the dev_node_t structure(s) should be
       initialized and arranged in a linked list at link->dev. *//*  */
    sprintf(dev->node.dev_name, "elsa");
    dev->node.major = dev->node.minor = 0x0;

    link->dev_node = &dev->node;

    /* Finally, report what we've done */
    printk(KERN_INFO "%s: index 0x%02x: ",
           dev->node.dev_name, link->conf.ConfigIndex);
    if (link->conf.Attributes & CONF_ENABLE_IRQ)
        printk(", irq %d", link->irq.AssignedIRQ);
    if (link->io.NumPorts1)
        printk(", io 0x%04x-0x%04x", link->io.BasePort1,
               link->io.BasePort1+link->io.NumPorts1-1);
    if (link->io.NumPorts2)
        printk(" & 0x%04x-0x%04x", link->io.BasePort2,
               link->io.BasePort2+link->io.NumPorts2-1);
    printk("\n");

    link->state &= ~DEV_CONFIG_PENDING;

    icard.para[0] = link->irq.AssignedIRQ;
    icard.para[1] = link->io.BasePort1;
    icard.protocol = protocol;
    icard.typ = ISDN_CTYPE_ELSA_PCMCIA;
    
    i = hisax_init_pcmcia(link, &(((local_info_t*)link->priv)->busy), &icard);
    if (i < 0) {
    	printk(KERN_ERR "elsa_cs: failed to initialize Elsa PCMCIA %d at i/o %#x\n",
    		i, link->io.BasePort1);
    	elsa_cs_release(link);
    } else
    	((local_info_t*)link->priv)->cardnr = i;

    return 0;
cs_failed:
    cs_error(link, last_fn, i);
    elsa_cs_release(link);
    return -ENODEV;
} /* elsa_cs_config */

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

    After a card is removed, elsa_cs_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 elsa_cs_release(struct pcmcia_device *link)
{
    local_info_t *local = link->priv;

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

    if (local) {
    	if (local->cardnr >= 0) {
    	    /* no unregister function with hisax */
	    HiSax_closecard(local->cardnr);
	}
    }

    pcmcia_disable_device(link);
} /* elsa_cs_release */

static int elsa_suspend(struct pcmcia_device *link)
{
	local_info_t *dev = link->priv;

        dev->busy = 1;

	return 0;
}

static int elsa_resume(struct pcmcia_device *link)
{
	local_info_t *dev = link->priv;

        dev->busy = 0;

	return 0;
}

static struct pcmcia_device_id elsa_ids[] = {
	PCMCIA_DEVICE_PROD_ID12("ELSA AG (Aachen, Germany)", "MicroLink ISDN/MC ", 0x983de2c4, 0x333ba257),
	PCMCIA_DEVICE_PROD_ID12("ELSA GmbH, Aachen", "MicroLink ISDN/MC ", 0x639e5718, 0x333ba257),
	PCMCIA_DEVICE_NULL
};
MODULE_DEVICE_TABLE(pcmcia, elsa_ids);

static struct pcmcia_driver elsa_cs_driver = {
	.owner		= THIS_MODULE,
	.drv		= {
		.name	= "elsa_cs",
	},
	.probe		= elsa_cs_probe,
	.remove		= elsa_cs_detach,
	.id_table	= elsa_ids,
	.suspend	= elsa_suspend,
	.resume		= elsa_resume,
};

static int __init init_elsa_cs(void)
{
	return pcmcia_register_driver(&elsa_cs_driver);
}

static void __exit exit_elsa_cs(void)
{
	pcmcia_unregister_driver(&elsa_cs_driver);
}

module_init(init_elsa_cs);
module_exit(exit_elsa_cs);
Commit	Line	Data
1da177e4 LT	1	/*======================================================================
	2
	3	An elsa_cs PCMCIA client driver
	4
	5	This driver is for the Elsa PCM ISDN Cards, i.e. the MicroLink
	6
	7
	8	The contents of this file are subject to the Mozilla Public
	9	License Version 1.1 (the "License"); you may not use this file
	10	except in compliance with the License. You may obtain a copy of
	11	the License at http://www.mozilla.org/MPL/
	12
	13	Software distributed under the License is distributed on an "AS
	14	IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
	15	implied. See the License for the specific language governing
	16	rights and limitations under the License.
	17
	18	The initial developer of the original code is David A. Hinds
	19	<dahinds@users.sourceforge.net>. Portions created by David A. Hinds
	20	are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
	21
	22	Modifications from dummy_cs.c are Copyright (C) 1999-2001 Klaus
	23	Lichtenwalder <Lichtenwalder@ACM.org>. All Rights Reserved.
	24
	25	Alternatively, the contents of this file may be used under the
	26	terms of the GNU General Public License version 2 (the "GPL"), in
	27	which case the provisions of the GPL are applicable instead of the
	28	above. If you wish to allow the use of your version of this file
	29	only under the terms of the GPL and not to allow others to use
	30	your version of this file under the MPL, indicate your decision
	31	by deleting the provisions above and replace them with the notice
	32	and other provisions required by the GPL. If you do not delete
	33	the provisions above, a recipient may use your version of this
	34	file under either the MPL or the GPL.
	35
	36	======================================================================*/
	37
	38	#include <linux/module.h>
	39	#include <linux/kernel.h>
	40	#include <linux/init.h>
	41	#include <linux/sched.h>
	42	#include <linux/ptrace.h>
	43	#include <linux/slab.h>
	44	#include <linux/string.h>
	45	#include <linux/timer.h>
	46	#include <linux/ioport.h>
	47	#include <asm/io.h>
	48	#include <asm/system.h>
	49
1da177e4 LT	50	#include <pcmcia/cs_types.h>
	51	#include <pcmcia/cs.h>
	52	#include <pcmcia/cistpl.h>
	53	#include <pcmcia/cisreg.h>
	54	#include <pcmcia/ds.h>
	55	#include "hisax_cfg.h"
	56
	57	MODULE_DESCRIPTION("ISDN4Linux: PCMCIA client driver for Elsa PCM cards");
	58	MODULE_AUTHOR("Klaus Lichtenwalder");
	59	MODULE_LICENSE("Dual MPL/GPL");
	60
	61	/*
	62	All the PCMCIA modules use PCMCIA_DEBUG to control debugging. If
	63	you do not define PCMCIA_DEBUG at all, all the debug code will be
	64	left out. If you compile with PCMCIA_DEBUG=0, the debug code will
	65	be present but disabled -- but it can then be enabled for specific
	66	modules at load time with a 'pc_debug=#' option to insmod.
	67	*/
	68
	69	#ifdef PCMCIA_DEBUG
	70	static int pc_debug = PCMCIA_DEBUG;
	71	module_param(pc_debug, int, 0);
	72	#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args);
	73	static char *version =
	74	"elsa_cs.c $Revision: 1.2.2.4 $ $Date: 2004/01/25 15:07:06 $ (K.Lichtenwalder)";
	75	#else
	76	#define DEBUG(n, args...)
	77	#endif
	78
	79	/====================================================================/
	80
	81	/* Parameters that can be set with 'insmod' */
	82
	83	static int protocol = 2; /* EURO-ISDN Default */
	84	module_param(protocol, int, 0);
	85
	86	/====================================================================/
	87
	88	/*
	89	The event() function is this driver's Card Services event handler.
	90	It will be called by Card Services when an appropriate card status
	91	event is received. The config() and release() entry points are
	92	used to configure or release a socket, in response to card insertion
	93	and ejection events. They are invoked from the elsa_cs event
	94	handler.
	95	*/
	96
15b99ac1	97	static int elsa_cs_config(struct pcmcia_device *link);
fba395ee	98	static void elsa_cs_release(struct pcmcia_device *link);
1da177e4 LT	99
	100	/*
	101	The attach() and detach() entry points are used to create and destroy
	102	"instances" of the driver, where each instance represents everything
	103	needed to manage one actual PCMCIA card.
	104	*/
	105
cc3b4866	106	static void elsa_cs_detach(struct pcmcia_device *p_dev);
1da177e4	107
1da177e4	108	/*
1da177e4 LT	109	A driver needs to provide a dev_node_t structure for each device
	110	on a card. In some cases, there is only one device per card (for
	111	example, ethernet cards, modems). In other cases, there may be
	112	many actual or logical devices (SCSI adapters, memory cards with
	113	multiple partitions). The dev_node_t structures need to be kept
fba395ee	114	in a linked list starting at the 'dev' field of a struct pcmcia_device
1da177e4 LT	115	structure. We allocate them in the card's private data structure,
	116	because they generally shouldn't be allocated dynamically.
	117	In this case, we also provide a flag to indicate if a device is
	118	"stopped" due to a power management event, or card ejection. The
	119	device IO routines can use a flag like this to throttle IO to a
	120	card that is not ready to accept it.
	121	*/
	122
	123	typedef struct local_info_t {
fd238232	124	struct pcmcia_device *p_dev;
1da177e4 LT	125	dev_node_t node;
	126	int busy;
	127	int cardnr;
	128	} local_info_t;
	129
	130	/*======================================================================
	131
	132	elsa_cs_attach() creates an "instance" of the driver, allocatingx
	133	local data structures for one device. The device is registered
	134	with Card Services.
	135
	136	The dev_link structure is initialized, but we don't actually
	137	configure the card at this point -- we wait until we receive a
	138	card insertion event.
	139
	140	======================================================================*/
	141
15b99ac1	142	static int elsa_cs_probe(struct pcmcia_device *link)
1da177e4	143	{
1da177e4	144	local_info_t *local;
1da177e4 LT	145
	146	DEBUG(0, "elsa_cs_attach()\n");
	147
	148	/* Allocate space for private device-specific data */
	149	local = kmalloc(sizeof(local_info_t), GFP_KERNEL);
f8cfa618	150	if (!local) return -ENOMEM;
1da177e4	151	memset(local, 0, sizeof(local_info_t));
fd238232	152
fba395ee	153	local->p_dev = link;
fd238232 DB	154	link->priv = local;
fd238232 DB	155
1da177e4	156	local->cardnr = -1;
1da177e4 LT	157
	158	/* Interrupt setup */
	159	link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING\|IRQ_FIRST_SHARED;
	160	link->irq.IRQInfo1 = IRQ_LEVEL_ID\|IRQ_SHARE_ID;
	161	link->irq.Handler = NULL;
	162
	163	/*
	164	General socket configuration defaults can go here. In this
	165	client, we assume very little, and rely on the CIS for almost
	166	everything. In most clients, many details (i.e., number, sizes,
	167	and attributes of IO windows) are fixed by the nature of the
	168	device, and can be hard-wired here.
	169	*/
	170	link->io.NumPorts1 = 8;
	171	link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
	172	link->io.IOAddrLines = 3;
	173
	174	link->conf.Attributes = CONF_ENABLE_IRQ;
1da177e4 LT	175	link->conf.IntType = INT_MEMORY_AND_IO;
1da177e4 LT	176
f8cfa618	177	link->state \|= DEV_PRESENT \| DEV_CONFIG_PENDING;
15b99ac1	178	return elsa_cs_config(link);
1da177e4 LT	179	} /* elsa_cs_attach */
	180
	181	/*======================================================================
	182
	183	This deletes a driver "instance". The device is de-registered
	184	with Card Services. If it has been released, all local data
	185	structures are freed. Otherwise, the structures will be freed
	186	when the device is released.
	187
	188	======================================================================*/
	189
fba395ee	190	static void elsa_cs_detach(struct pcmcia_device *link)
1da177e4	191	{
1da177e4	192	local_info_t *info = link->priv;
1da177e4 LT	193
	194	DEBUG(0, "elsa_cs_detach(0x%p)\n", link);
	195
cc3b4866	196	if (link->state & DEV_CONFIG) {
b4635811 DB	197	info->busy = 1;
b4635811 DB	198	elsa_cs_release(link);
1da177e4 LT	199	}
1da177e4 LT	200
1da177e4 LT	201	kfree(info);
	202
	203	} /* elsa_cs_detach */
	204
	205	/*======================================================================
	206
	207	elsa_cs_config() is scheduled to run after a CARD_INSERTION event
	208	is received, to configure the PCMCIA socket, and to make the
	209	device available to the system.
	210
	211	======================================================================*/
fba395ee	212	static int get_tuple(struct pcmcia_device handle, tuple_t tuple,
1da177e4 LT	213	cisparse_t *parse)
	214	{
	215	int i = pcmcia_get_tuple_data(handle, tuple);
	216	if (i != CS_SUCCESS) return i;
	217	return pcmcia_parse_tuple(handle, tuple, parse);
	218	}
	219
fba395ee	220	static int first_tuple(struct pcmcia_device handle, tuple_t tuple,
1da177e4 LT	221	cisparse_t *parse)
	222	{
	223	int i = pcmcia_get_first_tuple(handle, tuple);
	224	if (i != CS_SUCCESS) return i;
	225	return get_tuple(handle, tuple, parse);
	226	}
	227
fba395ee	228	static int next_tuple(struct pcmcia_device handle, tuple_t tuple,
1da177e4 LT	229	cisparse_t *parse)
	230	{
	231	int i = pcmcia_get_next_tuple(handle, tuple);
	232	if (i != CS_SUCCESS) return i;
	233	return get_tuple(handle, tuple, parse);
	234	}
	235
15b99ac1	236	static int elsa_cs_config(struct pcmcia_device *link)
1da177e4	237	{
1da177e4 LT	238	tuple_t tuple;
	239	cisparse_t parse;
	240	local_info_t *dev;
	241	int i, j, last_fn;
	242	u_short buf[128];
	243	cistpl_cftable_entry_t *cf = &parse.cftable_entry;
	244	IsdnCard_t icard;
	245
	246	DEBUG(0, "elsa_config(0x%p)\n", link);
1da177e4 LT	247	dev = link->priv;
	248
	249	/*
	250	This reads the card's CONFIG tuple to find its configuration
	251	registers.
	252	*/
	253	tuple.DesiredTuple = CISTPL_CONFIG;
	254	tuple.TupleData = (cisdata_t *)buf;
	255	tuple.TupleDataMax = 255;
	256	tuple.TupleOffset = 0;
	257	tuple.Attributes = 0;
fba395ee	258	i = first_tuple(link, &tuple, &parse);
1da177e4 LT	259	if (i != CS_SUCCESS) {
	260	last_fn = ParseTuple;
	261	goto cs_failed;
	262	}
	263	link->conf.ConfigBase = parse.config.base;
	264	link->conf.Present = parse.config.rmask[0];
	265
	266	/* Configure card */
	267	link->state \|= DEV_CONFIG;
	268
	269	tuple.TupleData = (cisdata_t *)buf;
	270	tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
	271	tuple.Attributes = 0;
	272	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
fba395ee	273	i = first_tuple(link, &tuple, &parse);
1da177e4 LT	274	while (i == CS_SUCCESS) {
	275	if ( (cf->io.nwin > 0) && cf->io.win[0].base) {
	276	printk(KERN_INFO "(elsa_cs: looks like the 96 model)\n");
	277	link->conf.ConfigIndex = cf->index;
	278	link->io.BasePort1 = cf->io.win[0].base;
fba395ee	279	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	280	if (i == CS_SUCCESS) break;
	281	} else {
	282	printk(KERN_INFO "(elsa_cs: looks like the 97 model)\n");
	283	link->conf.ConfigIndex = cf->index;
	284	for (i = 0, j = 0x2f0; j > 0x100; j -= 0x10) {
	285	link->io.BasePort1 = j;
fba395ee	286	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	287	if (i == CS_SUCCESS) break;
	288	}
	289	break;
	290	}
fba395ee	291	i = next_tuple(link, &tuple, &parse);
1da177e4 LT	292	}
	293
	294	if (i != CS_SUCCESS) {
	295	last_fn = RequestIO;
	296	goto cs_failed;
	297	}
	298
fba395ee	299	i = pcmcia_request_irq(link, &link->irq);
1da177e4 LT	300	if (i != CS_SUCCESS) {
	301	link->irq.AssignedIRQ = 0;
	302	last_fn = RequestIRQ;
	303	goto cs_failed;
	304	}
	305
fba395ee	306	i = pcmcia_request_configuration(link, &link->conf);
1da177e4 LT	307	if (i != CS_SUCCESS) {
	308	last_fn = RequestConfiguration;
	309	goto cs_failed;
	310	}
	311
	312	/* At this point, the dev_node_t structure(s) should be
	313	initialized and arranged in a linked list at link->dev. // */
	314	sprintf(dev->node.dev_name, "elsa");
	315	dev->node.major = dev->node.minor = 0x0;
	316
fd238232	317	link->dev_node = &dev->node;
1da177e4 LT	318
1da177e4 LT	319	/* Finally, report what we've done */
70294b46 DB	320	printk(KERN_INFO "%s: index 0x%02x: ",
70294b46 DB	321	dev->node.dev_name, link->conf.ConfigIndex);
1da177e4 LT	322	if (link->conf.Attributes & CONF_ENABLE_IRQ)
	323	printk(", irq %d", link->irq.AssignedIRQ);
	324	if (link->io.NumPorts1)
	325	printk(", io 0x%04x-0x%04x", link->io.BasePort1,
	326	link->io.BasePort1+link->io.NumPorts1-1);
	327	if (link->io.NumPorts2)
	328	printk(" & 0x%04x-0x%04x", link->io.BasePort2,
	329	link->io.BasePort2+link->io.NumPorts2-1);
	330	printk("\n");
	331
	332	link->state &= ~DEV_CONFIG_PENDING;
	333
	334	icard.para[0] = link->irq.AssignedIRQ;
	335	icard.para[1] = link->io.BasePort1;
	336	icard.protocol = protocol;
	337	icard.typ = ISDN_CTYPE_ELSA_PCMCIA;
	338
	339	i = hisax_init_pcmcia(link, &(((local_info_t*)link->priv)->busy), &icard);
	340	if (i < 0) {
	341	printk(KERN_ERR "elsa_cs: failed to initialize Elsa PCMCIA %d at i/o %#x\n",
	342	i, link->io.BasePort1);
	343	elsa_cs_release(link);
	344	} else
	345	((local_info_t*)link->priv)->cardnr = i;
	346
15b99ac1	347	return 0;
1da177e4	348	cs_failed:
fba395ee	349	cs_error(link, last_fn, i);
1da177e4	350	elsa_cs_release(link);
15b99ac1	351	return -ENODEV;
1da177e4 LT	352	} /* elsa_cs_config */
	353
	354	/*======================================================================
	355
	356	After a card is removed, elsa_cs_release() will unregister the net
	357	device, and release the PCMCIA configuration. If the device is
	358	still open, this will be postponed until it is closed.
	359
	360	======================================================================*/
	361
fba395ee	362	static void elsa_cs_release(struct pcmcia_device *link)
1da177e4 LT	363	{
	364	local_info_t *local = link->priv;
	365
	366	DEBUG(0, "elsa_cs_release(0x%p)\n", link);
	367
	368	if (local) {
	369	if (local->cardnr >= 0) {
	370	/* no unregister function with hisax */
	371	HiSax_closecard(local->cardnr);
	372	}
	373	}
5f2a71fc	374
fba395ee	375	pcmcia_disable_device(link);
1da177e4 LT	376	} /* elsa_cs_release */
1da177e4 LT	377
fba395ee	378	static int elsa_suspend(struct pcmcia_device *link)
98e4c28b	379	{
98e4c28b DB	380	local_info_t *dev = link->priv;
98e4c28b DB	381
98e4c28b	382	dev->busy = 1;
98e4c28b DB	383
	384	return 0;
	385	}
	386
fba395ee	387	static int elsa_resume(struct pcmcia_device *link)
98e4c28b	388	{
98e4c28b DB	389	local_info_t *dev = link->priv;
98e4c28b DB	390
98e4c28b DB	391	dev->busy = 0;
	392
	393	return 0;
	394	}
	395
02ae38cf DB	396	static struct pcmcia_device_id elsa_ids[] = {
	397	PCMCIA_DEVICE_PROD_ID12("ELSA AG (Aachen, Germany)", "MicroLink ISDN/MC ", 0x983de2c4, 0x333ba257),
	398	PCMCIA_DEVICE_PROD_ID12("ELSA GmbH, Aachen", "MicroLink ISDN/MC ", 0x639e5718, 0x333ba257),
	399	PCMCIA_DEVICE_NULL
	400	};
	401	MODULE_DEVICE_TABLE(pcmcia, elsa_ids);
	402
1da177e4 LT	403	static struct pcmcia_driver elsa_cs_driver = {
	404	.owner = THIS_MODULE,
	405	.drv = {
	406	.name = "elsa_cs",
	407	},
15b99ac1	408	.probe = elsa_cs_probe,
cc3b4866	409	.remove = elsa_cs_detach,
02ae38cf	410	.id_table = elsa_ids,
98e4c28b DB	411	.suspend = elsa_suspend,
98e4c28b DB	412	.resume = elsa_resume,
1da177e4 LT	413	};
	414
	415	static int __init init_elsa_cs(void)
	416	{
	417	return pcmcia_register_driver(&elsa_cs_driver);
	418	}
	419
	420	static void __exit exit_elsa_cs(void)
	421	{
	422	pcmcia_unregister_driver(&elsa_cs_driver);
1da177e4 LT	423	}
	424
	425	module_init(init_elsa_cs);
	426	module_exit(exit_elsa_cs);