[linux-2.6-block.git] / drivers / tty / ipwireless / main.c

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