[mirror_ubuntu-artful-kernel.git] / drivers / isdn / hisax / avma1_cs.c

/*
 * PCMCIA client driver for AVM A1 / Fritz!PCMCIA
 *
 * Author       Carsten Paeth
 * Copyright    1998-2001 by Carsten Paeth <calle@calle.in-berlin.de>
 * 
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 */

#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 <asm/io.h>
#include <asm/system.h>

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

MODULE_DESCRIPTION("ISDN4Linux: PCMCIA client driver for AVM A1/Fritz!PCMCIA cards");
MODULE_AUTHOR("Carsten Paeth");
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 =
"avma1_cs.c 1.00 1998/01/23 10:00:00 (Carsten Paeth)";
#else
#define DEBUG(n, args...)
#endif

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

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

static int isdnprot = 2;

module_param(isdnprot, 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 skeleton event
   handler.
*/

static int avma1cs_config(struct pcmcia_device *link);
static void avma1cs_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 avma1cs_detach(struct pcmcia_device *p_dev);


/*
   A linked list of "instances" of the skeleton 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 can't be allocated dynamically.
*/
   
typedef struct local_info_t {
    dev_node_t	node;
} local_info_t;

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

    avma1cs_attach() creates an "instance" of the driver, allocating
    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 avma1cs_probe(struct pcmcia_device *p_dev)
{
    local_info_t *local;

    DEBUG(0, "avma1cs_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));
    p_dev->priv = local;

    /* The io structure describes IO port mapping */
    p_dev->io.NumPorts1 = 16;
    p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
    p_dev->io.NumPorts2 = 16;
    p_dev->io.Attributes2 = IO_DATA_PATH_WIDTH_16;
    p_dev->io.IOAddrLines = 5;

    /* Interrupt setup */
    p_dev->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
    p_dev->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;

    p_dev->irq.IRQInfo1 = IRQ_LEVEL_ID;

    /* General socket configuration */
    p_dev->conf.Attributes = CONF_ENABLE_IRQ;
    p_dev->conf.IntType = INT_MEMORY_AND_IO;
    p_dev->conf.ConfigIndex = 1;
    p_dev->conf.Present = PRESENT_OPTION;

    return avma1cs_config(p_dev);
} /* avma1cs_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 avma1cs_detach(struct pcmcia_device *link)
{
	DEBUG(0, "avma1cs_detach(0x%p)\n", link);
	avma1cs_release(link);
	kfree(link->priv);
} /* avma1cs_detach */

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

    avma1cs_config() is scheduled to run after a CARD_INSERTION event
    is received, to configure the PCMCIA socket, and to make the
    ethernet 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 avma1cs_config(struct pcmcia_device *link)
{
    tuple_t tuple;
    cisparse_t parse;
    cistpl_cftable_entry_t *cf = &parse.cftable_entry;
    local_info_t *dev;
    int i;
    u_char buf[64];
    char devname[128];
    IsdnCard_t	icard;
    int busy = 0;

    dev = link->priv;

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

    /*
       This reads the card's CONFIG tuple to find its configuration
       registers.
    */
    do {
	tuple.DesiredTuple = CISTPL_CONFIG;
	i = pcmcia_get_first_tuple(link, &tuple);
	if (i != CS_SUCCESS) break;
	tuple.TupleData = buf;
	tuple.TupleDataMax = 64;
	tuple.TupleOffset = 0;
	i = pcmcia_get_tuple_data(link, &tuple);
	if (i != CS_SUCCESS) break;
	i = pcmcia_parse_tuple(link, &tuple, &parse);
	if (i != CS_SUCCESS) break;
	link->conf.ConfigBase = parse.config.base;
    } while (0);
    if (i != CS_SUCCESS) {
	cs_error(link, ParseTuple, i);
	return -ENODEV;
    }

    do {

	tuple.Attributes = 0;
	tuple.TupleData = buf;
	tuple.TupleDataMax = 254;
	tuple.TupleOffset = 0;
	tuple.DesiredTuple = CISTPL_VERS_1;

	devname[0] = 0;
	if( !first_tuple(link, &tuple, &parse) && parse.version_1.ns > 1 ) {
	    strlcpy(devname,parse.version_1.str + parse.version_1.ofs[1], 
			sizeof(devname));
	}
	/*
         * find IO port
         */
	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) {
		link->conf.ConfigIndex = cf->index;
		link->io.BasePort1 = cf->io.win[0].base;
		link->io.NumPorts1 = cf->io.win[0].len;
		link->io.NumPorts2 = 0;
		printk(KERN_INFO "avma1_cs: testing i/o %#x-%#x\n",
			link->io.BasePort1,
			link->io.BasePort1+link->io.NumPorts1 - 1);
		i = pcmcia_request_io(link, &link->io);
		if (i == CS_SUCCESS) goto found_port;
	    }
	    i = next_tuple(link, &tuple, &parse);
	}

found_port:
	if (i != CS_SUCCESS) {
	    cs_error(link, RequestIO, i);
	    break;
	}
	
	/*
	 * allocate an interrupt line
	 */
	i = pcmcia_request_irq(link, &link->irq);
	if (i != CS_SUCCESS) {
	    cs_error(link, RequestIRQ, i);
	    /* undo */
	    pcmcia_disable_device(link);
	    break;
	}

	/*
	 * configure the PCMCIA socket
	 */
	i = pcmcia_request_configuration(link, &link->conf);
	if (i != CS_SUCCESS) {
	    cs_error(link, RequestConfiguration, i);
	    pcmcia_disable_device(link);
	    break;
	}

    } while (0);

    /* At this point, the dev_node_t structure(s) should be
       initialized and arranged in a linked list at link->dev. */

    strcpy(dev->node.dev_name, "A1");
    dev->node.major = 45;
    dev->node.minor = 0;
    link->dev_node = &dev->node;

    /* If any step failed, release any partially configured state */
    if (i != 0) {
	avma1cs_release(link);
	return -ENODEV;
    }

    printk(KERN_NOTICE "avma1_cs: checking at i/o %#x, irq %d\n",
				link->io.BasePort1, link->irq.AssignedIRQ);

    icard.para[0] = link->irq.AssignedIRQ;
    icard.para[1] = link->io.BasePort1;
    icard.protocol = isdnprot;
    icard.typ = ISDN_CTYPE_A1_PCMCIA;
    
    i = hisax_init_pcmcia(link, &busy, &icard);
    if (i < 0) {
    	printk(KERN_ERR "avma1_cs: failed to initialize AVM A1 PCMCIA %d at i/o %#x\n", i, link->io.BasePort1);
	avma1cs_release(link);
	return -ENODEV;
    }
    dev->node.minor = i;

    return 0;
} /* avma1cs_config */

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

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

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

	/* now unregister function with hisax */
	HiSax_closecard(local->node.minor);

	pcmcia_disable_device(link);
} /* avma1cs_release */


