[deliverable/linux.git] / drivers / tty / ipwireless / main.c

/*
 * IPWireless 3G PCMCIA Network Driver
 *
 * Original code
 *   by Stephen Blackheath <stephen@blacksapphire.com>,
 *      Ben Martel <benm@symmetric.co.nz>
 *
 * Copyrighted as follows:
 *   Copyright (C) 2004 by Symmetric Systems Ltd (NZ)
 *
 * Various driver changes and rewrites, port to new kernels
 *   Copyright (C) 2006-2007 Jiri Kosina
 *
 * Misc code cleanups and updates
 *   Copyright (C) 2007 David Sterba
 */

#include "hardware.h"
#include "network.h"
#include "main.h"
#include "tty.h"

#include <linux/delay.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/slab.h>

#include <pcmcia/cisreg.h>
#include <pcmcia/device_id.h>
#include <pcmcia/ss.h>
#include <pcmcia/ds.h>

static const struct pcmcia_device_id ipw_ids[] = {
	PCMCIA_DEVICE_MANF_CARD(0x02f2, 0x0100),
	PCMCIA_DEVICE_MANF_CARD(0x02f2, 0x0200),
	PCMCIA_DEVICE_NULL
};
MODULE_DEVICE_TABLE(pcmcia, ipw_ids);

static void ipwireless_detach(struct pcmcia_device *link);

/*
 * Module params
 */
/* Debug mode: more verbose, print sent/recv bytes */
int ipwireless_debug;
int ipwireless_loopback;
int ipwireless_out_queue = 10;

module_param_named(debug, ipwireless_debug, int, 0);
module_param_named(loopback, ipwireless_loopback, int, 0);
module_param_named(out_queue, ipwireless_out_queue, int, 0);
MODULE_PARM_DESC(debug, "switch on debug messages [0]");
MODULE_PARM_DESC(loopback,
		"debug: enable ras_raw channel [0]");
MODULE_PARM_DESC(out_queue, "debug: set size of outgoing PPP queue [10]");

/* Executes in process context. */
static void signalled_reboot_work(struct work_struct *work_reboot)
{
	struct ipw_dev *ipw = container_of(work_reboot, struct ipw_dev,
			work_reboot);
	struct pcmcia_device *link = ipw->link;
	pcmcia_reset_card(link->socket);
}

static void signalled_reboot_callback(void *callback_data)
{
	struct ipw_dev *ipw = (struct ipw_dev *) callback_data;

	/* Delegate to process context. */
	schedule_work(&ipw->work_reboot);
}

static int ipwireless_probe(struct pcmcia_device *p_dev, void *priv_data)
{
	struct ipw_dev *ipw = priv_data;
	int ret;

	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
	p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;

	/* 0x40 causes it to generate level mode interrupts. */
	/* 0x04 enables IREQ pin. */
	p_dev->config_index |= 0x44;
	p_dev->io_lines = 16;
	ret = pcmcia_request_io(p_dev);
	if (ret)
		return ret;

	if (!request_region(p_dev->resource[0]->start,
			    resource_size(p_dev->resource[0]),
			    IPWIRELESS_PCCARD_NAME)) {
		ret = -EBUSY;
		goto exit;
	}

	p_dev->resource[2]->flags |=
		WIN_DATA_WIDTH_16 | WIN_MEMORY_TYPE_CM | WIN_ENABLE;

	ret = pcmcia_request_window(p_dev, p_dev->resource[2], 0);
	if (ret != 0)
		goto exit1;

	ret = pcmcia_map_mem_page(p_dev, p_dev->resource[2], p_dev->card_addr);
	if (ret != 0)
		goto exit1;

	ipw->is_v2_card = resource_size(p_dev->resource[2]) == 0x100;

	ipw->common_memory = ioremap(p_dev->resource[2]->start,
				resource_size(p_dev->resource[2]));
	if (!request_mem_region(p_dev->resource[2]->start,
				resource_size(p_dev->resource[2]),
				IPWIRELESS_PCCARD_NAME)) {
		ret = -EBUSY;
		goto exit2;
	}

	p_dev->resource[3]->flags |= WIN_DATA_WIDTH_16 | WIN_MEMORY_TYPE_AM |
					WIN_ENABLE;
	p_dev->resource[3]->end = 0; /* this used to be 0x1000 */
	ret = pcmcia_request_window(p_dev, p_dev->resource[3], 0);
	if (ret != 0)
		goto exit3;

	ret = pcmcia_map_mem_page(p_dev, p_dev->resource[3], 0);
	if (ret != 0)
		goto exit3;

	ipw->attr_memory = ioremap(p_dev->resource[3]->start,
				resource_size(p_dev->resource[3]));
	if (!request_mem_region(p_dev->resource[3]->start,
				resource_size(p_dev->resource[3]),
				IPWIRELESS_PCCARD_NAME)) {
		ret = -EBUSY;
		goto exit4;
	}

	return 0;

exit4:
	iounmap(ipw->attr_memory);
exit3:
	release_mem_region(p_dev->resource[2]->start,
			resource_size(p_dev->resource[2]));
exit2:
	iounmap(ipw->common_memory);
exit1:
	release_region(p_dev->resource[0]->start,
		       resource_size(p_dev->resource[0]));
exit:
	pcmcia_disable_device(p_dev);
	return ret;
}

