[mirror_ubuntu-artful-kernel.git] / drivers / net / wireless / airo_cs.c

/*======================================================================

    Aironet driver for 4500 and 4800 series cards

    This code is released under both the GPL version 2 and BSD licenses.
    Either license may be used.  The respective licenses are found at
    the end of this file.

    This code was developed by Benjamin Reed <breed@users.sourceforge.net>
    including portions of which come from the Aironet PC4500
    Developer's Reference Manual and used with permission.  Copyright
    (C) 1999 Benjamin Reed.  All Rights Reserved.  Permission to use
    code in the Developer's manual was granted for this driver by
    Aironet.

    In addition this module was derived from dummy_cs.
    The initial developer of dummy_cs is David A. Hinds
    <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
    are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.

======================================================================*/

#ifdef __IN_PCMCIA_PACKAGE__
#include <pcmcia/k_compat.h>
#endif
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/ptrace.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/netdevice.h>

#include <pcmcia/cistpl.h>
#include <pcmcia/cisreg.h>
#include <pcmcia/ds.h>

#include <linux/io.h>
#include <asm/system.h>

#include "airo.h"


/*====================================================================*/

MODULE_AUTHOR("Benjamin Reed");
MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet "
		   "cards.  This is the module that links the PCMCIA card "
		   "with the airo module.");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340 PCMCIA cards");

/*====================================================================*/

/*
   The event() function is this driver's Card Services event handler.
   It will be called by Card Services when an appropriate card status
   event is received.  The config() and release() entry points are
   used to configure or release a socket, in response to card
   insertion and ejection events.  They are invoked from the airo_cs
   event handler.
*/

static int airo_config(struct pcmcia_device *link);
static void airo_release(struct pcmcia_device *link);

/*
   The attach() and detach() entry points are used to create and destroy
   "instances" of the driver, where each instance represents everything
   needed to manage one actual PCMCIA card.
*/

static void airo_detach(struct pcmcia_device *p_dev);

typedef struct local_info_t {
	struct net_device *eth_dev;
} local_info_t;

/*======================================================================

  airo_attach() creates an "instance" of the driver, allocating
  local data structures for one device.  The device is registered
  with Card Services.

  The dev_link 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 airo_probe(struct pcmcia_device *p_dev)
{
	local_info_t *local;

	dev_dbg(&p_dev->dev, "airo_attach()\n");

	/* Allocate space for private device-specific data */
	local = kzalloc(sizeof(local_info_t), GFP_KERNEL);
	if (!local) {
		printk(KERN_ERR "airo_cs: no memory for new device\n");
		return -ENOMEM;
	}
	p_dev->priv = local;

	return airo_config(p_dev);
} /* airo_attach */

/*======================================================================

  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 airo_detach(struct pcmcia_device *link)
{
	dev_dbg(&link->dev, "airo_detach\n");

	airo_release(link);

	if (((local_info_t *)link->priv)->eth_dev) {
		stop_airo_card(((local_info_t *)link->priv)->eth_dev, 0);
	}
	((local_info_t *)link->priv)->eth_dev = NULL;

	kfree(link->priv);
} /* airo_detach */

/*======================================================================

  airo_config() is scheduled to run after a CARD_INSERTION event
  is received, to configure the PCMCIA socket, and to make the
  device available to the system.

  ======================================================================*/

static int airo_cs_config_check(struct pcmcia_device *p_dev, void *priv_data)
{
	if (p_dev->config_index == 0)
		return -EINVAL;

	return pcmcia_request_io(p_dev);
}


