[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / char / pcmcia / 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 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;
	struct resource *io_resource;
	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;

	io_resource = request_region(p_dev->resource[0]->start,
				resource_size(p_dev->resource[0]),
				IPWIRELESS_PCCARD_NAME);

	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 exit2;

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

	ipw->attr_memory = ioremap(p_dev->resource[2]->start,
				resource_size(p_dev->resource[2]));
	request_mem_region(p_dev->resource[2]->start,
			resource_size(p_dev->resource[2]),
			IPWIRELESS_PCCARD_NAME);

	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 exit2;

	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]));
	request_mem_region(p_dev->resource[3]->start,
			resource_size(p_dev->resource[3]),
			IPWIRELESS_PCCARD_NAME);

	return 0;

exit3:
exit2:
	if (ipw->common_memory) {
		release_mem_region(p_dev->resource[2]->start,
				resource_size(p_dev->resource[2]));
		iounmap(ipw->common_memory);
	}
exit1:
	release_resource(io_resource);
	pcmcia_disable_device(p_dev);
	return -1;
}

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)
{
	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,
	.drv = { .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;

	printk(KERN_INFO IPWIRELESS_PCCARD_NAME " "
	       IPWIRELESS_PCMCIA_VERSION " by " IPWIRELESS_PCMCIA_AUTHOR "\n");

	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)
{
	printk(KERN_INFO IPWIRELESS_PCCARD_NAME " "
			IPWIRELESS_PCMCIA_VERSION " removed\n");

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