static int config_ipwireless(struct ipw_dev *ipw)
{
	struct pcmcia_device *link = ipw->link;
	int ret = 0;

	ipw->is_v2_card = 0;
	link->config_flags |= CONF_AUTO_SET_IO | CONF_AUTO_SET_IOMEM |
		CONF_ENABLE_IRQ;

	ret = pcmcia_loop_config(link, ipwireless_probe, ipw);
	if (ret != 0)
		return ret;

	INIT_WORK(&ipw->work_reboot, signalled_reboot_work);

	ipwireless_init_hardware_v1(ipw->hardware, link->resource[0]->start,
				    ipw->attr_memory, ipw->common_memory,
				    ipw->is_v2_card, signalled_reboot_callback,
				    ipw);

	ret = pcmcia_request_irq(link, ipwireless_interrupt);
	if (ret != 0)
		goto exit;

	printk(KERN_INFO IPWIRELESS_PCCARD_NAME ": Card type %s\n",
			ipw->is_v2_card ? "V2/V3" : "V1");
	printk(KERN_INFO IPWIRELESS_PCCARD_NAME
		": I/O ports %pR, irq %d\n", link->resource[0],
			(unsigned int) link->irq);
	if (ipw->attr_memory && ipw->common_memory)
		printk(KERN_INFO IPWIRELESS_PCCARD_NAME
			": attr memory %pR, common memory %pR\n",
			link->resource[3],
			link->resource[2]);

	ipw->network = ipwireless_network_create(ipw->hardware);
	if (!ipw->network)
		goto exit;

	ipw->tty = ipwireless_tty_create(ipw->hardware, ipw->network);
	if (!ipw->tty)
		goto exit;

	ipwireless_init_hardware_v2_v3(ipw->hardware);

	/*
	 * Do the RequestConfiguration last, because it enables interrupts.
	 * Then we don't get any interrupts before we're ready for them.
	 */
	ret = pcmcia_enable_device(link);
	if (ret != 0)
		goto exit;

	return 0;

exit:
	if (ipw->common_memory) {
		release_mem_region(link->resource[2]->start,
				resource_size(link->resource[2]));
		iounmap(ipw->common_memory);
	}
	if (ipw->attr_memory) {
		release_mem_region(link->resource[3]->start,
				resource_size(link->resource[3]));
		iounmap(ipw->attr_memory);
	}
	pcmcia_disable_device(link);
	return -1;
}

static void release_ipwireless(struct ipw_dev *ipw)
{
	release_region(ipw->link->resource[0]->start,
		       resource_size(ipw->link->resource[0]));
	if (ipw->common_memory) {
		release_mem_region(ipw->link->resource[2]->start,
				resource_size(ipw->link->resource[2]));
		iounmap(ipw->common_memory);
	}
	if (ipw->attr_memory) {
		release_mem_region(ipw->link->resource[3]->start,
				resource_size(ipw->link->resource[3]));
		iounmap(ipw->attr_memory);
	}
	pcmcia_disable_device(ipw->link);
}

/*
 * ipwireless_attach() creates an "instance" of the driver, allocating
 * local data structures for one device (one interface).  The device
 * is registered with Card Services.
 *
 * The pcmcia_device 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 ipwireless_attach(struct pcmcia_device *link)
{
	struct ipw_dev *ipw;
	int ret;

	ipw = kzalloc(sizeof(struct ipw_dev), GFP_KERNEL);
	if (!ipw)
		return -ENOMEM;

	ipw->link = link;
	link->priv = ipw;

	ipw->hardware = ipwireless_hardware_create();
	if (!ipw->hardware) {
		kfree(ipw);
		return -ENOMEM;
	}
	/* RegisterClient will call config_ipwireless */

	ret = config_ipwireless(ipw);

	if (ret != 0) {
		ipwireless_detach(link);
		return ret;
	}

	return 0;
}

