Merge branch 'upstream-fixes'
[linux-2.6] / 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 #include <linux/config.h>
24 #ifdef __IN_PCMCIA_PACKAGE__
25 #include <pcmcia/k_compat.h>
26 #endif
27 #include <linux/init.h>
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/ptrace.h>
31 #include <linux/slab.h>
32 #include <linux/string.h>
33 #include <linux/timer.h>
34 #include <linux/netdevice.h>
35
36 #include <pcmcia/cs_types.h>
37 #include <pcmcia/cs.h>
38 #include <pcmcia/cistpl.h>
39 #include <pcmcia/cisreg.h>
40 #include <pcmcia/ds.h>
41
42 #include <asm/io.h>
43 #include <asm/system.h>
44
45 #include "airo.h"
46
47 /*
48    All the PCMCIA modules use PCMCIA_DEBUG to control debugging.  If
49    you do not define PCMCIA_DEBUG at all, all the debug code will be
50    left out.  If you compile with PCMCIA_DEBUG=0, the debug code will
51    be present but disabled -- but it can then be enabled for specific
52    modules at load time with a 'pc_debug=#' option to insmod.
53 */
54 #ifdef PCMCIA_DEBUG
55 static int pc_debug = PCMCIA_DEBUG;
56 module_param(pc_debug, int, 0);
57 static char *version = "$Revision: 1.2 $";
58 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args);
59 #else
60 #define DEBUG(n, args...)
61 #endif
62
63 /*====================================================================*/
64
65 MODULE_AUTHOR("Benjamin Reed");
66 MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet \
67                    cards.  This is the module that links the PCMCIA card \
68                    with the airo module.");
69 MODULE_LICENSE("Dual BSD/GPL");
70 MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340 PCMCIA cards");
71
72 /*====================================================================*/
73
74 /*
75    The event() function is this driver's Card Services event handler.
76    It will be called by Card Services when an appropriate card status
77    event is received.  The config() and release() entry points are
78    used to configure or release a socket, in response to card
79    insertion and ejection events.  They are invoked from the airo_cs
80    event handler. 
81 */
82
83 static void airo_config(dev_link_t *link);
84 static void airo_release(dev_link_t *link);
85
86 /*
87    The attach() and detach() entry points are used to create and destroy
88    "instances" of the driver, where each instance represents everything
89    needed to manage one actual PCMCIA card.
90 */
91
92 static void airo_detach(struct pcmcia_device *p_dev);
93
94 /*
95    You'll also need to prototype all the functions that will actually
96    be used to talk to your device.  See 'pcmem_cs' for a good example
97    of a fully self-sufficient driver; the other drivers rely more or
98    less on other parts of the kernel.
99 */
100
101 /*
102    A linked list of "instances" of the  aironet device.  Each actual
103    PCMCIA card corresponds to one device instance, and is described
104    by one dev_link_t structure (defined in ds.h).
105
106    You may not want to use a linked list for this -- for example, the
107    memory card driver uses an array of dev_link_t pointers, where minor
108    device numbers are used to derive the corresponding array index.
109 */
110
111 /*
112    A driver needs to provide a dev_node_t structure for each device
113    on a card.  In some cases, there is only one device per card (for
114    example, ethernet cards, modems).  In other cases, there may be
115    many actual or logical devices (SCSI adapters, memory cards with
116    multiple partitions).  The dev_node_t structures need to be kept
117    in a linked list starting at the 'dev' field of a dev_link_t
118    structure.  We allocate them in the card's private data structure,
119    because they generally shouldn't be allocated dynamically.
120
121    In this case, we also provide a flag to indicate if a device is
122    "stopped" due to a power management event, or card ejection.  The
123    device IO routines can use a flag like this to throttle IO to a
124    card that is not ready to accept it.
125 */
126    
127 typedef struct local_info_t {
128         dev_node_t      node;
129         struct net_device *eth_dev;
130 } local_info_t;
131
132 /*======================================================================
133   
134   airo_attach() creates an "instance" of the driver, allocating
135   local data structures for one device.  The device is registered
136   with Card Services.
137   
138   The dev_link structure is initialized, but we don't actually
139   configure the card at this point -- we wait until we receive a
140   card insertion event.
141   
142   ======================================================================*/
143
144 static int airo_attach(struct pcmcia_device *p_dev)
145 {
146         dev_link_t *link;
147         local_info_t *local;
148
149         DEBUG(0, "airo_attach()\n");
150
151         /* Initialize the dev_link_t structure */
152         link = kzalloc(sizeof(struct dev_link_t), GFP_KERNEL);
153         if (!link) {
154                 printk(KERN_ERR "airo_cs: no memory for new device\n");
155                 return -ENOMEM;
156         }
157         
158         /* Interrupt setup */
159         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
160         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
161         link->irq.Handler = NULL;
162         
163         /*
164           General socket configuration defaults can go here.  In this
165           client, we assume very little, and rely on the CIS for almost
166           everything.  In most clients, many details (i.e., number, sizes,
167           and attributes of IO windows) are fixed by the nature of the
168           device, and can be hard-wired here.
169         */
170         link->conf.Attributes = 0;
171         link->conf.Vcc = 50;
172         link->conf.IntType = INT_MEMORY_AND_IO;
173         
174         /* Allocate space for private device-specific data */
175         local = kzalloc(sizeof(local_info_t), GFP_KERNEL);
176         if (!local) {
177                 printk(KERN_ERR "airo_cs: no memory for new device\n");
178                 kfree (link);
179                 return -ENOMEM;
180         }
181         link->priv = local;
182
183         link->handle = p_dev;
184         p_dev->instance = link;
185
186         link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
187         airo_config(link);
188
189         return 0;
190 } /* airo_attach */
191
192 /*======================================================================
193   
194   This deletes a driver "instance".  The device is de-registered
195   with Card Services.  If it has been released, all local data
196   structures are freed.  Otherwise, the structures will be freed
197   when the device is released.
198   
199   ======================================================================*/
200
201 static void airo_detach(struct pcmcia_device *p_dev)
202 {
203         dev_link_t *link = dev_to_instance(p_dev);
204
205         DEBUG(0, "airo_detach(0x%p)\n", link);
206
207         if (link->state & DEV_CONFIG)
208                 airo_release(link);
209
210         if ( ((local_info_t*)link->priv)->eth_dev ) {
211                 stop_airo_card( ((local_info_t*)link->priv)->eth_dev, 0 );
212         }
213         ((local_info_t*)link->priv)->eth_dev = NULL;
214
215         kfree(link->priv);
216         kfree(link);
217 } /* airo_detach */
218
219 /*======================================================================
220   
221   airo_config() is scheduled to run after a CARD_INSERTION event
222   is received, to configure the PCMCIA socket, and to make the
223   device available to the system.
224   
225   ======================================================================*/
226
227 #define CS_CHECK(fn, ret) \
228 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
229
230 static void airo_config(dev_link_t *link)
231 {
232         client_handle_t handle;
233         tuple_t tuple;
234         cisparse_t parse;
235         local_info_t *dev;
236         int last_fn, last_ret;
237         u_char buf[64];
238         win_req_t req;
239         memreq_t map;
240         
241         handle = link->handle;
242         dev = link->priv;
243
244         DEBUG(0, "airo_config(0x%p)\n", link);
245         
246         /*
247           This reads the card's CONFIG tuple to find its configuration
248           registers.
249         */
250         tuple.DesiredTuple = CISTPL_CONFIG;
251         tuple.Attributes = 0;
252         tuple.TupleData = buf;
253         tuple.TupleDataMax = sizeof(buf);
254         tuple.TupleOffset = 0;
255         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
256         CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
257         CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
258         link->conf.ConfigBase = parse.config.base;
259         link->conf.Present = parse.config.rmask[0];
260         
261         /* Configure card */
262         link->state |= DEV_CONFIG;
263         
264         /*
265           In this loop, we scan the CIS for configuration table entries,
266           each of which describes a valid card configuration, including
267           voltage, IO window, memory window, and interrupt settings.
268           
269           We make no assumptions about the card to be configured: we use
270           just the information available in the CIS.  In an ideal world,
271           this would work for any PCMCIA card, but it requires a complete
272           and accurate CIS.  In practice, a driver usually "knows" most of
273           these things without consulting the CIS, and most client drivers
274           will only use the CIS to fill in implementation-defined details.
275         */
276         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
277         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
278         while (1) {
279                 cistpl_cftable_entry_t dflt = { 0 };
280                 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
281                 if (pcmcia_get_tuple_data(handle, &tuple) != 0 ||
282                                 pcmcia_parse_tuple(handle, &tuple, &parse) != 0)
283                         goto next_entry;
284                 
285                 if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg;
286                 if (cfg->index == 0) goto next_entry;
287                 link->conf.ConfigIndex = cfg->index;
288                 
289                 /* Does this card need audio output? */
290                 if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
291                         link->conf.Attributes |= CONF_ENABLE_SPKR;
292                         link->conf.Status = CCSR_AUDIO_ENA;
293                 }
294                 
295                 /* Use power settings for Vcc and Vpp if present */
296                 /*  Note that the CIS values need to be rescaled */
297                 if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM))
298                         link->conf.Vcc = cfg->vcc.param[CISTPL_POWER_VNOM]/10000;
299                 else if (dflt.vcc.present & (1<<CISTPL_POWER_VNOM))
300                         link->conf.Vcc = dflt.vcc.param[CISTPL_POWER_VNOM]/10000;
301                 
302                 if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
303                         link->conf.Vpp1 = link->conf.Vpp2 =
304                                 cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
305                 else if (dflt.vpp1.present & (1<<CISTPL_POWER_VNOM))
306                         link->conf.Vpp1 = link->conf.Vpp2 =
307                                 dflt.vpp1.param[CISTPL_POWER_VNOM]/10000;
308                 
309                 /* Do we need to allocate an interrupt? */
310                 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1)
311                         link->conf.Attributes |= CONF_ENABLE_IRQ;
312                 
313                 /* IO window settings */
314                 link->io.NumPorts1 = link->io.NumPorts2 = 0;
315                 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
316                         cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
317                         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
318                         if (!(io->flags & CISTPL_IO_8BIT))
319                                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
320                         if (!(io->flags & CISTPL_IO_16BIT))
321                                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
322                         link->io.BasePort1 = io->win[0].base;
323                         link->io.NumPorts1 = io->win[0].len;
324                         if (io->nwin > 1) {
325                                 link->io.Attributes2 = link->io.Attributes1;
326                                 link->io.BasePort2 = io->win[1].base;
327                                 link->io.NumPorts2 = io->win[1].len;
328                         }
329                 }
330                 
331                 /* This reserves IO space but doesn't actually enable it */
332                 if (pcmcia_request_io(link->handle, &link->io) != 0)
333                         goto next_entry;
334                 
335                 /*
336                   Now set up a common memory window, if needed.  There is room
337                   in the dev_link_t structure for one memory window handle,
338                   but if the base addresses need to be saved, or if multiple
339                   windows are needed, the info should go in the private data
340                   structure for this device.
341                   
342                   Note that the memory window base is a physical address, and
343                   needs to be mapped to virtual space with ioremap() before it
344                   is used.
345                 */
346                 if ((cfg->mem.nwin > 0) || (dflt.mem.nwin > 0)) {
347                         cistpl_mem_t *mem =
348                                 (cfg->mem.nwin) ? &cfg->mem : &dflt.mem;
349                         req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM;
350                         req.Base = mem->win[0].host_addr;
351                         req.Size = mem->win[0].len;
352                         req.AccessSpeed = 0;
353                         if (pcmcia_request_window(&link->handle, &req, &link->win) != 0)
354                                 goto next_entry;
355                         map.Page = 0; map.CardOffset = mem->win[0].card_addr;
356                         if (pcmcia_map_mem_page(link->win, &map) != 0)
357                                 goto next_entry;
358                 }
359                 /* If we got this far, we're cool! */
360                 break;
361                 
362         next_entry:
363                 CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple));
364         }
365         
366     /*
367       Allocate an interrupt line.  Note that this does not assign a
368       handler to the interrupt, unless the 'Handler' member of the
369       irq structure is initialized.
370     */
371         if (link->conf.Attributes & CONF_ENABLE_IRQ)
372                 CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
373         
374         /*
375           This actually configures the PCMCIA socket -- setting up
376           the I/O windows and the interrupt mapping, and putting the
377           card and host interface into "Memory and IO" mode.
378         */
379         CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
380         ((local_info_t*)link->priv)->eth_dev = 
381                 init_airo_card( link->irq.AssignedIRQ,
382                                 link->io.BasePort1, 1, &handle_to_dev(handle) );
383         if (!((local_info_t*)link->priv)->eth_dev) goto cs_failed;
384         
385         /*
386           At this point, the dev_node_t structure(s) need to be
387           initialized and arranged in a linked list at link->dev.
388         */
389         strcpy(dev->node.dev_name, ((local_info_t*)link->priv)->eth_dev->name );
390         dev->node.major = dev->node.minor = 0;
391         link->dev = &dev->node;
392         
393         /* Finally, report what we've done */
394         printk(KERN_INFO "%s: index 0x%02x: Vcc %d.%d",
395                dev->node.dev_name, link->conf.ConfigIndex,
396                link->conf.Vcc/10, link->conf.Vcc%10);
397         if (link->conf.Vpp1)
398                 printk(", Vpp %d.%d", link->conf.Vpp1/10, link->conf.Vpp1%10);
399         if (link->conf.Attributes & CONF_ENABLE_IRQ)
400                 printk(", irq %d", link->irq.AssignedIRQ);
401         if (link->io.NumPorts1)
402                 printk(", io 0x%04x-0x%04x", link->io.BasePort1,
403                        link->io.BasePort1+link->io.NumPorts1-1);
404         if (link->io.NumPorts2)
405                 printk(" & 0x%04x-0x%04x", link->io.BasePort2,
406                        link->io.BasePort2+link->io.NumPorts2-1);
407         if (link->win)
408                 printk(", mem 0x%06lx-0x%06lx", req.Base,
409                        req.Base+req.Size-1);
410         printk("\n");
411         
412         link->state &= ~DEV_CONFIG_PENDING;
413         return;
414         
415  cs_failed:
416         cs_error(link->handle, last_fn, last_ret);
417         airo_release(link);
418         
419 } /* airo_config */
420
421 /*======================================================================
422   
423   After a card is removed, airo_release() will unregister the
424   device, and release the PCMCIA configuration.  If the device is
425   still open, this will be postponed until it is closed.
426   
427   ======================================================================*/
428
429 static void airo_release(dev_link_t *link)
430 {
431         DEBUG(0, "airo_release(0x%p)\n", link);
432         
433         /* Unlink the device chain */
434         link->dev = NULL;
435         
436         /*
437           In a normal driver, additional code may be needed to release
438           other kernel data structures associated with this device. 
439         */
440         
441         /* Don't bother checking to see if these succeed or not */
442         if (link->win)
443                 pcmcia_release_window(link->win);
444         pcmcia_release_configuration(link->handle);
445         if (link->io.NumPorts1)
446                 pcmcia_release_io(link->handle, &link->io);
447         if (link->irq.AssignedIRQ)
448                 pcmcia_release_irq(link->handle, &link->irq);
449         link->state &= ~DEV_CONFIG;
450 }
451
452 static int airo_suspend(struct pcmcia_device *p_dev)
453 {
454         dev_link_t *link = dev_to_instance(p_dev);
455         local_info_t *local = link->priv;
456
457         link->state |= DEV_SUSPEND;
458         if (link->state & DEV_CONFIG) {
459                 netif_device_detach(local->eth_dev);
460                 pcmcia_release_configuration(link->handle);
461         }
462
463         return 0;
464 }
465
466 static int airo_resume(struct pcmcia_device *p_dev)
467 {
468         dev_link_t *link = dev_to_instance(p_dev);
469         local_info_t *local = link->priv;
470
471         link->state &= ~DEV_SUSPEND;
472         if (link->state & DEV_CONFIG) {
473                 pcmcia_request_configuration(link->handle, &link->conf);
474                 reset_airo_card(local->eth_dev);
475                 netif_device_attach(local->eth_dev);
476         }
477
478         return 0;
479 }
480
481 static struct pcmcia_device_id airo_ids[] = {
482         PCMCIA_DEVICE_MANF_CARD(0x015f, 0x000a),
483         PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0005),
484         PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0007),
485         PCMCIA_DEVICE_MANF_CARD(0x0105, 0x0007),
486         PCMCIA_DEVICE_NULL,
487 };
488 MODULE_DEVICE_TABLE(pcmcia, airo_ids);
489
490 static struct pcmcia_driver airo_driver = {
491         .owner          = THIS_MODULE,
492         .drv            = {
493                 .name   = "airo_cs",
494         },
495         .probe          = airo_attach,
496         .remove         = airo_detach,
497         .id_table       = airo_ids,
498         .suspend        = airo_suspend,
499         .resume         = airo_resume,
500 };
501
502 static int airo_cs_init(void)
503 {
504         return pcmcia_register_driver(&airo_driver);
505 }
506
507 static void airo_cs_cleanup(void)
508 {
509         pcmcia_unregister_driver(&airo_driver);
510 }
511
512 /*
513     This program is free software; you can redistribute it and/or
514     modify it under the terms of the GNU General Public License
515     as published by the Free Software Foundation; either version 2
516     of the License, or (at your option) any later version.
517
518     This program is distributed in the hope that it will be useful,
519     but WITHOUT ANY WARRANTY; without even the implied warranty of
520     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
521     GNU General Public License for more details.
522
523     In addition:
524
525     Redistribution and use in source and binary forms, with or without
526     modification, are permitted provided that the following conditions
527     are met:
528
529     1. Redistributions of source code must retain the above copyright
530        notice, this list of conditions and the following disclaimer.
531     2. Redistributions in binary form must reproduce the above copyright
532        notice, this list of conditions and the following disclaimer in the
533        documentation and/or other materials provided with the distribution.
534     3. The name of the author may not be used to endorse or promote
535        products derived from this software without specific prior written
536        permission.
537
538     THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
539     IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
540     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
541     ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
542     INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
543     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
544     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
545     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
546     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
547     IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
548     POSSIBILITY OF SUCH DAMAGE.    
549 */
550
551 module_init(airo_cs_init);
552 module_exit(airo_cs_cleanup);