static struct pcmcia_device_id avma1cs_ids[] = {
	PCMCIA_DEVICE_PROD_ID12("AVM", "ISDN A", 0x95d42008, 0xadc9d4bb),
	PCMCIA_DEVICE_PROD_ID12("ISDN", "CARD", 0x8d9761c8, 0x01c5aa7b),
	PCMCIA_DEVICE_NULL
};
MODULE_DEVICE_TABLE(pcmcia, avma1cs_ids);

static struct pcmcia_driver avma1cs_driver = {
	.owner		= THIS_MODULE,
	.drv		= {
		.name	= "avma1_cs",
	},
	.probe		= avma1cs_probe,
	.remove		= avma1cs_detach,
	.id_table	= avma1cs_ids,
};

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

static int __init init_avma1_cs(void)
{
	return(pcmcia_register_driver(&avma1cs_driver));
}

static void __exit exit_avma1_cs(void)
{
	pcmcia_unregister_driver(&avma1cs_driver);
}

module_init(init_avma1_cs);
module_exit(exit_avma1_cs);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* PCMCIA client driver for AVM A1 / Fritz!PCMCIA
	3	*
	4	* Author Carsten Paeth
	5	* Copyright 1998-2001 by Carsten Paeth <calle@calle.in-berlin.de>
	6	*
	7	* This software may be used and distributed according to the terms
	8	* of the GNU General Public License, incorporated herein by reference.
	9	*
	10	*/
	11
	12	#include <linux/module.h>
	13
	14
	15	#include <linux/kernel.h>
	16	#include <linux/init.h>
	17	#include <linux/sched.h>
	18	#include <linux/ptrace.h>
	19	#include <linux/slab.h>
	20	#include <linux/string.h>
	21	#include <asm/io.h>
	22	#include <asm/system.h>
	23