/*
 * 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 ipwireless_detach(struct pcmcia_device *link)
{
	struct ipw_dev *ipw = link->priv;

	release_ipwireless(ipw);

	if (ipw->tty != NULL)
		ipwireless_tty_free(ipw->tty);
	if (ipw->network != NULL)
		ipwireless_network_free(ipw->network);
	if (ipw->hardware != NULL)
		ipwireless_hardware_free(ipw->hardware);
	kfree(ipw);
}

static struct pcmcia_driver me = {
	.owner		= THIS_MODULE,
	.probe          = ipwireless_attach,
	.remove         = ipwireless_detach,
	.name		= IPWIRELESS_PCCARD_NAME,
	.id_table       = ipw_ids
};

/*
 * Module insertion : initialisation of the module.
 * Register the card with cardmgr...
 */
static int __init init_ipwireless(void)
{
	int ret;

	ret = ipwireless_tty_init();
	if (ret != 0)
		return ret;

	ret = pcmcia_register_driver(&me);
	if (ret != 0)
		ipwireless_tty_release();

	return ret;
}

/*
 * Module removal
 */
static void __exit exit_ipwireless(void)
{
	pcmcia_unregister_driver(&me);
	ipwireless_tty_release();
}

module_init(init_ipwireless);
module_exit(exit_ipwireless);

MODULE_AUTHOR(IPWIRELESS_PCMCIA_AUTHOR);
MODULE_DESCRIPTION(IPWIRELESS_PCCARD_NAME " " IPWIRELESS_PCMCIA_VERSION);
MODULE_LICENSE("GPL");
Commit	Line	Data
099dc4fb DS	1	/*
	2	* IPWireless 3G PCMCIA Network Driver
	3	*
	4	* Original code
	5	* by Stephen Blackheath <stephen@blacksapphire.com>,
	6	* Ben Martel <benm@symmetric.co.nz>
	7	*
	8	* Copyrighted as follows:
	9	* Copyright (C) 2004 by Symmetric Systems Ltd (NZ)
	10	*
	11	* Various driver changes and rewrites, port to new kernels
	12	* Copyright (C) 2006-2007 Jiri Kosina
	13	*
	14	* Misc code cleanups and updates
	15	* Copyright (C) 2007 David Sterba
	16	*/
	17
	18	#include "hardware.h"
	19	#include "network.h"
	20	#include "main.h"
	21	#include "tty.h"
	22
	23	#include <linux/delay.h>
	24	#include <linux/init.h>
	25	#include <linux/io.h>
	26	#include <linux/kernel.h>
	27	#include <linux/module.h>
	28	#include <linux/sched.h>
	29	#include <linux/slab.h>
	30
099dc4fb DS	31	#include <pcmcia/cisreg.h>
	32	#include <pcmcia/device_id.h>
	33	#include <pcmcia/ss.h>
	34	#include <pcmcia/ds.h>
099dc4fb	35
25f8f54f	36	static const struct pcmcia_device_id ipw_ids[] = {
099dc4fb DS	37	PCMCIA_DEVICE_MANF_CARD(0x02f2, 0x0100),
	38	PCMCIA_DEVICE_MANF_CARD(0x02f2, 0x0200),
	39	PCMCIA_DEVICE_NULL
	40	};
	41	MODULE_DEVICE_TABLE(pcmcia, ipw_ids);
	42
	43	static void ipwireless_detach(struct pcmcia_device *link);
	44
	45	/*
	46	* Module params
	47	*/
	48	/* Debug mode: more verbose, print sent/recv bytes */
	49	int ipwireless_debug;
	50	int ipwireless_loopback;
bee9c7c0	51	int ipwireless_out_queue = 10;
099dc4fb DS	52
	53	module_param_named(debug, ipwireless_debug, int, 0);
	54	module_param_named(loopback, ipwireless_loopback, int, 0);
	55	module_param_named(out_queue, ipwireless_out_queue, int, 0);
	56	MODULE_PARM_DESC(debug, "switch on debug messages [0]");
	57	MODULE_PARM_DESC(loopback,
	58	"debug: enable ras_raw channel [0]");
