[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;

    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);

	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];

    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");

    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
15b99ac1	177	return elsa_cs_config(link);
1da177e4 LT	178	} /* elsa_cs_attach */
	179
	180	/*======================================================================
	181
	182	This deletes a driver "instance". The device is de-registered
	183	with Card Services. If it has been released, all local data
	184	structures are freed. Otherwise, the structures will be freed
	185	when the device is released.
	186
	187	======================================================================*/
	188
fba395ee	189	static void elsa_cs_detach(struct pcmcia_device *link)
1da177e4	190	{
e2d40963	191	local_info_t *info = link->priv;
1da177e4	192
e2d40963	193	DEBUG(0, "elsa_cs_detach(0x%p)\n", link);
1da177e4	194
e2d40963 DB	195	info->busy = 1;
e2d40963 DB	196	elsa_cs_release(link);
1da177e4	197
e2d40963	198	kfree(info);
1da177e4 LT	199	} /* elsa_cs_detach */
	200
	201	/*======================================================================
	202
	203	elsa_cs_config() is scheduled to run after a CARD_INSERTION event
	204	is received, to configure the PCMCIA socket, and to make the
	205	device available to the system.
	206
	207	======================================================================*/
fba395ee	208	static int get_tuple(struct pcmcia_device handle, tuple_t tuple,
1da177e4 LT	209	cisparse_t *parse)
	210	{
	211	int i = pcmcia_get_tuple_data(handle, tuple);
	212	if (i != CS_SUCCESS) return i;
	213	return pcmcia_parse_tuple(handle, tuple, parse);
	214	}
	215
fba395ee	216	static int first_tuple(struct pcmcia_device handle, tuple_t tuple,
1da177e4 LT	217	cisparse_t *parse)
	218	{
	219	int i = pcmcia_get_first_tuple(handle, tuple);
	220	if (i != CS_SUCCESS) return i;
	221	return get_tuple(handle, tuple, parse);
	222	}
	223
fba395ee	224	static int next_tuple(struct pcmcia_device handle, tuple_t tuple,
1da177e4 LT	225	cisparse_t *parse)
	226	{
	227	int i = pcmcia_get_next_tuple(handle, tuple);
	228	if (i != CS_SUCCESS) return i;
	229	return get_tuple(handle, tuple, parse);
	230	}
	231
15b99ac1	232	static int elsa_cs_config(struct pcmcia_device *link)
1da177e4	233	{
1da177e4 LT	234	tuple_t tuple;
	235	cisparse_t parse;
	236	local_info_t *dev;
	237	int i, j, last_fn;
	238	u_short buf[128];
	239	cistpl_cftable_entry_t *cf = &parse.cftable_entry;
	240	IsdnCard_t icard;
	241
	242	DEBUG(0, "elsa_config(0x%p)\n", link);
1da177e4 LT	243	dev = link->priv;
	244
	245	/*
	246	This reads the card's CONFIG tuple to find its configuration
	247	registers.
	248	*/
	249	tuple.DesiredTuple = CISTPL_CONFIG;
	250	tuple.TupleData = (cisdata_t *)buf;
	251	tuple.TupleDataMax = 255;
	252	tuple.TupleOffset = 0;
	253	tuple.Attributes = 0;
fba395ee	254	i = first_tuple(link, &tuple, &parse);
1da177e4 LT	255	if (i != CS_SUCCESS) {
	256	last_fn = ParseTuple;
	257	goto cs_failed;
	258	}
	259	link->conf.ConfigBase = parse.config.base;
	260	link->conf.Present = parse.config.rmask[0];
	261
1da177e4 LT	262	tuple.TupleData = (cisdata_t *)buf;
	263	tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
	264	tuple.Attributes = 0;
	265	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
fba395ee	266	i = first_tuple(link, &tuple, &parse);
1da177e4 LT	267	while (i == CS_SUCCESS) {
	268	if ( (cf->io.nwin > 0) && cf->io.win[0].base) {
	269	printk(KERN_INFO "(elsa_cs: looks like the 96 model)\n");
	270	link->conf.ConfigIndex = cf->index;
	271	link->io.BasePort1 = cf->io.win[0].base;
fba395ee	272	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	273	if (i == CS_SUCCESS) break;
	274	} else {
	275	printk(KERN_INFO "(elsa_cs: looks like the 97 model)\n");
	276	link->conf.ConfigIndex = cf->index;
	277	for (i = 0, j = 0x2f0; j > 0x100; j -= 0x10) {
	278	link->io.BasePort1 = j;
fba395ee	279	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	280	if (i == CS_SUCCESS) break;
	281	}
	282	break;
	283	}
fba395ee	284	i = next_tuple(link, &tuple, &parse);
1da177e4 LT	285	}
	286
	287	if (i != CS_SUCCESS) {
	288	last_fn = RequestIO;
	289	goto cs_failed;
	290	}
	291
fba395ee	292	i = pcmcia_request_irq(link, &link->irq);
1da177e4 LT	293	if (i != CS_SUCCESS) {
	294	link->irq.AssignedIRQ = 0;
	295	last_fn = RequestIRQ;
	296	goto cs_failed;
	297	}
	298
fba395ee	299	i = pcmcia_request_configuration(link, &link->conf);
1da177e4 LT	300	if (i != CS_SUCCESS) {
	301	last_fn = RequestConfiguration;
	302	goto cs_failed;
	303	}
	304
	305	/* At this point, the dev_node_t structure(s) should be
	306	initialized and arranged in a linked list at link->dev. // */
	307	sprintf(dev->node.dev_name, "elsa");
	308	dev->node.major = dev->node.minor = 0x0;
	309
fd238232	310	link->dev_node = &dev->node;
1da177e4 LT	311
1da177e4 LT	312	/* Finally, report what we've done */
70294b46 DB	313	printk(KERN_INFO "%s: index 0x%02x: ",
70294b46 DB	314	dev->node.dev_name, link->conf.ConfigIndex);
1da177e4 LT	315	if (link->conf.Attributes & CONF_ENABLE_IRQ)
	316	printk(", irq %d", link->irq.AssignedIRQ);
	317	if (link->io.NumPorts1)
	318	printk(", io 0x%04x-0x%04x", link->io.BasePort1,
	319	link->io.BasePort1+link->io.NumPorts1-1);
	320	if (link->io.NumPorts2)
	321	printk(" & 0x%04x-0x%04x", link->io.BasePort2,
	322	link->io.BasePort2+link->io.NumPorts2-1);
	323	printk("\n");
	324
1da177e4 LT	325	icard.para[0] = link->irq.AssignedIRQ;
	326	icard.para[1] = link->io.BasePort1;
	327	icard.protocol = protocol;
	328	icard.typ = ISDN_CTYPE_ELSA_PCMCIA;
	329
	330	i = hisax_init_pcmcia(link, &(((local_info_t*)link->priv)->busy), &icard);
	331	if (i < 0) {
	332	printk(KERN_ERR "elsa_cs: failed to initialize Elsa PCMCIA %d at i/o %#x\n",
	333	i, link->io.BasePort1);
	334	elsa_cs_release(link);
	335	} else
	336	((local_info_t*)link->priv)->cardnr = i;
	337
15b99ac1	338	return 0;
1da177e4	339	cs_failed:
fba395ee	340	cs_error(link, last_fn, i);
1da177e4	341	elsa_cs_release(link);
15b99ac1	342	return -ENODEV;
1da177e4 LT	343	} /* elsa_cs_config */
	344
	345	/*======================================================================
	346
	347	After a card is removed, elsa_cs_release() will unregister the net
	348	device, and release the PCMCIA configuration. If the device is
	349	still open, this will be postponed until it is closed.
	350
	351	======================================================================*/
	352
