1 /*======================================================================
3 Aironet driver for 4500 and 4800 series cards
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
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
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
19 are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
21 ======================================================================*/
23 #ifdef __IN_PCMCIA_PACKAGE__
24 #include <pcmcia/k_compat.h>
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>
35 #include <pcmcia/cs_types.h>
36 #include <pcmcia/cs.h>
37 #include <pcmcia/cistpl.h>
38 #include <pcmcia/cisreg.h>
39 #include <pcmcia/ds.h>
42 #include <asm/system.h>
47 All the PCMCIA modules use PCMCIA_DEBUG to control debugging. If
48 you do not define PCMCIA_DEBUG at all, all the debug code will be
49 left out. If you compile with PCMCIA_DEBUG=0, the debug code will
50 be present but disabled -- but it can then be enabled for specific
51 modules at load time with a 'pc_debug=#' option to insmod.
54 static int pc_debug = PCMCIA_DEBUG;
55 module_param(pc_debug, int, 0);
56 static char *version = "$Revision: 1.2 $";
57 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args);
59 #define DEBUG(n, args...)
62 /*====================================================================*/
64 MODULE_AUTHOR("Benjamin Reed");
65 MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet \
66 cards. This is the module that links the PCMCIA card \
67 with the airo module.");
68 MODULE_LICENSE("Dual BSD/GPL");
69 MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340 PCMCIA cards");
71 /*====================================================================*/
74 The event() function is this driver's Card Services event handler.
75 It will be called by Card Services when an appropriate card status
76 event is received. The config() and release() entry points are
77 used to configure or release a socket, in response to card
78 insertion and ejection events. They are invoked from the airo_cs
82 static int airo_config(struct pcmcia_device *link);
83 static void airo_release(struct pcmcia_device *link);
86 The attach() and detach() entry points are used to create and destroy
87 "instances" of the driver, where each instance represents everything
88 needed to manage one actual PCMCIA card.
91 static void airo_detach(struct pcmcia_device *p_dev);
94 You'll also need to prototype all the functions that will actually
95 be used to talk to your device. See 'pcmem_cs' for a good example
96 of a fully self-sufficient driver; the other drivers rely more or
97 less on other parts of the kernel.
101 A linked list of "instances" of the aironet device. Each actual
102 PCMCIA card corresponds to one device instance, and is described
103 by one struct pcmcia_device structure (defined in ds.h).
105 You may not want to use a linked list for this -- for example, the
106 memory card driver uses an array of struct pcmcia_device pointers, where minor
107 device numbers are used to derive the corresponding array index.
111 A driver needs to provide a dev_node_t structure for each device
112 on a card. In some cases, there is only one device per card (for
113 example, ethernet cards, modems). In other cases, there may be
114 many actual or logical devices (SCSI adapters, memory cards with
115 multiple partitions). The dev_node_t structures need to be kept
116 in a linked list starting at the 'dev' field of a struct pcmcia_device
117 structure. We allocate them in the card's private data structure,
118 because they generally shouldn't be allocated dynamically.
120 In this case, we also provide a flag to indicate if a device is
121 "stopped" due to a power management event, or card ejection. The
122 device IO routines can use a flag like this to throttle IO to a
123 card that is not ready to accept it.
126 typedef struct local_info_t {
128 struct net_device *eth_dev;
131 /*======================================================================
133 airo_attach() creates an "instance" of the driver, allocating
134 local data structures for one device. The device is registered
137 The dev_link structure is initialized, but we don't actually
138 configure the card at this point -- we wait until we receive a
139 card insertion event.
141 ======================================================================*/
143 static int airo_probe(struct pcmcia_device *p_dev)
147 DEBUG(0, "airo_attach()\n");
149 /* Interrupt setup */
150 p_dev->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
151 p_dev->irq.IRQInfo1 = IRQ_LEVEL_ID;
152 p_dev->irq.Handler = NULL;
155 General socket configuration defaults can go here. In this
156 client, we assume very little, and rely on the CIS for almost
157 everything. In most clients, many details (i.e., number, sizes,
158 and attributes of IO windows) are fixed by the nature of the
159 device, and can be hard-wired here.
161 p_dev->conf.Attributes = 0;
162 p_dev->conf.IntType = INT_MEMORY_AND_IO;
164 /* Allocate space for private device-specific data */
165 local = kzalloc(sizeof(local_info_t), GFP_KERNEL);
167 printk(KERN_ERR "airo_cs: no memory for new device\n");
172 return airo_config(p_dev);
175 /*======================================================================
177 This deletes a driver "instance". The device is de-registered
178 with Card Services. If it has been released, all local data
179 structures are freed. Otherwise, the structures will be freed
180 when the device is released.
182 ======================================================================*/
184 static void airo_detach(struct pcmcia_device *link)
186 DEBUG(0, "airo_detach(0x%p)\n", link);
190 if ( ((local_info_t*)link->priv)->eth_dev ) {
191 stop_airo_card( ((local_info_t*)link->priv)->eth_dev, 0 );
193 ((local_info_t*)link->priv)->eth_dev = NULL;
198 /*======================================================================
200 airo_config() is scheduled to run after a CARD_INSERTION event
201 is received, to configure the PCMCIA socket, and to make the
202 device available to the system.
204 ======================================================================*/
206 #define CS_CHECK(fn, ret) \
207 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
209 struct airo_cs_config_data {
210 cistpl_cftable_entry_t dflt;
214 static int airo_cs_config_check(struct pcmcia_device *p_dev,
215 cistpl_cftable_entry_t *cfg,
218 struct airo_cs_config_data *cfg_mem = priv_data;
220 if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
221 cfg_mem->dflt = *cfg;
226 /* Does this card need audio output? */
227 if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
228 p_dev->conf.Attributes |= CONF_ENABLE_SPKR;
229 p_dev->conf.Status = CCSR_AUDIO_ENA;
232 /* Use power settings for Vcc and Vpp if present */
233 /* Note that the CIS values need to be rescaled */
234 if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
235 p_dev->conf.Vpp = cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
236 else if (cfg_mem->dflt.vpp1.present & (1<<CISTPL_POWER_VNOM))
237 p_dev->conf.Vpp = cfg_mem->dflt.vpp1.param[CISTPL_POWER_VNOM]/10000;
239 /* Do we need to allocate an interrupt? */
240 if (cfg->irq.IRQInfo1 || cfg_mem->dflt.irq.IRQInfo1)
241 p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
243 /* IO window settings */
244 p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0;
245 if ((cfg->io.nwin > 0) || (cfg_mem->dflt.io.nwin > 0)) {
246 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &cfg_mem->dflt.io;
247 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
248 if (!(io->flags & CISTPL_IO_8BIT))
249 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
250 if (!(io->flags & CISTPL_IO_16BIT))
251 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
252 p_dev->io.BasePort1 = io->win[0].base;
253 p_dev->io.NumPorts1 = io->win[0].len;
255 p_dev->io.Attributes2 = p_dev->io.Attributes1;
256 p_dev->io.BasePort2 = io->win[1].base;
257 p_dev->io.NumPorts2 = io->win[1].len;
261 /* This reserves IO space but doesn't actually enable it */
262 if (pcmcia_request_io(p_dev, &p_dev->io) != 0)
266 Now set up a common memory window, if needed. There is room
267 in the struct pcmcia_device structure for one memory window handle,
268 but if the base addresses need to be saved, or if multiple
269 windows are needed, the info should go in the private data
270 structure for this device.
272 Note that the memory window base is a physical address, and
273 needs to be mapped to virtual space with ioremap() before it
276 if ((cfg->mem.nwin > 0) || (cfg_mem->dflt.mem.nwin > 0)) {
277 cistpl_mem_t *mem = (cfg->mem.nwin) ? &cfg->mem : &cfg_mem->dflt.mem;
279 cfg_mem->req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM;
280 cfg_mem->req.Base = mem->win[0].host_addr;
281 cfg_mem->req.Size = mem->win[0].len;
282 cfg_mem->req.AccessSpeed = 0;
283 if (pcmcia_request_window(&p_dev, &cfg_mem->req, &p_dev->win) != 0)
286 map.CardOffset = mem->win[0].card_addr;
287 if (pcmcia_map_mem_page(p_dev->win, &map) != 0)
290 /* If we got this far, we're cool! */
295 static int airo_config(struct pcmcia_device *link)
298 struct airo_cs_config_data *cfg_mem;
299 int last_fn, last_ret;
303 DEBUG(0, "airo_config(0x%p)\n", link);
305 cfg_mem = kzalloc(sizeof(struct airo_cs_config_data), GFP_KERNEL);
310 * In this loop, we scan the CIS for configuration table
311 * entries, each of which describes a valid card
312 * configuration, including voltage, IO window, memory window,
313 * and interrupt settings.
315 * We make no assumptions about the card to be configured: we
316 * use just the information available in the CIS. In an ideal
317 * world, this would work for any PCMCIA card, but it requires
318 * a complete and accurate CIS. In practice, a driver usually
319 * "knows" most of these things without consulting the CIS,
320 * and most client drivers will only use the CIS to fill in
321 * implementation-defined details.
323 last_ret = pcmcia_loop_config(link, airo_cs_config_check, cfg_mem);
328 Allocate an interrupt line. Note that this does not assign a
329 handler to the interrupt, unless the 'Handler' member of the
330 irq structure is initialized.
332 if (link->conf.Attributes & CONF_ENABLE_IRQ)
333 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
336 This actually configures the PCMCIA socket -- setting up
337 the I/O windows and the interrupt mapping, and putting the
338 card and host interface into "Memory and IO" mode.
340 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
341 ((local_info_t*)link->priv)->eth_dev =
342 init_airo_card( link->irq.AssignedIRQ,
343 link->io.BasePort1, 1, &handle_to_dev(link) );
344 if (!((local_info_t*)link->priv)->eth_dev) goto cs_failed;
347 At this point, the dev_node_t structure(s) need to be
348 initialized and arranged in a linked list at link->dev_node.
350 strcpy(dev->node.dev_name, ((local_info_t*)link->priv)->eth_dev->name );
351 dev->node.major = dev->node.minor = 0;
352 link->dev_node = &dev->node;
354 /* Finally, report what we've done */
355 printk(KERN_INFO "%s: index 0x%02x: ",
356 dev->node.dev_name, link->conf.ConfigIndex);
358 printk(", Vpp %d.%d", link->conf.Vpp/10, link->conf.Vpp%10);
359 if (link->conf.Attributes & CONF_ENABLE_IRQ)
360 printk(", irq %d", link->irq.AssignedIRQ);
361 if (link->io.NumPorts1)
362 printk(", io 0x%04x-0x%04x", link->io.BasePort1,
363 link->io.BasePort1+link->io.NumPorts1-1);
364 if (link->io.NumPorts2)
365 printk(" & 0x%04x-0x%04x", link->io.BasePort2,
366 link->io.BasePort2+link->io.NumPorts2-1);
368 printk(", mem 0x%06lx-0x%06lx", cfg_mem->req.Base,
369 cfg_mem->req.Base+cfg_mem->req.Size-1);
375 cs_error(link, last_fn, last_ret);
382 /*======================================================================
384 After a card is removed, airo_release() will unregister the
385 device, and release the PCMCIA configuration. If the device is
386 still open, this will be postponed until it is closed.
388 ======================================================================*/
390 static void airo_release(struct pcmcia_device *link)
392 DEBUG(0, "airo_release(0x%p)\n", link);
393 pcmcia_disable_device(link);
396 static int airo_suspend(struct pcmcia_device *link)
398 local_info_t *local = link->priv;
400 netif_device_detach(local->eth_dev);
405 static int airo_resume(struct pcmcia_device *link)
407 local_info_t *local = link->priv;
410 reset_airo_card(local->eth_dev);
411 netif_device_attach(local->eth_dev);
417 static struct pcmcia_device_id airo_ids[] = {
418 PCMCIA_DEVICE_MANF_CARD(0x015f, 0x000a),
419 PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0005),
420 PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0007),
421 PCMCIA_DEVICE_MANF_CARD(0x0105, 0x0007),
424 MODULE_DEVICE_TABLE(pcmcia, airo_ids);
426 static struct pcmcia_driver airo_driver = {
427 .owner = THIS_MODULE,
432 .remove = airo_detach,
433 .id_table = airo_ids,
434 .suspend = airo_suspend,
435 .resume = airo_resume,
438 static int airo_cs_init(void)
440 return pcmcia_register_driver(&airo_driver);
443 static void airo_cs_cleanup(void)
445 pcmcia_unregister_driver(&airo_driver);
449 This program is free software; you can redistribute it and/or
450 modify it under the terms of the GNU General Public License
451 as published by the Free Software Foundation; either version 2
452 of the License, or (at your option) any later version.
454 This program is distributed in the hope that it will be useful,
455 but WITHOUT ANY WARRANTY; without even the implied warranty of
456 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
457 GNU General Public License for more details.
461 Redistribution and use in source and binary forms, with or without
462 modification, are permitted provided that the following conditions
465 1. Redistributions of source code must retain the above copyright
466 notice, this list of conditions and the following disclaimer.
467 2. Redistributions in binary form must reproduce the above copyright
468 notice, this list of conditions and the following disclaimer in the
469 documentation and/or other materials provided with the distribution.
470 3. The name of the author may not be used to endorse or promote
471 products derived from this software without specific prior written
474 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
475 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
476 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
477 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
478 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
479 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
480 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
481 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
482 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
483 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
484 POSSIBILITY OF SUCH DAMAGE.
487 module_init(airo_cs_init);
488 module_exit(airo_cs_cleanup);