[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 (!ipw->common_memory) {
		ret = -ENOMEM;
		goto exit1;
	}
	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 (!ipw->attr_memory) {
		ret = -ENOMEM;
		goto exit3;
	}
	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]));
1bbb1c31 KL	117	if (!ipw->common_memory) {
	118	ret = -ENOMEM;
	119	goto exit1;
	120	}
d5bb2923 JL	121	if (!request_mem_region(p_dev->resource[2]->start,
	122	resource_size(p_dev->resource[2]),
	123	IPWIRELESS_PCCARD_NAME)) {
	124	ret = -EBUSY;
	125	goto exit2;
	126	}
af757923	127
cdb13808 DB	128	p_dev->resource[3]->flags \|= WIN_DATA_WIDTH_16 \| WIN_MEMORY_TYPE_AM \|
	129	WIN_ENABLE;
	130	p_dev->resource[3]->end = 0; /* this used to be 0x1000 */
	131	ret = pcmcia_request_window(p_dev, p_dev->resource[3], 0);
cbf624f0	132	if (ret != 0)
d5bb2923	133	goto exit3;
099dc4fb	134
cdb13808	135	ret = pcmcia_map_mem_page(p_dev, p_dev->resource[3], 0);
cbf624f0	136	if (ret != 0)
af757923	137	goto exit3;
099dc4fb	138
cdb13808 DB	139	ipw->attr_memory = ioremap(p_dev->resource[3]->start,
cdb13808 DB	140	resource_size(p_dev->resource[3]));
1bbb1c31 KL	141	if (!ipw->attr_memory) {
	142	ret = -ENOMEM;
	143	goto exit3;
	144	}
d5bb2923 JL	145	if (!request_mem_region(p_dev->resource[3]->start,
	146	resource_size(p_dev->resource[3]),
	147	IPWIRELESS_PCCARD_NAME)) {
	148	ret = -EBUSY;
	149	goto exit4;
	150	}
099dc4fb	151
af757923	152	return 0;
099dc4fb	153
d5bb2923 JL	154	exit4:
d5bb2923 JL	155	iounmap(ipw->attr_memory);
af757923	156	exit3:
d5bb2923 JL	157	release_mem_region(p_dev->resource[2]->start,
d5bb2923 JL	158	resource_size(p_dev->resource[2]));
af757923	159	exit2:
d5bb2923	160	iounmap(ipw->common_memory);
af757923	161	exit1:
d5bb2923 JL	162	release_region(p_dev->resource[0]->start,
	163	resource_size(p_dev->resource[0]));
	164	exit:
af757923	165	pcmcia_disable_device(p_dev);
d5bb2923	166	return ret;
af757923	167	}
099dc4fb	168
af757923 DB	169	static int config_ipwireless(struct ipw_dev *ipw)
	170	{
	171	struct pcmcia_device *link = ipw->link;
	172	int ret = 0;
099dc4fb	173
af757923	174	ipw->is_v2_card = 0;
00990e7c DB	175	link->config_flags \|= CONF_AUTO_SET_IO \| CONF_AUTO_SET_IOMEM \|
00990e7c DB	176	CONF_ENABLE_IRQ;
099dc4fb	177
af757923	178	ret = pcmcia_loop_config(link, ipwireless_probe, ipw);
cbf624f0	179	if (ret != 0)
af757923	180	return ret;
099dc4fb	181
099dc4fb DS	182	INIT_WORK(&ipw->work_reboot, signalled_reboot_work);
099dc4fb DS	183
9a017a91	184	ipwireless_init_hardware_v1(ipw->hardware, link->resource[0]->start,
099dc4fb DS	185	ipw->attr_memory, ipw->common_memory,
	186	ipw->is_v2_card, signalled_reboot_callback,
	187	ipw);
	188
eb14120f	189	ret = pcmcia_request_irq(link, ipwireless_interrupt);
cbf624f0	190	if (ret != 0)
af757923	191	goto exit;
099dc4fb	192
099dc4fb DS	193	printk(KERN_INFO IPWIRELESS_PCCARD_NAME ": Card type %s\n",
	194	ipw->is_v2_card ? "V2/V3" : "V1");
	195	printk(KERN_INFO IPWIRELESS_PCCARD_NAME
9a017a91	196	": I/O ports %pR, irq %d\n", link->resource[0],
eb14120f	197	(unsigned int) link->irq);
099dc4fb DS	198	if (ipw->attr_memory && ipw->common_memory)
099dc4fb DS	199	printk(KERN_INFO IPWIRELESS_PCCARD_NAME
cdb13808 DB	200	": attr memory %pR, common memory %pR\n",
	201	link->resource[3],
	202	link->resource[2]);
099dc4fb DS	203
	204	ipw->network = ipwireless_network_create(ipw->hardware);
	205	if (!ipw->network)
af757923	206	goto exit;
099dc4fb	207
b498ada6	208	ipw->tty = ipwireless_tty_create(ipw->hardware, ipw->network);
099dc4fb	209	if (!ipw->tty)
af757923	210	goto exit;
099dc4fb DS	211
	212	ipwireless_init_hardware_v2_v3(ipw->hardware);
	213
	214	/*
	215	* Do the RequestConfiguration last, because it enables interrupts.
	216	* Then we don't get any interrupts before we're ready for them.
	217	*/
1ac71e5a	218	ret = pcmcia_enable_device(link);
cbf624f0	219	if (ret != 0)
af757923	220	goto exit;
099dc4fb	221
099dc4fb DS	222	return 0;
099dc4fb DS	223
af757923	224	exit:
099dc4fb	225	if (ipw->common_memory) {
cdb13808 DB	226	release_mem_region(link->resource[2]->start,
cdb13808 DB	227	resource_size(link->resource[2]));
099dc4fb	228	iounmap(ipw->common_memory);
099dc4fb	229	}
cdb13808 DB	230	if (ipw->attr_memory) {
	231	release_mem_region(link->resource[3]->start,
	232	resource_size(link->resource[3]));
	233	iounmap(ipw->attr_memory);
	234	}
099dc4fb	235	pcmcia_disable_device(link);
099dc4fb DS	236	return -1;
	237	}
	238
	239	static void release_ipwireless(struct ipw_dev *ipw)
	240	{
d5bb2923 JL	241	release_region(ipw->link->resource[0]->start,
d5bb2923 JL	242	resource_size(ipw->link->resource[0]));
09e491e9	243	if (ipw->common_memory) {
cdb13808 DB	244	release_mem_region(ipw->link->resource[2]->start,
cdb13808 DB	245	resource_size(ipw->link->resource[2]));
099dc4fb	246	iounmap(ipw->common_memory);
09e491e9 DS	247	}
09e491e9 DS	248	if (ipw->attr_memory) {
cdb13808 DB	249	release_mem_region(ipw->link->resource[3]->start,
cdb13808 DB	250	resource_size(ipw->link->resource[3]));
099dc4fb	251	iounmap(ipw->attr_memory);
09e491e9	252	}
09e491e9	253	pcmcia_disable_device(ipw->link);
099dc4fb DS	254	}
	255
	256	/*
	257	* ipwireless_attach() creates an "instance" of the driver, allocating
	258	* local data structures for one device (one interface). The device
	259	* is registered with Card Services.
	260	*
	261	* The pcmcia_device structure is initialized, but we don't actually
	262	* configure the card at this point -- we wait until we receive a
	263	* card insertion event.
	264	*/
	265	static int ipwireless_attach(struct pcmcia_device *link)
	266	{
	267	struct ipw_dev *ipw;
	268	int ret;
	269
	270	ipw = kzalloc(sizeof(struct ipw_dev), GFP_KERNEL);
	271	if (!ipw)
	272	return -ENOMEM;
	273
	274	ipw->link = link;
	275	link->priv = ipw;
099dc4fb	276
099dc4fb DS	277	ipw->hardware = ipwireless_hardware_create();
	278	if (!ipw->hardware) {
	279	kfree(ipw);
	280	return -ENOMEM;
	281	}
	282	/* RegisterClient will call config_ipwireless */
	283
	284	ret = config_ipwireless(ipw);
	285
	286	if (ret != 0) {
099dc4fb DS	287	ipwireless_detach(link);
	288	return ret;
	289	}
	290
	291	return 0;
	292	}
	293
	294	/*
	295	* This deletes a driver "instance". The device is de-registered with
	296	* Card Services. If it has been released, all local data structures
	297	* are freed. Otherwise, the structures will be freed when the device
	298	* is released.
	299	*/
	300	static void ipwireless_detach(struct pcmcia_device *link)
	301	{
	302	struct ipw_dev *ipw = link->priv;
	303
	304	release_ipwireless(ipw);
	305
099dc4fb DS	306	if (ipw->tty != NULL)
	307	ipwireless_tty_free(ipw->tty);
	308	if (ipw->network != NULL)
	309	ipwireless_network_free(ipw->network);
	310	if (ipw->hardware != NULL)
	311	ipwireless_hardware_free(ipw->hardware);
	312	kfree(ipw);
	313	}
	314
	315	static struct pcmcia_driver me = {
	316	.owner = THIS_MODULE,
	317	.probe = ipwireless_attach,
	318	.remove = ipwireless_detach,
2e9b981a	319	.name = IPWIRELESS_PCCARD_NAME,
099dc4fb DS	320	.id_table = ipw_ids
	321	};
	322
	323	/*
	324	* Module insertion : initialisation of the module.
	325	* Register the card with cardmgr...
	326	*/
	327	static int __init init_ipwireless(void)
	328	{
	329	int ret;
	330
099dc4fb DS	331	ret = ipwireless_tty_init();
	332	if (ret != 0)
	333	return ret;
	334
	335	ret = pcmcia_register_driver(&me);
	336	if (ret != 0)
	337	ipwireless_tty_release();
	338
	339	return ret;
	340	}
	341
	342	/*
	343	* Module removal
	344	*/
	345	static void __exit exit_ipwireless(void)
	346	{
099dc4fb DS	347	pcmcia_unregister_driver(&me);
	348	ipwireless_tty_release();
	349	}
	350
	351	module_init(init_ipwireless);
	352	module_exit(exit_ipwireless);
	353
	354	MODULE_AUTHOR(IPWIRELESS_PCMCIA_AUTHOR);
	355	MODULE_DESCRIPTION(IPWIRELESS_PCCARD_NAME " " IPWIRELESS_PCMCIA_VERSION);
	356	MODULE_LICENSE("GPL");