fba395ee	353	static void elsa_cs_release(struct pcmcia_device *link)
1da177e4 LT	354	{
	355	local_info_t *local = link->priv;
	356
	357	DEBUG(0, "elsa_cs_release(0x%p)\n", link);
	358
	359	if (local) {
	360	if (local->cardnr >= 0) {
	361	/* no unregister function with hisax */
	362	HiSax_closecard(local->cardnr);
	363	}
	364	}
5f2a71fc	365
fba395ee	366	pcmcia_disable_device(link);
1da177e4 LT	367	} /* elsa_cs_release */
1da177e4 LT	368
fba395ee	369	static int elsa_suspend(struct pcmcia_device *link)
98e4c28b	370	{
98e4c28b DB	371	local_info_t *dev = link->priv;
98e4c28b DB	372
98e4c28b	373	dev->busy = 1;
98e4c28b DB	374
	375	return 0;
	376	}
	377
fba395ee	378	static int elsa_resume(struct pcmcia_device *link)
98e4c28b	379	{
98e4c28b DB	380	local_info_t *dev = link->priv;
98e4c28b DB	381
98e4c28b DB	382	dev->busy = 0;
	383
	384	return 0;
	385	}
	386
02ae38cf DB	387	static struct pcmcia_device_id elsa_ids[] = {
	388	PCMCIA_DEVICE_PROD_ID12("ELSA AG (Aachen, Germany)", "MicroLink ISDN/MC ", 0x983de2c4, 0x333ba257),
	389	PCMCIA_DEVICE_PROD_ID12("ELSA GmbH, Aachen", "MicroLink ISDN/MC ", 0x639e5718, 0x333ba257),
	390	PCMCIA_DEVICE_NULL
	391	};
	392	MODULE_DEVICE_TABLE(pcmcia, elsa_ids);
	393
1da177e4 LT	394	static struct pcmcia_driver elsa_cs_driver = {
	395	.owner = THIS_MODULE,
	396	.drv = {
	397	.name = "elsa_cs",
	398	},
15b99ac1	399	.probe = elsa_cs_probe,
cc3b4866	400	.remove = elsa_cs_detach,
02ae38cf	401	.id_table = elsa_ids,
98e4c28b DB	402	.suspend = elsa_suspend,
98e4c28b DB	403	.resume = elsa_resume,
1da177e4 LT	404	};
	405
	406	static int __init init_elsa_cs(void)
	407	{
	408	return pcmcia_register_driver(&elsa_cs_driver);
	409	}
	410
	411	static void __exit exit_elsa_cs(void)
	412	{
	413	pcmcia_unregister_driver(&elsa_cs_driver);
1da177e4 LT	414	}
	415
	416	module_init(init_elsa_cs);
	417	module_exit(exit_elsa_cs);