bee9c7c0	59	MODULE_PARM_DESC(out_queue, "debug: set size of outgoing PPP queue [10]");
099dc4fb DS	60
	61	/* Executes in process context. */
	62	static void signalled_reboot_work(struct work_struct *work_reboot)
	63	{
	64	struct ipw_dev *ipw = container_of(work_reboot, struct ipw_dev,
	65	work_reboot);
	66	struct pcmcia_device *link = ipw->link;
cbf624f0	67	pcmcia_reset_card(link->socket);
099dc4fb DS	68	}
	69
	70	static void signalled_reboot_callback(void *callback_data)
	71	{
	72	struct ipw_dev ipw = (struct ipw_dev ) callback_data;
	73
	74	/* Delegate to process context. */
	75	schedule_work(&ipw->work_reboot);
	76	}
	77
00990e7c	78	static int ipwireless_probe(struct pcmcia_device p_dev, void priv_data)
aaa8cfda	79	{
af757923	80	struct ipw_dev *ipw = priv_data;
af757923 DB	81	int ret;
af757923 DB	82
00990e7c	83	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
90abdc3b	84	p_dev->resource[0]->flags \|= IO_DATA_PATH_WIDTH_AUTO;
aaa8cfda	85
aaa8cfda DB	86	/* 0x40 causes it to generate level mode interrupts. */
aaa8cfda DB	87	/* 0x04 enables IREQ pin. */
00990e7c	88	p_dev->config_index \|= 0x44;
90abdc3b DB	89	p_dev->io_lines = 16;
90abdc3b DB	90	ret = pcmcia_request_io(p_dev);
af757923 DB	91	if (ret)
af757923 DB	92	return ret;
aaa8cfda	93
d5bb2923 JL	94	if (!request_region(p_dev->resource[0]->start,
	95	resource_size(p_dev->resource[0]),
	96	IPWIRELESS_PCCARD_NAME)) {
	97	ret = -EBUSY;
	98	goto exit;
	99	}
099dc4fb	100
cdb13808	101	p_dev->resource[2]->flags \|=
af757923	102	WIN_DATA_WIDTH_16 \| WIN_MEMORY_TYPE_CM \| WIN_ENABLE;
099dc4fb	103
cdb13808	104	ret = pcmcia_request_window(p_dev, p_dev->resource[2], 0);
cbf624f0	105	if (ret != 0)
af757923	106	goto exit1;
099dc4fb	107
00990e7c	108	ret = pcmcia_map_mem_page(p_dev, p_dev->resource[2], p_dev->card_addr);
cbf624f0	109	if (ret != 0)
d5bb2923	110	goto exit1;
099dc4fb	111
00990e7c	112	ipw->is_v2_card = resource_size(p_dev->resource[2]) == 0x100;
099dc4fb	113
d5bb2923	114	ipw->common_memory = ioremap(p_dev->resource[2]->start,
cdb13808	115	resource_size(p_dev->resource[2]));
d5bb2923 JL	116	if (!request_mem_region(p_dev->resource[2]->start,
	117	resource_size(p_dev->resource[2]),
	118	IPWIRELESS_PCCARD_NAME)) {
	119	ret = -EBUSY;
	120	goto exit2;
	121	}
af757923	122
cdb13808 DB	123	p_dev->resource[3]->flags \|= WIN_DATA_WIDTH_16 \| WIN_MEMORY_TYPE_AM \|
	124	WIN_ENABLE;
	125	p_dev->resource[3]->end = 0; /* this used to be 0x1000 */
	126	ret = pcmcia_request_window(p_dev, p_dev->resource[3], 0);
cbf624f0	127	if (ret != 0)
d5bb2923	128	goto exit3;
099dc4fb	129
cdb13808	130	ret = pcmcia_map_mem_page(p_dev, p_dev->resource[3], 0);
cbf624f0	131	if (ret != 0)
af757923	132	goto exit3;
099dc4fb	133
cdb13808 DB	134	ipw->attr_memory = ioremap(p_dev->resource[3]->start,
cdb13808 DB	135	resource_size(p_dev->resource[3]));
d5bb2923 JL	136	if (!request_mem_region(p_dev->resource[3]->start,
	137	resource_size(p_dev->resource[3]),
	138	IPWIRELESS_PCCARD_NAME)) {
	139	ret = -EBUSY;
	140	goto exit4;
	141	}
099dc4fb	142
af757923	143	return 0;
099dc4fb	144
d5bb2923 JL	145	exit4:
d5bb2923 JL	146	iounmap(ipw->attr_memory);
af757923	147	exit3:
d5bb2923 JL	148	release_mem_region(p_dev->resource[2]->start,
d5bb2923 JL	149	resource_size(p_dev->resource[2]));
af757923	150	exit2:
d5bb2923	151	iounmap(ipw->common_memory);
af757923	152	exit1:
d5bb2923 JL	153	release_region(p_dev->resource[0]->start,
	154	resource_size(p_dev->resource[0]));
	155	exit:
af757923	156	pcmcia_disable_device(p_dev);
d5bb2923	157	return ret;
af757923	158	}
099dc4fb	159
af757923 DB	160	static int config_ipwireless(struct ipw_dev *ipw)
	161	{
	162	struct pcmcia_device *link = ipw->link;
	163	int ret = 0;
099dc4fb	164
af757923	165	ipw->is_v2_card = 0;
00990e7c DB	166	link->config_flags \|= CONF_AUTO_SET_IO \| CONF_AUTO_SET_IOMEM \|
00990e7c DB	167	CONF_ENABLE_IRQ;
099dc4fb	168
af757923	169	ret = pcmcia_loop_config(link, ipwireless_probe, ipw);
cbf624f0	170	if (ret != 0)
af757923	171	return ret;
099dc4fb	172
099dc4fb DS	173	INIT_WORK(&ipw->work_reboot, signalled_reboot_work);
099dc4fb DS	174
9a017a91	175	ipwireless_init_hardware_v1(ipw->hardware, link->resource[0]->start,
099dc4fb DS	176	ipw->attr_memory, ipw->common_memory,
	177	ipw->is_v2_card, signalled_reboot_callback,
	178	ipw);
	179
eb14120f	180	ret = pcmcia_request_irq(link, ipwireless_interrupt);
cbf624f0	181	if (ret != 0)
af757923	182	goto exit;
099dc4fb	183
099dc4fb DS	184	printk(KERN_INFO IPWIRELESS_PCCARD_NAME ": Card type %s\n",
	185	ipw->is_v2_card ? "V2/V3" : "V1");
	186	printk(KERN_INFO IPWIRELESS_PCCARD_NAME
9a017a91	187	": I/O ports %pR, irq %d\n", link->resource[0],
eb14120f	188	(unsigned int) link->irq);
099dc4fb DS	189	if (ipw->attr_memory && ipw->common_memory)
099dc4fb DS	190	printk(KERN_INFO IPWIRELESS_PCCARD_NAME
cdb13808 DB	191	": attr memory %pR, common memory %pR\n",
	192	link->resource[3],
	193	link->resource[2]);
099dc4fb DS	194
	195	ipw->network = ipwireless_network_create(ipw->hardware);
	196	if (!ipw->network)
af757923	197	goto exit;
099dc4fb	198
b498ada6	199	ipw->tty = ipwireless_tty_create(ipw->hardware, ipw->network);
099dc4fb	200	if (!ipw->tty)
af757923	201	goto exit;
099dc4fb DS	202
	203	ipwireless_init_hardware_v2_v3(ipw->hardware);
	204
	205	/*
	206	* Do the RequestConfiguration last, because it enables interrupts.
	207	* Then we don't get any interrupts before we're ready for them.
	208	*/
1ac71e5a	209	ret = pcmcia_enable_device(link);
cbf624f0	210	if (ret != 0)
af757923	211	goto exit;
099dc4fb	212
099dc4fb DS	213	return 0;
099dc4fb DS	214
af757923	215	exit:
099dc4fb	216	if (ipw->common_memory) {
cdb13808 DB	217	release_mem_region(link->resource[2]->start,
cdb13808 DB	218	resource_size(link->resource[2]));
099dc4fb	219	iounmap(ipw->common_memory);
099dc4fb	220	}
cdb13808 DB	221	if (ipw->attr_memory) {
	222	release_mem_region(link->resource[3]->start,
	223	resource_size(link->resource[3]));
	224	iounmap(ipw->attr_memory);
	225	}
099dc4fb	226	pcmcia_disable_device(link);
099dc4fb DS	227	return -1;
	228	}
	229
	230	static void release_ipwireless(struct ipw_dev *ipw)
	231	{
d5bb2923 JL	232	release_region(ipw->link->resource[0]->start,
d5bb2923 JL	233	resource_size(ipw->link->resource[0]));
09e491e9	234	if (ipw->common_memory) {
cdb13808 DB	235	release_mem_region(ipw->link->resource[2]->start,
cdb13808 DB	236	resource_size(ipw->link->resource[2]));
099dc4fb	237	iounmap(ipw->common_memory);
09e491e9 DS	238	}
09e491e9 DS	239	if (ipw->attr_memory) {
cdb13808 DB	240	release_mem_region(ipw->link->resource[3]->start,
cdb13808 DB	241	resource_size(ipw->link->resource[3]));
099dc4fb	242	iounmap(ipw->attr_memory);
09e491e9	243	}
09e491e9	244	pcmcia_disable_device(ipw->link);
099dc4fb DS	245	}
	246
	247	/*
	248	* ipwireless_attach() creates an "instance" of the driver, allocating
	249	* local data structures for one device (one interface). The device
	250	* is registered with Card Services.
	251	*
	252	* The pcmcia_device structure is initialized, but we don't actually
	253	* configure the card at this point -- we wait until we receive a
	254	* card insertion event.
	255	*/
	256	static int ipwireless_attach(struct pcmcia_device *link)
	257	{
	258	struct ipw_dev *ipw;
	259	int ret;
	260
	261	ipw = kzalloc(sizeof(struct ipw_dev), GFP_KERNEL);
	262	if (!ipw)
	263	return -ENOMEM;
	264
	265	ipw->link = link;
	266	link->priv = ipw;
099dc4fb	267
099dc4fb DS	268	ipw->hardware = ipwireless_hardware_create();
	269	if (!ipw->hardware) {
	270	kfree(ipw);
	271	return -ENOMEM;
	272	}
	273	/* RegisterClient will call config_ipwireless */
	274
	275	ret = config_ipwireless(ipw);
	276
	277	if (ret != 0) {
099dc4fb DS	278	ipwireless_detach(link);
	279	return ret;
	280	}
	281
	282	return 0;
	283	}
	284
	285	/*
	286	* This deletes a driver "instance". The device is de-registered with
	287	* Card Services. If it has been released, all local data structures
	288	* are freed. Otherwise, the structures will be freed when the device
	289	* is released.
	290	*/
	291	static void ipwireless_detach(struct pcmcia_device *link)
	292	{
	293	struct ipw_dev *ipw = link->priv;
	294
	295	release_ipwireless(ipw);
	296
099dc4fb DS	297	if (ipw->tty != NULL)
	298	ipwireless_tty_free(ipw->tty);
	299	if (ipw->network != NULL)
	300	ipwireless_network_free(ipw->network);
	301	if (ipw->hardware != NULL)
	302	ipwireless_hardware_free(ipw->hardware);
	303	kfree(ipw);
	304	}
	305
	306	static struct pcmcia_driver me = {
	307	.owner = THIS_MODULE,
	308	.probe = ipwireless_attach,
	309	.remove = ipwireless_detach,
2e9b981a	310	.name = IPWIRELESS_PCCARD_NAME,
099dc4fb DS	311	.id_table = ipw_ids
	312	};
	313
	314	/*
	315	* Module insertion : initialisation of the module.
	316	* Register the card with cardmgr...
	317	*/
	318	static int __init init_ipwireless(void)
	319	{
	320	int ret;
	321
099dc4fb DS	322	ret = ipwireless_tty_init();
	323	if (ret != 0)
	324	return ret;
	325
	326	ret = pcmcia_register_driver(&me);
	327	if (ret != 0)
	328	ipwireless_tty_release();
	329
	330	return ret;
	331	}
	332
	333	/*
	334	* Module removal
	335	*/
	336	static void __exit exit_ipwireless(void)
	337	{
099dc4fb DS	338	pcmcia_unregister_driver(&me);
	339	ipwireless_tty_release();
	340	}
	341
	342	module_init(init_ipwireless);
	343	module_exit(exit_ipwireless);
	344
	345	MODULE_AUTHOR(IPWIRELESS_PCMCIA_AUTHOR);
	346	MODULE_DESCRIPTION(IPWIRELESS_PCCARD_NAME " " IPWIRELESS_PCMCIA_VERSION);
	347	MODULE_LICENSE("GPL");