1da177e4 LT	24	#include <pcmcia/cs_types.h>
	25	#include <pcmcia/cs.h>
	26	#include <pcmcia/cistpl.h>
	27	#include <pcmcia/ds.h>
	28	#include "hisax_cfg.h"
	29
	30	MODULE_DESCRIPTION("ISDN4Linux: PCMCIA client driver for AVM A1/Fritz!PCMCIA cards");
	31	MODULE_AUTHOR("Carsten Paeth");
	32	MODULE_LICENSE("GPL");
	33
	34	/*
	35	All the PCMCIA modules use PCMCIA_DEBUG to control debugging. If
	36	you do not define PCMCIA_DEBUG at all, all the debug code will be
	37	left out. If you compile with PCMCIA_DEBUG=0, the debug code will
	38	be present but disabled -- but it can then be enabled for specific
	39	modules at load time with a 'pc_debug=#' option to insmod.
	40	*/
	41	#ifdef PCMCIA_DEBUG
	42	static int pc_debug = PCMCIA_DEBUG;
	43	module_param(pc_debug, int, 0);
	44	#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args);
	45	static char *version =
	46	"avma1_cs.c 1.00 1998/01/23 10:00:00 (Carsten Paeth)";
	47	#else
	48	#define DEBUG(n, args...)
	49	#endif
	50
	51	/====================================================================/
	52
	53	/* Parameters that can be set with 'insmod' */
	54
	55	static int isdnprot = 2;
	56
	57	module_param(isdnprot, int, 0);
	58
	59	/====================================================================/
	60
	61	/*
	62	The event() function is this driver's Card Services event handler.
	63	It will be called by Card Services when an appropriate card status
	64	event is received. The config() and release() entry points are
	65	used to configure or release a socket, in response to card insertion
	66	and ejection events. They are invoked from the skeleton event
	67	handler.
	68	*/
	69
15b99ac1	70	static int avma1cs_config(struct pcmcia_device *link);
fba395ee	71	static void avma1cs_release(struct pcmcia_device *link);
1da177e4 LT	72
	73	/*
	74	The attach() and detach() entry points are used to create and destroy
	75	"instances" of the driver, where each instance represents everything
	76	needed to manage one actual PCMCIA card.
	77	*/
	78
cc3b4866	79	static void avma1cs_detach(struct pcmcia_device *p_dev);
1da177e4	80
1da177e4 LT	81
	82	/*
	83	A linked list of "instances" of the skeleton device. Each actual
	84	PCMCIA card corresponds to one device instance, and is described
fba395ee	85	by one struct pcmcia_device structure (defined in ds.h).
1da177e4 LT	86
1da177e4 LT	87	You may not want to use a linked list for this -- for example, the
fba395ee	88	memory card driver uses an array of struct pcmcia_device pointers, where minor
1da177e4 LT	89	device numbers are used to derive the corresponding array index.
	90	*/
	91
1da177e4	92	/*
1da177e4 LT	93	A driver needs to provide a dev_node_t structure for each device
	94	on a card. In some cases, there is only one device per card (for
	95	example, ethernet cards, modems). In other cases, there may be
	96	many actual or logical devices (SCSI adapters, memory cards with
	97	multiple partitions). The dev_node_t structures need to be kept
fba395ee	98	in a linked list starting at the 'dev' field of a struct pcmcia_device
1da177e4 LT	99	structure. We allocate them in the card's private data structure,
	100	because they generally can't be allocated dynamically.
	101	*/
	102
	103	typedef struct local_info_t {
	104	dev_node_t node;
	105	} local_info_t;
	106
	107	/*======================================================================
	108
	109	avma1cs_attach() creates an "instance" of the driver, allocating
	110	local data structures for one device. The device is registered
	111	with Card Services.
	112
	113	The dev_link structure is initialized, but we don't actually
	114	configure the card at this point -- we wait until we receive a
	115	card insertion event.
	116
	117	======================================================================*/
	118