static int airo_config(struct pcmcia_device *link)
{
	local_info_t *dev;
	int ret;

	dev = link->priv;

	dev_dbg(&link->dev, "airo_config\n");

	link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
		CONF_AUTO_AUDIO | CONF_AUTO_SET_IO;

	/*
	 * In this loop, we scan the CIS for configuration table
	 * entries, each of which describes a valid card
	 * configuration, including voltage, IO window, memory window,
	 * and interrupt settings.
	 *
	 * We make no assumptions about the card to be configured: we
	 * use just the information available in the CIS.  In an ideal
	 * world, this would work for any PCMCIA card, but it requires
	 * a complete and accurate CIS.  In practice, a driver usually
	 * "knows" most of these things without consulting the CIS,
	 * and most client drivers will only use the CIS to fill in
	 * implementation-defined details.
	 */
	ret = pcmcia_loop_config(link, airo_cs_config_check, NULL);
	if (ret)
		goto failed;

	if (!link->irq)
		goto failed;

	/*
	  This actually configures the PCMCIA socket -- setting up
	  the I/O windows and the interrupt mapping, and putting the
	  card and host interface into "Memory and IO" mode.
	*/
	ret = pcmcia_enable_device(link);
	if (ret)
		goto failed;
	((local_info_t *)link->priv)->eth_dev =
		init_airo_card(link->irq,
			       link->resource[0]->start, 1, &link->dev);
	if (!((local_info_t *)link->priv)->eth_dev)
		goto failed;

	/* Finally, report what we've done */
	dev_info(&link->dev, "index 0x%02x: ",
	       link->config_index);
	if (link->vpp)
		printk(", Vpp %d.%d", link->vpp/10, link->vpp%10);
	printk(", irq %d", link->irq);
	if (link->resource[0])
		printk(" & %pR", link->resource[0]);
	if (link->resource[1])
		printk(" & %pR", link->resource[1]);
	printk("\n");
	return 0;

 failed:
	airo_release(link);
	return -ENODEV;
} /* airo_config */

/*======================================================================

  After a card is removed, airo_release() will unregister the
  device, and release the PCMCIA configuration.  If the device is
  still open, this will be postponed until it is closed.

  ======================================================================*/

static void airo_release(struct pcmcia_device *link)
{
	dev_dbg(&link->dev, "airo_release\n");
	pcmcia_disable_device(link);
}

static int airo_suspend(struct pcmcia_device *link)
{
	local_info_t *local = link->priv;

	netif_device_detach(local->eth_dev);

	return 0;
}

static int airo_resume(struct pcmcia_device *link)
{
	local_info_t *local = link->priv;

	if (link->open) {
		reset_airo_card(local->eth_dev);
		netif_device_attach(local->eth_dev);
	}

	return 0;
}

static struct pcmcia_device_id airo_ids[] = {
	PCMCIA_DEVICE_MANF_CARD(0x015f, 0x000a),
	PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0005),
	PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0007),
	PCMCIA_DEVICE_MANF_CARD(0x0105, 0x0007),
	PCMCIA_DEVICE_NULL,
};
MODULE_DEVICE_TABLE(pcmcia, airo_ids);

static struct pcmcia_driver airo_driver = {
	.owner		= THIS_MODULE,
	.drv		= {
		.name	= "airo_cs",
	},
	.probe		= airo_probe,
	.remove		= airo_detach,
	.id_table       = airo_ids,
	.suspend	= airo_suspend,
	.resume		= airo_resume,
};

static int airo_cs_init(void)
{
	return pcmcia_register_driver(&airo_driver);
}

static void airo_cs_cleanup(void)
{
	pcmcia_unregister_driver(&airo_driver);
}

/*
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation; either version 2
    of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    In addition:

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

    1. Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.
    2. Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.
    3. The name of the author may not be used to endorse or promote
       products derived from this software without specific prior written
       permission.

    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
    IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE.
*/

module_init(airo_cs_init);
module_exit(airo_cs_cleanup);
Commit	Line	Data
1da177e4 LT	1	/*======================================================================
	2
	3	Aironet driver for 4500 and 4800 series cards
	4
	5	This code is released under both the GPL version 2 and BSD licenses.
	6	Either license may be used. The respective licenses are found at
	7	the end of this file.
	8
	9	This code was developed by Benjamin Reed <breed@users.sourceforge.net>
	10	including portions of which come from the Aironet PC4500
	11	Developer's Reference Manual and used with permission. Copyright
	12	(C) 1999 Benjamin Reed. All Rights Reserved. Permission to use
	13	code in the Developer's manual was granted for this driver by
	14	Aironet.
	15
	16	In addition this module was derived from dummy_cs.
	17	The initial developer of dummy_cs is David A. Hinds
	18	<dahinds@users.sourceforge.net>. Portions created by David A. Hinds
05c9a4cf JD	19	are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
05c9a4cf JD	20
1da177e4 LT	21	======================================================================*/
1da177e4 LT	22
1da177e4 LT	23	#ifdef __IN_PCMCIA_PACKAGE__
	24	#include <pcmcia/k_compat.h>
	25	#endif
	26	#include <linux/init.h>
	27	#include <linux/kernel.h>
	28	#include <linux/module.h>
	29	#include <linux/ptrace.h>
	30	#include <linux/slab.h>
	31	#include <linux/string.h>
	32	#include <linux/timer.h>
	33	#include <linux/netdevice.h>
	34
