[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 void elsa_cs_config(dev_link_t *link);
static void elsa_cs_release(dev_link_t *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 dev_link_t
   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 {
    dev_link_t          link;
    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_attach(struct pcmcia_device *p_dev)
{
    dev_link_t *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->cardnr = -1;
    link = &local->link; link->priv = local;

    /* 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.Vcc = 50;
    link->conf.IntType = INT_MEMORY_AND_IO;

    link->handle = p_dev;
    p_dev->instance = link;

    link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
    elsa_cs_config(link);

    return 0;
} /* 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 *p_dev)
{
    dev_link_t *link = dev_to_instance(p_dev);
    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(client_handle_t 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(client_handle_t 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(client_handle_t 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 void elsa_cs_config(dev_link_t *link)
{
    client_handle_t handle;
    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);
    handle = link->handle;
    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(handle, &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(handle, &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->handle, &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->handle, &link->io);
            if (i == CS_SUCCESS) break;
          }
          break;
        }
        i = next_tuple(handle, &tuple, &parse);
    }

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

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

    i = pcmcia_request_configuration(link->handle, &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 = &dev->node;

    /* Finally, report what we've done */
    printk(KERN_INFO "%s: index 0x%02x: Vcc %d.%d",
           dev->node.dev_name, link->conf.ConfigIndex,
           link->conf.Vcc/10, link->conf.Vcc%10);
    if (link->conf.Vpp1)
        printk(", Vpp %d.%d", link->conf.Vpp1/10, link->conf.Vpp1%10);
    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;
cs_failed:
    cs_error(link->handle, last_fn, i);
    elsa_cs_release(link);
} /* 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(dev_link_t *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);
	}
    }
    /* Unlink the device chain */
    link->dev = NULL;

    /* Don't bother checking to see if these succeed or not */
    if (link->win)
        pcmcia_release_window(link->win);
    pcmcia_release_configuration(link->handle);
    pcmcia_release_io(link->handle, &link->io);
    pcmcia_release_irq(link->handle, &link->irq);
    link->state &= ~DEV_CONFIG;
} /* elsa_cs_release */

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

	link->state |= DEV_SUSPEND;
        dev->busy = 1;
	if (link->state & DEV_CONFIG)
		pcmcia_release_configuration(link->handle);

	return 0;
}

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

	link->state &= ~DEV_SUSPEND;
	if (link->state & DEV_CONFIG)
		pcmcia_request_configuration(link->handle, &link->conf);
        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_attach,
	.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
	97	static void elsa_cs_config(dev_link_t *link);
	98	static void elsa_cs_release(dev_link_t *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
	114	in a linked list starting at the 'dev' field of a dev_link_t
	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 {
	124	dev_link_t link;
	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
f8cfa618	142	static int elsa_cs_attach(struct pcmcia_device *p_dev)
1da177e4	143	{
1da177e4 LT	144	dev_link_t *link;
1da177e4 LT	145	local_info_t *local;
1da177e4 LT	146
	147	DEBUG(0, "elsa_cs_attach()\n");
	148
	149	/* Allocate space for private device-specific data */
	150	local = kmalloc(sizeof(local_info_t), GFP_KERNEL);
f8cfa618	151	if (!local) return -ENOMEM;
1da177e4 LT	152	memset(local, 0, sizeof(local_info_t));
	153	local->cardnr = -1;
	154	link = &local->link; link->priv = local;
	155
	156	/* Interrupt setup */
	157	link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING\|IRQ_FIRST_SHARED;
	158	link->irq.IRQInfo1 = IRQ_LEVEL_ID\|IRQ_SHARE_ID;
	159	link->irq.Handler = NULL;
	160
	161	/*
	162	General socket configuration defaults can go here. In this
	163	client, we assume very little, and rely on the CIS for almost
	164	everything. In most clients, many details (i.e., number, sizes,
	165	and attributes of IO windows) are fixed by the nature of the
	166	device, and can be hard-wired here.
	167	*/
	168	link->io.NumPorts1 = 8;
	169	link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
	170	link->io.IOAddrLines = 3;
	171
	172	link->conf.Attributes = CONF_ENABLE_IRQ;
	173	link->conf.Vcc = 50;
	174	link->conf.IntType = INT_MEMORY_AND_IO;
	175
f8cfa618 DB	176	link->handle = p_dev;
f8cfa618 DB	177	p_dev->instance = link;
1da177e4	178
f8cfa618 DB	179	link->state \|= DEV_PRESENT \| DEV_CONFIG_PENDING;
	180	elsa_cs_config(link);
	181
	182	return 0;
1da177e4 LT	183	} /* elsa_cs_attach */
	184
	185	/*======================================================================
	186
	187	This deletes a driver "instance". The device is de-registered
	188	with Card Services. If it has been released, all local data
	189	structures are freed. Otherwise, the structures will be freed
	190	when the device is released.
	191
	192	======================================================================*/
	193
cc3b4866	194	static void elsa_cs_detach(struct pcmcia_device *p_dev)
1da177e4	195	{
cc3b4866	196	dev_link_t *link = dev_to_instance(p_dev);
1da177e4	197	local_info_t *info = link->priv;
1da177e4 LT	198
	199	DEBUG(0, "elsa_cs_detach(0x%p)\n", link);
	200
cc3b4866	201	if (link->state & DEV_CONFIG) {
b4635811 DB	202	info->busy = 1;
b4635811 DB	203	elsa_cs_release(link);
1da177e4 LT	204	}
1da177e4 LT	205
1da177e4 LT	206	kfree(info);
	207
	208	} /* elsa_cs_detach */
	209
	210	/*======================================================================
	211
	212	elsa_cs_config() is scheduled to run after a CARD_INSERTION event
	213	is received, to configure the PCMCIA socket, and to make the
	214	device available to the system.
	215
	216	======================================================================*/
	217	static int get_tuple(client_handle_t handle, tuple_t *tuple,
	218	cisparse_t *parse)
	219	{
	220	int i = pcmcia_get_tuple_data(handle, tuple);
	221	if (i != CS_SUCCESS) return i;
	222	return pcmcia_parse_tuple(handle, tuple, parse);
	223	}
	224
	225	static int first_tuple(client_handle_t handle, tuple_t *tuple,
	226	cisparse_t *parse)
	227	{
	228	int i = pcmcia_get_first_tuple(handle, tuple);
	229	if (i != CS_SUCCESS) return i;
	230	return get_tuple(handle, tuple, parse);
	231	}
	232
	233	static int next_tuple(client_handle_t handle, tuple_t *tuple,
	234	cisparse_t *parse)
	235	{
	236	int i = pcmcia_get_next_tuple(handle, tuple);
	237	if (i != CS_SUCCESS) return i;
	238	return get_tuple(handle, tuple, parse);
	239	}
	240
	241	static void elsa_cs_config(dev_link_t *link)
	242	{
	243	client_handle_t handle;
	244	tuple_t tuple;
	245	cisparse_t parse;
	246	local_info_t *dev;
	247	int i, j, last_fn;
	248	u_short buf[128];
	249	cistpl_cftable_entry_t *cf = &parse.cftable_entry;
	250	IsdnCard_t icard;
	251
	252	DEBUG(0, "elsa_config(0x%p)\n", link);
	253	handle = link->handle;
	254	dev = link->priv;
	255
	256	/*
	257	This reads the card's CONFIG tuple to find its configuration
	258	registers.
	259	*/
	260	tuple.DesiredTuple = CISTPL_CONFIG;
	261	tuple.TupleData = (cisdata_t *)buf;
	262	tuple.TupleDataMax = 255;
	263	tuple.TupleOffset = 0;
	264	tuple.Attributes = 0;
	265	i = first_tuple(handle, &tuple, &parse);
	266	if (i != CS_SUCCESS) {
	267	last_fn = ParseTuple;
	268	goto cs_failed;
	269	}
270	link->conf.ConfigBase = parse.config.base;
271	link->conf.Present = parse.config.rmask[0];
272
273	/* Configure card */
274	link->state \|= DEV_CONFIG;
275
276	tuple.TupleData = (cisdata_t *)buf;
277	tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
278	tuple.Attributes = 0;
279	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
280	i = first_tuple(handle, &tuple, &parse);
281	while (i == CS_SUCCESS) {
282	if ( (cf->io.nwin > 0) && cf->io.win[0].base) {
283	printk(KERN_INFO "(elsa_cs: looks like the 96 model)\n");
284	link->conf.ConfigIndex = cf->index;
285	link->io.BasePort1 = cf->io.win[0].base;
286	i = pcmcia_request_io(link->handle, &link->io);
287	if (i == CS_SUCCESS) break;
288	} else {
289	printk(KERN_INFO "(elsa_cs: looks like the 97 model)\n");
290	link->conf.ConfigIndex = cf->index;
291	for (i = 0, j = 0x2f0; j > 0x100; j -= 0x10) {
292	link->io.BasePort1 = j;
293	i = pcmcia_request_io(link->handle, &link->io);
294	if (i == CS_SUCCESS) break;
295	}
296	break;
297	}
298	i = next_tuple(handle, &tuple, &parse);
299	}
300
301	if (i != CS_SUCCESS) {
302	last_fn = RequestIO;
303	goto cs_failed;
304	}
305
306	i = pcmcia_request_irq(link->handle, &link->irq);
307	if (i != CS_SUCCESS) {
308	link->irq.AssignedIRQ = 0;
309	last_fn = RequestIRQ;
310	goto cs_failed;
311	}
312
313	i = pcmcia_request_configuration(link->handle, &link->conf);
314	if (i != CS_SUCCESS) {
315	last_fn = RequestConfiguration;
316	goto cs_failed;
317	}
318
319	/* At this point, the dev_node_t structure(s) should be
320	initialized and arranged in a linked list at link->dev. // */
321	sprintf(dev->node.dev_name, "elsa");
322	dev->node.major = dev->node.minor = 0x0;
323
324	link->dev = &dev->node;
325
326	/* Finally, report what we've done */
327	printk(KERN_INFO "%s: index 0x%02x: Vcc %d.%d",
328	dev->node.dev_name, link->conf.ConfigIndex,
329	link->conf.Vcc/10, link->conf.Vcc%10);
330	if (link->conf.Vpp1)
331	printk(", Vpp %d.%d", link->conf.Vpp1/10, link->conf.Vpp1%10);
332	if (link->conf.Attributes & CONF_ENABLE_IRQ)
333	printk(", irq %d", link->irq.AssignedIRQ);
334	if (link->io.NumPorts1)
335	printk(", io 0x%04x-0x%04x", link->io.BasePort1,
336	link->io.BasePort1+link->io.NumPorts1-1);
337	if (link->io.NumPorts2)
338	printk(" & 0x%04x-0x%04x", link->io.BasePort2,
339	link->io.BasePort2+link->io.NumPorts2-1);
340	printk("\n");
341
342	link->state &= ~DEV_CONFIG_PENDING;
343
344	icard.para[0] = link->irq.AssignedIRQ;
345	icard.para[1] = link->io.BasePort1;
346	icard.protocol = protocol;
347	icard.typ = ISDN_CTYPE_ELSA_PCMCIA;
348
349	i = hisax_init_pcmcia(link, &(((local_info_t*)link->priv)->busy), &icard);
350	if (i < 0) {
351	printk(KERN_ERR "elsa_cs: failed to initialize Elsa PCMCIA %d at i/o %#x\n",
352	i, link->io.BasePort1);
353	elsa_cs_release(link);
354	} else
355	((local_info_t*)link->priv)->cardnr = i;
356
357	return;
358	cs_failed:
359	cs_error(link->handle, last_fn, i);
360	elsa_cs_release(link);
361	} /* elsa_cs_config */
362
363	/*======================================================================
364
365	After a card is removed, elsa_cs_release() will unregister the net
366	device, and release the PCMCIA configuration. If the device is
367	still open, this will be postponed until it is closed.
368
369	======================================================================*/
370
371	static void elsa_cs_release(dev_link_t *link)
372	{
373	local_info_t *local = link->priv;
374
375	DEBUG(0, "elsa_cs_release(0x%p)\n", link);
376
377	if (local) {
378	if (local->cardnr >= 0) {
379	/* no unregister function with hisax */
380	HiSax_closecard(local->cardnr);
381	}
382	}
383	/* Unlink the device chain */
384	link->dev = NULL;
385
386	/* Don't bother checking to see if these succeed or not */
387	if (link->win)
388	pcmcia_release_window(link->win);
389	pcmcia_release_configuration(link->handle);
390	pcmcia_release_io(link->handle, &link->io);
391	pcmcia_release_irq(link->handle, &link->irq);
392	link->state &= ~DEV_CONFIG;
393	} /* elsa_cs_release */
394
98e4c28b DB	395	static int elsa_suspend(struct pcmcia_device *p_dev)
	396	{
	397	dev_link_t *link = dev_to_instance(p_dev);
	398	local_info_t *dev = link->priv;
	399
	400	link->state \|= DEV_SUSPEND;
	401	dev->busy = 1;
	402	if (link->state & DEV_CONFIG)
	403	pcmcia_release_configuration(link->handle);
	404
	405	return 0;
	406	}
	407
	408	static int elsa_resume(struct pcmcia_device *p_dev)
	409	{
	410	dev_link_t *link = dev_to_instance(p_dev);
	411	local_info_t *dev = link->priv;
	412
	413	link->state &= ~DEV_SUSPEND;
	414	if (link->state & DEV_CONFIG)
	415	pcmcia_request_configuration(link->handle, &link->conf);
	416	dev->busy = 0;
	417
	418	return 0;
	419	}
	420
02ae38cf DB	421	static struct pcmcia_device_id elsa_ids[] = {
	422	PCMCIA_DEVICE_PROD_ID12("ELSA AG (Aachen, Germany)", "MicroLink ISDN/MC ", 0x983de2c4, 0x333ba257),
	423	PCMCIA_DEVICE_PROD_ID12("ELSA GmbH, Aachen", "MicroLink ISDN/MC ", 0x639e5718, 0x333ba257),
	424	PCMCIA_DEVICE_NULL
	425	};
	426	MODULE_DEVICE_TABLE(pcmcia, elsa_ids);
	427
1da177e4 LT	428	static struct pcmcia_driver elsa_cs_driver = {
	429	.owner = THIS_MODULE,
	430	.drv = {
	431	.name = "elsa_cs",
	432	},
f8cfa618	433	.probe = elsa_cs_attach,
cc3b4866	434	.remove = elsa_cs_detach,
02ae38cf	435	.id_table = elsa_ids,
98e4c28b DB	436	.suspend = elsa_suspend,
98e4c28b DB	437	.resume = elsa_resume,
1da177e4 LT	438	};
	439
	440	static int __init init_elsa_cs(void)
	441	{
	442	return pcmcia_register_driver(&elsa_cs_driver);
	443	}
	444
	445	static void __exit exit_elsa_cs(void)
	446	{
	447	pcmcia_unregister_driver(&elsa_cs_driver);
1da177e4 LT	448	}
	449
	450	module_init(init_elsa_cs);
	451	module_exit(exit_elsa_cs);