15b99ac1	119	static int avma1cs_probe(struct pcmcia_device *p_dev)
1da177e4	120	{
1da177e4	121	local_info_t *local;
f8cfa618	122
1da177e4 LT	123	DEBUG(0, "avma1cs_attach()\n");
1da177e4 LT	124
1da177e4 LT	125	/* Allocate space for private device-specific data */
1da177e4 LT	126	local = kmalloc(sizeof(local_info_t), GFP_KERNEL);
fd238232	127	if (!local)
f8cfa618	128	return -ENOMEM;
fd238232	129
1da177e4	130	memset(local, 0, sizeof(local_info_t));
fd238232	131	p_dev->priv = local;
1da177e4 LT	132
1da177e4 LT	133	/* The io structure describes IO port mapping */
fd238232 DB	134	p_dev->io.NumPorts1 = 16;
	135	p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	136	p_dev->io.NumPorts2 = 16;
	137	p_dev->io.Attributes2 = IO_DATA_PATH_WIDTH_16;
	138	p_dev->io.IOAddrLines = 5;
1da177e4 LT	139
1da177e4 LT	140	/* Interrupt setup */
fd238232 DB	141	p_dev->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
fd238232 DB	142	p_dev->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING\|IRQ_FIRST_SHARED;
1da177e4	143
fd238232	144	p_dev->irq.IRQInfo1 = IRQ_LEVEL_ID;
1da177e4 LT	145
1da177e4 LT	146	/* General socket configuration */
fd238232 DB	147	p_dev->conf.Attributes = CONF_ENABLE_IRQ;
	148	p_dev->conf.IntType = INT_MEMORY_AND_IO;
	149	p_dev->conf.ConfigIndex = 1;
	150	p_dev->conf.Present = PRESENT_OPTION;
f8cfa618	151
15b99ac1	152	return avma1cs_config(p_dev);
1da177e4 LT	153	} /* avma1cs_attach */
	154
	155	/*======================================================================
	156
	157	This deletes a driver "instance". The device is de-registered
	158	with Card Services. If it has been released, all local data
	159	structures are freed. Otherwise, the structures will be freed
	160	when the device is released.
	161
	162	======================================================================*/
	163
fba395ee	164	static void avma1cs_detach(struct pcmcia_device *link)
1da177e4	165	{
e2d40963 DB	166	DEBUG(0, "avma1cs_detach(0x%p)\n", link);
	167	avma1cs_release(link);
	168	kfree(link->priv);
1da177e4 LT	169	} /* avma1cs_detach */
	170
	171	/*======================================================================
	172
	173	avma1cs_config() is scheduled to run after a CARD_INSERTION event
	174	is received, to configure the PCMCIA socket, and to make the
	175	ethernet device available to the system.
	176
	177	======================================================================*/
	178
fba395ee	179	static int get_tuple(struct pcmcia_device handle, tuple_t tuple,
1da177e4 LT	180	cisparse_t *parse)
	181	{
	182	int i = pcmcia_get_tuple_data(handle, tuple);
	183	if (i != CS_SUCCESS) return i;
	184	return pcmcia_parse_tuple(handle, tuple, parse);
	185	}
	186
fba395ee	187	static int first_tuple(struct pcmcia_device handle, tuple_t tuple,
1da177e4 LT	188	cisparse_t *parse)
	189	{
	190	int i = pcmcia_get_first_tuple(handle, tuple);
	191	if (i != CS_SUCCESS) return i;
	192	return get_tuple(handle, tuple, parse);
	193	}
	194
fba395ee	195	static int next_tuple(struct pcmcia_device handle, tuple_t tuple,
1da177e4 LT	196	cisparse_t *parse)
	197	{
	198	int i = pcmcia_get_next_tuple(handle, tuple);
	199	if (i != CS_SUCCESS) return i;
	200	return get_tuple(handle, tuple, parse);
	201	}
	202