1da177e4 LT	35	#include <pcmcia/cistpl.h>
	36	#include <pcmcia/cisreg.h>
	37	#include <pcmcia/ds.h>
	38
05c9a4cf	39	#include <linux/io.h>
1da177e4 LT	40	#include <asm/system.h>
1da177e4 LT	41
d3808760 AB	42	#include "airo.h"
d3808760 AB	43
1da177e4 LT	44
	45	/====================================================================/
	46
	47	MODULE_AUTHOR("Benjamin Reed");
05c9a4cf JD	48	MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet "
	49	"cards. This is the module that links the PCMCIA card "
	50	"with the airo module.");
1da177e4 LT	51	MODULE_LICENSE("Dual BSD/GPL");
	52	MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340 PCMCIA cards");
	53
	54	/====================================================================/
	55
	56	/*
	57	The event() function is this driver's Card Services event handler.
	58	It will be called by Card Services when an appropriate card status
	59	event is received. The config() and release() entry points are
	60	used to configure or release a socket, in response to card
	61	insertion and ejection events. They are invoked from the airo_cs
05c9a4cf	62	event handler.
1da177e4 LT	63	*/
1da177e4 LT	64
15b99ac1	65	static int airo_config(struct pcmcia_device *link);
fba395ee	66	static void airo_release(struct pcmcia_device *link);
1da177e4 LT	67
	68	/*
	69	The attach() and detach() entry points are used to create and destroy
	70	"instances" of the driver, where each instance represents everything
	71	needed to manage one actual PCMCIA card.
	72	*/
	73
cc3b4866	74	static void airo_detach(struct pcmcia_device *p_dev);
1da177e4	75
1da177e4	76	typedef struct local_info_t {
1da177e4 LT	77	struct net_device *eth_dev;
	78	} local_info_t;
	79
	80	/*======================================================================
05c9a4cf	81
1da177e4 LT	82	airo_attach() creates an "instance" of the driver, allocating
	83	local data structures for one device. The device is registered
	84	with Card Services.
05c9a4cf	85
1da177e4 LT	86	The dev_link structure is initialized, but we don't actually
	87	configure the card at this point -- we wait until we receive a
	88	card insertion event.
05c9a4cf	89
1da177e4 LT	90	======================================================================*/
1da177e4 LT	91
15b99ac1	92	static int airo_probe(struct pcmcia_device *p_dev)
1da177e4	93	{
1da177e4	94	local_info_t *local;
f8cfa618	95
2caff147	96	dev_dbg(&p_dev->dev, "airo_attach()\n");
1da177e4	97
1da177e4	98	/* Allocate space for private device-specific data */
b69a3aa8	99	local = kzalloc(sizeof(local_info_t), GFP_KERNEL);
1da177e4 LT	100	if (!local) {
1da177e4 LT	101	printk(KERN_ERR "airo_cs: no memory for new device\n");
f8cfa618	102	return -ENOMEM;
1da177e4	103	}
fd238232	104	p_dev->priv = local;
f8cfa618	105
15b99ac1	106	return airo_config(p_dev);
1da177e4 LT	107	} /* airo_attach */
	108
	109	/*======================================================================
05c9a4cf	110
1da177e4 LT	111	This deletes a driver "instance". The device is de-registered
	112	with Card Services. If it has been released, all local data
	113	structures are freed. Otherwise, the structures will be freed
	114	when the device is released.
05c9a4cf	115
1da177e4 LT	116	======================================================================*/
1da177e4 LT	117
fba395ee	118	static void airo_detach(struct pcmcia_device *link)
1da177e4	119	{
2caff147	120	dev_dbg(&link->dev, "airo_detach\n");
b4635811	121
e2d40963	122	airo_release(link);
b4635811	123
05c9a4cf JD	124	if (((local_info_t *)link->priv)->eth_dev) {
05c9a4cf JD	125	stop_airo_card(((local_info_t *)link->priv)->eth_dev, 0);
1da177e4	126	}
05c9a4cf	127	((local_info_t *)link->priv)->eth_dev = NULL;
cc3b4866	128
b4558ea9	129	kfree(link->priv);
1da177e4 LT	130	} /* airo_detach */
	131
	132	/*======================================================================
05c9a4cf	133
1da177e4 LT	134	airo_config() is scheduled to run after a CARD_INSERTION event
	135	is received, to configure the PCMCIA socket, and to make the
	136	device available to the system.
05c9a4cf	137
1da177e4 LT	138	======================================================================*/
1da177e4 LT	139
00990e7c	140	static int airo_cs_config_check(struct pcmcia_device p_dev, void priv_data)
b54bf94b	141	{
00990e7c DB	142	if (p_dev->config_index == 0)
00990e7c DB	143	return -EINVAL;
b54bf94b	144
00990e7c	145	return pcmcia_request_io(p_dev);
b54bf94b DB	146	}
	147
	148
