[GitHub/LineageOS/android_kernel_motorola_exynos9610.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 {
	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_attach(struct pcmcia_device *p_dev)
{
    local_info_t *local;
    dev_link_t *link = dev_to_instance(p_dev);

    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 = p_dev;
    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;
    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_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;
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);
	}
    }

    pcmcia_disable_device(link->handle);
} /* 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;

        dev->busy = 1;

	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;

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