15b99ac1	203	static int avma1cs_config(struct pcmcia_device *link)
1da177e4	204	{
1da177e4 LT	205	tuple_t tuple;
	206	cisparse_t parse;
	207	cistpl_cftable_entry_t *cf = &parse.cftable_entry;
	208	local_info_t *dev;
	209	int i;
	210	u_char buf[64];
	211	char devname[128];
	212	IsdnCard_t icard;
	213	int busy = 0;
fba395ee	214
1da177e4 LT	215	dev = link->priv;
	216
	217	DEBUG(0, "avma1cs_config(0x%p)\n", link);
	218
	219	/*
	220	This reads the card's CONFIG tuple to find its configuration
	221	registers.
	222	*/
	223	do {
	224	tuple.DesiredTuple = CISTPL_CONFIG;
fba395ee	225	i = pcmcia_get_first_tuple(link, &tuple);
1da177e4 LT	226	if (i != CS_SUCCESS) break;
	227	tuple.TupleData = buf;
	228	tuple.TupleDataMax = 64;
	229	tuple.TupleOffset = 0;
fba395ee	230	i = pcmcia_get_tuple_data(link, &tuple);
1da177e4	231	if (i != CS_SUCCESS) break;
fba395ee	232	i = pcmcia_parse_tuple(link, &tuple, &parse);
1da177e4 LT	233	if (i != CS_SUCCESS) break;
	234	link->conf.ConfigBase = parse.config.base;
	235	} while (0);
	236	if (i != CS_SUCCESS) {
fba395ee	237	cs_error(link, ParseTuple, i);
15b99ac1	238	return -ENODEV;
1da177e4	239	}
1da177e4 LT	240
	241	do {
	242
	243	tuple.Attributes = 0;
	244	tuple.TupleData = buf;
	245	tuple.TupleDataMax = 254;
	246	tuple.TupleOffset = 0;
	247	tuple.DesiredTuple = CISTPL_VERS_1;
	248
	249	devname[0] = 0;
fba395ee	250	if( !first_tuple(link, &tuple, &parse) && parse.version_1.ns > 1 ) {
1da177e4 LT	251	strlcpy(devname,parse.version_1.str + parse.version_1.ofs[1],
	252	sizeof(devname));
	253	}
	254	/*
	255	* find IO port
	256	*/
	257	tuple.TupleData = (cisdata_t *)buf;
	258	tuple.TupleOffset = 0; tuple.TupleDataMax = 255;
	259	tuple.Attributes = 0;
	260	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
fba395ee	261	i = first_tuple(link, &tuple, &parse);
1da177e4 LT	262	while (i == CS_SUCCESS) {
	263	if (cf->io.nwin > 0) {
	264	link->conf.ConfigIndex = cf->index;
	265	link->io.BasePort1 = cf->io.win[0].base;
	266	link->io.NumPorts1 = cf->io.win[0].len;
	267	link->io.NumPorts2 = 0;
	268	printk(KERN_INFO "avma1_cs: testing i/o %#x-%#x\n",
	269	link->io.BasePort1,
	270	link->io.BasePort1+link->io.NumPorts1 - 1);
fba395ee	271	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	272	if (i == CS_SUCCESS) goto found_port;
1da177e4 LT	273	}
fba395ee	274	i = next_tuple(link, &tuple, &parse);
1da177e4 LT	275	}
	276
	277	found_port:
	278	if (i != CS_SUCCESS) {
fba395ee	279	cs_error(link, RequestIO, i);
1da177e4 LT	280	break;
	281	}
	282
	283	/*
	284	* allocate an interrupt line
	285	*/
fba395ee	286	i = pcmcia_request_irq(link, &link->irq);
1da177e4	287	if (i != CS_SUCCESS) {
fba395ee	288	cs_error(link, RequestIRQ, i);
50db3fdb	289	/* undo */
fba395ee	290	pcmcia_disable_device(link);
1da177e4 LT	291	break;
1da177e4 LT	292	}
50db3fdb	293
1da177e4 LT	294	/*
	295	* configure the PCMCIA socket
	296	*/
fba395ee	297	i = pcmcia_request_configuration(link, &link->conf);
1da177e4	298	if (i != CS_SUCCESS) {
fba395ee DB	299	cs_error(link, RequestConfiguration, i);
fba395ee DB	300	pcmcia_disable_device(link);
1da177e4 LT	301	break;
	302	}
	303
	304	} while (0);
	305
	306	/* At this point, the dev_node_t structure(s) should be
	307	initialized and arranged in a linked list at link->dev. */
	308
	309	strcpy(dev->node.dev_name, "A1");
	310	dev->node.major = 45;
	311	dev->node.minor = 0;
fd238232	312	link->dev_node = &dev->node;
e2d40963	313
1da177e4 LT	314	/* If any step failed, release any partially configured state */
	315	if (i != 0) {
	316	avma1cs_release(link);
15b99ac1	317	return -ENODEV;
1da177e4 LT	318	}
	319
	320	printk(KERN_NOTICE "avma1_cs: checking at i/o %#x, irq %d\n",
	321	link->io.BasePort1, link->irq.AssignedIRQ);
	322
	323	icard.para[0] = link->irq.AssignedIRQ;
	324	icard.para[1] = link->io.BasePort1;
	325	icard.protocol = isdnprot;
	326	icard.typ = ISDN_CTYPE_A1_PCMCIA;
	327
	328	i = hisax_init_pcmcia(link, &busy, &icard);
	329	if (i < 0) {
	330	printk(KERN_ERR "avma1_cs: failed to initialize AVM A1 PCMCIA %d at i/o %#x\n", i, link->io.BasePort1);
	331	avma1cs_release(link);
15b99ac1	332	return -ENODEV;
1da177e4 LT	333	}
	334	dev->node.minor = i;
	335
15b99ac1	336	return 0;
1da177e4 LT	337	} /* avma1cs_config */
	338
	339	/*======================================================================
	340
	341	After a card is removed, avma1cs_release() will unregister the net
	342	device, and release the PCMCIA configuration. If the device is
	343	still open, this will be postponed until it is closed.
	344
	345	======================================================================*/
	346
