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

/* $Id: teles_cs.c,v 1.1.2.2 2004/01/25 15:07:06 keil Exp $ */
/*======================================================================

    A teles S0 PCMCIA client driver

    Based on skeleton by David Hinds, dhinds@allegro.stanford.edu
    Written by Christof Petig, christof.petig@wtal.de
    
    Also inspired by ELSA PCMCIA driver 
    by Klaus Lichtenwalder <Lichtenwalder@ACM.org>
    
    Extentions to new hisax_pcmcia by Karsten Keil

    minor changes to be compatible with kernel 2.4.x
    by Jan.Schubert@GMX.li

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

#include <linux/kernel.h>
#include <linux/module.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 Teles PCMCIA cards");
MODULE_AUTHOR("Christof Petig, christof.petig@wtal.de, Karsten Keil, kkeil@suse.de");
MODULE_LICENSE("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 =
"teles_cs.c 2.10 2002/07/30 22:23:34 kkeil";
#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 teles_cs event
   handler.
*/

static int teles_cs_config(struct pcmcia_device *link);
static void teles_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 teles_detach(struct pcmcia_device *p_dev);

/*
   A linked list of "instances" of the teles_cs device.  Each actual
   PCMCIA card corresponds to one device instance, and is described
   by one struct pcmcia_device structure (defined in ds.h).

   You may not want to use a linked list for this -- for example, the
   memory card driver uses an array of struct pcmcia_device pointers, where minor
   device numbers are used to derive the corresponding array index.
*/

/*
   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;

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

    teles_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 teles_probe(struct pcmcia_device *link)
{
    local_info_t *local;

    DEBUG(0, "teles_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;

    local->p_dev = 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 = 96;
    link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
    link->io.IOAddrLines = 5;

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

    return teles_cs_config(link);
} /* teles_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 teles_detach(struct pcmcia_device *link)
{
	local_info_t *info = link->priv;

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

	info->busy = 1;
	teles_cs_release(link);

	kfree(info);
} /* teles_detach */

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

    teles_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 teles_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, "teles_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 "(teles_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 "(teles_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, "teles");
    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_TELESPCMCIA;
    
    i = hisax_init_pcmcia(link, &(((local_info_t*)link->priv)->busy), &icard);
    if (i < 0) {
    	printk(KERN_ERR "teles_cs: failed to initialize Teles PCMCIA %d at i/o %#x\n",
    		i, link->io.BasePort1);
    	teles_cs_release(link);
	return -ENODEV;
    }

    ((local_info_t*)link->priv)->cardnr = i;
    return 0;

cs_failed:
    cs_error(link, last_fn, i);
    teles_cs_release(link);
    return -ENODEV;
} /* teles_cs_config */

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

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

    DEBUG(0, "teles_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);
} /* teles_cs_release */

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

        dev->busy = 1;

	return 0;
}

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

        dev->busy = 0;

	return 0;
}


static struct pcmcia_device_id teles_ids[] = {
	PCMCIA_DEVICE_PROD_ID12("TELES", "S0/PC", 0x67b50eae, 0xe9e70119),
	PCMCIA_DEVICE_NULL,
};
MODULE_DEVICE_TABLE(pcmcia, teles_ids);

static struct pcmcia_driver teles_cs_driver = {
	.owner		= THIS_MODULE,
	.drv		= {
		.name	= "teles_cs",
	},
	.probe		= teles_probe,
	.remove		= teles_detach,
	.id_table       = teles_ids,
	.suspend	= teles_suspend,
	.resume		= teles_resume,
};

static int __init init_teles_cs(void)
{
	return pcmcia_register_driver(&teles_cs_driver);
}

static void __exit exit_teles_cs(void)
{
	pcmcia_unregister_driver(&teles_cs_driver);
}

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