4fbe811bebfc2537f5a2b63b7b343a4f2812afda
[linux-2.6.git] / drivers / net / wireless / airo_cs.c
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
19     are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.    
20     
21 ======================================================================*/
22
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
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>
40
41 #include <asm/io.h>
42 #include <asm/system.h>
43
44 #include "airo.h"
45
46 /*
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.
52 */
53 #ifdef PCMCIA_DEBUG
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);
58 #else
59 #define DEBUG(n, args...)
60 #endif
61
62 /*====================================================================*/
63
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");
70
71 /*====================================================================*/
72
73 /*
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
79    event handler. 
80 */
81
82 static int airo_config(struct pcmcia_device *link);
83 static void airo_release(struct pcmcia_device *link);
84
85 /*
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.
89 */
90
91 static void airo_detach(struct pcmcia_device *p_dev);
92
93 /*
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.
98 */
99
100 /*
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).
104
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.
108 */
109
110 /*
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.
119
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.
124 */
125    
126 typedef struct local_info_t {
127         dev_node_t      node;
128         struct net_device *eth_dev;
129 } local_info_t;
130
131 /*======================================================================
132   
133   airo_attach() creates an "instance" of the driver, allocating
134   local data structures for one device.  The device is registered
135   with Card Services.
136   
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.
140   
141   ======================================================================*/
142
143 static int airo_probe(struct pcmcia_device *p_dev)
144 {
145         local_info_t *local;
146
147         DEBUG(0, "airo_attach()\n");
148
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;
153         
154         /*
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.
160         */
161         p_dev->conf.Attributes = 0;
162         p_dev->conf.IntType = INT_MEMORY_AND_IO;
163         
164         /* Allocate space for private device-specific data */
165         local = kzalloc(sizeof(local_info_t), GFP_KERNEL);
166         if (!local) {
167                 printk(KERN_ERR "airo_cs: no memory for new device\n");
168                 return -ENOMEM;
169         }
170         p_dev->priv = local;
171
172         return airo_config(p_dev);
173 } /* airo_attach */
174
175 /*======================================================================
176   
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.
181   
182   ======================================================================*/
183
184 static void airo_detach(struct pcmcia_device *link)
185 {
186         DEBUG(0, "airo_detach(0x%p)\n", link);
187
188         airo_release(link);
189
190         if ( ((local_info_t*)link->priv)->eth_dev ) {
191                 stop_airo_card( ((local_info_t*)link->priv)->eth_dev, 0 );
192         }
193         ((local_info_t*)link->priv)->eth_dev = NULL;
194
195         kfree(link->priv);
196 } /* airo_detach */
197
198 /*======================================================================
199   
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.
203   
204   ======================================================================*/
205
206 #define CS_CHECK(fn, ret) \
207 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
208
209 struct airo_cs_config_data {
210         cistpl_cftable_entry_t dflt;
211         win_req_t req;
212 };
213
214 static int airo_cs_config_check(struct pcmcia_device *p_dev,
215                                 cistpl_cftable_entry_t *cfg,
216                                 void *priv_data)
217 {
218         struct airo_cs_config_data *cfg_mem = priv_data;
219
220         if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
221                 cfg_mem->dflt = *cfg;
222
223         if (cfg->index == 0)
224                 return -ENODEV;
225
226         p_dev->conf.ConfigIndex = cfg->index;
227
228         /* Does this card need audio output? */
229         if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
230                 p_dev->conf.Attributes |= CONF_ENABLE_SPKR;
231                 p_dev->conf.Status = CCSR_AUDIO_ENA;
232         }
233
234         /* Use power settings for Vcc and Vpp if present */
235         /*  Note that the CIS values need to be rescaled */
236         if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
237                 p_dev->conf.Vpp = cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
238         else if (cfg_mem->dflt.vpp1.present & (1<<CISTPL_POWER_VNOM))
239                 p_dev->conf.Vpp = cfg_mem->dflt.vpp1.param[CISTPL_POWER_VNOM]/10000;
240
241         /* Do we need to allocate an interrupt? */
242         if (cfg->irq.IRQInfo1 || cfg_mem->dflt.irq.IRQInfo1)
243                 p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
244
245         /* IO window settings */
246         p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0;
247         if ((cfg->io.nwin > 0) || (cfg_mem->dflt.io.nwin > 0)) {
248                 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &cfg_mem->dflt.io;
249                 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
250                 if (!(io->flags & CISTPL_IO_8BIT))
251                         p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
252                 if (!(io->flags & CISTPL_IO_16BIT))
253                         p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
254                 p_dev->io.BasePort1 = io->win[0].base;
255                 p_dev->io.NumPorts1 = io->win[0].len;
256                 if (io->nwin > 1) {
257                         p_dev->io.Attributes2 = p_dev->io.Attributes1;
258                         p_dev->io.BasePort2 = io->win[1].base;
259                         p_dev->io.NumPorts2 = io->win[1].len;
260                 }
261         }
262
263         /* This reserves IO space but doesn't actually enable it */
264         if (pcmcia_request_io(p_dev, &p_dev->io) != 0)
265                 return -ENODEV;
266
267         /*
268           Now set up a common memory window, if needed.  There is room
269           in the struct pcmcia_device structure for one memory window handle,
270           but if the base addresses need to be saved, or if multiple
271           windows are needed, the info should go in the private data
272           structure for this device.
273
274           Note that the memory window base is a physical address, and
275           needs to be mapped to virtual space with ioremap() before it
276           is used.
277         */
278         if ((cfg->mem.nwin > 0) || (cfg_mem->dflt.mem.nwin > 0)) {
279                 cistpl_mem_t *mem = (cfg->mem.nwin) ? &cfg->mem : &cfg_mem->dflt.mem;
280                 memreq_t map;
281                 cfg_mem->req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM;
282                 cfg_mem->req.Base = mem->win[0].host_addr;
283                 cfg_mem->req.Size = mem->win[0].len;
284                 cfg_mem->req.AccessSpeed = 0;
285                 if (pcmcia_request_window(&p_dev, &cfg_mem->req, &p_dev->win) != 0)
286                         return -ENODEV;
287                 map.Page = 0;
288                 map.CardOffset = mem->win[0].card_addr;
289                 if (pcmcia_map_mem_page(p_dev->win, &map) != 0)
290                         return -ENODEV;
291         }
292         /* If we got this far, we're cool! */
293         return 0;
294 }
295
296
297 static int airo_config(struct pcmcia_device *link)
298 {
299         local_info_t *dev;
300         struct airo_cs_config_data *cfg_mem;
301         int last_fn, last_ret;
302
303         dev = link->priv;
304
305         DEBUG(0, "airo_config(0x%p)\n", link);
306
307         cfg_mem = kzalloc(sizeof(struct airo_cs_config_data), GFP_KERNEL);
308         if (!cfg_mem)
309                 return -ENOMEM;
310
311         /*
312          * In this loop, we scan the CIS for configuration table
313          * entries, each of which describes a valid card
314          * configuration, including voltage, IO window, memory window,
315          * and interrupt settings.
316          *
317          * We make no assumptions about the card to be configured: we
318          * use just the information available in the CIS.  In an ideal
319          * world, this would work for any PCMCIA card, but it requires
320          * a complete and accurate CIS.  In practice, a driver usually
321          * "knows" most of these things without consulting the CIS,
322          * and most client drivers will only use the CIS to fill in
323          * implementation-defined details.
324          */
325         last_ret = pcmcia_loop_config(link, airo_cs_config_check, cfg_mem);
326         if (last_ret)
327                 goto failed;
328
329         /*
330           Allocate an interrupt line.  Note that this does not assign a
331           handler to the interrupt, unless the 'Handler' member of the
332           irq structure is initialized.
333         */
334         if (link->conf.Attributes & CONF_ENABLE_IRQ)
335                 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
336         
337         /*
338           This actually configures the PCMCIA socket -- setting up
339           the I/O windows and the interrupt mapping, and putting the
340           card and host interface into "Memory and IO" mode.
341         */
342         CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
343         ((local_info_t*)link->priv)->eth_dev = 
344                 init_airo_card( link->irq.AssignedIRQ,
345                                 link->io.BasePort1, 1, &handle_to_dev(link) );
346         if (!((local_info_t*)link->priv)->eth_dev) goto cs_failed;
347         
348         /*
349           At this point, the dev_node_t structure(s) need to be
350           initialized and arranged in a linked list at link->dev_node.
351         */
352         strcpy(dev->node.dev_name, ((local_info_t*)link->priv)->eth_dev->name );
353         dev->node.major = dev->node.minor = 0;
354         link->dev_node = &dev->node;
355         
356         /* Finally, report what we've done */
357         printk(KERN_INFO "%s: index 0x%02x: ",
358                dev->node.dev_name, link->conf.ConfigIndex);
359         if (link->conf.Vpp)
360                 printk(", Vpp %d.%d", link->conf.Vpp/10, link->conf.Vpp%10);
361         if (link->conf.Attributes & CONF_ENABLE_IRQ)
362                 printk(", irq %d", link->irq.AssignedIRQ);
363         if (link->io.NumPorts1)
364                 printk(", io 0x%04x-0x%04x", link->io.BasePort1,
365                        link->io.BasePort1+link->io.NumPorts1-1);
366         if (link->io.NumPorts2)
367                 printk(" & 0x%04x-0x%04x", link->io.BasePort2,
368                        link->io.BasePort2+link->io.NumPorts2-1);
369         if (link->win)
370                 printk(", mem 0x%06lx-0x%06lx", cfg_mem->req.Base,
371                        cfg_mem->req.Base+cfg_mem->req.Size-1);
372         printk("\n");
373         kfree(cfg_mem);
374         return 0;
375
376  cs_failed:
377         cs_error(link, last_fn, last_ret);
378  failed:
379         airo_release(link);
380         kfree(cfg_mem);
381         return -ENODEV;
382 } /* airo_config */
383
384 /*======================================================================
385   
386   After a card is removed, airo_release() will unregister the
387   device, and release the PCMCIA configuration.  If the device is
388   still open, this will be postponed until it is closed.
389   
390   ======================================================================*/
391
392 static void airo_release(struct pcmcia_device *link)
393 {
394         DEBUG(0, "airo_release(0x%p)\n", link);
395         pcmcia_disable_device(link);
396 }
397
398 static int airo_suspend(struct pcmcia_device *link)
399 {
400         local_info_t *local = link->priv;
401
402         netif_device_detach(local->eth_dev);
403
404         return 0;
405 }
406
407 static int airo_resume(struct pcmcia_device *link)
408 {
409         local_info_t *local = link->priv;
410
411         if (link->open) {
412                 reset_airo_card(local->eth_dev);
413                 netif_device_attach(local->eth_dev);
414         }
415
416         return 0;
417 }
418
419 static struct pcmcia_device_id airo_ids[] = {
420         PCMCIA_DEVICE_MANF_CARD(0x015f, 0x000a),
421         PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0005),
422         PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0007),
423         PCMCIA_DEVICE_MANF_CARD(0x0105, 0x0007),
424         PCMCIA_DEVICE_NULL,
425 };
426 MODULE_DEVICE_TABLE(pcmcia, airo_ids);
427
428 static struct pcmcia_driver airo_driver = {
429         .owner          = THIS_MODULE,
430         .drv            = {
431                 .name   = "airo_cs",
432         },
433         .probe          = airo_probe,
434         .remove         = airo_detach,
435         .id_table       = airo_ids,
436         .suspend        = airo_suspend,
437         .resume         = airo_resume,
438 };
439
440 static int airo_cs_init(void)
441 {
442         return pcmcia_register_driver(&airo_driver);
443 }
444
445 static void airo_cs_cleanup(void)
446 {
447         pcmcia_unregister_driver(&airo_driver);
448 }
449
450 /*
451     This program is free software; you can redistribute it and/or
452     modify it under the terms of the GNU General Public License
453     as published by the Free Software Foundation; either version 2
454     of the License, or (at your option) any later version.
455
456     This program is distributed in the hope that it will be useful,
457     but WITHOUT ANY WARRANTY; without even the implied warranty of
458     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
459     GNU General Public License for more details.
460
461     In addition:
462
463     Redistribution and use in source and binary forms, with or without
464     modification, are permitted provided that the following conditions
465     are met:
466
467     1. Redistributions of source code must retain the above copyright
468        notice, this list of conditions and the following disclaimer.
469     2. Redistributions in binary form must reproduce the above copyright
470        notice, this list of conditions and the following disclaimer in the
471        documentation and/or other materials provided with the distribution.
472     3. The name of the author may not be used to endorse or promote
473        products derived from this software without specific prior written
474        permission.
475
476     THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
477     IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
478     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
479     ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
480     INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
481     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
482     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
483     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
484     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
485     IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
486     POSSIBILITY OF SUCH DAMAGE.    
487 */
488
489 module_init(airo_cs_init);
490 module_exit(airo_cs_cleanup);