15b99ac1	149	static int airo_config(struct pcmcia_device *link)
1da177e4	150	{
1da177e4	151	local_info_t *dev;
2caff147	152	int ret;
fba395ee	153
1da177e4 LT	154	dev = link->priv;
1da177e4 LT	155
2caff147	156	dev_dbg(&link->dev, "airo_config\n");
e2d40963	157
440eed43	158	link->config_flags \|= CONF_ENABLE_IRQ \| CONF_AUTO_SET_VPP \|
00990e7c	159	CONF_AUTO_AUDIO \| CONF_AUTO_SET_IO;
440eed43	160
1da177e4	161	/*
b54bf94b DB	162	* In this loop, we scan the CIS for configuration table
	163	* entries, each of which describes a valid card
	164	* configuration, including voltage, IO window, memory window,
	165	* and interrupt settings.
	166	*
	167	* We make no assumptions about the card to be configured: we
	168	* use just the information available in the CIS. In an ideal
	169	* world, this would work for any PCMCIA card, but it requires
	170	* a complete and accurate CIS. In practice, a driver usually
	171	* "knows" most of these things without consulting the CIS,
	172	* and most client drivers will only use the CIS to fill in
	173	* implementation-defined details.
	174	*/
0f52e86d	175	ret = pcmcia_loop_config(link, airo_cs_config_check, NULL);
2caff147	176	if (ret)
b54bf94b DB	177	goto failed;
b54bf94b DB	178
eb14120f DB	179	if (!link->irq)
eb14120f DB	180	goto failed;
05c9a4cf	181
1da177e4 LT	182	/*
	183	This actually configures the PCMCIA socket -- setting up
	184	the I/O windows and the interrupt mapping, and putting the
	185	card and host interface into "Memory and IO" mode.
	186	*/
1ac71e5a	187	ret = pcmcia_enable_device(link);
2caff147 DB	188	if (ret)
2caff147 DB	189	goto failed;
05c9a4cf	190	((local_info_t *)link->priv)->eth_dev =
eb14120f	191	init_airo_card(link->irq,
9a017a91	192	link->resource[0]->start, 1, &link->dev);
05c9a4cf	193	if (!((local_info_t *)link->priv)->eth_dev)
2caff147	194	goto failed;
05c9a4cf	195
1da177e4	196	/* Finally, report what we've done */
ded6a1a3	197	dev_info(&link->dev, "index 0x%02x: ",
7feabb64	198	link->config_index);
e8405f0f DB	199	if (link->vpp)
e8405f0f DB	200	printk(", Vpp %d.%d", link->vpp/10, link->vpp%10);
eb14120f	201	printk(", irq %d", link->irq);
9a017a91 DB	202	if (link->resource[0])
	203	printk(" & %pR", link->resource[0]);
	204	if (link->resource[1])
	205	printk(" & %pR", link->resource[1]);
1da177e4	206	printk("\n");
15b99ac1 DB	207	return 0;
15b99ac1 DB	208
b54bf94b	209	failed:
1da177e4	210	airo_release(link);
15b99ac1	211	return -ENODEV;
1da177e4 LT	212	} /* airo_config */
	213
	214	/*======================================================================
05c9a4cf	215
1da177e4 LT	216	After a card is removed, airo_release() will unregister the
	217	device, and release the PCMCIA configuration. If the device is
	218	still open, this will be postponed until it is closed.
05c9a4cf	219
1da177e4 LT	220	======================================================================*/
1da177e4 LT	221
fba395ee	222	static void airo_release(struct pcmcia_device *link)
1da177e4	223	{
2caff147	224	dev_dbg(&link->dev, "airo_release\n");
fba395ee	225	pcmcia_disable_device(link);
1da177e4 LT	226	}
1da177e4 LT	227
fba395ee	228	static int airo_suspend(struct pcmcia_device *link)
98e4c28b	229	{
98e4c28b DB	230	local_info_t *local = link->priv;
98e4c28b DB	231
e2d40963	232	netif_device_detach(local->eth_dev);
98e4c28b DB	233
	234	return 0;
	235	}
	236
