[linux-2.6-block.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>
#include <pcmcia/cs.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;
	int ret = pcmcia_reset_card(link->socket);

	if (ret != 0)
		cs_error(link, ResetCard, ret);
}

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 config_ipwireless(struct ipw_dev *ipw)
{
	struct pcmcia_device *link = ipw->link;
	int ret;
	tuple_t tuple;
	unsigned short buf[64];
	cisparse_t parse;
	unsigned short cor_value;
	memreq_t memreq_attr_memory;
	memreq_t memreq_common_memory;

	ipw->is_v2_card = 0;

	tuple.Attributes = 0;
	tuple.TupleData = (cisdata_t *) buf;
	tuple.TupleDataMax = sizeof(buf);
	tuple.TupleOffset = 0;

	tuple.DesiredTuple = RETURN_FIRST_TUPLE;

	ret = pcmcia_get_first_tuple(link, &tuple);

	while (ret == 0) {
		ret = pcmcia_get_tuple_data(link, &tuple);

		if (ret != 0) {
			cs_error(link, GetTupleData, ret);
			goto exit0;
		}
		ret = pcmcia_get_next_tuple(link, &tuple);
	}

	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;

	ret = pcmcia_get_first_tuple(link, &tuple);

	if (ret != 0) {
		cs_error(link, GetFirstTuple, ret);
		goto exit0;
	}

	ret = pcmcia_get_tuple_data(link, &tuple);

	if (ret != 0) {
		cs_error(link, GetTupleData, ret);
		goto exit0;
	}

	ret = pcmcia_parse_tuple(&tuple, &parse);

	if (ret != 0) {
		cs_error(link, ParseTuple, ret);
		goto exit0;
	}

	link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
	link->io.BasePort1 = parse.cftable_entry.io.win[0].base;
	link->io.NumPorts1 = parse.cftable_entry.io.win[0].len;
	link->io.IOAddrLines = 16;

	link->irq.IRQInfo1 = parse.cftable_entry.irq.IRQInfo1;

	/* 0x40 causes it to generate level mode interrupts. */
	/* 0x04 enables IREQ pin. */
	cor_value = parse.cftable_entry.index | 0x44;
	link->conf.ConfigIndex = cor_value;

	/* IRQ and I/O settings */
	tuple.DesiredTuple = CISTPL_CONFIG;

	ret = pcmcia_get_first_tuple(link, &tuple);

	if (ret != 0) {
		cs_error(link, GetFirstTuple, ret);
		goto exit0;
	}

	ret = pcmcia_get_tuple_data(link, &tuple);

	if (ret != 0) {
		cs_error(link, GetTupleData, ret);
		goto exit0;
	}

	ret = pcmcia_parse_tuple(&tuple, &parse);

	if (ret != 0) {
		cs_error(link, GetTupleData, ret);
		goto exit0;
	}
	link->conf.Attributes = CONF_ENABLE_IRQ;
	link->conf.ConfigBase = parse.config.base;
	link->conf.Present = parse.config.rmask[0];
	link->conf.IntType = INT_MEMORY_AND_IO;

	link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING | IRQ_HANDLE_PRESENT;
	link->irq.Handler = ipwireless_interrupt;
	link->irq.Instance = ipw->hardware;

	ret = pcmcia_request_io(link, &link->io);

	if (ret != 0) {
		cs_error(link, RequestIO, ret);
		goto exit0;
	}

	request_region(link->io.BasePort1, link->io.NumPorts1,
			IPWIRELESS_PCCARD_NAME);

	/* memory settings */

	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;

	ret = pcmcia_get_first_tuple(link, &tuple);

	if (ret != 0) {
		cs_error(link, GetFirstTuple, ret);
		goto exit1;
	}

	ret = pcmcia_get_tuple_data(link, &tuple);

	if (ret != 0) {
		cs_error(link, GetTupleData, ret);
		goto exit1;
	}

	ret = pcmcia_parse_tuple(&tuple, &parse);

	if (ret != 0) {
		cs_error(link, ParseTuple, ret);
		goto exit1;
	}

	if (parse.cftable_entry.mem.nwin > 0) {
		ipw->request_common_memory.Attributes =
			WIN_DATA_WIDTH_16 | WIN_MEMORY_TYPE_CM | WIN_ENABLE;
		ipw->request_common_memory.Base =
			parse.cftable_entry.mem.win[0].host_addr;
		ipw->request_common_memory.Size = parse.cftable_entry.mem.win[0].len;
		if (ipw->request_common_memory.Size < 0x1000)
			ipw->request_common_memory.Size = 0x1000;
		ipw->request_common_memory.AccessSpeed = 0;

		ret = pcmcia_request_window(&link, &ipw->request_common_memory,
				&ipw->handle_common_memory);

		if (ret != 0) {
			cs_error(link, RequestWindow, ret);
			goto exit1;
		}

		memreq_common_memory.CardOffset =
			parse.cftable_entry.mem.win[0].card_addr;
		memreq_common_memory.Page = 0;

		ret = pcmcia_map_mem_page(ipw->handle_common_memory,
				&memreq_common_memory);

		if (ret != 0) {
			cs_error(link, MapMemPage, ret);
			goto exit1;
		}

		ipw->is_v2_card =
			parse.cftable_entry.mem.win[0].len == 0x100;

		ipw->common_memory = ioremap(ipw->request_common_memory.Base,
				ipw->request_common_memory.Size);
		request_mem_region(ipw->request_common_memory.Base,
				ipw->request_common_memory.Size, IPWIRELESS_PCCARD_NAME);

		ipw->request_attr_memory.Attributes =
			WIN_DATA_WIDTH_16 | WIN_MEMORY_TYPE_AM | WIN_ENABLE;
		ipw->request_attr_memory.Base = 0;
		ipw->request_attr_memory.Size = 0;	/* this used to be 0x1000 */
		ipw->request_attr_memory.AccessSpeed = 0;

		ret = pcmcia_request_window(&link, &ipw->request_attr_memory,
				&ipw->handle_attr_memory);

		if (ret != 0) {
			cs_error(link, RequestWindow, ret);
			goto exit2;
		}

		memreq_attr_memory.CardOffset = 0;
		memreq_attr_memory.Page = 0;

		ret = pcmcia_map_mem_page(ipw->handle_attr_memory,
				&memreq_attr_memory);

		if (ret != 0) {
			cs_error(link, MapMemPage, ret);
			goto exit2;
		}

		ipw->attr_memory = ioremap(ipw->request_attr_memory.Base,
				ipw->request_attr_memory.Size);
		request_mem_region(ipw->request_attr_memory.Base, ipw->request_attr_memory.Size,
				IPWIRELESS_PCCARD_NAME);
	}

	INIT_WORK(&ipw->work_reboot, signalled_reboot_work);

	ipwireless_init_hardware_v1(ipw->hardware, link->io.BasePort1,
				    ipw->attr_memory, ipw->common_memory,
				    ipw->is_v2_card, signalled_reboot_callback,
				    ipw);

	ret = pcmcia_request_irq(link, &link->irq);

	if (ret != 0) {
		cs_error(link, RequestIRQ, ret);
		goto exit3;
	}

	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 0x%04x-0x%04x, irq %d\n",
			(unsigned int) link->io.BasePort1,
			(unsigned int) (link->io.BasePort1 +
				link->io.NumPorts1 - 1),
			(unsigned int) link->irq.AssignedIRQ);
	if (ipw->attr_memory && ipw->common_memory)
		printk(KERN_INFO IPWIRELESS_PCCARD_NAME
			": attr memory 0x%08lx-0x%08lx, common memory 0x%08lx-0x%08lx\n",
			ipw->request_attr_memory.Base,
			ipw->request_attr_memory.Base
			+ ipw->request_attr_memory.Size - 1,
			ipw->request_common_memory.Base,
			ipw->request_common_memory.Base
			+ ipw->request_common_memory.Size - 1);

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

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

	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_request_configuration(link, &link->conf);

	if (ret != 0) {
		cs_error(link, RequestConfiguration, ret);
		goto exit4;
	}

	link->dev_node = &ipw->nodes[0];

	return 0;