fba395ee	347	static void avma1cs_release(struct pcmcia_device *link)
1da177e4	348	{
5f2a71fc	349	local_info_t *local = link->priv;
1da177e4	350
5f2a71fc	351	DEBUG(0, "avma1cs_release(0x%p)\n", link);
1da177e4	352
5f2a71fc DB	353	/* now unregister function with hisax */
5f2a71fc DB	354	HiSax_closecard(local->node.minor);
1da177e4	355
fba395ee	356	pcmcia_disable_device(link);
1da177e4 LT	357	} /* avma1cs_release */
1da177e4 LT	358
1da177e4	359
c594c12c DB	360	static struct pcmcia_device_id avma1cs_ids[] = {
	361	PCMCIA_DEVICE_PROD_ID12("AVM", "ISDN A", 0x95d42008, 0xadc9d4bb),
	362	PCMCIA_DEVICE_PROD_ID12("ISDN", "CARD", 0x8d9761c8, 0x01c5aa7b),
	363	PCMCIA_DEVICE_NULL
	364	};
	365	MODULE_DEVICE_TABLE(pcmcia, avma1cs_ids);
	366
1da177e4 LT	367	static struct pcmcia_driver avma1cs_driver = {
	368	.owner = THIS_MODULE,
	369	.drv = {
	370	.name = "avma1_cs",
	371	},
15b99ac1	372	.probe = avma1cs_probe,
cc3b4866	373	.remove = avma1cs_detach,
c594c12c	374	.id_table = avma1cs_ids,
1da177e4	375	};
8661bb5b	376
1da177e4 LT	377	/====================================================================/
	378
	379	static int __init init_avma1_cs(void)
	380	{
	381	return(pcmcia_register_driver(&avma1cs_driver));
	382	}
	383
	384	static void __exit exit_avma1_cs(void)
	385	{
	386	pcmcia_unregister_driver(&avma1cs_driver);
1da177e4 LT	387	}
	388
	389	module_init(init_avma1_cs);
	390	module_exit(exit_avma1_cs);