fba395ee	237	static int airo_resume(struct pcmcia_device *link)
98e4c28b	238	{
98e4c28b DB	239	local_info_t *local = link->priv;
98e4c28b DB	240
e2d40963	241	if (link->open) {
98e4c28b DB	242	reset_airo_card(local->eth_dev);
	243	netif_device_attach(local->eth_dev);
	244	}
	245
	246	return 0;
	247	}
	248
7018d06d DB	249	static struct pcmcia_device_id airo_ids[] = {
	250	PCMCIA_DEVICE_MANF_CARD(0x015f, 0x000a),
	251	PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0005),
	252	PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0007),
	253	PCMCIA_DEVICE_MANF_CARD(0x0105, 0x0007),
	254	PCMCIA_DEVICE_NULL,
	255	};
	256	MODULE_DEVICE_TABLE(pcmcia, airo_ids);
	257
1da177e4 LT	258	static struct pcmcia_driver airo_driver = {
	259	.owner = THIS_MODULE,
	260	.drv = {
	261	.name = "airo_cs",
	262	},
15b99ac1	263	.probe = airo_probe,
cc3b4866	264	.remove = airo_detach,
7018d06d	265	.id_table = airo_ids,
98e4c28b DB	266	.suspend = airo_suspend,
98e4c28b DB	267	.resume = airo_resume,
1da177e4 LT	268	};
	269
	270	static int airo_cs_init(void)
	271	{
	272	return pcmcia_register_driver(&airo_driver);
	273	}
	274
	275	static void airo_cs_cleanup(void)
	276	{
	277	pcmcia_unregister_driver(&airo_driver);
1da177e4 LT	278	}
	279
	280	/*
	281	This program is free software; you can redistribute it and/or
	282	modify it under the terms of the GNU General Public License
	283	as published by the Free Software Foundation; either version 2
	284	of the License, or (at your option) any later version.
	285
	286	This program is distributed in the hope that it will be useful,
	287	but WITHOUT ANY WARRANTY; without even the implied warranty of
	288	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	289	GNU General Public License for more details.
	290
	291	In addition:
	292
	293	Redistribution and use in source and binary forms, with or without
	294	modification, are permitted provided that the following conditions
	295	are met:
	296
	297	1. Redistributions of source code must retain the above copyright
	298	notice, this list of conditions and the following disclaimer.
	299	2. Redistributions in binary form must reproduce the above copyright
	300	notice, this list of conditions and the following disclaimer in the
	301	documentation and/or other materials provided with the distribution.
	302	3. The name of the author may not be used to endorse or promote
	303	products derived from this software without specific prior written
	304	permission.
	305
	306	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	307	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	308	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	309	ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
	310	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	311	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	312	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	313	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	314	STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	315	IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
05c9a4cf	316	POSSIBILITY OF SUCH DAMAGE.
1da177e4 LT	317	*/
	318
	319	module_init(airo_cs_init);
	320	module_exit(airo_cs_cleanup);