exit4:
	pcmcia_disable_device(link);
exit3:
	if (ipw->attr_memory) {
		release_mem_region(ipw->request_attr_memory.Base,
				ipw->request_attr_memory.Size);
		iounmap(ipw->attr_memory);
		pcmcia_release_window(ipw->handle_attr_memory);
		pcmcia_disable_device(link);
	}
exit2:
	if (ipw->common_memory) {
		release_mem_region(ipw->request_common_memory.Base,
				ipw->request_common_memory.Size);
		iounmap(ipw->common_memory);
		pcmcia_release_window(ipw->handle_common_memory);
	}
exit1:
	pcmcia_disable_device(link);
exit0:
	return -1;
}

static void release_ipwireless(struct ipw_dev *ipw)
{
	pcmcia_disable_device(ipw->link);

	if (ipw->common_memory) {
		release_mem_region(ipw->request_common_memory.Base,
				ipw->request_common_memory.Size);
		iounmap(ipw->common_memory);
	}
	if (ipw->attr_memory) {
		release_mem_region(ipw->request_attr_memory.Base,
				ipw->request_attr_memory.Size);
		iounmap(ipw->attr_memory);
	}
	if (ipw->common_memory)
		pcmcia_release_window(ipw->handle_common_memory);
	if (ipw->attr_memory)
		pcmcia_release_window(ipw->handle_attr_memory);

	/* Break the link with Card Services */
	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;
	link->irq.Instance = ipw;

	/* Link this device into our device list. */
	link->dev_node = &ipw->nodes[0];

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

	ret = config_ipwireless(ipw);

	if (ret != 0) {
		cs_error(link, RegisterClient, ret);
		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>
	35	#include <pcmcia/cs.h>
	36
	37	static struct pcmcia_device_id ipw_ids[] = {
	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;
994917f8	68	int ret = pcmcia_reset_card(link->socket);
099dc4fb	69
4c89e88b	70	if (ret != 0)
099dc4fb DS	71	cs_error(link, ResetCard, ret);
	72	}
	73
	74	static void signalled_reboot_callback(void *callback_data)
	75	{
	76	struct ipw_dev ipw = (struct ipw_dev ) callback_data;
	77
	78	/* Delegate to process context. */
	79	schedule_work(&ipw->work_reboot);
	80	}
	81
	82	static int config_ipwireless(struct ipw_dev *ipw)
	83	{
	84	struct pcmcia_device *link = ipw->link;
	85	int ret;
099dc4fb DS	86	tuple_t tuple;
	87	unsigned short buf[64];
	88	cisparse_t parse;
	89	unsigned short cor_value;
099dc4fb DS	90	memreq_t memreq_attr_memory;
	91	memreq_t memreq_common_memory;
	92
	93	ipw->is_v2_card = 0;
	94
	95	tuple.Attributes = 0;
	96	tuple.TupleData = (cisdata_t *) buf;
	97	tuple.TupleDataMax = sizeof(buf);
	98	tuple.TupleOffset = 0;
	99
	100	tuple.DesiredTuple = RETURN_FIRST_TUPLE;
	101
	102	ret = pcmcia_get_first_tuple(link, &tuple);
	103
	104	while (ret == 0) {
	105	ret = pcmcia_get_tuple_data(link, &tuple);
	106
4c89e88b	107	if (ret != 0) {
099dc4fb DS	108	cs_error(link, GetTupleData, ret);
	109	goto exit0;
	110	}
	111	ret = pcmcia_get_next_tuple(link, &tuple);
	112	}
	113
	114	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
	115
	116	ret = pcmcia_get_first_tuple(link, &tuple);
	117
4c89e88b	118	if (ret != 0) {
099dc4fb DS	119	cs_error(link, GetFirstTuple, ret);
	120	goto exit0;
	121	}
	122
	123	ret = pcmcia_get_tuple_data(link, &tuple);
	124
4c89e88b	125	if (ret != 0) {
099dc4fb DS	126	cs_error(link, GetTupleData, ret);
	127	goto exit0;
	128	}
	129
2f3061eb	130	ret = pcmcia_parse_tuple(&tuple, &parse);
099dc4fb	131
4c89e88b	132	if (ret != 0) {
099dc4fb DS	133	cs_error(link, ParseTuple, ret);
	134	goto exit0;
	135	}
	136
	137	link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
	138	link->io.BasePort1 = parse.cftable_entry.io.win[0].base;
	139	link->io.NumPorts1 = parse.cftable_entry.io.win[0].len;
	140	link->io.IOAddrLines = 16;
	141
	142	link->irq.IRQInfo1 = parse.cftable_entry.irq.IRQInfo1;
	143
	144	/* 0x40 causes it to generate level mode interrupts. */
	145	/* 0x04 enables IREQ pin. */
	146	cor_value = parse.cftable_entry.index \| 0x44;
	147	link->conf.ConfigIndex = cor_value;
	148
	149	/* IRQ and I/O settings */
	150	tuple.DesiredTuple = CISTPL_CONFIG;
	151
	152	ret = pcmcia_get_first_tuple(link, &tuple);
	153
4c89e88b	154	if (ret != 0) {
099dc4fb DS	155	cs_error(link, GetFirstTuple, ret);
	156	goto exit0;
	157	}
	158
	159	ret = pcmcia_get_tuple_data(link, &tuple);
	160
4c89e88b	161	if (ret != 0) {
099dc4fb DS	162	cs_error(link, GetTupleData, ret);
	163	goto exit0;
	164	}
	165
2f3061eb	166	ret = pcmcia_parse_tuple(&tuple, &parse);
099dc4fb	167
4c89e88b	168	if (ret != 0) {
099dc4fb DS	169	cs_error(link, GetTupleData, ret);
	170	goto exit0;
	171	}
	172	link->conf.Attributes = CONF_ENABLE_IRQ;
	173	link->conf.ConfigBase = parse.config.base;
	174	link->conf.Present = parse.config.rmask[0];
	175	link->conf.IntType = INT_MEMORY_AND_IO;
	176
	177	link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING \| IRQ_HANDLE_PRESENT;
	178	link->irq.Handler = ipwireless_interrupt;
	179	link->irq.Instance = ipw->hardware;
	180
	181	ret = pcmcia_request_io(link, &link->io);
	182
4c89e88b	183	if (ret != 0) {
099dc4fb DS	184	cs_error(link, RequestIO, ret);
	185	goto exit0;
	186	}
	187
09e491e9 DS	188	request_region(link->io.BasePort1, link->io.NumPorts1,
	189	IPWIRELESS_PCCARD_NAME);
	190
099dc4fb DS	191	/* memory settings */
	192
	193	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
	194
	195	ret = pcmcia_get_first_tuple(link, &tuple);
	196
4c89e88b	197	if (ret != 0) {
099dc4fb DS	198	cs_error(link, GetFirstTuple, ret);
	199	goto exit1;
	200	}
	201
	202	ret = pcmcia_get_tuple_data(link, &tuple);
	203
4c89e88b	204	if (ret != 0) {
099dc4fb DS	205	cs_error(link, GetTupleData, ret);
	206	goto exit1;
	207	}
	208
2f3061eb	209	ret = pcmcia_parse_tuple(&tuple, &parse);
099dc4fb	210
4c89e88b	211	if (ret != 0) {
099dc4fb DS	212	cs_error(link, ParseTuple, ret);
	213	goto exit1;
	214	}
	215
	216	if (parse.cftable_entry.mem.nwin > 0) {
09e491e9	217	ipw->request_common_memory.Attributes =
099dc4fb	218	WIN_DATA_WIDTH_16 \| WIN_MEMORY_TYPE_CM \| WIN_ENABLE;
09e491e9	219	ipw->request_common_memory.Base =
099dc4fb	220	parse.cftable_entry.mem.win[0].host_addr;
09e491e9 DS	221	ipw->request_common_memory.Size = parse.cftable_entry.mem.win[0].len;
	222	if (ipw->request_common_memory.Size < 0x1000)
	223	ipw->request_common_memory.Size = 0x1000;
	224	ipw->request_common_memory.AccessSpeed = 0;
099dc4fb	225
09e491e9	226	ret = pcmcia_request_window(&link, &ipw->request_common_memory,
099dc4fb DS	227	&ipw->handle_common_memory);
099dc4fb DS	228
4c89e88b	229	if (ret != 0) {
099dc4fb DS	230	cs_error(link, RequestWindow, ret);
	231	goto exit1;
	232	}
	233
	234	memreq_common_memory.CardOffset =
	235	parse.cftable_entry.mem.win[0].card_addr;
	236	memreq_common_memory.Page = 0;
	237
	238	ret = pcmcia_map_mem_page(ipw->handle_common_memory,
	239	&memreq_common_memory);
	240
4c89e88b	241	if (ret != 0) {
099dc4fb DS	242	cs_error(link, MapMemPage, ret);
	243	goto exit1;
	244	}
	245
	246	ipw->is_v2_card =
	247	parse.cftable_entry.mem.win[0].len == 0x100;
	248
09e491e9 DS	249	ipw->common_memory = ioremap(ipw->request_common_memory.Base,
	250	ipw->request_common_memory.Size);
	251	request_mem_region(ipw->request_common_memory.Base,
	252	ipw->request_common_memory.Size, IPWIRELESS_PCCARD_NAME);
099dc4fb	253
09e491e9	254	ipw->request_attr_memory.Attributes =
099dc4fb	255	WIN_DATA_WIDTH_16 \| WIN_MEMORY_TYPE_AM \| WIN_ENABLE;
09e491e9 DS	256	ipw->request_attr_memory.Base = 0;
	257	ipw->request_attr_memory.Size = 0; /* this used to be 0x1000 */
	258	ipw->request_attr_memory.AccessSpeed = 0;
099dc4fb	259
09e491e9	260	ret = pcmcia_request_window(&link, &ipw->request_attr_memory,
099dc4fb DS	261	&ipw->handle_attr_memory);
099dc4fb DS	262
4c89e88b	263	if (ret != 0) {
099dc4fb DS	264	cs_error(link, RequestWindow, ret);
	265	goto exit2;
	266	}
	267
	268	memreq_attr_memory.CardOffset = 0;
	269	memreq_attr_memory.Page = 0;
	270
	271	ret = pcmcia_map_mem_page(ipw->handle_attr_memory,
	272	&memreq_attr_memory);
	273
4c89e88b	274	if (ret != 0) {
099dc4fb DS	275	cs_error(link, MapMemPage, ret);
	276	goto exit2;
	277	}
	278
09e491e9 DS	279	ipw->attr_memory = ioremap(ipw->request_attr_memory.Base,
	280	ipw->request_attr_memory.Size);
	281	request_mem_region(ipw->request_attr_memory.Base, ipw->request_attr_memory.Size,
	282	IPWIRELESS_PCCARD_NAME);
099dc4fb DS	283	}
	284
	285	INIT_WORK(&ipw->work_reboot, signalled_reboot_work);
	286
	287	ipwireless_init_hardware_v1(ipw->hardware, link->io.BasePort1,
	288	ipw->attr_memory, ipw->common_memory,
	289	ipw->is_v2_card, signalled_reboot_callback,
	290	ipw);
	291
	292	ret = pcmcia_request_irq(link, &link->irq);
	293
4c89e88b	294	if (ret != 0) {
099dc4fb DS	295	cs_error(link, RequestIRQ, ret);
	296	goto exit3;
	297	}
	298
099dc4fb DS	299	printk(KERN_INFO IPWIRELESS_PCCARD_NAME ": Card type %s\n",
	300	ipw->is_v2_card ? "V2/V3" : "V1");
	301	printk(KERN_INFO IPWIRELESS_PCCARD_NAME
	302	": I/O ports 0x%04x-0x%04x, irq %d\n",
	303	(unsigned int) link->io.BasePort1,
	304	(unsigned int) (link->io.BasePort1 +
	305	link->io.NumPorts1 - 1),
	306	(unsigned int) link->irq.AssignedIRQ);
	307	if (ipw->attr_memory && ipw->common_memory)
	308	printk(KERN_INFO IPWIRELESS_PCCARD_NAME
622e713e	309	": attr memory 0x%08lx-0x%08lx, common memory 0x%08lx-0x%08lx\n",
09e491e9 DS	310	ipw->request_attr_memory.Base,
	311	ipw->request_attr_memory.Base
	312	+ ipw->request_attr_memory.Size - 1,
	313	ipw->request_common_memory.Base,
	314	ipw->request_common_memory.Base
	315	+ ipw->request_common_memory.Size - 1);
099dc4fb DS	316
	317	ipw->network = ipwireless_network_create(ipw->hardware);
	318	if (!ipw->network)
	319	goto exit3;
	320
	321	ipw->tty = ipwireless_tty_create(ipw->hardware, ipw->network,
	322	ipw->nodes);
	323	if (!ipw->tty)
	324	goto exit3;
	325
	326	ipwireless_init_hardware_v2_v3(ipw->hardware);
	327
	328	/*
	329	* Do the RequestConfiguration last, because it enables interrupts.
	330	* Then we don't get any interrupts before we're ready for them.
	331	*/
	332	ret = pcmcia_request_configuration(link, &link->conf);
	333
4c89e88b	334	if (ret != 0) {
099dc4fb DS	335	cs_error(link, RequestConfiguration, ret);
	336	goto exit4;
	337	}
	338
	339	link->dev_node = &ipw->nodes[0];
	340
	341	return 0;
	342
	343	exit4:
	344	pcmcia_disable_device(link);
	345	exit3:
	346	if (ipw->attr_memory) {
09e491e9 DS	347	release_mem_region(ipw->request_attr_memory.Base,
09e491e9 DS	348	ipw->request_attr_memory.Size);
099dc4fb DS	349	iounmap(ipw->attr_memory);
	350	pcmcia_release_window(ipw->handle_attr_memory);
	351	pcmcia_disable_device(link);
	352	}
	353	exit2:
	354	if (ipw->common_memory) {
09e491e9 DS	355	release_mem_region(ipw->request_common_memory.Base,
09e491e9 DS	356	ipw->request_common_memory.Size);
099dc4fb DS	357	iounmap(ipw->common_memory);
	358	pcmcia_release_window(ipw->handle_common_memory);
	359	}
	360	exit1:
	361	pcmcia_disable_device(link);
	362	exit0:
	363	return -1;
	364	}
	365
	366	static void release_ipwireless(struct ipw_dev *ipw)
	367	{
09e491e9	368	pcmcia_disable_device(ipw->link);
099dc4fb	369
09e491e9 DS	370	if (ipw->common_memory) {
	371	release_mem_region(ipw->request_common_memory.Base,
	372	ipw->request_common_memory.Size);
099dc4fb	373	iounmap(ipw->common_memory);
09e491e9 DS	374	}
	375	if (ipw->attr_memory) {
	376	release_mem_region(ipw->request_attr_memory.Base,
	377	ipw->request_attr_memory.Size);
099dc4fb	378	iounmap(ipw->attr_memory);
09e491e9	379	}
099dc4fb DS	380	if (ipw->common_memory)
	381	pcmcia_release_window(ipw->handle_common_memory);
	382	if (ipw->attr_memory)
	383	pcmcia_release_window(ipw->handle_attr_memory);
09e491e9 DS	384
	385	/* Break the link with Card Services */
	386	pcmcia_disable_device(ipw->link);
099dc4fb DS	387	}
	388
	389	/*
	390	* ipwireless_attach() creates an "instance" of the driver, allocating
	391	* local data structures for one device (one interface). The device
	392	* is registered with Card Services.
	393	*
	394	* The pcmcia_device structure is initialized, but we don't actually
	395	* configure the card at this point -- we wait until we receive a
	396	* card insertion event.
	397	*/
	398	static int ipwireless_attach(struct pcmcia_device *link)
	399	{
	400	struct ipw_dev *ipw;
	401	int ret;
	402
	403	ipw = kzalloc(sizeof(struct ipw_dev), GFP_KERNEL);
	404	if (!ipw)
	405	return -ENOMEM;
	406
	407	ipw->link = link;
	408	link->priv = ipw;
	409	link->irq.Instance = ipw;
	410
	411	/* Link this device into our device list. */
	412	link->dev_node = &ipw->nodes[0];
	413
	414	ipw->hardware = ipwireless_hardware_create();
	415	if (!ipw->hardware) {
	416	kfree(ipw);
	417	return -ENOMEM;
	418	}
	419	/* RegisterClient will call config_ipwireless */
	420
	421	ret = config_ipwireless(ipw);
	422
	423	if (ret != 0) {
	424	cs_error(link, RegisterClient, ret);
	425	ipwireless_detach(link);
	426	return ret;
	427	}
	428
	429	return 0;
	430	}
	431
	432	/*
	433	* This deletes a driver "instance". The device is de-registered with
	434	* Card Services. If it has been released, all local data structures
	435	* are freed. Otherwise, the structures will be freed when the device
	436	* is released.
	437	*/
	438	static void ipwireless_detach(struct pcmcia_device *link)
	439	{
	440	struct ipw_dev *ipw = link->priv;
	441
	442	release_ipwireless(ipw);
	443
099dc4fb DS	444	if (ipw->tty != NULL)
	445	ipwireless_tty_free(ipw->tty);
	446	if (ipw->network != NULL)
	447	ipwireless_network_free(ipw->network);
	448	if (ipw->hardware != NULL)
	449	ipwireless_hardware_free(ipw->hardware);
	450	kfree(ipw);
	451	}
	452
	453	static struct pcmcia_driver me = {
	454	.owner = THIS_MODULE,
	455	.probe = ipwireless_attach,
	456	.remove = ipwireless_detach,
	457	.drv = { .name = IPWIRELESS_PCCARD_NAME },
	458	.id_table = ipw_ids
	459	};
	460
	461	/*
	462	* Module insertion : initialisation of the module.
	463	* Register the card with cardmgr...
	464	*/
	465	static int __init init_ipwireless(void)
	466	{
	467	int ret;
	468
	469	printk(KERN_INFO IPWIRELESS_PCCARD_NAME " "
	470	IPWIRELESS_PCMCIA_VERSION " by " IPWIRELESS_PCMCIA_AUTHOR "\n");
	471
	472	ret = ipwireless_tty_init();
	473	if (ret != 0)
	474	return ret;
	475
	476	ret = pcmcia_register_driver(&me);
	477	if (ret != 0)
	478	ipwireless_tty_release();
	479
	480	return ret;
	481	}
	482
	483	/*
	484	* Module removal
	485	*/
	486	static void __exit exit_ipwireless(void)
	487	{
	488	printk(KERN_INFO IPWIRELESS_PCCARD_NAME " "
	489	IPWIRELESS_PCMCIA_VERSION " removed\n");
	490
	491	pcmcia_unregister_driver(&me);
	492	ipwireless_tty_release();
	493	}
	494
	495	module_init(init_ipwireless);
	496	module_exit(exit_ipwireless);
	497
	498	MODULE_AUTHOR(IPWIRELESS_PCMCIA_AUTHOR);
	499	MODULE_DESCRIPTION(IPWIRELESS_PCCARD_NAME " " IPWIRELESS_PCMCIA_VERSION);
	500	MODULE_LICENSE("GPL");