airo: simplify WEP index and capability checks
[linux-2.6.git] / drivers / net / wireless / airo.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.  Major code contributions were received from Javier Achirica
15     <achirica@users.sourceforge.net> and Jean Tourrilhes <jt@hpl.hp.com>.
16     Code was also integrated from the Cisco Aironet driver for Linux.
17     Support for MPI350 cards was added by Fabrice Bellet
18     <fabrice@bellet.info>.
19
20 ======================================================================*/
21
22 #include <linux/err.h>
23 #include <linux/init.h>
24
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/proc_fs.h>
28
29 #include <linux/sched.h>
30 #include <linux/ptrace.h>
31 #include <linux/slab.h>
32 #include <linux/string.h>
33 #include <linux/timer.h>
34 #include <linux/interrupt.h>
35 #include <linux/in.h>
36 #include <linux/bitops.h>
37 #include <linux/scatterlist.h>
38 #include <linux/crypto.h>
39 #include <asm/io.h>
40 #include <asm/system.h>
41 #include <asm/unaligned.h>
42
43 #include <linux/netdevice.h>
44 #include <linux/etherdevice.h>
45 #include <linux/skbuff.h>
46 #include <linux/if_arp.h>
47 #include <linux/ioport.h>
48 #include <linux/pci.h>
49 #include <asm/uaccess.h>
50 #include <linux/kthread.h>
51 #include <linux/freezer.h>
52
53 #include <linux/ieee80211.h>
54
55 #include "airo.h"
56
57 #define DRV_NAME "airo"
58
59 #ifdef CONFIG_PCI
60 static struct pci_device_id card_ids[] = {
61         { 0x14b9, 1, PCI_ANY_ID, PCI_ANY_ID, },
62         { 0x14b9, 0x4500, PCI_ANY_ID, PCI_ANY_ID },
63         { 0x14b9, 0x4800, PCI_ANY_ID, PCI_ANY_ID, },
64         { 0x14b9, 0x0340, PCI_ANY_ID, PCI_ANY_ID, },
65         { 0x14b9, 0x0350, PCI_ANY_ID, PCI_ANY_ID, },
66         { 0x14b9, 0x5000, PCI_ANY_ID, PCI_ANY_ID, },
67         { 0x14b9, 0xa504, PCI_ANY_ID, PCI_ANY_ID, },
68         { 0, }
69 };
70 MODULE_DEVICE_TABLE(pci, card_ids);
71
72 static int airo_pci_probe(struct pci_dev *, const struct pci_device_id *);
73 static void airo_pci_remove(struct pci_dev *);
74 static int airo_pci_suspend(struct pci_dev *pdev, pm_message_t state);
75 static int airo_pci_resume(struct pci_dev *pdev);
76
77 static struct pci_driver airo_driver = {
78         .name     = DRV_NAME,
79         .id_table = card_ids,
80         .probe    = airo_pci_probe,
81         .remove   = __devexit_p(airo_pci_remove),
82         .suspend  = airo_pci_suspend,
83         .resume   = airo_pci_resume,
84 };
85 #endif /* CONFIG_PCI */
86
87 /* Include Wireless Extension definition and check version - Jean II */
88 #include <linux/wireless.h>
89 #define WIRELESS_SPY            /* enable iwspy support */
90 #include <net/iw_handler.h>     /* New driver API */
91
92 #define CISCO_EXT               /* enable Cisco extensions */
93 #ifdef CISCO_EXT
94 #include <linux/delay.h>
95 #endif
96
97 /* Hack to do some power saving */
98 #define POWER_ON_DOWN
99
100 /* As you can see this list is HUGH!
101    I really don't know what a lot of these counts are about, but they
102    are all here for completeness.  If the IGNLABEL macro is put in
103    infront of the label, that statistic will not be included in the list
104    of statistics in the /proc filesystem */
105
106 #define IGNLABEL(comment) NULL
107 static char *statsLabels[] = {
108         "RxOverrun",
109         IGNLABEL("RxPlcpCrcErr"),
110         IGNLABEL("RxPlcpFormatErr"),
111         IGNLABEL("RxPlcpLengthErr"),
112         "RxMacCrcErr",
113         "RxMacCrcOk",
114         "RxWepErr",
115         "RxWepOk",
116         "RetryLong",
117         "RetryShort",
118         "MaxRetries",
119         "NoAck",
120         "NoCts",
121         "RxAck",
122         "RxCts",
123         "TxAck",
124         "TxRts",
125         "TxCts",
126         "TxMc",
127         "TxBc",
128         "TxUcFrags",
129         "TxUcPackets",
130         "TxBeacon",
131         "RxBeacon",
132         "TxSinColl",
133         "TxMulColl",
134         "DefersNo",
135         "DefersProt",
136         "DefersEngy",
137         "DupFram",
138         "RxFragDisc",
139         "TxAged",
140         "RxAged",
141         "LostSync-MaxRetry",
142         "LostSync-MissedBeacons",
143         "LostSync-ArlExceeded",
144         "LostSync-Deauth",
145         "LostSync-Disassoced",
146         "LostSync-TsfTiming",
147         "HostTxMc",
148         "HostTxBc",
149         "HostTxUc",
150         "HostTxFail",
151         "HostRxMc",
152         "HostRxBc",
153         "HostRxUc",
154         "HostRxDiscard",
155         IGNLABEL("HmacTxMc"),
156         IGNLABEL("HmacTxBc"),
157         IGNLABEL("HmacTxUc"),
158         IGNLABEL("HmacTxFail"),
159         IGNLABEL("HmacRxMc"),
160         IGNLABEL("HmacRxBc"),
161         IGNLABEL("HmacRxUc"),
162         IGNLABEL("HmacRxDiscard"),
163         IGNLABEL("HmacRxAccepted"),
164         "SsidMismatch",
165         "ApMismatch",
166         "RatesMismatch",
167         "AuthReject",
168         "AuthTimeout",
169         "AssocReject",
170         "AssocTimeout",
171         IGNLABEL("ReasonOutsideTable"),
172         IGNLABEL("ReasonStatus1"),
173         IGNLABEL("ReasonStatus2"),
174         IGNLABEL("ReasonStatus3"),
175         IGNLABEL("ReasonStatus4"),
176         IGNLABEL("ReasonStatus5"),
177         IGNLABEL("ReasonStatus6"),
178         IGNLABEL("ReasonStatus7"),
179         IGNLABEL("ReasonStatus8"),
180         IGNLABEL("ReasonStatus9"),
181         IGNLABEL("ReasonStatus10"),
182         IGNLABEL("ReasonStatus11"),
183         IGNLABEL("ReasonStatus12"),
184         IGNLABEL("ReasonStatus13"),
185         IGNLABEL("ReasonStatus14"),
186         IGNLABEL("ReasonStatus15"),
187         IGNLABEL("ReasonStatus16"),
188         IGNLABEL("ReasonStatus17"),
189         IGNLABEL("ReasonStatus18"),
190         IGNLABEL("ReasonStatus19"),
191         "RxMan",
192         "TxMan",
193         "RxRefresh",
194         "TxRefresh",
195         "RxPoll",
196         "TxPoll",
197         "HostRetries",
198         "LostSync-HostReq",
199         "HostTxBytes",
200         "HostRxBytes",
201         "ElapsedUsec",
202         "ElapsedSec",
203         "LostSyncBetterAP",
204         "PrivacyMismatch",
205         "Jammed",
206         "DiscRxNotWepped",
207         "PhyEleMismatch",
208         (char*)-1 };
209 #ifndef RUN_AT
210 #define RUN_AT(x) (jiffies+(x))
211 #endif
212
213
214 /* These variables are for insmod, since it seems that the rates
215    can only be set in setup_card.  Rates should be a comma separated
216    (no spaces) list of rates (up to 8). */
217
218 static int rates[8];
219 static int basic_rate;
220 static char *ssids[3];
221
222 static int io[4];
223 static int irq[4];
224
225 static
226 int maxencrypt /* = 0 */; /* The highest rate that the card can encrypt at.
227                        0 means no limit.  For old cards this was 4 */
228
229 static int auto_wep /* = 0 */; /* If set, it tries to figure out the wep mode */
230 static int aux_bap /* = 0 */; /* Checks to see if the aux ports are needed to read
231                     the bap, needed on some older cards and buses. */
232 static int adhoc;
233
234 static int probe = 1;
235
236 static int proc_uid /* = 0 */;
237
238 static int proc_gid /* = 0 */;
239
240 static int airo_perm = 0555;
241
242 static int proc_perm = 0644;
243
244 MODULE_AUTHOR("Benjamin Reed");
245 MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet \
246 cards.  Direct support for ISA/PCI/MPI cards and support \
247 for PCMCIA when used with airo_cs.");
248 MODULE_LICENSE("Dual BSD/GPL");
249 MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340/350");
250 module_param_array(io, int, NULL, 0);
251 module_param_array(irq, int, NULL, 0);
252 module_param(basic_rate, int, 0);
253 module_param_array(rates, int, NULL, 0);
254 module_param_array(ssids, charp, NULL, 0);
255 module_param(auto_wep, int, 0);
256 MODULE_PARM_DESC(auto_wep, "If non-zero, the driver will keep looping through \
257 the authentication options until an association is made.  The value of \
258 auto_wep is number of the wep keys to check.  A value of 2 will try using \
259 the key at index 0 and index 1.");
260 module_param(aux_bap, int, 0);
261 MODULE_PARM_DESC(aux_bap, "If non-zero, the driver will switch into a mode \
262 than seems to work better for older cards with some older buses.  Before \
263 switching it checks that the switch is needed.");
264 module_param(maxencrypt, int, 0);
265 MODULE_PARM_DESC(maxencrypt, "The maximum speed that the card can do \
266 encryption.  Units are in 512kbs.  Zero (default) means there is no limit. \
267 Older cards used to be limited to 2mbs (4).");
268 module_param(adhoc, int, 0);
269 MODULE_PARM_DESC(adhoc, "If non-zero, the card will start in adhoc mode.");
270 module_param(probe, int, 0);
271 MODULE_PARM_DESC(probe, "If zero, the driver won't start the card.");
272
273 module_param(proc_uid, int, 0);
274 MODULE_PARM_DESC(proc_uid, "The uid that the /proc files will belong to.");
275 module_param(proc_gid, int, 0);
276 MODULE_PARM_DESC(proc_gid, "The gid that the /proc files will belong to.");
277 module_param(airo_perm, int, 0);
278 MODULE_PARM_DESC(airo_perm, "The permission bits of /proc/[driver/]aironet.");
279 module_param(proc_perm, int, 0);
280 MODULE_PARM_DESC(proc_perm, "The permission bits of the files in /proc");
281
282 /* This is a kind of sloppy hack to get this information to OUT4500 and
283    IN4500.  I would be extremely interested in the situation where this
284    doesn't work though!!! */
285 static int do8bitIO /* = 0 */;
286
287 /* Return codes */
288 #define SUCCESS 0
289 #define ERROR -1
290 #define NO_PACKET -2
291
292 /* Commands */
293 #define NOP2            0x0000
294 #define MAC_ENABLE      0x0001
295 #define MAC_DISABLE     0x0002
296 #define CMD_LOSE_SYNC   0x0003 /* Not sure what this does... */
297 #define CMD_SOFTRESET   0x0004
298 #define HOSTSLEEP       0x0005
299 #define CMD_MAGIC_PKT   0x0006
300 #define CMD_SETWAKEMASK 0x0007
301 #define CMD_READCFG     0x0008
302 #define CMD_SETMODE     0x0009
303 #define CMD_ALLOCATETX  0x000a
304 #define CMD_TRANSMIT    0x000b
305 #define CMD_DEALLOCATETX 0x000c
306 #define NOP             0x0010
307 #define CMD_WORKAROUND  0x0011
308 #define CMD_ALLOCATEAUX 0x0020
309 #define CMD_ACCESS      0x0021
310 #define CMD_PCIBAP      0x0022
311 #define CMD_PCIAUX      0x0023
312 #define CMD_ALLOCBUF    0x0028
313 #define CMD_GETTLV      0x0029
314 #define CMD_PUTTLV      0x002a
315 #define CMD_DELTLV      0x002b
316 #define CMD_FINDNEXTTLV 0x002c
317 #define CMD_PSPNODES    0x0030
318 #define CMD_SETCW       0x0031    
319 #define CMD_SETPCF      0x0032    
320 #define CMD_SETPHYREG   0x003e
321 #define CMD_TXTEST      0x003f
322 #define MAC_ENABLETX    0x0101
323 #define CMD_LISTBSS     0x0103
324 #define CMD_SAVECFG     0x0108
325 #define CMD_ENABLEAUX   0x0111
326 #define CMD_WRITERID    0x0121
327 #define CMD_USEPSPNODES 0x0130
328 #define MAC_ENABLERX    0x0201
329
330 /* Command errors */
331 #define ERROR_QUALIF 0x00
332 #define ERROR_ILLCMD 0x01
333 #define ERROR_ILLFMT 0x02
334 #define ERROR_INVFID 0x03
335 #define ERROR_INVRID 0x04
336 #define ERROR_LARGE 0x05
337 #define ERROR_NDISABL 0x06
338 #define ERROR_ALLOCBSY 0x07
339 #define ERROR_NORD 0x0B
340 #define ERROR_NOWR 0x0C
341 #define ERROR_INVFIDTX 0x0D
342 #define ERROR_TESTACT 0x0E
343 #define ERROR_TAGNFND 0x12
344 #define ERROR_DECODE 0x20
345 #define ERROR_DESCUNAV 0x21
346 #define ERROR_BADLEN 0x22
347 #define ERROR_MODE 0x80
348 #define ERROR_HOP 0x81
349 #define ERROR_BINTER 0x82
350 #define ERROR_RXMODE 0x83
351 #define ERROR_MACADDR 0x84
352 #define ERROR_RATES 0x85
353 #define ERROR_ORDER 0x86
354 #define ERROR_SCAN 0x87
355 #define ERROR_AUTH 0x88
356 #define ERROR_PSMODE 0x89
357 #define ERROR_RTYPE 0x8A
358 #define ERROR_DIVER 0x8B
359 #define ERROR_SSID 0x8C
360 #define ERROR_APLIST 0x8D
361 #define ERROR_AUTOWAKE 0x8E
362 #define ERROR_LEAP 0x8F
363
364 /* Registers */
365 #define COMMAND 0x00
366 #define PARAM0 0x02
367 #define PARAM1 0x04
368 #define PARAM2 0x06
369 #define STATUS 0x08
370 #define RESP0 0x0a
371 #define RESP1 0x0c
372 #define RESP2 0x0e
373 #define LINKSTAT 0x10
374 #define SELECT0 0x18
375 #define OFFSET0 0x1c
376 #define RXFID 0x20
377 #define TXALLOCFID 0x22
378 #define TXCOMPLFID 0x24
379 #define DATA0 0x36
380 #define EVSTAT 0x30
381 #define EVINTEN 0x32
382 #define EVACK 0x34
383 #define SWS0 0x28
384 #define SWS1 0x2a
385 #define SWS2 0x2c
386 #define SWS3 0x2e
387 #define AUXPAGE 0x3A
388 #define AUXOFF 0x3C
389 #define AUXDATA 0x3E
390
391 #define FID_TX 1
392 #define FID_RX 2
393 /* Offset into aux memory for descriptors */
394 #define AUX_OFFSET 0x800
395 /* Size of allocated packets */
396 #define PKTSIZE 1840
397 #define RIDSIZE 2048
398 /* Size of the transmit queue */
399 #define MAXTXQ 64
400
401 /* BAP selectors */
402 #define BAP0 0 /* Used for receiving packets */
403 #define BAP1 2 /* Used for xmiting packets and working with RIDS */
404
405 /* Flags */
406 #define COMMAND_BUSY 0x8000
407
408 #define BAP_BUSY 0x8000
409 #define BAP_ERR 0x4000
410 #define BAP_DONE 0x2000
411
412 #define PROMISC 0xffff
413 #define NOPROMISC 0x0000
414
415 #define EV_CMD 0x10
416 #define EV_CLEARCOMMANDBUSY 0x4000
417 #define EV_RX 0x01
418 #define EV_TX 0x02
419 #define EV_TXEXC 0x04
420 #define EV_ALLOC 0x08
421 #define EV_LINK 0x80
422 #define EV_AWAKE 0x100
423 #define EV_TXCPY 0x400
424 #define EV_UNKNOWN 0x800
425 #define EV_MIC 0x1000 /* Message Integrity Check Interrupt */
426 #define EV_AWAKEN 0x2000
427 #define STATUS_INTS (EV_AWAKE|EV_LINK|EV_TXEXC|EV_TX|EV_TXCPY|EV_RX|EV_MIC)
428
429 #ifdef CHECK_UNKNOWN_INTS
430 #define IGNORE_INTS ( EV_CMD | EV_UNKNOWN)
431 #else
432 #define IGNORE_INTS (~STATUS_INTS)
433 #endif
434
435 /* RID TYPES */
436 #define RID_RW 0x20
437
438 /* The RIDs */
439 #define RID_CAPABILITIES 0xFF00
440 #define RID_APINFO     0xFF01
441 #define RID_RADIOINFO  0xFF02
442 #define RID_UNKNOWN3   0xFF03
443 #define RID_RSSI       0xFF04
444 #define RID_CONFIG     0xFF10
445 #define RID_SSID       0xFF11
446 #define RID_APLIST     0xFF12
447 #define RID_DRVNAME    0xFF13
448 #define RID_ETHERENCAP 0xFF14
449 #define RID_WEP_TEMP   0xFF15
450 #define RID_WEP_PERM   0xFF16
451 #define RID_MODULATION 0xFF17
452 #define RID_OPTIONS    0xFF18
453 #define RID_ACTUALCONFIG 0xFF20 /*readonly*/
454 #define RID_FACTORYCONFIG 0xFF21
455 #define RID_UNKNOWN22  0xFF22
456 #define RID_LEAPUSERNAME 0xFF23
457 #define RID_LEAPPASSWORD 0xFF24
458 #define RID_STATUS     0xFF50
459 #define RID_BEACON_HST 0xFF51
460 #define RID_BUSY_HST   0xFF52
461 #define RID_RETRIES_HST 0xFF53
462 #define RID_UNKNOWN54  0xFF54
463 #define RID_UNKNOWN55  0xFF55
464 #define RID_UNKNOWN56  0xFF56
465 #define RID_MIC        0xFF57
466 #define RID_STATS16    0xFF60
467 #define RID_STATS16DELTA 0xFF61
468 #define RID_STATS16DELTACLEAR 0xFF62
469 #define RID_STATS      0xFF68
470 #define RID_STATSDELTA 0xFF69
471 #define RID_STATSDELTACLEAR 0xFF6A
472 #define RID_ECHOTEST_RID 0xFF70
473 #define RID_ECHOTEST_RESULTS 0xFF71
474 #define RID_BSSLISTFIRST 0xFF72
475 #define RID_BSSLISTNEXT  0xFF73
476 #define RID_WPA_BSSLISTFIRST 0xFF74
477 #define RID_WPA_BSSLISTNEXT  0xFF75
478
479 typedef struct {
480         u16 cmd;
481         u16 parm0;
482         u16 parm1;
483         u16 parm2;
484 } Cmd;
485
486 typedef struct {
487         u16 status;
488         u16 rsp0;
489         u16 rsp1;
490         u16 rsp2;
491 } Resp;
492
493 /*
494  * Rids and endian-ness:  The Rids will always be in cpu endian, since
495  * this all the patches from the big-endian guys end up doing that.
496  * so all rid access should use the read/writeXXXRid routines.
497  */
498
499 /* This is redundant for x86 archs, but it seems necessary for ARM */
500 #pragma pack(1)
501
502 /* This structure came from an email sent to me from an engineer at
503    aironet for inclusion into this driver */
504 typedef struct {
505         __le16 len;
506         __le16 kindex;
507         u8 mac[ETH_ALEN];
508         __le16 klen;
509         u8 key[16];
510 } WepKeyRid;
511
512 /* These structures are from the Aironet's PC4500 Developers Manual */
513 typedef struct {
514         __le16 len;
515         u8 ssid[32];
516 } Ssid;
517
518 typedef struct {
519         __le16 len;
520         Ssid ssids[3];
521 } SsidRid;
522
523 typedef struct {
524         __le16 len;
525         __le16 modulation;
526 #define MOD_DEFAULT cpu_to_le16(0)
527 #define MOD_CCK cpu_to_le16(1)
528 #define MOD_MOK cpu_to_le16(2)
529 } ModulationRid;
530
531 typedef struct {
532         __le16 len; /* sizeof(ConfigRid) */
533         __le16 opmode; /* operating mode */
534 #define MODE_STA_IBSS cpu_to_le16(0)
535 #define MODE_STA_ESS cpu_to_le16(1)
536 #define MODE_AP cpu_to_le16(2)
537 #define MODE_AP_RPTR cpu_to_le16(3)
538 #define MODE_CFG_MASK cpu_to_le16(0xff)
539 #define MODE_ETHERNET_HOST cpu_to_le16(0<<8) /* rx payloads converted */
540 #define MODE_LLC_HOST cpu_to_le16(1<<8) /* rx payloads left as is */
541 #define MODE_AIRONET_EXTEND cpu_to_le16(1<<9) /* enable Aironet extenstions */
542 #define MODE_AP_INTERFACE cpu_to_le16(1<<10) /* enable ap interface extensions */
543 #define MODE_ANTENNA_ALIGN cpu_to_le16(1<<11) /* enable antenna alignment */
544 #define MODE_ETHER_LLC cpu_to_le16(1<<12) /* enable ethernet LLC */
545 #define MODE_LEAF_NODE cpu_to_le16(1<<13) /* enable leaf node bridge */
546 #define MODE_CF_POLLABLE cpu_to_le16(1<<14) /* enable CF pollable */
547 #define MODE_MIC cpu_to_le16(1<<15) /* enable MIC */
548         __le16 rmode; /* receive mode */
549 #define RXMODE_BC_MC_ADDR cpu_to_le16(0)
550 #define RXMODE_BC_ADDR cpu_to_le16(1) /* ignore multicasts */
551 #define RXMODE_ADDR cpu_to_le16(2) /* ignore multicast and broadcast */
552 #define RXMODE_RFMON cpu_to_le16(3) /* wireless monitor mode */
553 #define RXMODE_RFMON_ANYBSS cpu_to_le16(4)
554 #define RXMODE_LANMON cpu_to_le16(5) /* lan style monitor -- data packets only */
555 #define RXMODE_MASK cpu_to_le16(255)
556 #define RXMODE_DISABLE_802_3_HEADER cpu_to_le16(1<<8) /* disables 802.3 header on rx */
557 #define RXMODE_FULL_MASK (RXMODE_MASK | RXMODE_DISABLE_802_3_HEADER)
558 #define RXMODE_NORMALIZED_RSSI cpu_to_le16(1<<9) /* return normalized RSSI */
559         __le16 fragThresh;
560         __le16 rtsThres;
561         u8 macAddr[ETH_ALEN];
562         u8 rates[8];
563         __le16 shortRetryLimit;
564         __le16 longRetryLimit;
565         __le16 txLifetime; /* in kusec */
566         __le16 rxLifetime; /* in kusec */
567         __le16 stationary;
568         __le16 ordering;
569         __le16 u16deviceType; /* for overriding device type */
570         __le16 cfpRate;
571         __le16 cfpDuration;
572         __le16 _reserved1[3];
573         /*---------- Scanning/Associating ----------*/
574         __le16 scanMode;
575 #define SCANMODE_ACTIVE cpu_to_le16(0)
576 #define SCANMODE_PASSIVE cpu_to_le16(1)
577 #define SCANMODE_AIROSCAN cpu_to_le16(2)
578         __le16 probeDelay; /* in kusec */
579         __le16 probeEnergyTimeout; /* in kusec */
580         __le16 probeResponseTimeout;
581         __le16 beaconListenTimeout;
582         __le16 joinNetTimeout;
583         __le16 authTimeout;
584         __le16 authType;
585 #define AUTH_OPEN cpu_to_le16(0x1)
586 #define AUTH_ENCRYPT cpu_to_le16(0x101)
587 #define AUTH_SHAREDKEY cpu_to_le16(0x102)
588 #define AUTH_ALLOW_UNENCRYPTED cpu_to_le16(0x200)
589         __le16 associationTimeout;
590         __le16 specifiedApTimeout;
591         __le16 offlineScanInterval;
592         __le16 offlineScanDuration;
593         __le16 linkLossDelay;
594         __le16 maxBeaconLostTime;
595         __le16 refreshInterval;
596 #define DISABLE_REFRESH cpu_to_le16(0xFFFF)
597         __le16 _reserved1a[1];
598         /*---------- Power save operation ----------*/
599         __le16 powerSaveMode;
600 #define POWERSAVE_CAM cpu_to_le16(0)
601 #define POWERSAVE_PSP cpu_to_le16(1)
602 #define POWERSAVE_PSPCAM cpu_to_le16(2)
603         __le16 sleepForDtims;
604         __le16 listenInterval;
605         __le16 fastListenInterval;
606         __le16 listenDecay;
607         __le16 fastListenDelay;
608         __le16 _reserved2[2];
609         /*---------- Ap/Ibss config items ----------*/
610         __le16 beaconPeriod;
611         __le16 atimDuration;
612         __le16 hopPeriod;
613         __le16 channelSet;
614         __le16 channel;
615         __le16 dtimPeriod;
616         __le16 bridgeDistance;
617         __le16 radioID;
618         /*---------- Radio configuration ----------*/
619         __le16 radioType;
620 #define RADIOTYPE_DEFAULT cpu_to_le16(0)
621 #define RADIOTYPE_802_11 cpu_to_le16(1)
622 #define RADIOTYPE_LEGACY cpu_to_le16(2)
623         u8 rxDiversity;
624         u8 txDiversity;
625         __le16 txPower;
626 #define TXPOWER_DEFAULT 0
627         __le16 rssiThreshold;
628 #define RSSI_DEFAULT 0
629         __le16 modulation;
630 #define PREAMBLE_AUTO cpu_to_le16(0)
631 #define PREAMBLE_LONG cpu_to_le16(1)
632 #define PREAMBLE_SHORT cpu_to_le16(2)
633         __le16 preamble;
634         __le16 homeProduct;
635         __le16 radioSpecific;
636         /*---------- Aironet Extensions ----------*/
637         u8 nodeName[16];
638         __le16 arlThreshold;
639         __le16 arlDecay;
640         __le16 arlDelay;
641         __le16 _reserved4[1];
642         /*---------- Aironet Extensions ----------*/
643         u8 magicAction;
644 #define MAGIC_ACTION_STSCHG 1
645 #define MAGIC_ACTION_RESUME 2
646 #define MAGIC_IGNORE_MCAST (1<<8)
647 #define MAGIC_IGNORE_BCAST (1<<9)
648 #define MAGIC_SWITCH_TO_PSP (0<<10)
649 #define MAGIC_STAY_IN_CAM (1<<10)
650         u8 magicControl;
651         __le16 autoWake;
652 } ConfigRid;
653
654 typedef struct {
655         __le16 len;
656         u8 mac[ETH_ALEN];
657         __le16 mode;
658         __le16 errorCode;
659         __le16 sigQuality;
660         __le16 SSIDlen;
661         char SSID[32];
662         char apName[16];
663         u8 bssid[4][ETH_ALEN];
664         __le16 beaconPeriod;
665         __le16 dimPeriod;
666         __le16 atimDuration;
667         __le16 hopPeriod;
668         __le16 channelSet;
669         __le16 channel;
670         __le16 hopsToBackbone;
671         __le16 apTotalLoad;
672         __le16 generatedLoad;
673         __le16 accumulatedArl;
674         __le16 signalQuality;
675         __le16 currentXmitRate;
676         __le16 apDevExtensions;
677         __le16 normalizedSignalStrength;
678         __le16 shortPreamble;
679         u8 apIP[4];
680         u8 noisePercent; /* Noise percent in last second */
681         u8 noisedBm; /* Noise dBm in last second */
682         u8 noiseAvePercent; /* Noise percent in last minute */
683         u8 noiseAvedBm; /* Noise dBm in last minute */
684         u8 noiseMaxPercent; /* Highest noise percent in last minute */
685         u8 noiseMaxdBm; /* Highest noise dbm in last minute */
686         __le16 load;
687         u8 carrier[4];
688         __le16 assocStatus;
689 #define STAT_NOPACKETS 0
690 #define STAT_NOCARRIERSET 10
691 #define STAT_GOTCARRIERSET 11
692 #define STAT_WRONGSSID 20
693 #define STAT_BADCHANNEL 25
694 #define STAT_BADBITRATES 30
695 #define STAT_BADPRIVACY 35
696 #define STAT_APFOUND 40
697 #define STAT_APREJECTED 50
698 #define STAT_AUTHENTICATING 60
699 #define STAT_DEAUTHENTICATED 61
700 #define STAT_AUTHTIMEOUT 62
701 #define STAT_ASSOCIATING 70
702 #define STAT_DEASSOCIATED 71
703 #define STAT_ASSOCTIMEOUT 72
704 #define STAT_NOTAIROAP 73
705 #define STAT_ASSOCIATED 80
706 #define STAT_LEAPING 90
707 #define STAT_LEAPFAILED 91
708 #define STAT_LEAPTIMEDOUT 92
709 #define STAT_LEAPCOMPLETE 93
710 } StatusRid;
711
712 typedef struct {
713         __le16 len;
714         __le16 spacer;
715         __le32 vals[100];
716 } StatsRid;
717
718
719 typedef struct {
720         __le16 len;
721         u8 ap[4][ETH_ALEN];
722 } APListRid;
723
724 typedef struct {
725         __le16 len;
726         char oui[3];
727         char zero;
728         __le16 prodNum;
729         char manName[32];
730         char prodName[16];
731         char prodVer[8];
732         char factoryAddr[ETH_ALEN];
733         char aironetAddr[ETH_ALEN];
734         __le16 radioType;
735         __le16 country;
736         char callid[ETH_ALEN];
737         char supportedRates[8];
738         char rxDiversity;
739         char txDiversity;
740         __le16 txPowerLevels[8];
741         __le16 hardVer;
742         __le16 hardCap;
743         __le16 tempRange;
744         __le16 softVer;
745         __le16 softSubVer;
746         __le16 interfaceVer;
747         __le16 softCap;
748         __le16 bootBlockVer;
749         __le16 requiredHard;
750         __le16 extSoftCap;
751 } CapabilityRid;
752
753
754 /* Only present on firmware >= 5.30.17 */
755 typedef struct {
756   __le16 unknown[4];
757   u8 fixed[12]; /* WLAN management frame */
758   u8 iep[624];
759 } BSSListRidExtra;
760
761 typedef struct {
762   __le16 len;
763   __le16 index; /* First is 0 and 0xffff means end of list */
764 #define RADIO_FH 1 /* Frequency hopping radio type */
765 #define RADIO_DS 2 /* Direct sequence radio type */
766 #define RADIO_TMA 4 /* Proprietary radio used in old cards (2500) */
767   __le16 radioType;
768   u8 bssid[ETH_ALEN]; /* Mac address of the BSS */
769   u8 zero;
770   u8 ssidLen;
771   u8 ssid[32];
772   __le16 dBm;
773 #define CAP_ESS cpu_to_le16(1<<0)
774 #define CAP_IBSS cpu_to_le16(1<<1)
775 #define CAP_PRIVACY cpu_to_le16(1<<4)
776 #define CAP_SHORTHDR cpu_to_le16(1<<5)
777   __le16 cap;
778   __le16 beaconInterval;
779   u8 rates[8]; /* Same as rates for config rid */
780   struct { /* For frequency hopping only */
781     __le16 dwell;
782     u8 hopSet;
783     u8 hopPattern;
784     u8 hopIndex;
785     u8 fill;
786   } fh;
787   __le16 dsChannel;
788   __le16 atimWindow;
789
790   /* Only present on firmware >= 5.30.17 */
791   BSSListRidExtra extra;
792 } BSSListRid;
793
794 typedef struct {
795   BSSListRid bss;
796   struct list_head list;
797 } BSSListElement;
798
799 typedef struct {
800   u8 rssipct;
801   u8 rssidBm;
802 } tdsRssiEntry;
803
804 typedef struct {
805   u16 len;
806   tdsRssiEntry x[256];
807 } tdsRssiRid;
808
809 typedef struct {
810         u16 len;
811         u16 state;
812         u16 multicastValid;
813         u8  multicast[16];
814         u16 unicastValid;
815         u8  unicast[16];
816 } MICRid;
817
818 typedef struct {
819         __be16 typelen;
820
821         union {
822             u8 snap[8];
823             struct {
824                 u8 dsap;
825                 u8 ssap;
826                 u8 control;
827                 u8 orgcode[3];
828                 u8 fieldtype[2];
829             } llc;
830         } u;
831         __be32 mic;
832         __be32 seq;
833 } MICBuffer;
834
835 typedef struct {
836         u8 da[ETH_ALEN];
837         u8 sa[ETH_ALEN];
838 } etherHead;
839
840 #pragma pack()
841
842 #define TXCTL_TXOK (1<<1) /* report if tx is ok */
843 #define TXCTL_TXEX (1<<2) /* report if tx fails */
844 #define TXCTL_802_3 (0<<3) /* 802.3 packet */
845 #define TXCTL_802_11 (1<<3) /* 802.11 mac packet */
846 #define TXCTL_ETHERNET (0<<4) /* payload has ethertype */
847 #define TXCTL_LLC (1<<4) /* payload is llc */
848 #define TXCTL_RELEASE (0<<5) /* release after completion */
849 #define TXCTL_NORELEASE (1<<5) /* on completion returns to host */
850
851 #define BUSY_FID 0x10000
852
853 #ifdef CISCO_EXT
854 #define AIROMAGIC       0xa55a
855 /* Warning : SIOCDEVPRIVATE may disapear during 2.5.X - Jean II */
856 #ifdef SIOCIWFIRSTPRIV
857 #ifdef SIOCDEVPRIVATE
858 #define AIROOLDIOCTL    SIOCDEVPRIVATE
859 #define AIROOLDIDIFC    AIROOLDIOCTL + 1
860 #endif /* SIOCDEVPRIVATE */
861 #else /* SIOCIWFIRSTPRIV */
862 #define SIOCIWFIRSTPRIV SIOCDEVPRIVATE
863 #endif /* SIOCIWFIRSTPRIV */
864 /* This may be wrong. When using the new SIOCIWFIRSTPRIV range, we probably
865  * should use only "GET" ioctls (last bit set to 1). "SET" ioctls are root
866  * only and don't return the modified struct ifreq to the application which
867  * is usually a problem. - Jean II */
868 #define AIROIOCTL       SIOCIWFIRSTPRIV
869 #define AIROIDIFC       AIROIOCTL + 1
870
871 /* Ioctl constants to be used in airo_ioctl.command */
872
873 #define AIROGCAP                0       // Capability rid
874 #define AIROGCFG                1       // USED A LOT
875 #define AIROGSLIST              2       // System ID list
876 #define AIROGVLIST              3       // List of specified AP's
877 #define AIROGDRVNAM             4       //  NOTUSED
878 #define AIROGEHTENC             5       // NOTUSED
879 #define AIROGWEPKTMP            6
880 #define AIROGWEPKNV             7
881 #define AIROGSTAT               8
882 #define AIROGSTATSC32           9
883 #define AIROGSTATSD32           10
884 #define AIROGMICRID             11
885 #define AIROGMICSTATS           12
886 #define AIROGFLAGS              13
887 #define AIROGID                 14
888 #define AIRORRID                15
889 #define AIRORSWVERSION          17
890
891 /* Leave gap of 40 commands after AIROGSTATSD32 for future */
892
893 #define AIROPCAP                AIROGSTATSD32 + 40
894 #define AIROPVLIST              AIROPCAP      + 1
895 #define AIROPSLIST              AIROPVLIST    + 1
896 #define AIROPCFG                AIROPSLIST    + 1
897 #define AIROPSIDS               AIROPCFG      + 1
898 #define AIROPAPLIST             AIROPSIDS     + 1
899 #define AIROPMACON              AIROPAPLIST   + 1       /* Enable mac  */
900 #define AIROPMACOFF             AIROPMACON    + 1       /* Disable mac */
901 #define AIROPSTCLR              AIROPMACOFF   + 1
902 #define AIROPWEPKEY             AIROPSTCLR    + 1
903 #define AIROPWEPKEYNV           AIROPWEPKEY   + 1
904 #define AIROPLEAPPWD            AIROPWEPKEYNV + 1
905 #define AIROPLEAPUSR            AIROPLEAPPWD  + 1
906
907 /* Flash codes */
908
909 #define AIROFLSHRST            AIROPWEPKEYNV  + 40
910 #define AIROFLSHGCHR           AIROFLSHRST    + 1
911 #define AIROFLSHSTFL           AIROFLSHGCHR   + 1
912 #define AIROFLSHPCHR           AIROFLSHSTFL   + 1
913 #define AIROFLPUTBUF           AIROFLSHPCHR   + 1
914 #define AIRORESTART            AIROFLPUTBUF   + 1
915
916 #define FLASHSIZE       32768
917 #define AUXMEMSIZE      (256 * 1024)
918
919 typedef struct aironet_ioctl {
920         unsigned short command;         // What to do
921         unsigned short len;             // Len of data
922         unsigned short ridnum;          // rid number
923         unsigned char __user *data;     // d-data
924 } aironet_ioctl;
925
926 static char swversion[] = "2.1";
927 #endif /* CISCO_EXT */
928
929 #define NUM_MODULES       2
930 #define MIC_MSGLEN_MAX    2400
931 #define EMMH32_MSGLEN_MAX MIC_MSGLEN_MAX
932 #define AIRO_DEF_MTU      2312
933
934 typedef struct {
935         u32   size;            // size
936         u8    enabled;         // MIC enabled or not
937         u32   rxSuccess;       // successful packets received
938         u32   rxIncorrectMIC;  // pkts dropped due to incorrect MIC comparison
939         u32   rxNotMICed;      // pkts dropped due to not being MIC'd
940         u32   rxMICPlummed;    // pkts dropped due to not having a MIC plummed
941         u32   rxWrongSequence; // pkts dropped due to sequence number violation
942         u32   reserve[32];
943 } mic_statistics;
944
945 typedef struct {
946         u32 coeff[((EMMH32_MSGLEN_MAX)+3)>>2];
947         u64 accum;      // accumulated mic, reduced to u32 in final()
948         int position;   // current position (byte offset) in message
949         union {
950                 u8  d8[4];
951                 __be32 d32;
952         } part; // saves partial message word across update() calls
953 } emmh32_context;
954
955 typedef struct {
956         emmh32_context seed;        // Context - the seed
957         u32              rx;        // Received sequence number
958         u32              tx;        // Tx sequence number
959         u32              window;    // Start of window
960         u8               valid;     // Flag to say if context is valid or not
961         u8               key[16];
962 } miccntx;
963
964 typedef struct {
965         miccntx mCtx;           // Multicast context
966         miccntx uCtx;           // Unicast context
967 } mic_module;
968
969 typedef struct {
970         unsigned int  rid: 16;
971         unsigned int  len: 15;
972         unsigned int  valid: 1;
973         dma_addr_t host_addr;
974 } Rid;
975
976 typedef struct {
977         unsigned int  offset: 15;
978         unsigned int  eoc: 1;
979         unsigned int  len: 15;
980         unsigned int  valid: 1;
981         dma_addr_t host_addr;
982 } TxFid;
983
984 struct rx_hdr {
985         __le16 status, len;
986         u8 rssi[2];
987         u8 rate;
988         u8 freq;
989         __le16 tmp[4];
990 } __attribute__ ((packed));
991
992 typedef struct {
993         unsigned int  ctl: 15;
994         unsigned int  rdy: 1;
995         unsigned int  len: 15;
996         unsigned int  valid: 1;
997         dma_addr_t host_addr;
998 } RxFid;
999
1000 /*
1001  * Host receive descriptor
1002  */
1003 typedef struct {
1004         unsigned char __iomem *card_ram_off; /* offset into card memory of the
1005                                                 desc */
1006         RxFid         rx_desc;               /* card receive descriptor */
1007         char          *virtual_host_addr;    /* virtual address of host receive
1008                                                 buffer */
1009         int           pending;
1010 } HostRxDesc;
1011
1012 /*
1013  * Host transmit descriptor
1014  */
1015 typedef struct {
1016         unsigned char __iomem *card_ram_off;         /* offset into card memory of the
1017                                                 desc */
1018         TxFid         tx_desc;               /* card transmit descriptor */
1019         char          *virtual_host_addr;    /* virtual address of host receive
1020                                                 buffer */
1021         int           pending;
1022 } HostTxDesc;
1023
1024 /*
1025  * Host RID descriptor
1026  */
1027 typedef struct {
1028         unsigned char __iomem *card_ram_off;      /* offset into card memory of the
1029                                              descriptor */
1030         Rid           rid_desc;           /* card RID descriptor */
1031         char          *virtual_host_addr; /* virtual address of host receive
1032                                              buffer */
1033 } HostRidDesc;
1034
1035 typedef struct {
1036         u16 sw0;
1037         u16 sw1;
1038         u16 status;
1039         u16 len;
1040 #define HOST_SET (1 << 0)
1041 #define HOST_INT_TX (1 << 1) /* Interrupt on successful TX */
1042 #define HOST_INT_TXERR (1 << 2) /* Interrupt on unseccessful TX */
1043 #define HOST_LCC_PAYLOAD (1 << 4) /* LLC payload, 0 = Ethertype */
1044 #define HOST_DONT_RLSE (1 << 5) /* Don't release buffer when done */
1045 #define HOST_DONT_RETRY (1 << 6) /* Don't retry trasmit */
1046 #define HOST_CLR_AID (1 << 7) /* clear AID failure */
1047 #define HOST_RTS (1 << 9) /* Force RTS use */
1048 #define HOST_SHORT (1 << 10) /* Do short preamble */
1049         u16 ctl;
1050         u16 aid;
1051         u16 retries;
1052         u16 fill;
1053 } TxCtlHdr;
1054
1055 typedef struct {
1056         u16 ctl;
1057         u16 duration;
1058         char addr1[6];
1059         char addr2[6];
1060         char addr3[6];
1061         u16 seq;
1062         char addr4[6];
1063 } WifiHdr;
1064
1065
1066 typedef struct {
1067         TxCtlHdr ctlhdr;
1068         u16 fill1;
1069         u16 fill2;
1070         WifiHdr wifihdr;
1071         u16 gaplen;
1072         u16 status;
1073 } WifiCtlHdr;
1074
1075 static WifiCtlHdr wifictlhdr8023 = {
1076         .ctlhdr = {
1077                 .ctl    = HOST_DONT_RLSE,
1078         }
1079 };
1080
1081 // A few details needed for WEP (Wireless Equivalent Privacy)
1082 #define MAX_KEY_SIZE 13                 // 128 (?) bits
1083 #define MIN_KEY_SIZE  5                 // 40 bits RC4 - WEP
1084 typedef struct wep_key_t {
1085         u16     len;
1086         u8      key[16];        /* 40-bit and 104-bit keys */
1087 } wep_key_t;
1088
1089 /* Backward compatibility */
1090 #ifndef IW_ENCODE_NOKEY
1091 #define IW_ENCODE_NOKEY         0x0800  /* Key is write only, so not present */
1092 #define IW_ENCODE_MODE  (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
1093 #endif /* IW_ENCODE_NOKEY */
1094
1095 /* List of Wireless Handlers (new API) */
1096 static const struct iw_handler_def      airo_handler_def;
1097
1098 static const char version[] = "airo.c 0.6 (Ben Reed & Javier Achirica)";
1099
1100 struct airo_info;
1101
1102 static int get_dec_u16( char *buffer, int *start, int limit );
1103 static void OUT4500( struct airo_info *, u16 register, u16 value );
1104 static unsigned short IN4500( struct airo_info *, u16 register );
1105 static u16 setup_card(struct airo_info*, u8 *mac, int lock);
1106 static int enable_MAC(struct airo_info *ai, int lock);
1107 static void disable_MAC(struct airo_info *ai, int lock);
1108 static void enable_interrupts(struct airo_info*);
1109 static void disable_interrupts(struct airo_info*);
1110 static u16 issuecommand(struct airo_info*, Cmd *pCmd, Resp *pRsp);
1111 static int bap_setup(struct airo_info*, u16 rid, u16 offset, int whichbap);
1112 static int aux_bap_read(struct airo_info*, __le16 *pu16Dst, int bytelen,
1113                         int whichbap);
1114 static int fast_bap_read(struct airo_info*, __le16 *pu16Dst, int bytelen,
1115                          int whichbap);
1116 static int bap_write(struct airo_info*, const __le16 *pu16Src, int bytelen,
1117                      int whichbap);
1118 static int PC4500_accessrid(struct airo_info*, u16 rid, u16 accmd);
1119 static int PC4500_readrid(struct airo_info*, u16 rid, void *pBuf, int len, int lock);
1120 static int PC4500_writerid(struct airo_info*, u16 rid, const void
1121                            *pBuf, int len, int lock);
1122 static int do_writerid( struct airo_info*, u16 rid, const void *rid_data,
1123                         int len, int dummy );
1124 static u16 transmit_allocate(struct airo_info*, int lenPayload, int raw);
1125 static int transmit_802_3_packet(struct airo_info*, int len, char *pPacket);
1126 static int transmit_802_11_packet(struct airo_info*, int len, char *pPacket);
1127
1128 static int mpi_send_packet (struct net_device *dev);
1129 static void mpi_unmap_card(struct pci_dev *pci);
1130 static void mpi_receive_802_3(struct airo_info *ai);
1131 static void mpi_receive_802_11(struct airo_info *ai);
1132 static int waitbusy (struct airo_info *ai);
1133
1134 static irqreturn_t airo_interrupt( int irq, void* dev_id);
1135 static int airo_thread(void *data);
1136 static void timer_func( struct net_device *dev );
1137 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
1138 static struct iw_statistics *airo_get_wireless_stats (struct net_device *dev);
1139 static void airo_read_wireless_stats (struct airo_info *local);
1140 #ifdef CISCO_EXT
1141 static int readrids(struct net_device *dev, aironet_ioctl *comp);
1142 static int writerids(struct net_device *dev, aironet_ioctl *comp);
1143 static int flashcard(struct net_device *dev, aironet_ioctl *comp);
1144 #endif /* CISCO_EXT */
1145 static void micinit(struct airo_info *ai);
1146 static int micsetup(struct airo_info *ai);
1147 static int encapsulate(struct airo_info *ai, etherHead *pPacket, MICBuffer *buffer, int len);
1148 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *pPacket, u16 payLen);
1149
1150 static u8 airo_rssi_to_dbm (tdsRssiEntry *rssi_rid, u8 rssi);
1151 static u8 airo_dbm_to_pct (tdsRssiEntry *rssi_rid, u8 dbm);
1152
1153 static void airo_networks_free(struct airo_info *ai);
1154
1155 struct airo_info {
1156         struct net_device             *dev;
1157         struct list_head              dev_list;
1158         /* Note, we can have MAX_FIDS outstanding.  FIDs are 16-bits, so we
1159            use the high bit to mark whether it is in use. */
1160 #define MAX_FIDS 6
1161 #define MPI_MAX_FIDS 1
1162         int                           fids[MAX_FIDS];
1163         ConfigRid config;
1164         char keyindex; // Used with auto wep
1165         char defindex; // Used with auto wep
1166         struct proc_dir_entry *proc_entry;
1167         spinlock_t aux_lock;
1168 #define FLAG_RADIO_OFF  0       /* User disabling of MAC */
1169 #define FLAG_RADIO_DOWN 1       /* ifup/ifdown disabling of MAC */
1170 #define FLAG_RADIO_MASK 0x03
1171 #define FLAG_ENABLED    2
1172 #define FLAG_ADHOC      3       /* Needed by MIC */
1173 #define FLAG_MIC_CAPABLE 4
1174 #define FLAG_UPDATE_MULTI 5
1175 #define FLAG_UPDATE_UNI 6
1176 #define FLAG_802_11     7
1177 #define FLAG_PROMISC    8       /* IFF_PROMISC 0x100 - include/linux/if.h */
1178 #define FLAG_PENDING_XMIT 9
1179 #define FLAG_PENDING_XMIT11 10
1180 #define FLAG_MPI        11
1181 #define FLAG_REGISTERED 12
1182 #define FLAG_COMMIT     13
1183 #define FLAG_RESET      14
1184 #define FLAG_FLASHING   15
1185 #define FLAG_WPA_CAPABLE        16
1186         unsigned long flags;
1187 #define JOB_DIE 0
1188 #define JOB_XMIT        1
1189 #define JOB_XMIT11      2
1190 #define JOB_STATS       3
1191 #define JOB_PROMISC     4
1192 #define JOB_MIC 5
1193 #define JOB_EVENT       6
1194 #define JOB_AUTOWEP     7
1195 #define JOB_WSTATS      8
1196 #define JOB_SCAN_RESULTS  9
1197         unsigned long jobs;
1198         int (*bap_read)(struct airo_info*, __le16 *pu16Dst, int bytelen,
1199                         int whichbap);
1200         unsigned short *flash;
1201         tdsRssiEntry *rssi;
1202         struct task_struct *list_bss_task;
1203         struct task_struct *airo_thread_task;
1204         struct semaphore sem;
1205         wait_queue_head_t thr_wait;
1206         unsigned long expires;
1207         struct {
1208                 struct sk_buff *skb;
1209                 int fid;
1210         } xmit, xmit11;
1211         struct net_device *wifidev;
1212         struct iw_statistics    wstats;         // wireless stats
1213         unsigned long           scan_timeout;   /* Time scan should be read */
1214         struct iw_spy_data      spy_data;
1215         struct iw_public_data   wireless_data;
1216         /* MIC stuff */
1217         struct crypto_cipher    *tfm;
1218         mic_module              mod[2];
1219         mic_statistics          micstats;
1220         HostRxDesc rxfids[MPI_MAX_FIDS]; // rx/tx/config MPI350 descriptors
1221         HostTxDesc txfids[MPI_MAX_FIDS];
1222         HostRidDesc config_desc;
1223         unsigned long ridbus; // phys addr of config_desc
1224         struct sk_buff_head txq;// tx queue used by mpi350 code
1225         struct pci_dev          *pci;
1226         unsigned char           __iomem *pcimem;
1227         unsigned char           __iomem *pciaux;
1228         unsigned char           *shared;
1229         dma_addr_t              shared_dma;
1230         pm_message_t            power;
1231         SsidRid                 *SSID;
1232         APListRid               *APList;
1233 #define PCI_SHARED_LEN          2*MPI_MAX_FIDS*PKTSIZE+RIDSIZE
1234         char                    proc_name[IFNAMSIZ];
1235
1236         int                     wep_capable;
1237         int                     max_wep_idx;
1238
1239         /* WPA-related stuff */
1240         unsigned int bssListFirst;
1241         unsigned int bssListNext;
1242         unsigned int bssListRidLen;
1243
1244         struct list_head network_list;
1245         struct list_head network_free_list;
1246         BSSListElement *networks;
1247 };
1248
1249 static inline int bap_read(struct airo_info *ai, __le16 *pu16Dst, int bytelen,
1250                            int whichbap)
1251 {
1252         return ai->bap_read(ai, pu16Dst, bytelen, whichbap);
1253 }
1254
1255 static int setup_proc_entry( struct net_device *dev,
1256                              struct airo_info *apriv );
1257 static int takedown_proc_entry( struct net_device *dev,
1258                                 struct airo_info *apriv );
1259
1260 static int cmdreset(struct airo_info *ai);
1261 static int setflashmode (struct airo_info *ai);
1262 static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime);
1263 static int flashputbuf(struct airo_info *ai);
1264 static int flashrestart(struct airo_info *ai,struct net_device *dev);
1265
1266 #define airo_print(type, name, fmt, args...) \
1267         printk(type DRV_NAME "(%s): " fmt "\n", name, ##args)
1268
1269 #define airo_print_info(name, fmt, args...) \
1270         airo_print(KERN_INFO, name, fmt, ##args)
1271
1272 #define airo_print_dbg(name, fmt, args...) \
1273         airo_print(KERN_DEBUG, name, fmt, ##args)
1274
1275 #define airo_print_warn(name, fmt, args...) \
1276         airo_print(KERN_WARNING, name, fmt, ##args)
1277
1278 #define airo_print_err(name, fmt, args...) \
1279         airo_print(KERN_ERR, name, fmt, ##args)
1280
1281 #define AIRO_FLASH(dev) (((struct airo_info *)dev->ml_priv)->flash)
1282
1283 /***********************************************************************
1284  *                              MIC ROUTINES                           *
1285  ***********************************************************************
1286  */
1287
1288 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq);
1289 static void MoveWindow(miccntx *context, u32 micSeq);
1290 static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen,
1291                            struct crypto_cipher *tfm);
1292 static void emmh32_init(emmh32_context *context);
1293 static void emmh32_update(emmh32_context *context, u8 *pOctets, int len);
1294 static void emmh32_final(emmh32_context *context, u8 digest[4]);
1295 static int flashpchar(struct airo_info *ai,int byte,int dwelltime);
1296
1297 /* micinit - Initialize mic seed */
1298
1299 static void micinit(struct airo_info *ai)
1300 {
1301         MICRid mic_rid;
1302
1303         clear_bit(JOB_MIC, &ai->jobs);
1304         PC4500_readrid(ai, RID_MIC, &mic_rid, sizeof(mic_rid), 0);
1305         up(&ai->sem);
1306
1307         ai->micstats.enabled = (mic_rid.state & 0x00FF) ? 1 : 0;
1308
1309         if (ai->micstats.enabled) {
1310                 /* Key must be valid and different */
1311                 if (mic_rid.multicastValid && (!ai->mod[0].mCtx.valid ||
1312                     (memcmp (ai->mod[0].mCtx.key, mic_rid.multicast,
1313                              sizeof(ai->mod[0].mCtx.key)) != 0))) {
1314                         /* Age current mic Context */
1315                         memcpy(&ai->mod[1].mCtx,&ai->mod[0].mCtx,sizeof(miccntx));
1316                         /* Initialize new context */
1317                         memcpy(&ai->mod[0].mCtx.key,mic_rid.multicast,sizeof(mic_rid.multicast));
1318                         ai->mod[0].mCtx.window  = 33; //Window always points to the middle
1319                         ai->mod[0].mCtx.rx      = 0;  //Rx Sequence numbers
1320                         ai->mod[0].mCtx.tx      = 0;  //Tx sequence numbers
1321                         ai->mod[0].mCtx.valid   = 1;  //Key is now valid
1322   
1323                         /* Give key to mic seed */
1324                         emmh32_setseed(&ai->mod[0].mCtx.seed,mic_rid.multicast,sizeof(mic_rid.multicast), ai->tfm);
1325                 }
1326
1327                 /* Key must be valid and different */
1328                 if (mic_rid.unicastValid && (!ai->mod[0].uCtx.valid || 
1329                     (memcmp(ai->mod[0].uCtx.key, mic_rid.unicast,
1330                             sizeof(ai->mod[0].uCtx.key)) != 0))) {
1331                         /* Age current mic Context */
1332                         memcpy(&ai->mod[1].uCtx,&ai->mod[0].uCtx,sizeof(miccntx));
1333                         /* Initialize new context */
1334                         memcpy(&ai->mod[0].uCtx.key,mic_rid.unicast,sizeof(mic_rid.unicast));
1335         
1336                         ai->mod[0].uCtx.window  = 33; //Window always points to the middle
1337                         ai->mod[0].uCtx.rx      = 0;  //Rx Sequence numbers
1338                         ai->mod[0].uCtx.tx      = 0;  //Tx sequence numbers
1339                         ai->mod[0].uCtx.valid   = 1;  //Key is now valid
1340         
1341                         //Give key to mic seed
1342                         emmh32_setseed(&ai->mod[0].uCtx.seed, mic_rid.unicast, sizeof(mic_rid.unicast), ai->tfm);
1343                 }
1344         } else {
1345       /* So next time we have a valid key and mic is enabled, we will update
1346        * the sequence number if the key is the same as before.
1347        */
1348                 ai->mod[0].uCtx.valid = 0;
1349                 ai->mod[0].mCtx.valid = 0;
1350         }
1351 }
1352
1353 /* micsetup - Get ready for business */
1354
1355 static int micsetup(struct airo_info *ai) {
1356         int i;
1357
1358         if (ai->tfm == NULL)
1359                 ai->tfm = crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC);
1360
1361         if (IS_ERR(ai->tfm)) {
1362                 airo_print_err(ai->dev->name, "failed to load transform for AES");
1363                 ai->tfm = NULL;
1364                 return ERROR;
1365         }
1366
1367         for (i=0; i < NUM_MODULES; i++) {
1368                 memset(&ai->mod[i].mCtx,0,sizeof(miccntx));
1369                 memset(&ai->mod[i].uCtx,0,sizeof(miccntx));
1370         }
1371         return SUCCESS;
1372 }
1373
1374 static char micsnap[] = {0xAA,0xAA,0x03,0x00,0x40,0x96,0x00,0x02};
1375
1376 /*===========================================================================
1377  * Description: Mic a packet
1378  *    
1379  *      Inputs: etherHead * pointer to an 802.3 frame
1380  *    
1381  *     Returns: BOOLEAN if successful, otherwise false.
1382  *             PacketTxLen will be updated with the mic'd packets size.
1383  *
1384  *    Caveats: It is assumed that the frame buffer will already
1385  *             be big enough to hold the largets mic message possible.
1386  *            (No memory allocation is done here).
1387  *  
1388  *    Author: sbraneky (10/15/01)
1389  *    Merciless hacks by rwilcher (1/14/02)
1390  */
1391
1392 static int encapsulate(struct airo_info *ai ,etherHead *frame, MICBuffer *mic, int payLen)
1393 {
1394         miccntx   *context;
1395
1396         // Determine correct context
1397         // If not adhoc, always use unicast key
1398
1399         if (test_bit(FLAG_ADHOC, &ai->flags) && (frame->da[0] & 0x1))
1400                 context = &ai->mod[0].mCtx;
1401         else
1402                 context = &ai->mod[0].uCtx;
1403   
1404         if (!context->valid)
1405                 return ERROR;
1406
1407         mic->typelen = htons(payLen + 16); //Length of Mic'd packet
1408
1409         memcpy(&mic->u.snap, micsnap, sizeof(micsnap)); // Add Snap
1410
1411         // Add Tx sequence
1412         mic->seq = htonl(context->tx);
1413         context->tx += 2;
1414
1415         emmh32_init(&context->seed); // Mic the packet
1416         emmh32_update(&context->seed,frame->da,ETH_ALEN * 2); // DA,SA
1417         emmh32_update(&context->seed,(u8*)&mic->typelen,10); // Type/Length and Snap
1418         emmh32_update(&context->seed,(u8*)&mic->seq,sizeof(mic->seq)); //SEQ
1419         emmh32_update(&context->seed,frame->da + ETH_ALEN * 2,payLen); //payload
1420         emmh32_final(&context->seed, (u8*)&mic->mic);
1421
1422         /*    New Type/length ?????????? */
1423         mic->typelen = 0; //Let NIC know it could be an oversized packet
1424         return SUCCESS;
1425 }
1426
1427 typedef enum {
1428     NONE,
1429     NOMIC,
1430     NOMICPLUMMED,
1431     SEQUENCE,
1432     INCORRECTMIC,
1433 } mic_error;
1434
1435 /*===========================================================================
1436  *  Description: Decapsulates a MIC'd packet and returns the 802.3 packet
1437  *               (removes the MIC stuff) if packet is a valid packet.
1438  *      
1439  *       Inputs: etherHead  pointer to the 802.3 packet             
1440  *     
1441  *      Returns: BOOLEAN - TRUE if packet should be dropped otherwise FALSE
1442  *     
1443  *      Author: sbraneky (10/15/01)
1444  *    Merciless hacks by rwilcher (1/14/02)
1445  *---------------------------------------------------------------------------
1446  */
1447
1448 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *eth, u16 payLen)
1449 {
1450         int      i;
1451         u32      micSEQ;
1452         miccntx  *context;
1453         u8       digest[4];
1454         mic_error micError = NONE;
1455
1456         // Check if the packet is a Mic'd packet
1457
1458         if (!ai->micstats.enabled) {
1459                 //No Mic set or Mic OFF but we received a MIC'd packet.
1460                 if (memcmp ((u8*)eth + 14, micsnap, sizeof(micsnap)) == 0) {
1461                         ai->micstats.rxMICPlummed++;
1462                         return ERROR;
1463                 }
1464                 return SUCCESS;
1465         }
1466
1467         if (ntohs(mic->typelen) == 0x888E)
1468                 return SUCCESS;
1469
1470         if (memcmp (mic->u.snap, micsnap, sizeof(micsnap)) != 0) {
1471             // Mic enabled but packet isn't Mic'd
1472                 ai->micstats.rxMICPlummed++;
1473                 return ERROR;
1474         }
1475
1476         micSEQ = ntohl(mic->seq);            //store SEQ as CPU order
1477
1478         //At this point we a have a mic'd packet and mic is enabled
1479         //Now do the mic error checking.
1480
1481         //Receive seq must be odd
1482         if ( (micSEQ & 1) == 0 ) {
1483                 ai->micstats.rxWrongSequence++;
1484                 return ERROR;
1485         }
1486
1487         for (i = 0; i < NUM_MODULES; i++) {
1488                 int mcast = eth->da[0] & 1;
1489                 //Determine proper context 
1490                 context = mcast ? &ai->mod[i].mCtx : &ai->mod[i].uCtx;
1491         
1492                 //Make sure context is valid
1493                 if (!context->valid) {
1494                         if (i == 0)
1495                                 micError = NOMICPLUMMED;
1496                         continue;                
1497                 }
1498                 //DeMic it 
1499
1500                 if (!mic->typelen)
1501                         mic->typelen = htons(payLen + sizeof(MICBuffer) - 2);
1502         
1503                 emmh32_init(&context->seed);
1504                 emmh32_update(&context->seed, eth->da, ETH_ALEN*2); 
1505                 emmh32_update(&context->seed, (u8 *)&mic->typelen, sizeof(mic->typelen)+sizeof(mic->u.snap)); 
1506                 emmh32_update(&context->seed, (u8 *)&mic->seq,sizeof(mic->seq));        
1507                 emmh32_update(&context->seed, eth->da + ETH_ALEN*2,payLen);     
1508                 //Calculate MIC
1509                 emmh32_final(&context->seed, digest);
1510         
1511                 if (memcmp(digest, &mic->mic, 4)) { //Make sure the mics match
1512                   //Invalid Mic
1513                         if (i == 0)
1514                                 micError = INCORRECTMIC;
1515                         continue;
1516                 }
1517
1518                 //Check Sequence number if mics pass
1519                 if (RxSeqValid(ai, context, mcast, micSEQ) == SUCCESS) {
1520                         ai->micstats.rxSuccess++;
1521                         return SUCCESS;
1522                 }
1523                 if (i == 0)
1524                         micError = SEQUENCE;
1525         }
1526
1527         // Update statistics
1528         switch (micError) {
1529                 case NOMICPLUMMED: ai->micstats.rxMICPlummed++;   break;
1530                 case SEQUENCE:    ai->micstats.rxWrongSequence++; break;
1531                 case INCORRECTMIC: ai->micstats.rxIncorrectMIC++; break;
1532                 case NONE:  break;
1533                 case NOMIC: break;
1534         }
1535         return ERROR;
1536 }
1537
1538 /*===========================================================================
1539  * Description:  Checks the Rx Seq number to make sure it is valid
1540  *               and hasn't already been received
1541  *   
1542  *     Inputs: miccntx - mic context to check seq against
1543  *             micSeq  - the Mic seq number
1544  *   
1545  *    Returns: TRUE if valid otherwise FALSE. 
1546  *
1547  *    Author: sbraneky (10/15/01)
1548  *    Merciless hacks by rwilcher (1/14/02)
1549  *---------------------------------------------------------------------------
1550  */
1551
1552 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq)
1553 {
1554         u32 seq,index;
1555
1556         //Allow for the ap being rebooted - if it is then use the next 
1557         //sequence number of the current sequence number - might go backwards
1558
1559         if (mcast) {
1560                 if (test_bit(FLAG_UPDATE_MULTI, &ai->flags)) {
1561                         clear_bit (FLAG_UPDATE_MULTI, &ai->flags);
1562                         context->window = (micSeq > 33) ? micSeq : 33;
1563                         context->rx     = 0;        // Reset rx
1564                 }
1565         } else if (test_bit(FLAG_UPDATE_UNI, &ai->flags)) {
1566                 clear_bit (FLAG_UPDATE_UNI, &ai->flags);
1567                 context->window = (micSeq > 33) ? micSeq : 33; // Move window
1568                 context->rx     = 0;        // Reset rx
1569         }
1570
1571         //Make sequence number relative to START of window
1572         seq = micSeq - (context->window - 33);
1573
1574         //Too old of a SEQ number to check.
1575         if ((s32)seq < 0)
1576                 return ERROR;
1577     
1578         if ( seq > 64 ) {
1579                 //Window is infinite forward
1580                 MoveWindow(context,micSeq);
1581                 return SUCCESS;
1582         }
1583
1584         // We are in the window. Now check the context rx bit to see if it was already sent
1585         seq >>= 1;         //divide by 2 because we only have odd numbers
1586         index = 1 << seq;  //Get an index number
1587
1588         if (!(context->rx & index)) {
1589                 //micSEQ falls inside the window.
1590                 //Add seqence number to the list of received numbers.
1591                 context->rx |= index;
1592
1593                 MoveWindow(context,micSeq);
1594
1595                 return SUCCESS;
1596         }
1597         return ERROR;
1598 }
1599
1600 static void MoveWindow(miccntx *context, u32 micSeq)
1601 {
1602         u32 shift;
1603
1604         //Move window if seq greater than the middle of the window
1605         if (micSeq > context->window) {
1606                 shift = (micSeq - context->window) >> 1;
1607     
1608                     //Shift out old
1609                 if (shift < 32)
1610                         context->rx >>= shift;
1611                 else
1612                         context->rx = 0;
1613
1614                 context->window = micSeq;      //Move window
1615         }
1616 }
1617
1618 /*==============================================*/
1619 /*========== EMMH ROUTINES  ====================*/
1620 /*==============================================*/
1621
1622 /* mic accumulate */
1623 #define MIC_ACCUM(val)  \
1624         context->accum += (u64)(val) * context->coeff[coeff_position++];
1625
1626 static unsigned char aes_counter[16];
1627
1628 /* expand the key to fill the MMH coefficient array */
1629 static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen,
1630                            struct crypto_cipher *tfm)
1631 {
1632   /* take the keying material, expand if necessary, truncate at 16-bytes */
1633   /* run through AES counter mode to generate context->coeff[] */
1634   
1635         int i,j;
1636         u32 counter;
1637         u8 *cipher, plain[16];
1638
1639         crypto_cipher_setkey(tfm, pkey, 16);
1640         counter = 0;
1641         for (i = 0; i < ARRAY_SIZE(context->coeff); ) {
1642                 aes_counter[15] = (u8)(counter >> 0);
1643                 aes_counter[14] = (u8)(counter >> 8);
1644                 aes_counter[13] = (u8)(counter >> 16);
1645                 aes_counter[12] = (u8)(counter >> 24);
1646                 counter++;
1647                 memcpy (plain, aes_counter, 16);
1648                 crypto_cipher_encrypt_one(tfm, plain, plain);
1649                 cipher = plain;
1650                 for (j = 0; (j < 16) && (i < ARRAY_SIZE(context->coeff)); ) {
1651                         context->coeff[i++] = ntohl(*(__be32 *)&cipher[j]);
1652                         j += 4;
1653                 }
1654         }
1655 }
1656
1657 /* prepare for calculation of a new mic */
1658 static void emmh32_init(emmh32_context *context)
1659 {
1660         /* prepare for new mic calculation */
1661         context->accum = 0;
1662         context->position = 0;
1663 }
1664
1665 /* add some bytes to the mic calculation */
1666 static void emmh32_update(emmh32_context *context, u8 *pOctets, int len)
1667 {
1668         int     coeff_position, byte_position;
1669   
1670         if (len == 0) return;
1671   
1672         coeff_position = context->position >> 2;
1673   
1674         /* deal with partial 32-bit word left over from last update */
1675         byte_position = context->position & 3;
1676         if (byte_position) {
1677                 /* have a partial word in part to deal with */
1678                 do {
1679                         if (len == 0) return;
1680                         context->part.d8[byte_position++] = *pOctets++;
1681                         context->position++;
1682                         len--;
1683                 } while (byte_position < 4);
1684                 MIC_ACCUM(ntohl(context->part.d32));
1685         }
1686
1687         /* deal with full 32-bit words */
1688         while (len >= 4) {
1689                 MIC_ACCUM(ntohl(*(__be32 *)pOctets));
1690                 context->position += 4;
1691                 pOctets += 4;
1692                 len -= 4;
1693         }
1694
1695         /* deal with partial 32-bit word that will be left over from this update */
1696         byte_position = 0;
1697         while (len > 0) {
1698                 context->part.d8[byte_position++] = *pOctets++;
1699                 context->position++;
1700                 len--;
1701         }
1702 }
1703
1704 /* mask used to zero empty bytes for final partial word */
1705 static u32 mask32[4] = { 0x00000000L, 0xFF000000L, 0xFFFF0000L, 0xFFFFFF00L };
1706
1707 /* calculate the mic */
1708 static void emmh32_final(emmh32_context *context, u8 digest[4])
1709 {
1710         int     coeff_position, byte_position;
1711         u32     val;
1712   
1713         u64 sum, utmp;
1714         s64 stmp;
1715
1716         coeff_position = context->position >> 2;
1717   
1718         /* deal with partial 32-bit word left over from last update */
1719         byte_position = context->position & 3;
1720         if (byte_position) {
1721                 /* have a partial word in part to deal with */
1722                 val = ntohl(context->part.d32);
1723                 MIC_ACCUM(val & mask32[byte_position]); /* zero empty bytes */
1724         }
1725
1726         /* reduce the accumulated u64 to a 32-bit MIC */
1727         sum = context->accum;
1728         stmp = (sum  & 0xffffffffLL) - ((sum >> 32)  * 15);
1729         utmp = (stmp & 0xffffffffLL) - ((stmp >> 32) * 15);
1730         sum = utmp & 0xffffffffLL;
1731         if (utmp > 0x10000000fLL)
1732                 sum -= 15;
1733
1734         val = (u32)sum;
1735         digest[0] = (val>>24) & 0xFF;
1736         digest[1] = (val>>16) & 0xFF;
1737         digest[2] = (val>>8) & 0xFF;
1738         digest[3] = val & 0xFF;
1739 }
1740
1741 static int readBSSListRid(struct airo_info *ai, int first,
1742                       BSSListRid *list)
1743 {
1744         Cmd cmd;
1745         Resp rsp;
1746
1747         if (first == 1) {
1748                 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
1749                 memset(&cmd, 0, sizeof(cmd));
1750                 cmd.cmd=CMD_LISTBSS;
1751                 if (down_interruptible(&ai->sem))
1752                         return -ERESTARTSYS;
1753                 ai->list_bss_task = current;
1754                 issuecommand(ai, &cmd, &rsp);
1755                 up(&ai->sem);
1756                 /* Let the command take effect */
1757                 schedule_timeout_uninterruptible(3 * HZ);
1758                 ai->list_bss_task = NULL;
1759         }
1760         return PC4500_readrid(ai, first ? ai->bssListFirst : ai->bssListNext,
1761                             list, ai->bssListRidLen, 1);
1762 }
1763
1764 static int readWepKeyRid(struct airo_info *ai, WepKeyRid *wkr, int temp, int lock)
1765 {
1766         return PC4500_readrid(ai, temp ? RID_WEP_TEMP : RID_WEP_PERM,
1767                                 wkr, sizeof(*wkr), lock);
1768 }
1769
1770 static int writeWepKeyRid(struct airo_info *ai, WepKeyRid *wkr, int perm, int lock)
1771 {
1772         int rc;
1773         rc = PC4500_writerid(ai, RID_WEP_TEMP, wkr, sizeof(*wkr), lock);
1774         if (rc!=SUCCESS)
1775                 airo_print_err(ai->dev->name, "WEP_TEMP set %x", rc);
1776         if (perm) {
1777                 rc = PC4500_writerid(ai, RID_WEP_PERM, wkr, sizeof(*wkr), lock);
1778                 if (rc!=SUCCESS)
1779                         airo_print_err(ai->dev->name, "WEP_PERM set %x", rc);
1780         }
1781         return rc;
1782 }
1783
1784 static int readSsidRid(struct airo_info*ai, SsidRid *ssidr)
1785 {
1786         return PC4500_readrid(ai, RID_SSID, ssidr, sizeof(*ssidr), 1);
1787 }
1788
1789 static int writeSsidRid(struct airo_info*ai, SsidRid *pssidr, int lock)
1790 {
1791         return PC4500_writerid(ai, RID_SSID, pssidr, sizeof(*pssidr), lock);
1792 }
1793
1794 static int readConfigRid(struct airo_info *ai, int lock)
1795 {
1796         int rc;
1797         ConfigRid cfg;
1798
1799         if (ai->config.len)
1800                 return SUCCESS;
1801
1802         rc = PC4500_readrid(ai, RID_ACTUALCONFIG, &cfg, sizeof(cfg), lock);
1803         if (rc != SUCCESS)
1804                 return rc;
1805
1806         ai->config = cfg;
1807         return SUCCESS;
1808 }
1809
1810 static inline void checkThrottle(struct airo_info *ai)
1811 {
1812         int i;
1813 /* Old hardware had a limit on encryption speed */
1814         if (ai->config.authType != AUTH_OPEN && maxencrypt) {
1815                 for(i=0; i<8; i++) {
1816                         if (ai->config.rates[i] > maxencrypt) {
1817                                 ai->config.rates[i] = 0;
1818                         }
1819                 }
1820         }
1821 }
1822
1823 static int writeConfigRid(struct airo_info *ai, int lock)
1824 {
1825         ConfigRid cfgr;
1826
1827         if (!test_bit (FLAG_COMMIT, &ai->flags))
1828                 return SUCCESS;
1829
1830         clear_bit (FLAG_COMMIT, &ai->flags);
1831         clear_bit (FLAG_RESET, &ai->flags);
1832         checkThrottle(ai);
1833         cfgr = ai->config;
1834
1835         if ((cfgr.opmode & MODE_CFG_MASK) == MODE_STA_IBSS)
1836                 set_bit(FLAG_ADHOC, &ai->flags);
1837         else
1838                 clear_bit(FLAG_ADHOC, &ai->flags);
1839
1840         return PC4500_writerid( ai, RID_CONFIG, &cfgr, sizeof(cfgr), lock);
1841 }
1842
1843 static int readStatusRid(struct airo_info *ai, StatusRid *statr, int lock)
1844 {
1845         return PC4500_readrid(ai, RID_STATUS, statr, sizeof(*statr), lock);
1846 }
1847
1848 static int readAPListRid(struct airo_info *ai, APListRid *aplr)
1849 {
1850         return PC4500_readrid(ai, RID_APLIST, aplr, sizeof(*aplr), 1);
1851 }
1852
1853 static int writeAPListRid(struct airo_info *ai, APListRid *aplr, int lock)
1854 {
1855         return PC4500_writerid(ai, RID_APLIST, aplr, sizeof(*aplr), lock);
1856 }
1857
1858 static int readCapabilityRid(struct airo_info *ai, CapabilityRid *capr, int lock)
1859 {
1860         return PC4500_readrid(ai, RID_CAPABILITIES, capr, sizeof(*capr), lock);
1861 }
1862
1863 static int readStatsRid(struct airo_info*ai, StatsRid *sr, int rid, int lock)
1864 {
1865         return PC4500_readrid(ai, rid, sr, sizeof(*sr), lock);
1866 }
1867
1868 static void try_auto_wep(struct airo_info *ai)
1869 {
1870         if (auto_wep && !(ai->flags & FLAG_RADIO_DOWN)) {
1871                 ai->expires = RUN_AT(3*HZ);
1872                 wake_up_interruptible(&ai->thr_wait);
1873         }
1874 }
1875
1876 static int airo_open(struct net_device *dev) {
1877         struct airo_info *ai = dev->ml_priv;
1878         int rc = 0;
1879
1880         if (test_bit(FLAG_FLASHING, &ai->flags))
1881                 return -EIO;
1882
1883         /* Make sure the card is configured.
1884          * Wireless Extensions may postpone config changes until the card
1885          * is open (to pipeline changes and speed-up card setup). If
1886          * those changes are not yet commited, do it now - Jean II */
1887         if (test_bit(FLAG_COMMIT, &ai->flags)) {
1888                 disable_MAC(ai, 1);
1889                 writeConfigRid(ai, 1);
1890         }
1891
1892         if (ai->wifidev != dev) {
1893                 clear_bit(JOB_DIE, &ai->jobs);
1894                 ai->airo_thread_task = kthread_run(airo_thread, dev, dev->name);
1895                 if (IS_ERR(ai->airo_thread_task))
1896                         return (int)PTR_ERR(ai->airo_thread_task);
1897
1898                 rc = request_irq(dev->irq, airo_interrupt, IRQF_SHARED,
1899                         dev->name, dev);
1900                 if (rc) {
1901                         airo_print_err(dev->name,
1902                                 "register interrupt %d failed, rc %d",
1903                                 dev->irq, rc);
1904                         set_bit(JOB_DIE, &ai->jobs);
1905                         kthread_stop(ai->airo_thread_task);
1906                         return rc;
1907                 }
1908
1909                 /* Power on the MAC controller (which may have been disabled) */
1910                 clear_bit(FLAG_RADIO_DOWN, &ai->flags);
1911                 enable_interrupts(ai);
1912
1913                 try_auto_wep(ai);
1914         }
1915         enable_MAC(ai, 1);
1916
1917         netif_start_queue(dev);
1918         return 0;
1919 }
1920
1921 static int mpi_start_xmit(struct sk_buff *skb, struct net_device *dev) {
1922         int npacks, pending;
1923         unsigned long flags;
1924         struct airo_info *ai = dev->ml_priv;
1925
1926         if (!skb) {
1927                 airo_print_err(dev->name, "%s: skb == NULL!",__func__);
1928                 return 0;
1929         }
1930         npacks = skb_queue_len (&ai->txq);
1931
1932         if (npacks >= MAXTXQ - 1) {
1933                 netif_stop_queue (dev);
1934                 if (npacks > MAXTXQ) {
1935                         dev->stats.tx_fifo_errors++;
1936                         return 1;
1937                 }
1938                 skb_queue_tail (&ai->txq, skb);
1939                 return 0;
1940         }
1941
1942         spin_lock_irqsave(&ai->aux_lock, flags);
1943         skb_queue_tail (&ai->txq, skb);
1944         pending = test_bit(FLAG_PENDING_XMIT, &ai->flags);
1945         spin_unlock_irqrestore(&ai->aux_lock,flags);
1946         netif_wake_queue (dev);
1947
1948         if (pending == 0) {
1949                 set_bit(FLAG_PENDING_XMIT, &ai->flags);
1950                 mpi_send_packet (dev);
1951         }
1952         return 0;
1953 }
1954
1955 /*
1956  * @mpi_send_packet
1957  *
1958  * Attempt to transmit a packet. Can be called from interrupt
1959  * or transmit . return number of packets we tried to send
1960  */
1961
1962 static int mpi_send_packet (struct net_device *dev)
1963 {
1964         struct sk_buff *skb;
1965         unsigned char *buffer;
1966         s16 len;
1967         __le16 *payloadLen;
1968         struct airo_info *ai = dev->ml_priv;
1969         u8 *sendbuf;
1970
1971         /* get a packet to send */
1972
1973         if ((skb = skb_dequeue(&ai->txq)) == NULL) {
1974                 airo_print_err(dev->name,
1975                         "%s: Dequeue'd zero in send_packet()",
1976                         __func__);
1977                 return 0;
1978         }
1979
1980         /* check min length*/
1981         len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1982         buffer = skb->data;
1983
1984         ai->txfids[0].tx_desc.offset = 0;
1985         ai->txfids[0].tx_desc.valid = 1;
1986         ai->txfids[0].tx_desc.eoc = 1;
1987         ai->txfids[0].tx_desc.len =len+sizeof(WifiHdr);
1988
1989 /*
1990  * Magic, the cards firmware needs a length count (2 bytes) in the host buffer
1991  * right after  TXFID_HDR.The TXFID_HDR contains the status short so payloadlen
1992  * is immediatly after it. ------------------------------------------------
1993  *                         |TXFIDHDR+STATUS|PAYLOADLEN|802.3HDR|PACKETDATA|
1994  *                         ------------------------------------------------
1995  */
1996
1997         memcpy((char *)ai->txfids[0].virtual_host_addr,
1998                 (char *)&wifictlhdr8023, sizeof(wifictlhdr8023));
1999
2000         payloadLen = (__le16 *)(ai->txfids[0].virtual_host_addr +
2001                 sizeof(wifictlhdr8023));
2002         sendbuf = ai->txfids[0].virtual_host_addr +
2003                 sizeof(wifictlhdr8023) + 2 ;
2004
2005         /*
2006          * Firmware automaticly puts 802 header on so
2007          * we don't need to account for it in the length
2008          */
2009         if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
2010                 (ntohs(((__be16 *)buffer)[6]) != 0x888E)) {
2011                 MICBuffer pMic;
2012
2013                 if (encapsulate(ai, (etherHead *)buffer, &pMic, len - sizeof(etherHead)) != SUCCESS)
2014                         return ERROR;
2015
2016                 *payloadLen = cpu_to_le16(len-sizeof(etherHead)+sizeof(pMic));
2017                 ai->txfids[0].tx_desc.len += sizeof(pMic);
2018                 /* copy data into airo dma buffer */
2019                 memcpy (sendbuf, buffer, sizeof(etherHead));
2020                 buffer += sizeof(etherHead);
2021                 sendbuf += sizeof(etherHead);
2022                 memcpy (sendbuf, &pMic, sizeof(pMic));
2023                 sendbuf += sizeof(pMic);
2024                 memcpy (sendbuf, buffer, len - sizeof(etherHead));
2025         } else {
2026                 *payloadLen = cpu_to_le16(len - sizeof(etherHead));
2027
2028                 dev->trans_start = jiffies;
2029
2030                 /* copy data into airo dma buffer */
2031                 memcpy(sendbuf, buffer, len);
2032         }
2033
2034         memcpy_toio(ai->txfids[0].card_ram_off,
2035                 &ai->txfids[0].tx_desc, sizeof(TxFid));
2036
2037         OUT4500(ai, EVACK, 8);
2038
2039         dev_kfree_skb_any(skb);
2040         return 1;
2041 }
2042
2043 static void get_tx_error(struct airo_info *ai, s32 fid)
2044 {
2045         __le16 status;
2046
2047         if (fid < 0)
2048                 status = ((WifiCtlHdr *)ai->txfids[0].virtual_host_addr)->ctlhdr.status;
2049         else {
2050                 if (bap_setup(ai, ai->fids[fid] & 0xffff, 4, BAP0) != SUCCESS)
2051                         return;
2052                 bap_read(ai, &status, 2, BAP0);
2053         }
2054         if (le16_to_cpu(status) & 2) /* Too many retries */
2055                 ai->dev->stats.tx_aborted_errors++;
2056         if (le16_to_cpu(status) & 4) /* Transmit lifetime exceeded */
2057                 ai->dev->stats.tx_heartbeat_errors++;
2058         if (le16_to_cpu(status) & 8) /* Aid fail */
2059                 { }
2060         if (le16_to_cpu(status) & 0x10) /* MAC disabled */
2061                 ai->dev->stats.tx_carrier_errors++;
2062         if (le16_to_cpu(status) & 0x20) /* Association lost */
2063                 { }
2064         /* We produce a TXDROP event only for retry or lifetime
2065          * exceeded, because that's the only status that really mean
2066          * that this particular node went away.
2067          * Other errors means that *we* screwed up. - Jean II */
2068         if ((le16_to_cpu(status) & 2) ||
2069              (le16_to_cpu(status) & 4)) {
2070                 union iwreq_data        wrqu;
2071                 char junk[0x18];
2072
2073                 /* Faster to skip over useless data than to do
2074                  * another bap_setup(). We are at offset 0x6 and
2075                  * need to go to 0x18 and read 6 bytes - Jean II */
2076                 bap_read(ai, (__le16 *) junk, 0x18, BAP0);
2077
2078                 /* Copy 802.11 dest address.
2079                  * We use the 802.11 header because the frame may
2080                  * not be 802.3 or may be mangled...
2081                  * In Ad-Hoc mode, it will be the node address.
2082                  * In managed mode, it will be most likely the AP addr
2083                  * User space will figure out how to convert it to
2084                  * whatever it needs (IP address or else).
2085                  * - Jean II */
2086                 memcpy(wrqu.addr.sa_data, junk + 0x12, ETH_ALEN);
2087                 wrqu.addr.sa_family = ARPHRD_ETHER;
2088
2089                 /* Send event to user space */
2090                 wireless_send_event(ai->dev, IWEVTXDROP, &wrqu, NULL);
2091         }
2092 }
2093
2094 static void airo_end_xmit(struct net_device *dev) {
2095         u16 status;
2096         int i;
2097         struct airo_info *priv = dev->ml_priv;
2098         struct sk_buff *skb = priv->xmit.skb;
2099         int fid = priv->xmit.fid;
2100         u32 *fids = priv->fids;
2101
2102         clear_bit(JOB_XMIT, &priv->jobs);
2103         clear_bit(FLAG_PENDING_XMIT, &priv->flags);
2104         status = transmit_802_3_packet (priv, fids[fid], skb->data);
2105         up(&priv->sem);
2106
2107         i = 0;
2108         if ( status == SUCCESS ) {
2109                 dev->trans_start = jiffies;
2110                 for (; i < MAX_FIDS / 2 && (priv->fids[i] & 0xffff0000); i++);
2111         } else {
2112                 priv->fids[fid] &= 0xffff;
2113                 dev->stats.tx_window_errors++;
2114         }
2115         if (i < MAX_FIDS / 2)
2116                 netif_wake_queue(dev);
2117         dev_kfree_skb(skb);
2118 }
2119
2120 static int airo_start_xmit(struct sk_buff *skb, struct net_device *dev) {
2121         s16 len;
2122         int i, j;
2123         struct airo_info *priv = dev->ml_priv;
2124         u32 *fids = priv->fids;
2125
2126         if ( skb == NULL ) {
2127                 airo_print_err(dev->name, "%s: skb == NULL!", __func__);
2128                 return 0;
2129         }
2130
2131         /* Find a vacant FID */
2132         for( i = 0; i < MAX_FIDS / 2 && (fids[i] & 0xffff0000); i++ );
2133         for( j = i + 1; j < MAX_FIDS / 2 && (fids[j] & 0xffff0000); j++ );
2134
2135         if ( j >= MAX_FIDS / 2 ) {
2136                 netif_stop_queue(dev);
2137
2138                 if (i == MAX_FIDS / 2) {
2139                         dev->stats.tx_fifo_errors++;
2140                         return 1;
2141                 }
2142         }
2143         /* check min length*/
2144         len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2145         /* Mark fid as used & save length for later */
2146         fids[i] |= (len << 16);
2147         priv->xmit.skb = skb;
2148         priv->xmit.fid = i;
2149         if (down_trylock(&priv->sem) != 0) {
2150                 set_bit(FLAG_PENDING_XMIT, &priv->flags);
2151                 netif_stop_queue(dev);
2152                 set_bit(JOB_XMIT, &priv->jobs);
2153                 wake_up_interruptible(&priv->thr_wait);
2154         } else
2155                 airo_end_xmit(dev);
2156         return 0;
2157 }
2158
2159 static void airo_end_xmit11(struct net_device *dev) {
2160         u16 status;
2161         int i;
2162         struct airo_info *priv = dev->ml_priv;
2163         struct sk_buff *skb = priv->xmit11.skb;
2164         int fid = priv->xmit11.fid;
2165         u32 *fids = priv->fids;
2166
2167         clear_bit(JOB_XMIT11, &priv->jobs);
2168         clear_bit(FLAG_PENDING_XMIT11, &priv->flags);
2169         status = transmit_802_11_packet (priv, fids[fid], skb->data);
2170         up(&priv->sem);
2171
2172         i = MAX_FIDS / 2;
2173         if ( status == SUCCESS ) {
2174                 dev->trans_start = jiffies;
2175                 for (; i < MAX_FIDS && (priv->fids[i] & 0xffff0000); i++);
2176         } else {
2177                 priv->fids[fid] &= 0xffff;
2178                 dev->stats.tx_window_errors++;
2179         }
2180         if (i < MAX_FIDS)
2181                 netif_wake_queue(dev);
2182         dev_kfree_skb(skb);
2183 }
2184
2185 static int airo_start_xmit11(struct sk_buff *skb, struct net_device *dev) {
2186         s16 len;
2187         int i, j;
2188         struct airo_info *priv = dev->ml_priv;
2189         u32 *fids = priv->fids;
2190
2191         if (test_bit(FLAG_MPI, &priv->flags)) {
2192                 /* Not implemented yet for MPI350 */
2193                 netif_stop_queue(dev);
2194                 return -ENETDOWN;
2195         }
2196
2197         if ( skb == NULL ) {
2198                 airo_print_err(dev->name, "%s: skb == NULL!", __func__);
2199                 return 0;
2200         }
2201
2202         /* Find a vacant FID */
2203         for( i = MAX_FIDS / 2; i < MAX_FIDS && (fids[i] & 0xffff0000); i++ );
2204         for( j = i + 1; j < MAX_FIDS && (fids[j] & 0xffff0000); j++ );
2205
2206         if ( j >= MAX_FIDS ) {
2207                 netif_stop_queue(dev);
2208
2209                 if (i == MAX_FIDS) {
2210                         dev->stats.tx_fifo_errors++;
2211                         return 1;
2212                 }
2213         }
2214         /* check min length*/
2215         len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2216         /* Mark fid as used & save length for later */
2217         fids[i] |= (len << 16);
2218         priv->xmit11.skb = skb;
2219         priv->xmit11.fid = i;
2220         if (down_trylock(&priv->sem) != 0) {
2221                 set_bit(FLAG_PENDING_XMIT11, &priv->flags);
2222                 netif_stop_queue(dev);
2223                 set_bit(JOB_XMIT11, &priv->jobs);
2224                 wake_up_interruptible(&priv->thr_wait);
2225         } else
2226                 airo_end_xmit11(dev);
2227         return 0;
2228 }
2229
2230 static void airo_read_stats(struct net_device *dev)
2231 {
2232         struct airo_info *ai = dev->ml_priv;
2233         StatsRid stats_rid;
2234         __le32 *vals = stats_rid.vals;
2235
2236         clear_bit(JOB_STATS, &ai->jobs);
2237         if (ai->power.event) {
2238                 up(&ai->sem);
2239                 return;
2240         }
2241         readStatsRid(ai, &stats_rid, RID_STATS, 0);
2242         up(&ai->sem);
2243
2244         dev->stats.rx_packets = le32_to_cpu(vals[43]) + le32_to_cpu(vals[44]) +
2245                                le32_to_cpu(vals[45]);
2246         dev->stats.tx_packets = le32_to_cpu(vals[39]) + le32_to_cpu(vals[40]) +
2247                                le32_to_cpu(vals[41]);
2248         dev->stats.rx_bytes = le32_to_cpu(vals[92]);
2249         dev->stats.tx_bytes = le32_to_cpu(vals[91]);
2250         dev->stats.rx_errors = le32_to_cpu(vals[0]) + le32_to_cpu(vals[2]) +
2251                               le32_to_cpu(vals[3]) + le32_to_cpu(vals[4]);
2252         dev->stats.tx_errors = le32_to_cpu(vals[42]) +
2253                               dev->stats.tx_fifo_errors;
2254         dev->stats.multicast = le32_to_cpu(vals[43]);
2255         dev->stats.collisions = le32_to_cpu(vals[89]);
2256
2257         /* detailed rx_errors: */
2258         dev->stats.rx_length_errors = le32_to_cpu(vals[3]);
2259         dev->stats.rx_crc_errors = le32_to_cpu(vals[4]);
2260         dev->stats.rx_frame_errors = le32_to_cpu(vals[2]);
2261         dev->stats.rx_fifo_errors = le32_to_cpu(vals[0]);
2262 }
2263
2264 static struct net_device_stats *airo_get_stats(struct net_device *dev)
2265 {
2266         struct airo_info *local =  dev->ml_priv;
2267
2268         if (!test_bit(JOB_STATS, &local->jobs)) {
2269                 /* Get stats out of the card if available */
2270                 if (down_trylock(&local->sem) != 0) {
2271                         set_bit(JOB_STATS, &local->jobs);
2272                         wake_up_interruptible(&local->thr_wait);
2273                 } else
2274                         airo_read_stats(dev);
2275         }
2276
2277         return &dev->stats;
2278 }
2279
2280 static void airo_set_promisc(struct airo_info *ai) {
2281         Cmd cmd;
2282         Resp rsp;
2283
2284         memset(&cmd, 0, sizeof(cmd));
2285         cmd.cmd=CMD_SETMODE;
2286         clear_bit(JOB_PROMISC, &ai->jobs);
2287         cmd.parm0=(ai->flags&IFF_PROMISC) ? PROMISC : NOPROMISC;
2288         issuecommand(ai, &cmd, &rsp);
2289         up(&ai->sem);
2290 }
2291
2292 static void airo_set_multicast_list(struct net_device *dev) {
2293         struct airo_info *ai = dev->ml_priv;
2294
2295         if ((dev->flags ^ ai->flags) & IFF_PROMISC) {
2296                 change_bit(FLAG_PROMISC, &ai->flags);
2297                 if (down_trylock(&ai->sem) != 0) {
2298                         set_bit(JOB_PROMISC, &ai->jobs);
2299                         wake_up_interruptible(&ai->thr_wait);
2300                 } else
2301                         airo_set_promisc(ai);
2302         }
2303
2304         if ((dev->flags&IFF_ALLMULTI)||dev->mc_count>0) {
2305                 /* Turn on multicast.  (Should be already setup...) */
2306         }
2307 }
2308
2309 static int airo_set_mac_address(struct net_device *dev, void *p)
2310 {
2311         struct airo_info *ai = dev->ml_priv;
2312         struct sockaddr *addr = p;
2313
2314         readConfigRid(ai, 1);
2315         memcpy (ai->config.macAddr, addr->sa_data, dev->addr_len);
2316         set_bit (FLAG_COMMIT, &ai->flags);
2317         disable_MAC(ai, 1);
2318         writeConfigRid (ai, 1);
2319         enable_MAC(ai, 1);
2320         memcpy (ai->dev->dev_addr, addr->sa_data, dev->addr_len);
2321         if (ai->wifidev)
2322                 memcpy (ai->wifidev->dev_addr, addr->sa_data, dev->addr_len);
2323         return 0;
2324 }
2325
2326 static int airo_change_mtu(struct net_device *dev, int new_mtu)
2327 {
2328         if ((new_mtu < 68) || (new_mtu > 2400))
2329                 return -EINVAL;
2330         dev->mtu = new_mtu;
2331         return 0;
2332 }
2333
2334 static LIST_HEAD(airo_devices);
2335
2336 static void add_airo_dev(struct airo_info *ai)
2337 {
2338         /* Upper layers already keep track of PCI devices,
2339          * so we only need to remember our non-PCI cards. */
2340         if (!ai->pci)
2341                 list_add_tail(&ai->dev_list, &airo_devices);
2342 }
2343
2344 static void del_airo_dev(struct airo_info *ai)
2345 {
2346         if (!ai->pci)
2347                 list_del(&ai->dev_list);
2348 }
2349
2350 static int airo_close(struct net_device *dev) {
2351         struct airo_info *ai = dev->ml_priv;
2352
2353         netif_stop_queue(dev);
2354
2355         if (ai->wifidev != dev) {
2356 #ifdef POWER_ON_DOWN
2357                 /* Shut power to the card. The idea is that the user can save
2358                  * power when he doesn't need the card with "ifconfig down".
2359                  * That's the method that is most friendly towards the network
2360                  * stack (i.e. the network stack won't try to broadcast
2361                  * anything on the interface and routes are gone. Jean II */
2362                 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2363                 disable_MAC(ai, 1);
2364 #endif
2365                 disable_interrupts( ai );
2366
2367                 free_irq(dev->irq, dev);
2368
2369                 set_bit(JOB_DIE, &ai->jobs);
2370                 kthread_stop(ai->airo_thread_task);
2371         }
2372         return 0;
2373 }
2374
2375 void stop_airo_card( struct net_device *dev, int freeres )
2376 {
2377         struct airo_info *ai = dev->ml_priv;
2378
2379         set_bit(FLAG_RADIO_DOWN, &ai->flags);
2380         disable_MAC(ai, 1);
2381         disable_interrupts(ai);
2382         takedown_proc_entry( dev, ai );
2383         if (test_bit(FLAG_REGISTERED, &ai->flags)) {
2384                 unregister_netdev( dev );
2385                 if (ai->wifidev) {
2386                         unregister_netdev(ai->wifidev);
2387                         free_netdev(ai->wifidev);
2388                         ai->wifidev = NULL;
2389                 }
2390                 clear_bit(FLAG_REGISTERED, &ai->flags);
2391         }
2392         /*
2393          * Clean out tx queue
2394          */
2395         if (test_bit(FLAG_MPI, &ai->flags) && !skb_queue_empty(&ai->txq)) {
2396                 struct sk_buff *skb = NULL;
2397                 for (;(skb = skb_dequeue(&ai->txq));)
2398                         dev_kfree_skb(skb);
2399         }
2400
2401         airo_networks_free (ai);
2402
2403         kfree(ai->flash);
2404         kfree(ai->rssi);
2405         kfree(ai->APList);
2406         kfree(ai->SSID);
2407         if (freeres) {
2408                 /* PCMCIA frees this stuff, so only for PCI and ISA */
2409                 release_region( dev->base_addr, 64 );
2410                 if (test_bit(FLAG_MPI, &ai->flags)) {
2411                         if (ai->pci)
2412                                 mpi_unmap_card(ai->pci);
2413                         if (ai->pcimem)
2414                                 iounmap(ai->pcimem);
2415                         if (ai->pciaux)
2416                                 iounmap(ai->pciaux);
2417                         pci_free_consistent(ai->pci, PCI_SHARED_LEN,
2418                                 ai->shared, ai->shared_dma);
2419                 }
2420         }
2421         crypto_free_cipher(ai->tfm);
2422         del_airo_dev(ai);
2423         free_netdev( dev );
2424 }
2425
2426 EXPORT_SYMBOL(stop_airo_card);
2427
2428 static int wll_header_parse(const struct sk_buff *skb, unsigned char *haddr)
2429 {
2430         memcpy(haddr, skb_mac_header(skb) + 10, ETH_ALEN);
2431         return ETH_ALEN;
2432 }
2433
2434 static void mpi_unmap_card(struct pci_dev *pci)
2435 {
2436         unsigned long mem_start = pci_resource_start(pci, 1);
2437         unsigned long mem_len = pci_resource_len(pci, 1);
2438         unsigned long aux_start = pci_resource_start(pci, 2);
2439         unsigned long aux_len = AUXMEMSIZE;
2440
2441         release_mem_region(aux_start, aux_len);
2442         release_mem_region(mem_start, mem_len);
2443 }
2444
2445 /*************************************************************
2446  *  This routine assumes that descriptors have been setup .
2447  *  Run at insmod time or after reset  when the decriptors
2448  *  have been initialized . Returns 0 if all is well nz
2449  *  otherwise . Does not allocate memory but sets up card
2450  *  using previously allocated descriptors.
2451  */
2452 static int mpi_init_descriptors (struct airo_info *ai)
2453 {
2454         Cmd cmd;
2455         Resp rsp;
2456         int i;
2457         int rc = SUCCESS;
2458
2459         /* Alloc  card RX descriptors */
2460         netif_stop_queue(ai->dev);
2461
2462         memset(&rsp,0,sizeof(rsp));
2463         memset(&cmd,0,sizeof(cmd));
2464
2465         cmd.cmd = CMD_ALLOCATEAUX;
2466         cmd.parm0 = FID_RX;
2467         cmd.parm1 = (ai->rxfids[0].card_ram_off - ai->pciaux);
2468         cmd.parm2 = MPI_MAX_FIDS;
2469         rc=issuecommand(ai, &cmd, &rsp);
2470         if (rc != SUCCESS) {
2471                 airo_print_err(ai->dev->name, "Couldn't allocate RX FID");
2472                 return rc;
2473         }
2474
2475         for (i=0; i<MPI_MAX_FIDS; i++) {
2476                 memcpy_toio(ai->rxfids[i].card_ram_off,
2477                         &ai->rxfids[i].rx_desc, sizeof(RxFid));
2478         }
2479
2480         /* Alloc card TX descriptors */
2481
2482         memset(&rsp,0,sizeof(rsp));
2483         memset(&cmd,0,sizeof(cmd));
2484
2485         cmd.cmd = CMD_ALLOCATEAUX;
2486         cmd.parm0 = FID_TX;
2487         cmd.parm1 = (ai->txfids[0].card_ram_off - ai->pciaux);
2488         cmd.parm2 = MPI_MAX_FIDS;
2489
2490         for (i=0; i<MPI_MAX_FIDS; i++) {
2491                 ai->txfids[i].tx_desc.valid = 1;
2492                 memcpy_toio(ai->txfids[i].card_ram_off,
2493                         &ai->txfids[i].tx_desc, sizeof(TxFid));
2494         }
2495         ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2496
2497         rc=issuecommand(ai, &cmd, &rsp);
2498         if (rc != SUCCESS) {
2499                 airo_print_err(ai->dev->name, "Couldn't allocate TX FID");
2500                 return rc;
2501         }
2502
2503         /* Alloc card Rid descriptor */
2504         memset(&rsp,0,sizeof(rsp));
2505         memset(&cmd,0,sizeof(cmd));
2506
2507         cmd.cmd = CMD_ALLOCATEAUX;
2508         cmd.parm0 = RID_RW;
2509         cmd.parm1 = (ai->config_desc.card_ram_off - ai->pciaux);
2510         cmd.parm2 = 1; /* Magic number... */
2511         rc=issuecommand(ai, &cmd, &rsp);
2512         if (rc != SUCCESS) {
2513                 airo_print_err(ai->dev->name, "Couldn't allocate RID");
2514                 return rc;
2515         }
2516
2517         memcpy_toio(ai->config_desc.card_ram_off,
2518                 &ai->config_desc.rid_desc, sizeof(Rid));
2519
2520         return rc;
2521 }
2522
2523 /*
2524  * We are setting up three things here:
2525  * 1) Map AUX memory for descriptors: Rid, TxFid, or RxFid.
2526  * 2) Map PCI memory for issueing commands.
2527  * 3) Allocate memory (shared) to send and receive ethernet frames.
2528  */
2529 static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci)
2530 {
2531         unsigned long mem_start, mem_len, aux_start, aux_len;
2532         int rc = -1;
2533         int i;
2534         dma_addr_t busaddroff;
2535         unsigned char *vpackoff;
2536         unsigned char __iomem *pciaddroff;
2537
2538         mem_start = pci_resource_start(pci, 1);
2539         mem_len = pci_resource_len(pci, 1);
2540         aux_start = pci_resource_start(pci, 2);
2541         aux_len = AUXMEMSIZE;
2542
2543         if (!request_mem_region(mem_start, mem_len, DRV_NAME)) {
2544                 airo_print_err("", "Couldn't get region %x[%x]",
2545                         (int)mem_start, (int)mem_len);
2546                 goto out;
2547         }
2548         if (!request_mem_region(aux_start, aux_len, DRV_NAME)) {
2549                 airo_print_err("", "Couldn't get region %x[%x]",
2550                         (int)aux_start, (int)aux_len);
2551                 goto free_region1;
2552         }
2553
2554         ai->pcimem = ioremap(mem_start, mem_len);
2555         if (!ai->pcimem) {
2556                 airo_print_err("", "Couldn't map region %x[%x]",
2557                         (int)mem_start, (int)mem_len);
2558                 goto free_region2;
2559         }
2560         ai->pciaux = ioremap(aux_start, aux_len);
2561         if (!ai->pciaux) {
2562                 airo_print_err("", "Couldn't map region %x[%x]",
2563                         (int)aux_start, (int)aux_len);
2564                 goto free_memmap;
2565         }
2566
2567         /* Reserve PKTSIZE for each fid and 2K for the Rids */
2568         ai->shared = pci_alloc_consistent(pci, PCI_SHARED_LEN, &ai->shared_dma);
2569         if (!ai->shared) {
2570                 airo_print_err("", "Couldn't alloc_consistent %d",
2571                         PCI_SHARED_LEN);
2572                 goto free_auxmap;
2573         }
2574
2575         /*
2576          * Setup descriptor RX, TX, CONFIG
2577          */
2578         busaddroff = ai->shared_dma;
2579         pciaddroff = ai->pciaux + AUX_OFFSET;
2580         vpackoff   = ai->shared;
2581
2582         /* RX descriptor setup */
2583         for(i = 0; i < MPI_MAX_FIDS; i++) {
2584                 ai->rxfids[i].pending = 0;
2585                 ai->rxfids[i].card_ram_off = pciaddroff;
2586                 ai->rxfids[i].virtual_host_addr = vpackoff;
2587                 ai->rxfids[i].rx_desc.host_addr = busaddroff;
2588                 ai->rxfids[i].rx_desc.valid = 1;
2589                 ai->rxfids[i].rx_desc.len = PKTSIZE;
2590                 ai->rxfids[i].rx_desc.rdy = 0;
2591
2592                 pciaddroff += sizeof(RxFid);
2593                 busaddroff += PKTSIZE;
2594                 vpackoff   += PKTSIZE;
2595         }
2596
2597         /* TX descriptor setup */
2598         for(i = 0; i < MPI_MAX_FIDS; i++) {
2599                 ai->txfids[i].card_ram_off = pciaddroff;
2600                 ai->txfids[i].virtual_host_addr = vpackoff;
2601                 ai->txfids[i].tx_desc.valid = 1;
2602                 ai->txfids[i].tx_desc.host_addr = busaddroff;
2603                 memcpy(ai->txfids[i].virtual_host_addr,
2604                         &wifictlhdr8023, sizeof(wifictlhdr8023));
2605
2606                 pciaddroff += sizeof(TxFid);
2607                 busaddroff += PKTSIZE;
2608                 vpackoff   += PKTSIZE;
2609         }
2610         ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2611
2612         /* Rid descriptor setup */
2613         ai->config_desc.card_ram_off = pciaddroff;
2614         ai->config_desc.virtual_host_addr = vpackoff;
2615         ai->config_desc.rid_desc.host_addr = busaddroff;
2616         ai->ridbus = busaddroff;
2617         ai->config_desc.rid_desc.rid = 0;
2618         ai->config_desc.rid_desc.len = RIDSIZE;
2619         ai->config_desc.rid_desc.valid = 1;
2620         pciaddroff += sizeof(Rid);
2621         busaddroff += RIDSIZE;
2622         vpackoff   += RIDSIZE;
2623
2624         /* Tell card about descriptors */
2625         if (mpi_init_descriptors (ai) != SUCCESS)
2626                 goto free_shared;
2627
2628         return 0;
2629  free_shared:
2630         pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2631  free_auxmap:
2632         iounmap(ai->pciaux);
2633  free_memmap:
2634         iounmap(ai->pcimem);
2635  free_region2:
2636         release_mem_region(aux_start, aux_len);
2637  free_region1:
2638         release_mem_region(mem_start, mem_len);
2639  out:
2640         return rc;
2641 }
2642
2643 static const struct header_ops airo_header_ops = {
2644         .parse = wll_header_parse,
2645 };
2646
2647 static void wifi_setup(struct net_device *dev)
2648 {
2649         dev->header_ops = &airo_header_ops;
2650         dev->hard_start_xmit = &airo_start_xmit11;
2651         dev->get_stats = &airo_get_stats;
2652         dev->set_mac_address = &airo_set_mac_address;
2653         dev->do_ioctl = &airo_ioctl;
2654         dev->wireless_handlers = &airo_handler_def;
2655         dev->change_mtu = &airo_change_mtu;
2656         dev->open = &airo_open;
2657         dev->stop = &airo_close;
2658
2659         dev->type               = ARPHRD_IEEE80211;
2660         dev->hard_header_len    = ETH_HLEN;
2661         dev->mtu                = AIRO_DEF_MTU;
2662         dev->addr_len           = ETH_ALEN;
2663         dev->tx_queue_len       = 100; 
2664
2665         memset(dev->broadcast,0xFF, ETH_ALEN);
2666
2667         dev->flags              = IFF_BROADCAST|IFF_MULTICAST;
2668 }
2669
2670 static struct net_device *init_wifidev(struct airo_info *ai,
2671                                         struct net_device *ethdev)
2672 {
2673         int err;
2674         struct net_device *dev = alloc_netdev(0, "wifi%d", wifi_setup);
2675         if (!dev)
2676                 return NULL;
2677         dev->ml_priv = ethdev->ml_priv;
2678         dev->irq = ethdev->irq;
2679         dev->base_addr = ethdev->base_addr;
2680         dev->wireless_data = ethdev->wireless_data;
2681         SET_NETDEV_DEV(dev, ethdev->dev.parent);
2682         memcpy(dev->dev_addr, ethdev->dev_addr, dev->addr_len);
2683         err = register_netdev(dev);
2684         if (err<0) {
2685                 free_netdev(dev);
2686                 return NULL;
2687         }
2688         return dev;
2689 }
2690
2691 static int reset_card( struct net_device *dev , int lock) {
2692         struct airo_info *ai = dev->ml_priv;
2693
2694         if (lock && down_interruptible(&ai->sem))
2695                 return -1;
2696         waitbusy (ai);
2697         OUT4500(ai,COMMAND,CMD_SOFTRESET);
2698         msleep(200);
2699         waitbusy (ai);
2700         msleep(200);
2701         if (lock)
2702                 up(&ai->sem);
2703         return 0;
2704 }
2705
2706 #define AIRO_MAX_NETWORK_COUNT  64
2707 static int airo_networks_allocate(struct airo_info *ai)
2708 {
2709         if (ai->networks)
2710                 return 0;
2711
2712         ai->networks =
2713             kzalloc(AIRO_MAX_NETWORK_COUNT * sizeof(BSSListElement),
2714                     GFP_KERNEL);
2715         if (!ai->networks) {
2716                 airo_print_warn("", "Out of memory allocating beacons");
2717                 return -ENOMEM;
2718         }
2719
2720         return 0;
2721 }
2722
2723 static void airo_networks_free(struct airo_info *ai)
2724 {
2725         kfree(ai->networks);
2726         ai->networks = NULL;
2727 }
2728
2729 static void airo_networks_initialize(struct airo_info *ai)
2730 {
2731         int i;
2732
2733         INIT_LIST_HEAD(&ai->network_free_list);
2734         INIT_LIST_HEAD(&ai->network_list);
2735         for (i = 0; i < AIRO_MAX_NETWORK_COUNT; i++)
2736                 list_add_tail(&ai->networks[i].list,
2737                               &ai->network_free_list);
2738 }
2739
2740 static struct net_device *_init_airo_card( unsigned short irq, int port,
2741                                            int is_pcmcia, struct pci_dev *pci,
2742                                            struct device *dmdev )
2743 {
2744         struct net_device *dev;
2745         struct airo_info *ai;
2746         int i, rc;
2747         CapabilityRid cap_rid;
2748
2749         /* Create the network device object. */
2750         dev = alloc_netdev(sizeof(*ai), "", ether_setup);
2751         if (!dev) {
2752                 airo_print_err("", "Couldn't alloc_etherdev");
2753                 return NULL;
2754         }
2755
2756         ai = dev->ml_priv = netdev_priv(dev);
2757         ai->wifidev = NULL;
2758         ai->flags = 1 << FLAG_RADIO_DOWN;
2759         ai->jobs = 0;
2760         ai->dev = dev;
2761         if (pci && (pci->device == 0x5000 || pci->device == 0xa504)) {
2762                 airo_print_dbg("", "Found an MPI350 card");
2763                 set_bit(FLAG_MPI, &ai->flags);
2764         }
2765         spin_lock_init(&ai->aux_lock);
2766         sema_init(&ai->sem, 1);
2767         ai->config.len = 0;
2768         ai->pci = pci;
2769         init_waitqueue_head (&ai->thr_wait);
2770         ai->tfm = NULL;
2771         add_airo_dev(ai);
2772
2773         if (airo_networks_allocate (ai))
2774                 goto err_out_free;
2775         airo_networks_initialize (ai);
2776
2777         /* The Airo-specific entries in the device structure. */
2778         if (test_bit(FLAG_MPI,&ai->flags)) {
2779                 skb_queue_head_init (&ai->txq);
2780                 dev->hard_start_xmit = &mpi_start_xmit;
2781         } else
2782                 dev->hard_start_xmit = &airo_start_xmit;
2783         dev->get_stats = &airo_get_stats;
2784         dev->set_multicast_list = &airo_set_multicast_list;
2785         dev->set_mac_address = &airo_set_mac_address;
2786         dev->do_ioctl = &airo_ioctl;
2787         dev->wireless_handlers = &airo_handler_def;
2788         ai->wireless_data.spy_data = &ai->spy_data;
2789         dev->wireless_data = &ai->wireless_data;
2790         dev->change_mtu = &airo_change_mtu;
2791         dev->open = &airo_open;
2792         dev->stop = &airo_close;
2793         dev->irq = irq;
2794         dev->base_addr = port;
2795
2796         SET_NETDEV_DEV(dev, dmdev);
2797
2798         reset_card (dev, 1);
2799         msleep(400);
2800
2801         if (!is_pcmcia) {
2802                 if (!request_region(dev->base_addr, 64, DRV_NAME)) {
2803                         rc = -EBUSY;
2804                         airo_print_err(dev->name, "Couldn't request region");
2805                         goto err_out_nets;
2806                 }
2807         }
2808
2809         if (test_bit(FLAG_MPI,&ai->flags)) {
2810                 if (mpi_map_card(ai, pci)) {
2811                         airo_print_err("", "Could not map memory");
2812                         goto err_out_res;
2813                 }
2814         }
2815
2816         if (probe) {
2817                 if (setup_card(ai, dev->dev_addr, 1) != SUCCESS) {
2818                         airo_print_err(dev->name, "MAC could not be enabled" );
2819                         rc = -EIO;
2820                         goto err_out_map;
2821                 }
2822         } else if (!test_bit(FLAG_MPI,&ai->flags)) {
2823                 ai->bap_read = fast_bap_read;
2824                 set_bit(FLAG_FLASHING, &ai->flags);
2825         }
2826
2827         strcpy(dev->name, "eth%d");
2828         rc = register_netdev(dev);
2829         if (rc) {
2830                 airo_print_err(dev->name, "Couldn't register_netdev");
2831                 goto err_out_map;
2832         }
2833         ai->wifidev = init_wifidev(ai, dev);
2834         if (!ai->wifidev)
2835                 goto err_out_reg;
2836
2837         rc = readCapabilityRid(ai, &cap_rid, 1);
2838         if (rc != SUCCESS) {
2839                 rc = -EIO;
2840                 goto err_out_wifi;
2841         }
2842         /* WEP capability discovery */
2843         ai->wep_capable = (cap_rid.softCap & cpu_to_le16(0x02)) ? 1 : 0;
2844         ai->max_wep_idx = (cap_rid.softCap & cpu_to_le16(0x80)) ? 3 : 0;
2845
2846         airo_print_info(dev->name, "Firmware version %x.%x.%02x",
2847                         ((le16_to_cpu(cap_rid.softVer) >> 8) & 0xF),
2848                         (le16_to_cpu(cap_rid.softVer) & 0xFF),
2849                         le16_to_cpu(cap_rid.softSubVer));
2850
2851         /* Test for WPA support */
2852         /* Only firmware versions 5.30.17 or better can do WPA */
2853         if (le16_to_cpu(cap_rid.softVer) > 0x530
2854          || (le16_to_cpu(cap_rid.softVer) == 0x530
2855               && le16_to_cpu(cap_rid.softSubVer) >= 17)) {
2856                 airo_print_info(ai->dev->name, "WPA supported.");
2857
2858                 set_bit(FLAG_WPA_CAPABLE, &ai->flags);
2859                 ai->bssListFirst = RID_WPA_BSSLISTFIRST;
2860                 ai->bssListNext = RID_WPA_BSSLISTNEXT;
2861                 ai->bssListRidLen = sizeof(BSSListRid);
2862         } else {
2863                 airo_print_info(ai->dev->name, "WPA unsupported with firmware "
2864                         "versions older than 5.30.17.");
2865
2866                 ai->bssListFirst = RID_BSSLISTFIRST;
2867                 ai->bssListNext = RID_BSSLISTNEXT;
2868                 ai->bssListRidLen = sizeof(BSSListRid) - sizeof(BSSListRidExtra);
2869         }
2870
2871         set_bit(FLAG_REGISTERED,&ai->flags);
2872         airo_print_info(dev->name, "MAC enabled %pM", dev->dev_addr);
2873
2874         /* Allocate the transmit buffers */
2875         if (probe && !test_bit(FLAG_MPI,&ai->flags))
2876                 for( i = 0; i < MAX_FIDS; i++ )
2877                         ai->fids[i] = transmit_allocate(ai,AIRO_DEF_MTU,i>=MAX_FIDS/2);
2878
2879         if (setup_proc_entry(dev, dev->ml_priv) < 0)
2880                 goto err_out_wifi;
2881
2882         return dev;
2883
2884 err_out_wifi:
2885         unregister_netdev(ai->wifidev);
2886         free_netdev(ai->wifidev);
2887 err_out_reg:
2888         unregister_netdev(dev);
2889 err_out_map:
2890         if (test_bit(FLAG_MPI,&ai->flags) && pci) {
2891                 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2892                 iounmap(ai->pciaux);
2893                 iounmap(ai->pcimem);
2894                 mpi_unmap_card(ai->pci);
2895         }
2896 err_out_res:
2897         if (!is_pcmcia)
2898                 release_region( dev->base_addr, 64 );
2899 err_out_nets:
2900         airo_networks_free(ai);
2901         del_airo_dev(ai);
2902 err_out_free:
2903         free_netdev(dev);
2904         return NULL;
2905 }
2906
2907 struct net_device *init_airo_card( unsigned short irq, int port, int is_pcmcia,
2908                                   struct device *dmdev)
2909 {
2910         return _init_airo_card ( irq, port, is_pcmcia, NULL, dmdev);
2911 }
2912
2913 EXPORT_SYMBOL(init_airo_card);
2914
2915 static int waitbusy (struct airo_info *ai) {
2916         int delay = 0;
2917         while ((IN4500(ai, COMMAND) & COMMAND_BUSY) && (delay < 10000)) {
2918                 udelay (10);
2919                 if ((++delay % 20) == 0)
2920                         OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
2921         }
2922         return delay < 10000;
2923 }
2924
2925 int reset_airo_card( struct net_device *dev )
2926 {
2927         int i;
2928         struct airo_info *ai = dev->ml_priv;
2929
2930         if (reset_card (dev, 1))
2931                 return -1;
2932
2933         if ( setup_card(ai, dev->dev_addr, 1 ) != SUCCESS ) {
2934                 airo_print_err(dev->name, "MAC could not be enabled");
2935                 return -1;
2936         }
2937         airo_print_info(dev->name, "MAC enabled %pM", dev->dev_addr);
2938         /* Allocate the transmit buffers if needed */
2939         if (!test_bit(FLAG_MPI,&ai->flags))
2940                 for( i = 0; i < MAX_FIDS; i++ )
2941                         ai->fids[i] = transmit_allocate (ai,AIRO_DEF_MTU,i>=MAX_FIDS/2);
2942
2943         enable_interrupts( ai );
2944         netif_wake_queue(dev);
2945         return 0;
2946 }
2947
2948 EXPORT_SYMBOL(reset_airo_card);
2949
2950 static void airo_send_event(struct net_device *dev) {
2951         struct airo_info *ai = dev->ml_priv;
2952         union iwreq_data wrqu;
2953         StatusRid status_rid;
2954
2955         clear_bit(JOB_EVENT, &ai->jobs);
2956         PC4500_readrid(ai, RID_STATUS, &status_rid, sizeof(status_rid), 0);
2957         up(&ai->sem);
2958         wrqu.data.length = 0;
2959         wrqu.data.flags = 0;
2960         memcpy(wrqu.ap_addr.sa_data, status_rid.bssid[0], ETH_ALEN);
2961         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
2962
2963         /* Send event to user space */
2964         wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
2965 }
2966
2967 static void airo_process_scan_results (struct airo_info *ai) {
2968         union iwreq_data        wrqu;
2969         BSSListRid bss;
2970         int rc;
2971         BSSListElement * loop_net;
2972         BSSListElement * tmp_net;
2973
2974         /* Blow away current list of scan results */
2975         list_for_each_entry_safe (loop_net, tmp_net, &ai->network_list, list) {
2976                 list_move_tail (&loop_net->list, &ai->network_free_list);
2977                 /* Don't blow away ->list, just BSS data */
2978                 memset (loop_net, 0, sizeof (loop_net->bss));
2979         }
2980
2981         /* Try to read the first entry of the scan result */
2982         rc = PC4500_readrid(ai, ai->bssListFirst, &bss, ai->bssListRidLen, 0);
2983         if((rc) || (bss.index == cpu_to_le16(0xffff))) {
2984                 /* No scan results */
2985                 goto out;
2986         }
2987
2988         /* Read and parse all entries */
2989         tmp_net = NULL;
2990         while((!rc) && (bss.index != cpu_to_le16(0xffff))) {
2991                 /* Grab a network off the free list */
2992                 if (!list_empty(&ai->network_free_list)) {
2993                         tmp_net = list_entry(ai->network_free_list.next,
2994                                             BSSListElement, list);
2995                         list_del(ai->network_free_list.next);
2996                 }
2997
2998                 if (tmp_net != NULL) {
2999                         memcpy(tmp_net, &bss, sizeof(tmp_net->bss));
3000                         list_add_tail(&tmp_net->list, &ai->network_list);
3001                         tmp_net = NULL;
3002                 }
3003
3004                 /* Read next entry */
3005                 rc = PC4500_readrid(ai, ai->bssListNext,
3006                                     &bss, ai->bssListRidLen, 0);
3007         }
3008
3009 out:
3010         ai->scan_timeout = 0;
3011         clear_bit(JOB_SCAN_RESULTS, &ai->jobs);
3012         up(&ai->sem);
3013
3014         /* Send an empty event to user space.
3015          * We don't send the received data on
3016          * the event because it would require
3017          * us to do complex transcoding, and
3018          * we want to minimise the work done in
3019          * the irq handler. Use a request to
3020          * extract the data - Jean II */
3021         wrqu.data.length = 0;
3022         wrqu.data.flags = 0;
3023         wireless_send_event(ai->dev, SIOCGIWSCAN, &wrqu, NULL);
3024 }
3025
3026 static int airo_thread(void *data) {
3027         struct net_device *dev = data;
3028         struct airo_info *ai = dev->ml_priv;
3029         int locked;
3030
3031         set_freezable();
3032         while(1) {
3033                 /* make swsusp happy with our thread */
3034                 try_to_freeze();
3035
3036                 if (test_bit(JOB_DIE, &ai->jobs))
3037                         break;
3038
3039                 if (ai->jobs) {
3040                         locked = down_interruptible(&ai->sem);
3041                 } else {
3042                         wait_queue_t wait;
3043
3044                         init_waitqueue_entry(&wait, current);
3045                         add_wait_queue(&ai->thr_wait, &wait);
3046                         for (;;) {
3047                                 set_current_state(TASK_INTERRUPTIBLE);
3048                                 if (ai->jobs)
3049                                         break;
3050                                 if (ai->expires || ai->scan_timeout) {
3051                                         if (ai->scan_timeout &&
3052                                                         time_after_eq(jiffies,ai->scan_timeout)){
3053                                                 set_bit(JOB_SCAN_RESULTS, &ai->jobs);
3054                                                 break;
3055                                         } else if (ai->expires &&
3056                                                         time_after_eq(jiffies,ai->expires)){
3057                                                 set_bit(JOB_AUTOWEP, &ai->jobs);
3058                                                 break;
3059                                         }
3060                                         if (!kthread_should_stop() &&
3061                                             !freezing(current)) {
3062                                                 unsigned long wake_at;
3063                                                 if (!ai->expires || !ai->scan_timeout) {
3064                                                         wake_at = max(ai->expires,
3065                                                                 ai->scan_timeout);
3066                                                 } else {
3067                                                         wake_at = min(ai->expires,
3068                                                                 ai->scan_timeout);
3069                                                 }
3070                                                 schedule_timeout(wake_at - jiffies);
3071                                                 continue;
3072                                         }
3073                                 } else if (!kthread_should_stop() &&
3074                                            !freezing(current)) {
3075                                         schedule();
3076                                         continue;
3077                                 }
3078                                 break;
3079                         }
3080                         current->state = TASK_RUNNING;
3081                         remove_wait_queue(&ai->thr_wait, &wait);
3082                         locked = 1;
3083                 }
3084
3085                 if (locked)
3086                         continue;
3087
3088                 if (test_bit(JOB_DIE, &ai->jobs)) {
3089                         up(&ai->sem);
3090                         break;
3091                 }
3092
3093                 if (ai->power.event || test_bit(FLAG_FLASHING, &ai->flags)) {
3094                         up(&ai->sem);
3095                         continue;
3096                 }
3097
3098                 if (test_bit(JOB_XMIT, &ai->jobs))
3099                         airo_end_xmit(dev);
3100                 else if (test_bit(JOB_XMIT11, &ai->jobs))
3101                         airo_end_xmit11(dev);
3102                 else if (test_bit(JOB_STATS, &ai->jobs))
3103                         airo_read_stats(dev);
3104                 else if (test_bit(JOB_WSTATS, &ai->jobs))
3105                         airo_read_wireless_stats(ai);
3106                 else if (test_bit(JOB_PROMISC, &ai->jobs))
3107                         airo_set_promisc(ai);
3108                 else if (test_bit(JOB_MIC, &ai->jobs))
3109                         micinit(ai);
3110                 else if (test_bit(JOB_EVENT, &ai->jobs))
3111                         airo_send_event(dev);
3112                 else if (test_bit(JOB_AUTOWEP, &ai->jobs))
3113                         timer_func(dev);
3114                 else if (test_bit(JOB_SCAN_RESULTS, &ai->jobs))
3115                         airo_process_scan_results(ai);
3116                 else  /* Shouldn't get here, but we make sure to unlock */
3117                         up(&ai->sem);
3118         }
3119
3120         return 0;
3121 }
3122
3123 static int header_len(__le16 ctl)
3124 {
3125         u16 fc = le16_to_cpu(ctl);
3126         switch (fc & 0xc) {
3127         case 4:
3128                 if ((fc & 0xe0) == 0xc0)
3129                         return 10;      /* one-address control packet */
3130                 return 16;      /* two-address control packet */
3131         case 8:
3132                 if ((fc & 0x300) == 0x300)
3133                         return 30;      /* WDS packet */
3134         }
3135         return 24;
3136 }
3137
3138 static void airo_handle_cisco_mic(struct airo_info *ai)
3139 {
3140         if (test_bit(FLAG_MIC_CAPABLE, &ai->flags)) {
3141                 set_bit(JOB_MIC, &ai->jobs);
3142                 wake_up_interruptible(&ai->thr_wait);
3143         }
3144 }
3145
3146 /* Airo Status codes */
3147 #define STAT_NOBEACON   0x8000 /* Loss of sync - missed beacons */
3148 #define STAT_MAXRETRIES 0x8001 /* Loss of sync - max retries */
3149 #define STAT_MAXARL     0x8002 /* Loss of sync - average retry level exceeded*/
3150 #define STAT_FORCELOSS  0x8003 /* Loss of sync - host request */
3151 #define STAT_TSFSYNC    0x8004 /* Loss of sync - TSF synchronization */
3152 #define STAT_DEAUTH     0x8100 /* low byte is 802.11 reason code */
3153 #define STAT_DISASSOC   0x8200 /* low byte is 802.11 reason code */
3154 #define STAT_ASSOC_FAIL 0x8400 /* low byte is 802.11 reason code */
3155 #define STAT_AUTH_FAIL  0x0300 /* low byte is 802.11 reason code */
3156 #define STAT_ASSOC      0x0400 /* Associated */
3157 #define STAT_REASSOC    0x0600 /* Reassociated?  Only on firmware >= 5.30.17 */
3158
3159 static void airo_print_status(const char *devname, u16 status)
3160 {
3161         u8 reason = status & 0xFF;
3162
3163         switch (status) {
3164         case STAT_NOBEACON:
3165                 airo_print_dbg(devname, "link lost (missed beacons)");
3166                 break;
3167         case STAT_MAXRETRIES:
3168         case STAT_MAXARL:
3169                 airo_print_dbg(devname, "link lost (max retries)");
3170                 break;
3171         case STAT_FORCELOSS:
3172                 airo_print_dbg(devname, "link lost (local choice)");
3173                 break;
3174         case STAT_TSFSYNC:
3175                 airo_print_dbg(devname, "link lost (TSF sync lost)");
3176                 break;
3177         case STAT_DEAUTH:
3178                 airo_print_dbg(devname, "deauthenticated (reason: %d)", reason);
3179                 break;
3180         case STAT_DISASSOC:
3181                 airo_print_dbg(devname, "disassociated (reason: %d)", reason);
3182                 break;
3183         case STAT_ASSOC_FAIL:
3184                 airo_print_dbg(devname, "association failed (reason: %d)",
3185                                reason);
3186                 break;
3187         case STAT_AUTH_FAIL:
3188                 airo_print_dbg(devname, "authentication failed (reason: %d)",
3189                                reason);
3190                 break;
3191         default:
3192                 break;
3193         }
3194 }
3195
3196 static void airo_handle_link(struct airo_info *ai)
3197 {
3198         union iwreq_data wrqu;
3199         int scan_forceloss = 0;
3200         u16 status;
3201
3202         /* Get new status and acknowledge the link change */
3203         status = le16_to_cpu(IN4500(ai, LINKSTAT));
3204         OUT4500(ai, EVACK, EV_LINK);
3205
3206         if ((status == STAT_FORCELOSS) && (ai->scan_timeout > 0))
3207                 scan_forceloss = 1;
3208
3209         airo_print_status(ai->dev->name, status);
3210
3211         if ((status == STAT_ASSOC) || (status == STAT_REASSOC)) {
3212                 if (auto_wep)
3213                         ai->expires = 0;
3214                 if (ai->list_bss_task)
3215                         wake_up_process(ai->list_bss_task);
3216                 set_bit(FLAG_UPDATE_UNI, &ai->flags);
3217                 set_bit(FLAG_UPDATE_MULTI, &ai->flags);
3218
3219                 if (down_trylock(&ai->sem) != 0) {
3220                         set_bit(JOB_EVENT, &ai->jobs);
3221                         wake_up_interruptible(&ai->thr_wait);
3222                 } else
3223                         airo_send_event(ai->dev);
3224         } else if (!scan_forceloss) {
3225                 if (auto_wep && !ai->expires) {
3226                         ai->expires = RUN_AT(3*HZ);
3227                         wake_up_interruptible(&ai->thr_wait);
3228                 }
3229
3230                 /* Send event to user space */
3231                 memset(wrqu.ap_addr.sa_data, '\0', ETH_ALEN);
3232                 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
3233                 wireless_send_event(ai->dev, SIOCGIWAP, &wrqu, NULL);
3234         }
3235 }
3236
3237 static void airo_handle_rx(struct airo_info *ai)
3238 {
3239         struct sk_buff *skb = NULL;
3240         __le16 fc, v, *buffer, tmpbuf[4];
3241         u16 len, hdrlen = 0, gap, fid;
3242         struct rx_hdr hdr;
3243         int success = 0;
3244
3245         if (test_bit(FLAG_MPI, &ai->flags)) {
3246                 if (test_bit(FLAG_802_11, &ai->flags))
3247                         mpi_receive_802_11(ai);
3248                 else
3249                         mpi_receive_802_3(ai);
3250                 OUT4500(ai, EVACK, EV_RX);
3251                 return;
3252         }
3253
3254         fid = IN4500(ai, RXFID);
3255
3256         /* Get the packet length */
3257         if (test_bit(FLAG_802_11, &ai->flags)) {
3258                 bap_setup (ai, fid, 4, BAP0);
3259                 bap_read (ai, (__le16*)&hdr, sizeof(hdr), BAP0);
3260                 /* Bad CRC. Ignore packet */
3261                 if (le16_to_cpu(hdr.status) & 2)
3262                         hdr.len = 0;
3263                 if (ai->wifidev == NULL)
3264                         hdr.len = 0;
3265         } else {
3266                 bap_setup(ai, fid, 0x36, BAP0);
3267                 bap_read(ai, &hdr.len, 2, BAP0);
3268         }
3269         len = le16_to_cpu(hdr.len);
3270
3271         if (len > AIRO_DEF_MTU) {
3272                 airo_print_err(ai->dev->name, "Bad size %d", len);
3273                 goto done;
3274         }
3275         if (len == 0)
3276                 goto done;
3277
3278         if (test_bit(FLAG_802_11, &ai->flags)) {
3279                 bap_read(ai, &fc, sizeof (fc), BAP0);
3280                 hdrlen = header_len(fc);
3281         } else
3282                 hdrlen = ETH_ALEN * 2;
3283
3284         skb = dev_alloc_skb(len + hdrlen + 2 + 2);
3285         if (!skb) {
3286                 ai->dev->stats.rx_dropped++;
3287                 goto done;
3288         }
3289
3290         skb_reserve(skb, 2); /* This way the IP header is aligned */
3291         buffer = (__le16 *) skb_put(skb, len + hdrlen);
3292         if (test_bit(FLAG_802_11, &ai->flags)) {
3293                 buffer[0] = fc;
3294                 bap_read(ai, buffer + 1, hdrlen - 2, BAP0);
3295                 if (hdrlen == 24)
3296                         bap_read(ai, tmpbuf, 6, BAP0);
3297
3298                 bap_read(ai, &v, sizeof(v), BAP0);
3299                 gap = le16_to_cpu(v);
3300                 if (gap) {
3301                         if (gap <= 8) {
3302                                 bap_read(ai, tmpbuf, gap, BAP0);
3303                         } else {
3304                                 airo_print_err(ai->dev->name, "gaplen too "
3305                                         "big. Problems will follow...");
3306                         }
3307                 }
3308                 bap_read(ai, buffer + hdrlen/2, len, BAP0);
3309         } else {
3310                 MICBuffer micbuf;
3311
3312                 bap_read(ai, buffer, ETH_ALEN * 2, BAP0);
3313                 if (ai->micstats.enabled) {
3314                         bap_read(ai, (__le16 *) &micbuf, sizeof (micbuf), BAP0);
3315                         if (ntohs(micbuf.typelen) > 0x05DC)
3316                                 bap_setup(ai, fid, 0x44, BAP0);
3317                         else {
3318                                 if (len <= sizeof (micbuf)) {
3319                                         dev_kfree_skb_irq(skb);
3320                                         goto done;
3321                                 }
3322
3323                                 len -= sizeof(micbuf);
3324                                 skb_trim(skb, len + hdrlen);
3325                         }
3326                 }
3327
3328                 bap_read(ai, buffer + ETH_ALEN, len, BAP0);
3329                 if (decapsulate(ai, &micbuf, (etherHead*) buffer, len))
3330                         dev_kfree_skb_irq (skb);
3331                 else
3332                         success = 1;
3333         }
3334
3335 #ifdef WIRELESS_SPY
3336         if (success && (ai->spy_data.spy_number > 0)) {
3337                 char *sa;
3338                 struct iw_quality wstats;
3339
3340                 /* Prepare spy data : addr + qual */
3341                 if (!test_bit(FLAG_802_11, &ai->flags)) {
3342                         sa = (char *) buffer + 6;
3343                         bap_setup(ai, fid, 8, BAP0);
3344                         bap_read(ai, (__le16 *) hdr.rssi, 2, BAP0);
3345                 } else
3346                         sa = (char *) buffer + 10;
3347                 wstats.qual = hdr.rssi[0];
3348                 if (ai->rssi)
3349                         wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3350                 else
3351                         wstats.level = (hdr.rssi[1] + 321) / 2;
3352                 wstats.noise = ai->wstats.qual.noise;
3353                 wstats.updated =  IW_QUAL_LEVEL_UPDATED
3354                                 | IW_QUAL_QUAL_UPDATED
3355                                 | IW_QUAL_DBM;
3356                 /* Update spy records */
3357                 wireless_spy_update(ai->dev, sa, &wstats);
3358         }
3359 #endif /* WIRELESS_SPY */
3360
3361 done:
3362         OUT4500(ai, EVACK, EV_RX);
3363
3364         if (success) {
3365                 if (test_bit(FLAG_802_11, &ai->flags)) {
3366                         skb_reset_mac_header(skb);
3367                         skb->pkt_type = PACKET_OTHERHOST;
3368                         skb->dev = ai->wifidev;
3369                         skb->protocol = htons(ETH_P_802_2);
3370                 } else
3371                         skb->protocol = eth_type_trans(skb, ai->dev);
3372                 skb->ip_summed = CHECKSUM_NONE;
3373
3374                 netif_rx(skb);
3375         }
3376 }
3377
3378 static void airo_handle_tx(struct airo_info *ai, u16 status)
3379 {
3380         int i, len = 0, index = -1;
3381         u16 fid;
3382
3383         if (test_bit(FLAG_MPI, &ai->flags)) {
3384                 unsigned long flags;
3385
3386                 if (status & EV_TXEXC)
3387                         get_tx_error(ai, -1);
3388
3389                 spin_lock_irqsave(&ai->aux_lock, flags);
3390                 if (!skb_queue_empty(&ai->txq)) {
3391                         spin_unlock_irqrestore(&ai->aux_lock,flags);
3392                         mpi_send_packet(ai->dev);
3393                 } else {
3394                         clear_bit(FLAG_PENDING_XMIT, &ai->flags);
3395                         spin_unlock_irqrestore(&ai->aux_lock,flags);
3396                         netif_wake_queue(ai->dev);
3397                 }
3398                 OUT4500(ai, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3399                 return;
3400         }
3401
3402         fid = IN4500(ai, TXCOMPLFID);
3403
3404         for(i = 0; i < MAX_FIDS; i++) {
3405                 if ((ai->fids[i] & 0xffff) == fid) {
3406                         len = ai->fids[i] >> 16;
3407                         index = i;
3408                 }
3409         }
3410
3411         if (index != -1) {
3412                 if (status & EV_TXEXC)
3413                         get_tx_error(ai, index);
3414
3415                 OUT4500(ai, EVACK, status & (EV_TX | EV_TXEXC));
3416
3417                 /* Set up to be used again */
3418                 ai->fids[index] &= 0xffff;
3419                 if (index < MAX_FIDS / 2) {
3420                         if (!test_bit(FLAG_PENDING_XMIT, &ai->flags))
3421                                 netif_wake_queue(ai->dev);
3422                 } else {
3423                         if (!test_bit(FLAG_PENDING_XMIT11, &ai->flags))
3424                                 netif_wake_queue(ai->wifidev);
3425                 }
3426         } else {
3427                 OUT4500(ai, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3428                 airo_print_err(ai->dev->name, "Unallocated FID was used to xmit");
3429         }
3430 }
3431
3432 static irqreturn_t airo_interrupt(int irq, void *dev_id)
3433 {
3434         struct net_device *dev = dev_id;
3435         u16 status, savedInterrupts = 0;
3436         struct airo_info *ai = dev->ml_priv;
3437         int handled = 0;
3438
3439         if (!netif_device_present(dev))
3440                 return IRQ_NONE;
3441
3442         for (;;) {
3443                 status = IN4500(ai, EVSTAT);
3444                 if (!(status & STATUS_INTS) || (status == 0xffff))
3445                         break;
3446
3447                 handled = 1;
3448
3449                 if (status & EV_AWAKE) {
3450                         OUT4500(ai, EVACK, EV_AWAKE);
3451                         OUT4500(ai, EVACK, EV_AWAKE);
3452                 }
3453
3454                 if (!savedInterrupts) {
3455                         savedInterrupts = IN4500(ai, EVINTEN);
3456                         OUT4500(ai, EVINTEN, 0);
3457                 }
3458
3459                 if (status & EV_MIC) {
3460                         OUT4500(ai, EVACK, EV_MIC);
3461                         airo_handle_cisco_mic(ai);
3462                 }
3463
3464                 if (status & EV_LINK) {
3465                         /* Link status changed */
3466                         airo_handle_link(ai);
3467                 }
3468
3469                 /* Check to see if there is something to receive */
3470                 if (status & EV_RX)
3471                         airo_handle_rx(ai);
3472
3473                 /* Check to see if a packet has been transmitted */
3474                 if (status & (EV_TX | EV_TXCPY | EV_TXEXC))
3475                         airo_handle_tx(ai, status);
3476
3477                 if ( status & ~STATUS_INTS & ~IGNORE_INTS ) {
3478                         airo_print_warn(ai->dev->name, "Got weird status %x",
3479                                 status & ~STATUS_INTS & ~IGNORE_INTS );
3480                 }
3481         }
3482
3483         if (savedInterrupts)
3484                 OUT4500(ai, EVINTEN, savedInterrupts);
3485
3486         return IRQ_RETVAL(handled);
3487 }
3488
3489 /*
3490  *  Routines to talk to the card
3491  */
3492
3493 /*
3494  *  This was originally written for the 4500, hence the name
3495  *  NOTE:  If use with 8bit mode and SMP bad things will happen!
3496  *         Why would some one do 8 bit IO in an SMP machine?!?
3497  */
3498 static void OUT4500( struct airo_info *ai, u16 reg, u16 val ) {
3499         if (test_bit(FLAG_MPI,&ai->flags))
3500                 reg <<= 1;
3501         if ( !do8bitIO )
3502                 outw( val, ai->dev->base_addr + reg );
3503         else {
3504                 outb( val & 0xff, ai->dev->base_addr + reg );
3505                 outb( val >> 8, ai->dev->base_addr + reg + 1 );
3506         }
3507 }
3508
3509 static u16 IN4500( struct airo_info *ai, u16 reg ) {
3510         unsigned short rc;
3511
3512         if (test_bit(FLAG_MPI,&ai->flags))
3513                 reg <<= 1;
3514         if ( !do8bitIO )
3515                 rc = inw( ai->dev->base_addr + reg );
3516         else {
3517                 rc = inb( ai->dev->base_addr + reg );
3518                 rc += ((int)inb( ai->dev->base_addr + reg + 1 )) << 8;
3519         }
3520         return rc;
3521 }
3522
3523 static int enable_MAC(struct airo_info *ai, int lock)
3524 {
3525         int rc;
3526         Cmd cmd;
3527         Resp rsp;
3528
3529         /* FLAG_RADIO_OFF : Radio disabled via /proc or Wireless Extensions
3530          * FLAG_RADIO_DOWN : Radio disabled via "ifconfig ethX down"
3531          * Note : we could try to use !netif_running(dev) in enable_MAC()
3532          * instead of this flag, but I don't trust it *within* the
3533          * open/close functions, and testing both flags together is
3534          * "cheaper" - Jean II */
3535         if (ai->flags & FLAG_RADIO_MASK) return SUCCESS;
3536
3537         if (lock && down_interruptible(&ai->sem))
3538                 return -ERESTARTSYS;
3539
3540         if (!test_bit(FLAG_ENABLED, &ai->flags)) {
3541                 memset(&cmd, 0, sizeof(cmd));
3542                 cmd.cmd = MAC_ENABLE;
3543                 rc = issuecommand(ai, &cmd, &rsp);
3544                 if (rc == SUCCESS)
3545                         set_bit(FLAG_ENABLED, &ai->flags);
3546         } else
3547                 rc = SUCCESS;
3548
3549         if (lock)
3550             up(&ai->sem);
3551
3552         if (rc)
3553                 airo_print_err(ai->dev->name, "Cannot enable MAC");
3554         else if ((rsp.status & 0xFF00) != 0) {
3555                 airo_print_err(ai->dev->name, "Bad MAC enable reason=%x, "
3556                         "rid=%x, offset=%d", rsp.rsp0, rsp.rsp1, rsp.rsp2);
3557                 rc = ERROR;
3558         }
3559         return rc;
3560 }
3561
3562 static void disable_MAC( struct airo_info *ai, int lock ) {
3563         Cmd cmd;
3564         Resp rsp;
3565
3566         if (lock && down_interruptible(&ai->sem))
3567                 return;
3568
3569         if (test_bit(FLAG_ENABLED, &ai->flags)) {
3570                 memset(&cmd, 0, sizeof(cmd));
3571                 cmd.cmd = MAC_DISABLE; // disable in case already enabled
3572                 issuecommand(ai, &cmd, &rsp);
3573                 clear_bit(FLAG_ENABLED, &ai->flags);
3574         }
3575         if (lock)
3576                 up(&ai->sem);
3577 }
3578
3579 static void enable_interrupts( struct airo_info *ai ) {
3580         /* Enable the interrupts */
3581         OUT4500( ai, EVINTEN, STATUS_INTS );
3582 }
3583
3584 static void disable_interrupts( struct airo_info *ai ) {
3585         OUT4500( ai, EVINTEN, 0 );
3586 }
3587
3588 static void mpi_receive_802_3(struct airo_info *ai)
3589 {
3590         RxFid rxd;
3591         int len = 0;
3592         struct sk_buff *skb;
3593         char *buffer;
3594         int off = 0;
3595         MICBuffer micbuf;
3596
3597         memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3598         /* Make sure we got something */
3599         if (rxd.rdy && rxd.valid == 0) {
3600                 len = rxd.len + 12;
3601                 if (len < 12 || len > 2048)
3602                         goto badrx;
3603
3604                 skb = dev_alloc_skb(len);
3605                 if (!skb) {
3606                         ai->dev->stats.rx_dropped++;
3607                         goto badrx;
3608                 }
3609                 buffer = skb_put(skb,len);
3610                 memcpy(buffer, ai->rxfids[0].virtual_host_addr, ETH_ALEN * 2);
3611                 if (ai->micstats.enabled) {
3612                         memcpy(&micbuf,
3613                                 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2,
3614                                 sizeof(micbuf));
3615                         if (ntohs(micbuf.typelen) <= 0x05DC) {
3616                                 if (len <= sizeof(micbuf) + ETH_ALEN * 2)
3617                                         goto badmic;
3618
3619                                 off = sizeof(micbuf);
3620                                 skb_trim (skb, len - off);
3621                         }
3622                 }
3623                 memcpy(buffer + ETH_ALEN * 2,
3624                         ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2 + off,
3625                         len - ETH_ALEN * 2 - off);
3626                 if (decapsulate (ai, &micbuf, (etherHead*)buffer, len - off - ETH_ALEN * 2)) {
3627 badmic:
3628                         dev_kfree_skb_irq (skb);
3629                         goto badrx;
3630                 }
3631 #ifdef WIRELESS_SPY
3632                 if (ai->spy_data.spy_number > 0) {
3633                         char *sa;
3634                         struct iw_quality wstats;
3635                         /* Prepare spy data : addr + qual */
3636                         sa = buffer + ETH_ALEN;
3637                         wstats.qual = 0; /* XXX Where do I get that info from ??? */
3638                         wstats.level = 0;
3639                         wstats.updated = 0;
3640                         /* Update spy records */
3641                         wireless_spy_update(ai->dev, sa, &wstats);
3642                 }
3643 #endif /* WIRELESS_SPY */
3644
3645                 skb->ip_summed = CHECKSUM_NONE;
3646                 skb->protocol = eth_type_trans(skb, ai->dev);
3647                 netif_rx(skb);
3648         }
3649 badrx:
3650         if (rxd.valid == 0) {
3651                 rxd.valid = 1;
3652                 rxd.rdy = 0;
3653                 rxd.len = PKTSIZE;
3654                 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3655         }
3656 }
3657
3658 static void mpi_receive_802_11(struct airo_info *ai)
3659 {
3660         RxFid rxd;
3661         struct sk_buff *skb = NULL;
3662         u16 len, hdrlen = 0;
3663         __le16 fc;
3664         struct rx_hdr hdr;
3665         u16 gap;
3666         u16 *buffer;
3667         char *ptr = ai->rxfids[0].virtual_host_addr + 4;
3668
3669         memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3670         memcpy ((char *)&hdr, ptr, sizeof(hdr));
3671         ptr += sizeof(hdr);
3672         /* Bad CRC. Ignore packet */
3673         if (le16_to_cpu(hdr.status) & 2)
3674                 hdr.len = 0;
3675         if (ai->wifidev == NULL)
3676                 hdr.len = 0;
3677         len = le16_to_cpu(hdr.len);
3678         if (len > AIRO_DEF_MTU) {
3679                 airo_print_err(ai->dev->name, "Bad size %d", len);
3680                 goto badrx;
3681         }
3682         if (len == 0)
3683                 goto badrx;
3684
3685         fc = get_unaligned((__le16 *)ptr);
3686         hdrlen = header_len(fc);
3687
3688         skb = dev_alloc_skb( len + hdrlen + 2 );
3689         if ( !skb ) {
3690                 ai->dev->stats.rx_dropped++;
3691                 goto badrx;
3692         }
3693         buffer = (u16*)skb_put (skb, len + hdrlen);
3694         memcpy ((char *)buffer, ptr, hdrlen);
3695         ptr += hdrlen;
3696         if (hdrlen == 24)
3697                 ptr += 6;
3698         gap = get_unaligned_le16(ptr);
3699         ptr += sizeof(__le16);
3700         if (gap) {
3701                 if (gap <= 8)
3702                         ptr += gap;
3703                 else
3704                         airo_print_err(ai->dev->name,
3705                             "gaplen too big. Problems will follow...");
3706         }
3707         memcpy ((char *)buffer + hdrlen, ptr, len);
3708         ptr += len;
3709 #ifdef IW_WIRELESS_SPY    /* defined in iw_handler.h */
3710         if (ai->spy_data.spy_number > 0) {
3711                 char *sa;
3712                 struct iw_quality wstats;
3713                 /* Prepare spy data : addr + qual */
3714                 sa = (char*)buffer + 10;
3715                 wstats.qual = hdr.rssi[0];
3716                 if (ai->rssi)
3717                         wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3718                 else
3719                         wstats.level = (hdr.rssi[1] + 321) / 2;
3720                 wstats.noise = ai->wstats.qual.noise;
3721                 wstats.updated = IW_QUAL_QUAL_UPDATED
3722                         | IW_QUAL_LEVEL_UPDATED
3723                         | IW_QUAL_DBM;
3724                 /* Update spy records */
3725                 wireless_spy_update(ai->dev, sa, &wstats);
3726         }
3727 #endif /* IW_WIRELESS_SPY */
3728         skb_reset_mac_header(skb);
3729         skb->pkt_type = PACKET_OTHERHOST;
3730         skb->dev = ai->wifidev;
3731         skb->protocol = htons(ETH_P_802_2);
3732         skb->ip_summed = CHECKSUM_NONE;
3733         netif_rx( skb );
3734
3735 badrx:
3736         if (rxd.valid == 0) {
3737                 rxd.valid = 1;
3738                 rxd.rdy = 0;
3739                 rxd.len = PKTSIZE;
3740                 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3741         }
3742 }
3743
3744 static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
3745 {
3746         Cmd cmd;
3747         Resp rsp;
3748         int status;
3749         int i;
3750         SsidRid mySsid;
3751         __le16 lastindex;
3752         WepKeyRid wkr;
3753         int rc;
3754
3755         memset( &mySsid, 0, sizeof( mySsid ) );
3756         kfree (ai->flash);
3757         ai->flash = NULL;
3758
3759         /* The NOP is the first step in getting the card going */
3760         cmd.cmd = NOP;
3761         cmd.parm0 = cmd.parm1 = cmd.parm2 = 0;
3762         if (lock && down_interruptible(&ai->sem))
3763                 return ERROR;
3764         if ( issuecommand( ai, &cmd, &rsp ) != SUCCESS ) {
3765                 if (lock)
3766                         up(&ai->sem);
3767                 return ERROR;
3768         }
3769         disable_MAC( ai, 0);
3770
3771         // Let's figure out if we need to use the AUX port
3772         if (!test_bit(FLAG_MPI,&ai->flags)) {
3773                 cmd.cmd = CMD_ENABLEAUX;
3774                 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
3775                         if (lock)
3776                                 up(&ai->sem);
3777                         airo_print_err(ai->dev->name, "Error checking for AUX port");
3778                         return ERROR;
3779                 }
3780                 if (!aux_bap || rsp.status & 0xff00) {
3781                         ai->bap_read = fast_bap_read;
3782                         airo_print_dbg(ai->dev->name, "Doing fast bap_reads");
3783                 } else {
3784                         ai->bap_read = aux_bap_read;
3785                         airo_print_dbg(ai->dev->name, "Doing AUX bap_reads");
3786                 }
3787         }
3788         if (lock)
3789                 up(&ai->sem);
3790         if (ai->config.len == 0) {
3791                 tdsRssiRid rssi_rid;
3792                 CapabilityRid cap_rid;
3793
3794                 kfree(ai->APList);
3795                 ai->APList = NULL;
3796                 kfree(ai->SSID);
3797                 ai->SSID = NULL;
3798                 // general configuration (read/modify/write)
3799                 status = readConfigRid(ai, lock);
3800                 if ( status != SUCCESS ) return ERROR;
3801
3802                 status = readCapabilityRid(ai, &cap_rid, lock);
3803                 if ( status != SUCCESS ) return ERROR;
3804
3805                 status = PC4500_readrid(ai,RID_RSSI,&rssi_rid,sizeof(rssi_rid),lock);
3806                 if ( status == SUCCESS ) {
3807                         if (ai->rssi || (ai->rssi = kmalloc(512, GFP_KERNEL)) != NULL)
3808                                 memcpy(ai->rssi, (u8*)&rssi_rid + 2, 512); /* Skip RID length member */
3809                 }
3810                 else {
3811                         kfree(ai->rssi);
3812                         ai->rssi = NULL;
3813                         if (cap_rid.softCap & cpu_to_le16(8))
3814                                 ai->config.rmode |= RXMODE_NORMALIZED_RSSI;
3815                         else
3816                                 airo_print_warn(ai->dev->name, "unknown received signal "
3817                                                 "level scale");
3818                 }
3819                 ai->config.opmode = adhoc ? MODE_STA_IBSS : MODE_STA_ESS;
3820                 ai->config.authType = AUTH_OPEN;
3821                 ai->config.modulation = MOD_CCK;
3822
3823                 if (le16_to_cpu(cap_rid.len) >= sizeof(cap_rid) &&
3824                     (cap_rid.extSoftCap & cpu_to_le16(1)) &&
3825                     micsetup(ai) == SUCCESS) {
3826                         ai->config.opmode |= MODE_MIC;
3827                         set_bit(FLAG_MIC_CAPABLE, &ai->flags);
3828                 }
3829
3830                 /* Save off the MAC */
3831                 for( i = 0; i < ETH_ALEN; i++ ) {
3832                         mac[i] = ai->config.macAddr[i];
3833                 }
3834
3835                 /* Check to see if there are any insmod configured
3836                    rates to add */
3837                 if ( rates[0] ) {
3838                         int i = 0;
3839                         memset(ai->config.rates,0,sizeof(ai->config.rates));
3840                         for( i = 0; i < 8 && rates[i]; i++ ) {
3841                                 ai->config.rates[i] = rates[i];
3842                         }
3843                 }
3844                 if ( basic_rate > 0 ) {
3845                         int i;
3846                         for( i = 0; i < 8; i++ ) {
3847                                 if ( ai->config.rates[i] == basic_rate ||
3848                                      !ai->config.rates ) {
3849                                         ai->config.rates[i] = basic_rate | 0x80;
3850                                         break;
3851                                 }
3852                         }
3853                 }
3854                 set_bit (FLAG_COMMIT, &ai->flags);
3855         }
3856
3857         /* Setup the SSIDs if present */
3858         if ( ssids[0] ) {
3859                 int i;
3860                 for( i = 0; i < 3 && ssids[i]; i++ ) {
3861                         size_t len = strlen(ssids[i]);
3862                         if (len > 32)
3863                                 len = 32;
3864                         mySsid.ssids[i].len = cpu_to_le16(len);
3865                         memcpy(mySsid.ssids[i].ssid, ssids[i], len);
3866                 }
3867                 mySsid.len = cpu_to_le16(sizeof(mySsid));
3868         }
3869
3870         status = writeConfigRid(ai, lock);
3871         if ( status != SUCCESS ) return ERROR;
3872
3873         /* Set up the SSID list */
3874         if ( ssids[0] ) {
3875                 status = writeSsidRid(ai, &mySsid, lock);
3876                 if ( status != SUCCESS ) return ERROR;
3877         }
3878
3879         status = enable_MAC(ai, lock);
3880         if (status != SUCCESS)
3881                 return ERROR;
3882
3883         /* Grab the initial wep key, we gotta save it for auto_wep */
3884         rc = readWepKeyRid(ai, &wkr, 1, lock);
3885         if (rc == SUCCESS) do {
3886                 lastindex = wkr.kindex;
3887                 if (wkr.kindex == cpu_to_le16(0xffff)) {
3888                         ai->defindex = wkr.mac[0];
3889                 }
3890                 rc = readWepKeyRid(ai, &wkr, 0, lock);
3891         } while(lastindex != wkr.kindex);
3892
3893         try_auto_wep(ai);
3894
3895         return SUCCESS;
3896 }
3897
3898 static u16 issuecommand(struct airo_info *ai, Cmd *pCmd, Resp *pRsp) {
3899         // Im really paranoid about letting it run forever!
3900         int max_tries = 600000;
3901
3902         if (IN4500(ai, EVSTAT) & EV_CMD)
3903                 OUT4500(ai, EVACK, EV_CMD);
3904
3905         OUT4500(ai, PARAM0, pCmd->parm0);
3906         OUT4500(ai, PARAM1, pCmd->parm1);
3907         OUT4500(ai, PARAM2, pCmd->parm2);
3908         OUT4500(ai, COMMAND, pCmd->cmd);
3909
3910         while (max_tries-- && (IN4500(ai, EVSTAT) & EV_CMD) == 0) {
3911                 if ((IN4500(ai, COMMAND)) == pCmd->cmd)
3912                         // PC4500 didn't notice command, try again
3913                         OUT4500(ai, COMMAND, pCmd->cmd);
3914                 if (!in_atomic() && (max_tries & 255) == 0)
3915                         schedule();
3916         }
3917
3918         if ( max_tries == -1 ) {
3919                 airo_print_err(ai->dev->name,
3920                         "Max tries exceeded when issueing command");
3921                 if (IN4500(ai, COMMAND) & COMMAND_BUSY)
3922                         OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3923                 return ERROR;
3924         }
3925
3926         // command completed
3927         pRsp->status = IN4500(ai, STATUS);
3928         pRsp->rsp0 = IN4500(ai, RESP0);
3929         pRsp->rsp1 = IN4500(ai, RESP1);
3930         pRsp->rsp2 = IN4500(ai, RESP2);
3931         if ((pRsp->status & 0xff00)!=0 && pCmd->cmd != CMD_SOFTRESET)
3932                 airo_print_err(ai->dev->name,
3933                         "cmd:%x status:%x rsp0:%x rsp1:%x rsp2:%x",
3934                         pCmd->cmd, pRsp->status, pRsp->rsp0, pRsp->rsp1,
3935                         pRsp->rsp2);
3936
3937         // clear stuck command busy if necessary
3938         if (IN4500(ai, COMMAND) & COMMAND_BUSY) {
3939                 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3940         }
3941         // acknowledge processing the status/response
3942         OUT4500(ai, EVACK, EV_CMD);
3943
3944         return SUCCESS;
3945 }
3946
3947 /* Sets up the bap to start exchange data.  whichbap should
3948  * be one of the BAP0 or BAP1 defines.  Locks should be held before
3949  * calling! */
3950 static int bap_setup(struct airo_info *ai, u16 rid, u16 offset, int whichbap )
3951 {
3952         int timeout = 50;
3953         int max_tries = 3;
3954
3955         OUT4500(ai, SELECT0+whichbap, rid);
3956         OUT4500(ai, OFFSET0+whichbap, offset);
3957         while (1) {
3958                 int status = IN4500(ai, OFFSET0+whichbap);
3959                 if (status & BAP_BUSY) {
3960                         /* This isn't really a timeout, but its kinda
3961                            close */
3962                         if (timeout--) {
3963                                 continue;
3964                         }
3965                 } else if ( status & BAP_ERR ) {
3966                         /* invalid rid or offset */
3967                         airo_print_err(ai->dev->name, "BAP error %x %d",
3968                                 status, whichbap );
3969                         return ERROR;
3970                 } else if (status & BAP_DONE) { // success
3971                         return SUCCESS;
3972                 }
3973                 if ( !(max_tries--) ) {
3974                         airo_print_err(ai->dev->name,
3975                                 "BAP setup error too many retries\n");
3976                         return ERROR;
3977                 }
3978                 // -- PC4500 missed it, try again
3979                 OUT4500(ai, SELECT0+whichbap, rid);
3980                 OUT4500(ai, OFFSET0+whichbap, offset);
3981                 timeout = 50;
3982         }
3983 }
3984
3985 /* should only be called by aux_bap_read.  This aux function and the
3986    following use concepts not documented in the developers guide.  I
3987    got them from a patch given to my by Aironet */
3988 static u16 aux_setup(struct airo_info *ai, u16 page,
3989                      u16 offset, u16 *len)
3990 {
3991         u16 next;
3992
3993         OUT4500(ai, AUXPAGE, page);
3994         OUT4500(ai, AUXOFF, 0);
3995         next = IN4500(ai, AUXDATA);
3996         *len = IN4500(ai, AUXDATA)&0xff;
3997         if (offset != 4) OUT4500(ai, AUXOFF, offset);
3998         return next;
3999 }
4000
4001 /* requires call to bap_setup() first */
4002 static int aux_bap_read(struct airo_info *ai, __le16 *pu16Dst,
4003                         int bytelen, int whichbap)
4004 {
4005         u16 len;
4006         u16 page;
4007         u16 offset;
4008         u16 next;
4009         int words;
4010         int i;
4011         unsigned long flags;
4012
4013         spin_lock_irqsave(&ai->aux_lock, flags);
4014         page = IN4500(ai, SWS0+whichbap);
4015         offset = IN4500(ai, SWS2+whichbap);
4016         next = aux_setup(ai, page, offset, &len);
4017         words = (bytelen+1)>>1;
4018
4019         for (i=0; i<words;) {
4020                 int count;
4021                 count = (len>>1) < (words-i) ? (len>>1) : (words-i);
4022                 if ( !do8bitIO )
4023                         insw( ai->dev->base_addr+DATA0+whichbap,
4024                               pu16Dst+i,count );
4025                 else
4026                         insb( ai->dev->base_addr+DATA0+whichbap,
4027                               pu16Dst+i, count << 1 );
4028                 i += count;
4029                 if (i<words) {
4030                         next = aux_setup(ai, next, 4, &len);
4031                 }
4032         }
4033         spin_unlock_irqrestore(&ai->aux_lock, flags);
4034         return SUCCESS;
4035 }
4036
4037
4038 /* requires call to bap_setup() first */
4039 static int fast_bap_read(struct airo_info *ai, __le16 *pu16Dst,
4040                          int bytelen, int whichbap)
4041 {
4042         bytelen = (bytelen + 1) & (~1); // round up to even value
4043         if ( !do8bitIO )
4044                 insw( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen>>1 );
4045         else
4046                 insb( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen );
4047         return SUCCESS;
4048 }
4049
4050 /* requires call to bap_setup() first */
4051 static int bap_write(struct airo_info *ai, const __le16 *pu16Src,
4052                      int bytelen, int whichbap)
4053 {
4054         bytelen = (bytelen + 1) & (~1); // round up to even value
4055         if ( !do8bitIO )
4056                 outsw( ai->dev->base_addr+DATA0+whichbap,
4057                        pu16Src, bytelen>>1 );
4058         else
4059                 outsb( ai->dev->base_addr+DATA0+whichbap, pu16Src, bytelen );
4060         return SUCCESS;
4061 }
4062
4063 static int PC4500_accessrid(struct airo_info *ai, u16 rid, u16 accmd)
4064 {
4065         Cmd cmd; /* for issuing commands */
4066         Resp rsp; /* response from commands */
4067         u16 status;
4068
4069         memset(&cmd, 0, sizeof(cmd));
4070         cmd.cmd = accmd;
4071         cmd.parm0 = rid;
4072         status = issuecommand(ai, &cmd, &rsp);
4073         if (status != 0) return status;
4074         if ( (rsp.status & 0x7F00) != 0) {
4075                 return (accmd << 8) + (rsp.rsp0 & 0xFF);
4076         }
4077         return 0;
4078 }
4079
4080 /*  Note, that we are using BAP1 which is also used by transmit, so
4081  *  we must get a lock. */
4082 static int PC4500_readrid(struct airo_info *ai, u16 rid, void *pBuf, int len, int lock)
4083 {
4084         u16 status;
4085         int rc = SUCCESS;
4086
4087         if (lock) {
4088                 if (down_interruptible(&ai->sem))
4089                         return ERROR;
4090         }
4091         if (test_bit(FLAG_MPI,&ai->flags)) {
4092                 Cmd cmd;
4093                 Resp rsp;
4094
4095                 memset(&cmd, 0, sizeof(cmd));
4096                 memset(&rsp, 0, sizeof(rsp));
4097                 ai->config_desc.rid_desc.valid = 1;
4098                 ai->config_desc.rid_desc.len = RIDSIZE;
4099                 ai->config_desc.rid_desc.rid = 0;
4100                 ai->config_desc.rid_desc.host_addr = ai->ridbus;
4101
4102                 cmd.cmd = CMD_ACCESS;
4103                 cmd.parm0 = rid;
4104
4105                 memcpy_toio(ai->config_desc.card_ram_off,
4106                         &ai->config_desc.rid_desc, sizeof(Rid));
4107
4108                 rc = issuecommand(ai, &cmd, &rsp);
4109
4110                 if (rsp.status & 0x7f00)
4111                         rc = rsp.rsp0;
4112                 if (!rc)
4113                         memcpy(pBuf, ai->config_desc.virtual_host_addr, len);
4114                 goto done;
4115         } else {
4116                 if ((status = PC4500_accessrid(ai, rid, CMD_ACCESS))!=SUCCESS) {
4117                         rc = status;
4118                         goto done;
4119                 }
4120                 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4121                         rc = ERROR;
4122                         goto done;
4123                 }
4124                 // read the rid length field
4125                 bap_read(ai, pBuf, 2, BAP1);
4126                 // length for remaining part of rid
4127                 len = min(len, (int)le16_to_cpu(*(__le16*)pBuf)) - 2;
4128
4129                 if ( len <= 2 ) {
4130                         airo_print_err(ai->dev->name,
4131                                 "Rid %x has a length of %d which is too short",
4132                                 (int)rid, (int)len );
4133                         rc = ERROR;
4134                         goto done;
4135                 }
4136                 // read remainder of the rid
4137                 rc = bap_read(ai, ((__le16*)pBuf)+1, len, BAP1);
4138         }
4139 done:
4140         if (lock)
4141                 up(&ai->sem);
4142         return rc;
4143 }
4144
4145 /*  Note, that we are using BAP1 which is also used by transmit, so
4146  *  make sure this isnt called when a transmit is happening */
4147 static int PC4500_writerid(struct airo_info *ai, u16 rid,
4148                            const void *pBuf, int len, int lock)
4149 {
4150         u16 status;
4151         int rc = SUCCESS;
4152
4153         *(__le16*)pBuf = cpu_to_le16((u16)len);
4154
4155         if (lock) {
4156                 if (down_interruptible(&ai->sem))
4157                         return ERROR;
4158         }
4159         if (test_bit(FLAG_MPI,&ai->flags)) {
4160                 Cmd cmd;
4161                 Resp rsp;
4162
4163                 if (test_bit(FLAG_ENABLED, &ai->flags) && (RID_WEP_TEMP != rid))
4164                         airo_print_err(ai->dev->name,
4165                                 "%s: MAC should be disabled (rid=%04x)",
4166                                 __func__, rid);
4167                 memset(&cmd, 0, sizeof(cmd));
4168                 memset(&rsp, 0, sizeof(rsp));
4169
4170                 ai->config_desc.rid_desc.valid = 1;
4171                 ai->config_desc.rid_desc.len = *((u16 *)pBuf);
4172                 ai->config_desc.rid_desc.rid = 0;
4173
4174                 cmd.cmd = CMD_WRITERID;
4175                 cmd.parm0 = rid;
4176
4177                 memcpy_toio(ai->config_desc.card_ram_off,
4178                         &ai->config_desc.rid_desc, sizeof(Rid));
4179
4180                 if (len < 4 || len > 2047) {
4181                         airo_print_err(ai->dev->name, "%s: len=%d", __func__, len);
4182                         rc = -1;
4183                 } else {
4184                         memcpy((char *)ai->config_desc.virtual_host_addr,
4185                                 pBuf, len);
4186
4187                         rc = issuecommand(ai, &cmd, &rsp);
4188                         if ((rc & 0xff00) != 0) {
4189                                 airo_print_err(ai->dev->name, "%s: Write rid Error %d",
4190                                                 __func__, rc);
4191                                 airo_print_err(ai->dev->name, "%s: Cmd=%04x",
4192                                                 __func__, cmd.cmd);
4193                         }
4194
4195                         if ((rsp.status & 0x7f00))
4196                                 rc = rsp.rsp0;
4197                 }
4198         } else {
4199                 // --- first access so that we can write the rid data
4200                 if ( (status = PC4500_accessrid(ai, rid, CMD_ACCESS)) != 0) {
4201                         rc = status;
4202                         goto done;
4203                 }
4204                 // --- now write the rid data
4205                 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4206                         rc = ERROR;
4207                         goto done;
4208                 }
4209                 bap_write(ai, pBuf, len, BAP1);
4210                 // ---now commit the rid data
4211                 rc = PC4500_accessrid(ai, rid, 0x100|CMD_ACCESS);
4212         }
4213 done:
4214         if (lock)
4215                 up(&ai->sem);
4216         return rc;
4217 }
4218
4219 /* Allocates a FID to be used for transmitting packets.  We only use
4220    one for now. */
4221 static u16 transmit_allocate(struct airo_info *ai, int lenPayload, int raw)
4222 {
4223         unsigned int loop = 3000;
4224         Cmd cmd;
4225         Resp rsp;
4226         u16 txFid;
4227         __le16 txControl;
4228
4229         cmd.cmd = CMD_ALLOCATETX;
4230         cmd.parm0 = lenPayload;
4231         if (down_interruptible(&ai->sem))
4232                 return ERROR;
4233         if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
4234                 txFid = ERROR;
4235                 goto done;
4236         }
4237         if ( (rsp.status & 0xFF00) != 0) {
4238                 txFid = ERROR;
4239                 goto done;
4240         }
4241         /* wait for the allocate event/indication
4242          * It makes me kind of nervous that this can just sit here and spin,
4243          * but in practice it only loops like four times. */
4244         while (((IN4500(ai, EVSTAT) & EV_ALLOC) == 0) && --loop);
4245         if (!loop) {
4246                 txFid = ERROR;
4247                 goto done;
4248         }
4249
4250         // get the allocated fid and acknowledge
4251         txFid = IN4500(ai, TXALLOCFID);
4252         OUT4500(ai, EVACK, EV_ALLOC);
4253
4254         /*  The CARD is pretty cool since it converts the ethernet packet
4255          *  into 802.11.  Also note that we don't release the FID since we
4256          *  will be using the same one over and over again. */
4257         /*  We only have to setup the control once since we are not
4258          *  releasing the fid. */
4259         if (raw)
4260                 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_11
4261                         | TXCTL_ETHERNET | TXCTL_NORELEASE);
4262         else
4263                 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_3
4264                         | TXCTL_ETHERNET | TXCTL_NORELEASE);
4265         if (bap_setup(ai, txFid, 0x0008, BAP1) != SUCCESS)
4266                 txFid = ERROR;
4267         else
4268                 bap_write(ai, &txControl, sizeof(txControl), BAP1);
4269
4270 done:
4271         up(&ai->sem);
4272
4273         return txFid;
4274 }
4275
4276 /* In general BAP1 is dedicated to transmiting packets.  However,
4277    since we need a BAP when accessing RIDs, we also use BAP1 for that.
4278    Make sure the BAP1 spinlock is held when this is called. */
4279 static int transmit_802_3_packet(struct airo_info *ai, int len, char *pPacket)
4280 {
4281         __le16 payloadLen;
4282         Cmd cmd;
4283         Resp rsp;
4284         int miclen = 0;
4285         u16 txFid = len;
4286         MICBuffer pMic;
4287
4288         len >>= 16;
4289
4290         if (len <= ETH_ALEN * 2) {
4291                 airo_print_warn(ai->dev->name, "Short packet %d", len);
4292                 return ERROR;
4293         }
4294         len -= ETH_ALEN * 2;
4295
4296         if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled && 
4297             (ntohs(((__be16 *)pPacket)[6]) != 0x888E)) {
4298                 if (encapsulate(ai,(etherHead *)pPacket,&pMic,len) != SUCCESS)
4299                         return ERROR;
4300                 miclen = sizeof(pMic);
4301         }
4302         // packet is destination[6], source[6], payload[len-12]
4303         // write the payload length and dst/src/payload
4304         if (bap_setup(ai, txFid, 0x0036, BAP1) != SUCCESS) return ERROR;
4305         /* The hardware addresses aren't counted as part of the payload, so
4306          * we have to subtract the 12 bytes for the addresses off */
4307         payloadLen = cpu_to_le16(len + miclen);
4308         bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4309         bap_write(ai, (__le16*)pPacket, sizeof(etherHead), BAP1);
4310         if (miclen)
4311                 bap_write(ai, (__le16*)&pMic, miclen, BAP1);
4312         bap_write(ai, (__le16*)(pPacket + sizeof(etherHead)), len, BAP1);
4313         // issue the transmit command
4314         memset( &cmd, 0, sizeof( cmd ) );
4315         cmd.cmd = CMD_TRANSMIT;
4316         cmd.parm0 = txFid;
4317         if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4318         if ( (rsp.status & 0xFF00) != 0) return ERROR;
4319         return SUCCESS;
4320 }
4321
4322 static int transmit_802_11_packet(struct airo_info *ai, int len, char *pPacket)
4323 {
4324         __le16 fc, payloadLen;
4325         Cmd cmd;
4326         Resp rsp;
4327         int hdrlen;
4328         static u8 tail[(30-10) + 2 + 6] = {[30-10] = 6};
4329         /* padding of header to full size + le16 gaplen (6) + gaplen bytes */
4330         u16 txFid = len;
4331         len >>= 16;
4332
4333         fc = *(__le16*)pPacket;
4334         hdrlen = header_len(fc);
4335
4336         if (len < hdrlen) {
4337                 airo_print_warn(ai->dev->name, "Short packet %d", len);
4338                 return ERROR;
4339         }
4340
4341         /* packet is 802.11 header +  payload
4342          * write the payload length and dst/src/payload */
4343         if (bap_setup(ai, txFid, 6, BAP1) != SUCCESS) return ERROR;
4344         /* The 802.11 header aren't counted as part of the payload, so
4345          * we have to subtract the header bytes off */
4346         payloadLen = cpu_to_le16(len-hdrlen);
4347         bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4348         if (bap_setup(ai, txFid, 0x0014, BAP1) != SUCCESS) return ERROR;
4349         bap_write(ai, (__le16 *)pPacket, hdrlen, BAP1);
4350         bap_write(ai, (__le16 *)(tail + (hdrlen - 10)), 38 - hdrlen, BAP1);
4351
4352         bap_write(ai, (__le16 *)(pPacket + hdrlen), len - hdrlen, BAP1);
4353         // issue the transmit command
4354         memset( &cmd, 0, sizeof( cmd ) );
4355         cmd.cmd = CMD_TRANSMIT;
4356         cmd.parm0 = txFid;
4357         if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4358         if ( (rsp.status & 0xFF00) != 0) return ERROR;
4359         return SUCCESS;
4360 }
4361
4362 /*
4363  *  This is the proc_fs routines.  It is a bit messier than I would
4364  *  like!  Feel free to clean it up!
4365  */
4366
4367 static ssize_t proc_read( struct file *file,
4368                           char __user *buffer,
4369                           size_t len,
4370                           loff_t *offset);
4371
4372 static ssize_t proc_write( struct file *file,
4373                            const char __user *buffer,
4374                            size_t len,
4375                            loff_t *offset );
4376 static int proc_close( struct inode *inode, struct file *file );
4377
4378 static int proc_stats_open( struct inode *inode, struct file *file );
4379 static int proc_statsdelta_open( struct inode *inode, struct file *file );
4380 static int proc_status_open( struct inode *inode, struct file *file );
4381 static int proc_SSID_open( struct inode *inode, struct file *file );
4382 static int proc_APList_open( struct inode *inode, struct file *file );
4383 static int proc_BSSList_open( struct inode *inode, struct file *file );
4384 static int proc_config_open( struct inode *inode, struct file *file );
4385 static int proc_wepkey_open( struct inode *inode, struct file *file );
4386
4387 static const struct file_operations proc_statsdelta_ops = {
4388         .owner          = THIS_MODULE,
4389         .read           = proc_read,
4390         .open           = proc_statsdelta_open,
4391         .release        = proc_close
4392 };
4393
4394 static const struct file_operations proc_stats_ops = {
4395         .owner          = THIS_MODULE,
4396         .read           = proc_read,
4397         .open           = proc_stats_open,
4398         .release        = proc_close
4399 };
4400
4401 static const struct file_operations proc_status_ops = {
4402         .owner          = THIS_MODULE,
4403         .read           = proc_read,
4404         .open           = proc_status_open,
4405         .release        = proc_close
4406 };
4407
4408 static const struct file_operations proc_SSID_ops = {
4409         .owner          = THIS_MODULE,
4410         .read           = proc_read,
4411         .write          = proc_write,
4412         .open           = proc_SSID_open,
4413         .release        = proc_close
4414 };
4415
4416 static const struct file_operations proc_BSSList_ops = {
4417         .owner          = THIS_MODULE,
4418         .read           = proc_read,
4419         .write          = proc_write,
4420         .open           = proc_BSSList_open,
4421         .release        = proc_close
4422 };
4423
4424 static const struct file_operations proc_APList_ops = {
4425         .owner          = THIS_MODULE,
4426         .read           = proc_read,
4427         .write          = proc_write,
4428         .open           = proc_APList_open,
4429         .release        = proc_close
4430 };
4431
4432 static const struct file_operations proc_config_ops = {
4433         .owner          = THIS_MODULE,
4434         .read           = proc_read,
4435         .write          = proc_write,
4436         .open           = proc_config_open,
4437         .release        = proc_close
4438 };
4439
4440 static const struct file_operations proc_wepkey_ops = {
4441         .owner          = THIS_MODULE,
4442         .read           = proc_read,
4443         .write          = proc_write,
4444         .open           = proc_wepkey_open,
4445         .release        = proc_close
4446 };
4447
4448 static struct proc_dir_entry *airo_entry;
4449
4450 struct proc_data {
4451         int release_buffer;
4452         int readlen;
4453         char *rbuffer;
4454         int writelen;
4455         int maxwritelen;
4456         char *wbuffer;
4457         void (*on_close) (struct inode *, struct file *);
4458 };
4459
4460 static int setup_proc_entry( struct net_device *dev,
4461                              struct airo_info *apriv ) {
4462         struct proc_dir_entry *entry;
4463         /* First setup the device directory */
4464         strcpy(apriv->proc_name,dev->name);
4465         apriv->proc_entry = create_proc_entry(apriv->proc_name,
4466                                               S_IFDIR|airo_perm,
4467                                               airo_entry);
4468         if (!apriv->proc_entry)
4469                 goto fail;
4470         apriv->proc_entry->uid = proc_uid;
4471         apriv->proc_entry->gid = proc_gid;
4472         apriv->proc_entry->owner = THIS_MODULE;
4473
4474         /* Setup the StatsDelta */
4475         entry = proc_create_data("StatsDelta",
4476                                  S_IFREG | (S_IRUGO&proc_perm),
4477                                  apriv->proc_entry, &proc_statsdelta_ops, dev);
4478         if (!entry)
4479                 goto fail_stats_delta;
4480         entry->uid = proc_uid;
4481         entry->gid = proc_gid;
4482
4483         /* Setup the Stats */
4484         entry = proc_create_data("Stats",
4485                                  S_IFREG | (S_IRUGO&proc_perm),
4486                                  apriv->proc_entry, &proc_stats_ops, dev);
4487         if (!entry)
4488                 goto fail_stats;
4489         entry->uid = proc_uid;
4490         entry->gid = proc_gid;
4491
4492         /* Setup the Status */
4493         entry = proc_create_data("Status",
4494                                  S_IFREG | (S_IRUGO&proc_perm),
4495                                  apriv->proc_entry, &proc_status_ops, dev);
4496         if (!entry)
4497                 goto fail_status;
4498         entry->uid = proc_uid;
4499         entry->gid = proc_gid;
4500
4501         /* Setup the Config */
4502         entry = proc_create_data("Config",
4503                                  S_IFREG | proc_perm,
4504                                  apriv->proc_entry, &proc_config_ops, dev);
4505         if (!entry)
4506                 goto fail_config;
4507         entry->uid = proc_uid;
4508         entry->gid = proc_gid;
4509
4510         /* Setup the SSID */
4511         entry = proc_create_data("SSID",
4512                                  S_IFREG | proc_perm,
4513                                  apriv->proc_entry, &proc_SSID_ops, dev);
4514         if (!entry)
4515                 goto fail_ssid;
4516         entry->uid = proc_uid;
4517         entry->gid = proc_gid;
4518
4519         /* Setup the APList */
4520         entry = proc_create_data("APList",
4521                                  S_IFREG | proc_perm,
4522                                  apriv->proc_entry, &proc_APList_ops, dev);
4523         if (!entry)
4524                 goto fail_aplist;
4525         entry->uid = proc_uid;
4526         entry->gid = proc_gid;
4527
4528         /* Setup the BSSList */
4529         entry = proc_create_data("BSSList",
4530                                  S_IFREG | proc_perm,
4531                                  apriv->proc_entry, &proc_BSSList_ops, dev);
4532         if (!entry)
4533                 goto fail_bsslist;
4534         entry->uid = proc_uid;
4535         entry->gid = proc_gid;
4536
4537         /* Setup the WepKey */
4538         entry = proc_create_data("WepKey",
4539                                  S_IFREG | proc_perm,
4540                                  apriv->proc_entry, &proc_wepkey_ops, dev);
4541         if (!entry)
4542                 goto fail_wepkey;
4543         entry->uid = proc_uid;
4544         entry->gid = proc_gid;
4545
4546         return 0;
4547
4548 fail_wepkey:
4549         remove_proc_entry("BSSList", apriv->proc_entry);
4550 fail_bsslist:
4551         remove_proc_entry("APList", apriv->proc_entry);
4552 fail_aplist:
4553         remove_proc_entry("SSID", apriv->proc_entry);
4554 fail_ssid:
4555         remove_proc_entry("Config", apriv->proc_entry);
4556 fail_config:
4557         remove_proc_entry("Status", apriv->proc_entry);
4558 fail_status:
4559         remove_proc_entry("Stats", apriv->proc_entry);
4560 fail_stats:
4561         remove_proc_entry("StatsDelta", apriv->proc_entry);
4562 fail_stats_delta:
4563         remove_proc_entry(apriv->proc_name, airo_entry);
4564 fail:
4565         return -ENOMEM;
4566 }
4567
4568 static int takedown_proc_entry( struct net_device *dev,
4569                                 struct airo_info *apriv ) {
4570         if ( !apriv->proc_entry->namelen ) return 0;
4571         remove_proc_entry("Stats",apriv->proc_entry);
4572         remove_proc_entry("StatsDelta",apriv->proc_entry);
4573         remove_proc_entry("Status",apriv->proc_entry);
4574         remove_proc_entry("Config",apriv->proc_entry);
4575         remove_proc_entry("SSID",apriv->proc_entry);
4576         remove_proc_entry("APList",apriv->proc_entry);
4577         remove_proc_entry("BSSList",apriv->proc_entry);
4578         remove_proc_entry("WepKey",apriv->proc_entry);
4579         remove_proc_entry(apriv->proc_name,airo_entry);
4580         return 0;
4581 }
4582
4583 /*
4584  *  What we want from the proc_fs is to be able to efficiently read
4585  *  and write the configuration.  To do this, we want to read the
4586  *  configuration when the file is opened and write it when the file is
4587  *  closed.  So basically we allocate a read buffer at open and fill it
4588  *  with data, and allocate a write buffer and read it at close.
4589  */
4590
4591 /*
4592  *  The read routine is generic, it relies on the preallocated rbuffer
4593  *  to supply the data.
4594  */
4595 static ssize_t proc_read( struct file *file,
4596                           char __user *buffer,
4597                           size_t len,
4598                           loff_t *offset )
4599 {
4600         struct proc_data *priv = file->private_data;
4601
4602         if (!priv->rbuffer)
4603                 return -EINVAL;
4604
4605         return simple_read_from_buffer(buffer, len, offset, priv->rbuffer,
4606                                         priv->readlen);
4607 }
4608
4609 /*
4610  *  The write routine is generic, it fills in a preallocated rbuffer
4611  *  to supply the data.
4612  */
4613 static ssize_t proc_write( struct file *file,
4614                            const char __user *buffer,
4615                            size_t len,
4616                            loff_t *offset )
4617 {
4618         loff_t pos = *offset;
4619         struct proc_data *priv = (struct proc_data*)file->private_data;
4620
4621         if (!priv->wbuffer)
4622                 return -EINVAL;
4623
4624         if (pos < 0)
4625                 return -EINVAL;
4626         if (pos >= priv->maxwritelen)
4627                 return 0;
4628         if (len > priv->maxwritelen - pos)
4629                 len = priv->maxwritelen - pos;
4630         if (copy_from_user(priv->wbuffer + pos, buffer, len))
4631                 return -EFAULT;
4632         if ( pos + len > priv->writelen )
4633                 priv->writelen = len + file->f_pos;
4634         *offset = pos + len;
4635         return len;
4636 }
4637
4638 static int proc_status_open(struct inode *inode, struct file *file)
4639 {
4640         struct proc_data *data;
4641         struct proc_dir_entry *dp = PDE(inode);
4642         struct net_device *dev = dp->data;
4643         struct airo_info *apriv = dev->ml_priv;
4644         CapabilityRid cap_rid;
4645         StatusRid status_rid;
4646         u16 mode;
4647         int i;
4648
4649         if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4650                 return -ENOMEM;
4651         data = (struct proc_data *)file->private_data;
4652         if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4653                 kfree (file->private_data);
4654                 return -ENOMEM;
4655         }
4656
4657         readStatusRid(apriv, &status_rid, 1);
4658         readCapabilityRid(apriv, &cap_rid, 1);
4659
4660         mode = le16_to_cpu(status_rid.mode);
4661
4662         i = sprintf(data->rbuffer, "Status: %s%s%s%s%s%s%s%s%s\n",
4663                     mode & 1 ? "CFG ": "",
4664                     mode & 2 ? "ACT ": "",
4665                     mode & 0x10 ? "SYN ": "",
4666                     mode & 0x20 ? "LNK ": "",
4667                     mode & 0x40 ? "LEAP ": "",
4668                     mode & 0x80 ? "PRIV ": "",
4669                     mode & 0x100 ? "KEY ": "",
4670                     mode & 0x200 ? "WEP ": "",
4671                     mode & 0x8000 ? "ERR ": "");
4672         sprintf( data->rbuffer+i, "Mode: %x\n"
4673                  "Signal Strength: %d\n"
4674                  "Signal Quality: %d\n"
4675                  "SSID: %-.*s\n"
4676                  "AP: %-.16s\n"
4677                  "Freq: %d\n"
4678                  "BitRate: %dmbs\n"
4679                  "Driver Version: %s\n"
4680                  "Device: %s\nManufacturer: %s\nFirmware Version: %s\n"
4681                  "Radio type: %x\nCountry: %x\nHardware Version: %x\n"
4682                  "Software Version: %x\nSoftware Subversion: %x\n"
4683                  "Boot block version: %x\n",
4684                  le16_to_cpu(status_rid.mode),
4685                  le16_to_cpu(status_rid.normalizedSignalStrength),
4686                  le16_to_cpu(status_rid.signalQuality),
4687                  le16_to_cpu(status_rid.SSIDlen),
4688                  status_rid.SSID,
4689                  status_rid.apName,
4690                  le16_to_cpu(status_rid.channel),
4691                  le16_to_cpu(status_rid.currentXmitRate) / 2,
4692                  version,
4693                  cap_rid.prodName,
4694                  cap_rid.manName,
4695                  cap_rid.prodVer,
4696                  le16_to_cpu(cap_rid.radioType),
4697                  le16_to_cpu(cap_rid.country),
4698                  le16_to_cpu(cap_rid.hardVer),
4699                  le16_to_cpu(cap_rid.softVer),
4700                  le16_to_cpu(cap_rid.softSubVer),
4701                  le16_to_cpu(cap_rid.bootBlockVer));
4702         data->readlen = strlen( data->rbuffer );
4703         return 0;
4704 }
4705
4706 static int proc_stats_rid_open(struct inode*, struct file*, u16);
4707 static int proc_statsdelta_open( struct inode *inode,
4708                                  struct file *file ) {
4709         if (file->f_mode&FMODE_WRITE) {
4710                 return proc_stats_rid_open(inode, file, RID_STATSDELTACLEAR);
4711         }
4712         return proc_stats_rid_open(inode, file, RID_STATSDELTA);
4713 }
4714
4715 static int proc_stats_open( struct inode *inode, struct file *file ) {
4716         return proc_stats_rid_open(inode, file, RID_STATS);
4717 }
4718
4719 static int proc_stats_rid_open( struct inode *inode,
4720                                 struct file *file,
4721                                 u16 rid )
4722 {
4723         struct proc_data *data;
4724         struct proc_dir_entry *dp = PDE(inode);
4725         struct net_device *dev = dp->data;
4726         struct airo_info *apriv = dev->ml_priv;
4727         StatsRid stats;
4728         int i, j;
4729         __le32 *vals = stats.vals;
4730         int len = le16_to_cpu(stats.len);
4731
4732         if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4733                 return -ENOMEM;
4734         data = (struct proc_data *)file->private_data;
4735         if ((data->rbuffer = kmalloc( 4096, GFP_KERNEL )) == NULL) {
4736                 kfree (file->private_data);
4737                 return -ENOMEM;
4738         }
4739
4740         readStatsRid(apriv, &stats, rid, 1);
4741
4742         j = 0;
4743         for(i=0; statsLabels[i]!=(char *)-1 && i*4<len; i++) {
4744                 if (!statsLabels[i]) continue;
4745                 if (j+strlen(statsLabels[i])+16>4096) {
4746                         airo_print_warn(apriv->dev->name,
4747                                "Potentially disasterous buffer overflow averted!");
4748                         break;
4749                 }
4750                 j+=sprintf(data->rbuffer+j, "%s: %u\n", statsLabels[i],
4751                                 le32_to_cpu(vals[i]));
4752         }
4753         if (i*4 >= len) {
4754                 airo_print_warn(apriv->dev->name, "Got a short rid");
4755         }
4756         data->readlen = j;
4757         return 0;
4758 }
4759
4760 static int get_dec_u16( char *buffer, int *start, int limit ) {
4761         u16 value;
4762         int valid = 0;
4763         for( value = 0; buffer[*start] >= '0' &&
4764                      buffer[*start] <= '9' &&
4765                      *start < limit; (*start)++ ) {
4766                 valid = 1;
4767                 value *= 10;
4768                 value += buffer[*start] - '0';
4769         }
4770         if ( !valid ) return -1;
4771         return value;
4772 }
4773
4774 static int airo_config_commit(struct net_device *dev,
4775                               struct iw_request_info *info, void *zwrq,
4776                               char *extra);
4777
4778 static inline int sniffing_mode(struct airo_info *ai)
4779 {
4780         return le16_to_cpu(ai->config.rmode & RXMODE_MASK) >=
4781                 le16_to_cpu(RXMODE_RFMON);
4782 }
4783
4784 static void proc_config_on_close(struct inode *inode, struct file *file)
4785 {
4786         struct proc_data *data = file->private_data;
4787         struct proc_dir_entry *dp = PDE(inode);
4788         struct net_device *dev = dp->data;
4789         struct airo_info *ai = dev->ml_priv;
4790         char *line;
4791
4792         if ( !data->writelen ) return;
4793
4794         readConfigRid(ai, 1);
4795         set_bit (FLAG_COMMIT, &ai->flags);
4796
4797         line = data->wbuffer;
4798         while( line[0] ) {
4799 /*** Mode processing */
4800                 if ( !strncmp( line, "Mode: ", 6 ) ) {
4801                         line += 6;
4802                         if (sniffing_mode(ai))
4803                                 set_bit (FLAG_RESET, &ai->flags);
4804                         ai->config.rmode &= ~RXMODE_FULL_MASK;
4805                         clear_bit (FLAG_802_11, &ai->flags);
4806                         ai->config.opmode &= ~MODE_CFG_MASK;
4807                         ai->config.scanMode = SCANMODE_ACTIVE;
4808                         if ( line[0] == 'a' ) {
4809                                 ai->config.opmode |= MODE_STA_IBSS;
4810                         } else {
4811                                 ai->config.opmode |= MODE_STA_ESS;
4812                                 if ( line[0] == 'r' ) {
4813                                         ai->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
4814                                         ai->config.scanMode = SCANMODE_PASSIVE;
4815                                         set_bit (FLAG_802_11, &ai->flags);
4816                                 } else if ( line[0] == 'y' ) {
4817                                         ai->config.rmode |= RXMODE_RFMON_ANYBSS | RXMODE_DISABLE_802_3_HEADER;
4818                                         ai->config.scanMode = SCANMODE_PASSIVE;
4819                                         set_bit (FLAG_802_11, &ai->flags);
4820                                 } else if ( line[0] == 'l' )
4821                                         ai->config.rmode |= RXMODE_LANMON;
4822                         }
4823                         set_bit (FLAG_COMMIT, &ai->flags);
4824                 }
4825
4826 /*** Radio status */
4827                 else if (!strncmp(line,"Radio: ", 7)) {
4828                         line += 7;
4829                         if (!strncmp(line,"off",3)) {
4830                                 set_bit (FLAG_RADIO_OFF, &ai->flags);
4831                         } else {
4832                                 clear_bit (FLAG_RADIO_OFF, &ai->flags);
4833                         }
4834                 }
4835 /*** NodeName processing */
4836                 else if ( !strncmp( line, "NodeName: ", 10 ) ) {
4837                         int j;
4838
4839                         line += 10;
4840                         memset( ai->config.nodeName, 0, 16 );
4841 /* Do the name, assume a space between the mode and node name */
4842                         for( j = 0; j < 16 && line[j] != '\n'; j++ ) {
4843                                 ai->config.nodeName[j] = line[j];
4844                         }
4845                         set_bit (FLAG_COMMIT, &ai->flags);
4846                 }
4847
4848 /*** PowerMode processing */
4849                 else if ( !strncmp( line, "PowerMode: ", 11 ) ) {
4850                         line += 11;
4851                         if ( !strncmp( line, "PSPCAM", 6 ) ) {
4852                                 ai->config.powerSaveMode = POWERSAVE_PSPCAM;
4853                                 set_bit (FLAG_COMMIT, &ai->flags);
4854                         } else if ( !strncmp( line, "PSP", 3 ) ) {
4855                                 ai->config.powerSaveMode = POWERSAVE_PSP;
4856                                 set_bit (FLAG_COMMIT, &ai->flags);
4857                         } else {
4858                                 ai->config.powerSaveMode = POWERSAVE_CAM;
4859                                 set_bit (FLAG_COMMIT, &ai->flags);
4860                         }
4861                 } else if ( !strncmp( line, "DataRates: ", 11 ) ) {
4862                         int v, i = 0, k = 0; /* i is index into line,
4863                                                 k is index to rates */
4864
4865                         line += 11;
4866                         while((v = get_dec_u16(line, &i, 3))!=-1) {
4867                                 ai->config.rates[k++] = (u8)v;
4868                                 line += i + 1;
4869                                 i = 0;
4870                         }
4871                         set_bit (FLAG_COMMIT, &ai->flags);
4872                 } else if ( !strncmp( line, "Channel: ", 9 ) ) {
4873                         int v, i = 0;
4874                         line += 9;
4875                         v = get_dec_u16(line, &i, i+3);
4876                         if ( v != -1 ) {
4877                                 ai->config.channelSet = cpu_to_le16(v);
4878                                 set_bit (FLAG_COMMIT, &ai->flags);
4879                         }
4880                 } else if ( !strncmp( line, "XmitPower: ", 11 ) ) {
4881                         int v, i = 0;
4882                         line += 11;
4883                         v = get_dec_u16(line, &i, i+3);
4884                         if ( v != -1 ) {
4885                                 ai->config.txPower = cpu_to_le16(v);
4886                                 set_bit (FLAG_COMMIT, &ai->flags);
4887                         }
4888                 } else if ( !strncmp( line, "WEP: ", 5 ) ) {
4889                         line += 5;
4890                         switch( line[0] ) {
4891                         case 's':
4892                                 ai->config.authType = AUTH_SHAREDKEY;
4893                                 break;
4894                         case 'e':
4895                                 ai->config.authType = AUTH_ENCRYPT;
4896                                 break;
4897                         default:
4898                                 ai->config.authType = AUTH_OPEN;
4899                                 break;
4900                         }
4901                         set_bit (FLAG_COMMIT, &ai->flags);
4902                 } else if ( !strncmp( line, "LongRetryLimit: ", 16 ) ) {
4903                         int v, i = 0;
4904
4905                         line += 16;
4906                         v = get_dec_u16(line, &i, 3);
4907                         v = (v<0) ? 0 : ((v>255) ? 255 : v);
4908                         ai->config.longRetryLimit = cpu_to_le16(v);
4909                         set_bit (FLAG_COMMIT, &ai->flags);
4910                 } else if ( !strncmp( line, "ShortRetryLimit: ", 17 ) ) {
4911                         int v, i = 0;
4912
4913                         line += 17;
4914                         v = get_dec_u16(line, &i, 3);
4915                         v = (v<0) ? 0 : ((v>255) ? 255 : v);
4916                         ai->config.shortRetryLimit = cpu_to_le16(v);
4917                         set_bit (FLAG_COMMIT, &ai->flags);
4918                 } else if ( !strncmp( line, "RTSThreshold: ", 14 ) ) {
4919                         int v, i = 0;
4920
4921                         line += 14;
4922                         v = get_dec_u16(line, &i, 4);
4923                         v = (v<0) ? 0 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v);
4924                         ai->config.rtsThres = cpu_to_le16(v);
4925                         set_bit (FLAG_COMMIT, &ai->flags);
4926                 } else if ( !strncmp( line, "TXMSDULifetime: ", 16 ) ) {
4927                         int v, i = 0;
4928
4929                         line += 16;
4930                         v = get_dec_u16(line, &i, 5);
4931                         v = (v<0) ? 0 : v;
4932                         ai->config.txLifetime = cpu_to_le16(v);
4933                         set_bit (FLAG_COMMIT, &ai->flags);
4934                 } else if ( !strncmp( line, "RXMSDULifetime: ", 16 ) ) {
4935                         int v, i = 0;
4936
4937                         line += 16;
4938                         v = get_dec_u16(line, &i, 5);
4939                         v = (v<0) ? 0 : v;
4940                         ai->config.rxLifetime = cpu_to_le16(v);
4941                         set_bit (FLAG_COMMIT, &ai->flags);
4942                 } else if ( !strncmp( line, "TXDiversity: ", 13 ) ) {
4943                         ai->config.txDiversity =
4944                                 (line[13]=='l') ? 1 :
4945                                 ((line[13]=='r')? 2: 3);
4946                         set_bit (FLAG_COMMIT, &ai->flags);
4947                 } else if ( !strncmp( line, "RXDiversity: ", 13 ) ) {
4948                         ai->config.rxDiversity =
4949                                 (line[13]=='l') ? 1 :
4950                                 ((line[13]=='r')? 2: 3);
4951                         set_bit (FLAG_COMMIT, &ai->flags);
4952                 } else if ( !strncmp( line, "FragThreshold: ", 15 ) ) {
4953                         int v, i = 0;
4954
4955                         line += 15;
4956                         v = get_dec_u16(line, &i, 4);
4957                         v = (v<256) ? 256 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v);
4958                         v = v & 0xfffe; /* Make sure its even */
4959                         ai->config.fragThresh = cpu_to_le16(v);
4960                         set_bit (FLAG_COMMIT, &ai->flags);
4961                 } else if (!strncmp(line, "Modulation: ", 12)) {
4962                         line += 12;
4963                         switch(*line) {
4964                         case 'd':  ai->config.modulation=MOD_DEFAULT; set_bit(FLAG_COMMIT, &ai->flags); break;
4965                         case 'c':  ai->config.modulation=MOD_CCK; set_bit(FLAG_COMMIT, &ai->flags); break;
4966                         case 'm':  ai->config.modulation=MOD_MOK; set_bit(FLAG_COMMIT, &ai->flags); break;
4967                         default: airo_print_warn(ai->dev->name, "Unknown modulation");
4968                         }
4969                 } else if (!strncmp(line, "Preamble: ", 10)) {
4970                         line += 10;
4971                         switch(*line) {
4972                         case 'a': ai->config.preamble=PREAMBLE_AUTO; set_bit(FLAG_COMMIT, &ai->flags); break;
4973                         case 'l': ai->config.preamble=PREAMBLE_LONG; set_bit(FLAG_COMMIT, &ai->flags); break;
4974                         case 's': ai->config.preamble=PREAMBLE_SHORT; set_bit(FLAG_COMMIT, &ai->flags); break;
4975                         default: airo_print_warn(ai->dev->name, "Unknown preamble");
4976                         }
4977                 } else {
4978                         airo_print_warn(ai->dev->name, "Couldn't figure out %s", line);
4979                 }
4980                 while( line[0] && line[0] != '\n' ) line++;
4981                 if ( line[0] ) line++;
4982         }
4983         airo_config_commit(dev, NULL, NULL, NULL);
4984 }
4985
4986 static char *get_rmode(__le16 mode)
4987 {
4988         switch(mode & RXMODE_MASK) {
4989         case RXMODE_RFMON:  return "rfmon";
4990         case RXMODE_RFMON_ANYBSS:  return "yna (any) bss rfmon";
4991         case RXMODE_LANMON:  return "lanmon";
4992         }
4993         return "ESS";
4994 }
4995
4996 static int proc_config_open(struct inode *inode, struct file *file)
4997 {
4998         struct proc_data *data;
4999         struct proc_dir_entry *dp = PDE(inode);
5000         struct net_device *dev = dp->data;
5001         struct airo_info *ai = dev->ml_priv;
5002         int i;
5003         __le16 mode;
5004
5005         if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5006                 return -ENOMEM;
5007         data = (struct proc_data *)file->private_data;
5008         if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
5009                 kfree (file->private_data);
5010                 return -ENOMEM;
5011         }
5012         if ((data->wbuffer = kzalloc( 2048, GFP_KERNEL )) == NULL) {
5013                 kfree (data->rbuffer);
5014                 kfree (file->private_data);
5015                 return -ENOMEM;
5016         }
5017         data->maxwritelen = 2048;
5018         data->on_close = proc_config_on_close;
5019
5020         readConfigRid(ai, 1);
5021
5022         mode = ai->config.opmode & MODE_CFG_MASK;
5023         i = sprintf( data->rbuffer,
5024                      "Mode: %s\n"
5025                      "Radio: %s\n"
5026                      "NodeName: %-16s\n"
5027                      "PowerMode: %s\n"
5028                      "DataRates: %d %d %d %d %d %d %d %d\n"
5029                      "Channel: %d\n"
5030                      "XmitPower: %d\n",
5031                      mode == MODE_STA_IBSS ? "adhoc" :
5032                      mode == MODE_STA_ESS ? get_rmode(ai->config.rmode):
5033                      mode == MODE_AP ? "AP" :
5034                      mode == MODE_AP_RPTR ? "AP RPTR" : "Error",
5035                      test_bit(FLAG_RADIO_OFF, &ai->flags) ? "off" : "on",
5036                      ai->config.nodeName,
5037                      ai->config.powerSaveMode == POWERSAVE_CAM ? "CAM" :
5038                      ai->config.powerSaveMode == POWERSAVE_PSP ? "PSP" :
5039                      ai->config.powerSaveMode == POWERSAVE_PSPCAM ? "PSPCAM" :
5040                      "Error",
5041                      (int)ai->config.rates[0],
5042                      (int)ai->config.rates[1],
5043                      (int)ai->config.rates[2],
5044                      (int)ai->config.rates[3],
5045                      (int)ai->config.rates[4],
5046                      (int)ai->config.rates[5],
5047                      (int)ai->config.rates[6],
5048                      (int)ai->config.rates[7],
5049                      le16_to_cpu(ai->config.channelSet),
5050                      le16_to_cpu(ai->config.txPower)
5051                 );
5052         sprintf( data->rbuffer + i,
5053                  "LongRetryLimit: %d\n"
5054                  "ShortRetryLimit: %d\n"
5055                  "RTSThreshold: %d\n"
5056                  "TXMSDULifetime: %d\n"
5057                  "RXMSDULifetime: %d\n"
5058                  "TXDiversity: %s\n"
5059                  "RXDiversity: %s\n"
5060                  "FragThreshold: %d\n"
5061                  "WEP: %s\n"
5062                  "Modulation: %s\n"
5063                  "Preamble: %s\n",
5064                  le16_to_cpu(ai->config.longRetryLimit),
5065                  le16_to_cpu(ai->config.shortRetryLimit),
5066                  le16_to_cpu(ai->config.rtsThres),
5067                  le16_to_cpu(ai->config.txLifetime),
5068                  le16_to_cpu(ai->config.rxLifetime),
5069                  ai->config.txDiversity == 1 ? "left" :
5070                  ai->config.txDiversity == 2 ? "right" : "both",
5071                  ai->config.rxDiversity == 1 ? "left" :
5072                  ai->config.rxDiversity == 2 ? "right" : "both",
5073                  le16_to_cpu(ai->config.fragThresh),
5074                  ai->config.authType == AUTH_ENCRYPT ? "encrypt" :
5075                  ai->config.authType == AUTH_SHAREDKEY ? "shared" : "open",
5076                  ai->config.modulation == MOD_DEFAULT ? "default" :
5077                  ai->config.modulation == MOD_CCK ? "cck" :
5078                  ai->config.modulation == MOD_MOK ? "mok" : "error",
5079                  ai->config.preamble == PREAMBLE_AUTO ? "auto" :
5080                  ai->config.preamble == PREAMBLE_LONG ? "long" :
5081                  ai->config.preamble == PREAMBLE_SHORT ? "short" : "error"
5082                 );
5083         data->readlen = strlen( data->rbuffer );
5084         return 0;
5085 }
5086
5087 static void proc_SSID_on_close(struct inode *inode, struct file *file)
5088 {
5089         struct proc_data *data = (struct proc_data *)file->private_data;
5090         struct proc_dir_entry *dp = PDE(inode);
5091         struct net_device *dev = dp->data;
5092         struct airo_info *ai = dev->ml_priv;
5093         SsidRid SSID_rid;
5094         int i;
5095         char *p = data->wbuffer;
5096         char *end = p + data->writelen;
5097
5098         if (!data->writelen)
5099                 return;
5100
5101         *end = '\n'; /* sentinel; we have space for it */
5102
5103         memset(&SSID_rid, 0, sizeof(SSID_rid));
5104
5105         for (i = 0; i < 3 && p < end; i++) {
5106                 int j = 0;
5107                 /* copy up to 32 characters from this line */
5108                 while (*p != '\n' && j < 32)
5109                         SSID_rid.ssids[i].ssid[j++] = *p++;
5110                 if (j == 0)
5111                         break;
5112                 SSID_rid.ssids[i].len = cpu_to_le16(j);
5113                 /* skip to the beginning of the next line */
5114                 while (*p++ != '\n')
5115                         ;
5116         }
5117         if (i)
5118                 SSID_rid.len = cpu_to_le16(sizeof(SSID_rid));
5119         disable_MAC(ai, 1);
5120         writeSsidRid(ai, &SSID_rid, 1);
5121         enable_MAC(ai, 1);
5122 }
5123
5124 static inline u8 hexVal(char c) {
5125         if (c>='0' && c<='9') return c -= '0';
5126         if (c>='a' && c<='f') return c -= 'a'-10;
5127         if (c>='A' && c<='F') return c -= 'A'-10;
5128         return 0;
5129 }
5130
5131 static void proc_APList_on_close( struct inode *inode, struct file *file ) {
5132         struct proc_data *data = (struct proc_data *)file->private_data;
5133         struct proc_dir_entry *dp = PDE(inode);
5134         struct net_device *dev = dp->data;
5135         struct airo_info *ai = dev->ml_priv;
5136         APListRid APList_rid;
5137         int i;
5138
5139         if ( !data->writelen ) return;
5140
5141         memset( &APList_rid, 0, sizeof(APList_rid) );
5142         APList_rid.len = cpu_to_le16(sizeof(APList_rid));
5143
5144         for( i = 0; i < 4 && data->writelen >= (i+1)*6*3; i++ ) {
5145                 int j;
5146                 for( j = 0; j < 6*3 && data->wbuffer[j+i*6*3]; j++ ) {
5147                         switch(j%3) {
5148                         case 0:
5149                                 APList_rid.ap[i][j/3]=
5150                                         hexVal(data->wbuffer[j+i*6*3])<<4;
5151                                 break;
5152                         case 1:
5153                                 APList_rid.ap[i][j/3]|=
5154                                         hexVal(data->wbuffer[j+i*6*3]);
5155                                 break;
5156                         }
5157                 }
5158         }
5159         disable_MAC(ai, 1);
5160         writeAPListRid(ai, &APList_rid, 1);
5161         enable_MAC(ai, 1);
5162 }
5163
5164 /* This function wraps PC4500_writerid with a MAC disable */
5165 static int do_writerid( struct airo_info *ai, u16 rid, const void *rid_data,
5166                         int len, int dummy ) {
5167         int rc;
5168
5169         disable_MAC(ai, 1);
5170         rc = PC4500_writerid(ai, rid, rid_data, len, 1);
5171         enable_MAC(ai, 1);
5172         return rc;
5173 }
5174
5175 /* Returns the length of the key at the index.  If index == 0xffff
5176  * the index of the transmit key is returned.  If the key doesn't exist,
5177  * -1 will be returned.
5178  */
5179 static int get_wep_key(struct airo_info *ai, u16 index) {
5180         WepKeyRid wkr;
5181         int rc;
5182         __le16 lastindex;
5183
5184         rc = readWepKeyRid(ai, &wkr, 1, 1);
5185         if (rc == SUCCESS) do {
5186                 lastindex = wkr.kindex;
5187                 if (wkr.kindex == cpu_to_le16(index)) {
5188                         if (index == 0xffff) {
5189                                 return wkr.mac[0];
5190                         }
5191                         return le16_to_cpu(wkr.klen);
5192                 }
5193                 readWepKeyRid(ai, &wkr, 0, 1);
5194         } while (lastindex != wkr.kindex);
5195         return -1;
5196 }
5197
5198 static int set_wep_key(struct airo_info *ai, u16 index,
5199                        const char *key, u16 keylen, int perm, int lock )
5200 {
5201         static const unsigned char macaddr[ETH_ALEN] = { 0x01, 0, 0, 0, 0, 0 };
5202         WepKeyRid wkr;
5203
5204         memset(&wkr, 0, sizeof(wkr));
5205         if (keylen == 0) {
5206 // We are selecting which key to use
5207                 wkr.len = cpu_to_le16(sizeof(wkr));
5208                 wkr.kindex = cpu_to_le16(0xffff);
5209                 wkr.mac[0] = (char)index;
5210                 if (perm) ai->defindex = (char)index;
5211         } else {
5212 // We are actually setting the key
5213                 wkr.len = cpu_to_le16(sizeof(wkr));
5214                 wkr.kindex = cpu_to_le16(index);
5215                 wkr.klen = cpu_to_le16(keylen);
5216                 memcpy( wkr.key, key, keylen );
5217                 memcpy( wkr.mac, macaddr, ETH_ALEN );
5218         }
5219
5220         if (perm) disable_MAC(ai, lock);
5221         writeWepKeyRid(ai, &wkr, perm, lock);
5222         if (perm) enable_MAC(ai, lock);
5223         return 0;
5224 }
5225
5226 static void proc_wepkey_on_close( struct inode *inode, struct file *file ) {
5227         struct proc_data *data;
5228         struct proc_dir_entry *dp = PDE(inode);
5229         struct net_device *dev = dp->data;
5230         struct airo_info *ai = dev->ml_priv;
5231         int i;
5232         char key[16];
5233         u16 index = 0;
5234         int j = 0;
5235
5236         memset(key, 0, sizeof(key));
5237
5238         data = (struct proc_data *)file->private_data;
5239         if ( !data->writelen ) return;
5240
5241         if (data->wbuffer[0] >= '0' && data->wbuffer[0] <= '3' &&
5242             (data->wbuffer[1] == ' ' || data->wbuffer[1] == '\n')) {
5243                 index = data->wbuffer[0] - '0';
5244                 if (data->wbuffer[1] == '\n') {
5245                         set_wep_key(ai, index, NULL, 0, 1, 1);
5246                         return;
5247                 }
5248                 j = 2;
5249         } else {
5250                 airo_print_err(ai->dev->name, "WepKey passed invalid key index");
5251                 return;
5252         }
5253
5254         for( i = 0; i < 16*3 && data->wbuffer[i+j]; i++ ) {
5255                 switch(i%3) {
5256                 case 0:
5257                         key[i/3] = hexVal(data->wbuffer[i+j])<<4;
5258                         break;
5259                 case 1:
5260                         key[i/3] |= hexVal(data->wbuffer[i+j]);
5261                         break;
5262                 }
5263         }
5264         set_wep_key(ai, index, key, i/3, 1, 1);
5265 }
5266
5267 static int proc_wepkey_open( struct inode *inode, struct file *file )
5268 {
5269         struct proc_data *data;
5270         struct proc_dir_entry *dp = PDE(inode);
5271         struct net_device *dev = dp->data;
5272         struct airo_info *ai = dev->ml_priv;
5273         char *ptr;
5274         WepKeyRid wkr;
5275         __le16 lastindex;
5276         int j=0;
5277         int rc;
5278
5279         if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5280                 return -ENOMEM;
5281         memset(&wkr, 0, sizeof(wkr));
5282         data = (struct proc_data *)file->private_data;
5283         if ((data->rbuffer = kzalloc( 180, GFP_KERNEL )) == NULL) {
5284                 kfree (file->private_data);
5285                 return -ENOMEM;
5286         }
5287         data->writelen = 0;
5288         data->maxwritelen = 80;
5289         if ((data->wbuffer = kzalloc( 80, GFP_KERNEL )) == NULL) {
5290                 kfree (data->rbuffer);
5291                 kfree (file->private_data);
5292                 return -ENOMEM;
5293         }
5294         data->on_close = proc_wepkey_on_close;
5295
5296         ptr = data->rbuffer;
5297         strcpy(ptr, "No wep keys\n");
5298         rc = readWepKeyRid(ai, &wkr, 1, 1);
5299         if (rc == SUCCESS) do {
5300                 lastindex = wkr.kindex;
5301                 if (wkr.kindex == cpu_to_le16(0xffff)) {
5302                         j += sprintf(ptr+j, "Tx key = %d\n",
5303                                      (int)wkr.mac[0]);
5304                 } else {
5305                         j += sprintf(ptr+j, "Key %d set with length = %d\n",
5306                                      le16_to_cpu(wkr.kindex),
5307                                      le16_to_cpu(wkr.klen));
5308                 }
5309                 readWepKeyRid(ai, &wkr, 0, 1);
5310         } while((lastindex != wkr.kindex) && (j < 180-30));
5311
5312         data->readlen = strlen( data->rbuffer );
5313         return 0;
5314 }
5315
5316 static int proc_SSID_open(struct inode *inode, struct file *file)
5317 {
5318         struct proc_data *data;
5319         struct proc_dir_entry *dp = PDE(inode);
5320         struct net_device *dev = dp->data;
5321         struct airo_info *ai = dev->ml_priv;
5322         int i;
5323         char *ptr;
5324         SsidRid SSID_rid;
5325
5326         if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5327                 return -ENOMEM;
5328         data = (struct proc_data *)file->private_data;
5329         if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5330                 kfree (file->private_data);
5331                 return -ENOMEM;
5332         }
5333         data->writelen = 0;
5334         data->maxwritelen = 33*3;
5335         /* allocate maxwritelen + 1; we'll want a sentinel */
5336         if ((data->wbuffer = kzalloc(33*3 + 1, GFP_KERNEL)) == NULL) {
5337                 kfree (data->rbuffer);
5338                 kfree (file->private_data);
5339                 return -ENOMEM;
5340         }
5341         data->on_close = proc_SSID_on_close;
5342
5343         readSsidRid(ai, &SSID_rid);
5344         ptr = data->rbuffer;
5345         for (i = 0; i < 3; i++) {
5346                 int j;
5347                 size_t len = le16_to_cpu(SSID_rid.ssids[i].len);
5348                 if (!len)
5349                         break;
5350                 if (len > 32)
5351                         len = 32;
5352                 for (j = 0; j < len && SSID_rid.ssids[i].ssid[j]; j++)
5353                         *ptr++ = SSID_rid.ssids[i].ssid[j];
5354                 *ptr++ = '\n';
5355         }
5356         *ptr = '\0';
5357         data->readlen = strlen( data->rbuffer );
5358         return 0;
5359 }
5360
5361 static int proc_APList_open( struct inode *inode, struct file *file ) {
5362         struct proc_data *data;
5363         struct proc_dir_entry *dp = PDE(inode);
5364         struct net_device *dev = dp->data;
5365         struct airo_info *ai = dev->ml_priv;
5366         int i;
5367         char *ptr;
5368         APListRid APList_rid;
5369
5370         if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5371                 return -ENOMEM;
5372         data = (struct proc_data *)file->private_data;
5373         if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5374                 kfree (file->private_data);
5375                 return -ENOMEM;
5376         }
5377         data->writelen = 0;
5378         data->maxwritelen = 4*6*3;
5379         if ((data->wbuffer = kzalloc( data->maxwritelen, GFP_KERNEL )) == NULL) {
5380                 kfree (data->rbuffer);
5381                 kfree (file->private_data);
5382                 return -ENOMEM;
5383         }
5384         data->on_close = proc_APList_on_close;
5385
5386         readAPListRid(ai, &APList_rid);
5387         ptr = data->rbuffer;
5388         for( i = 0; i < 4; i++ ) {
5389 // We end when we find a zero MAC
5390                 if ( !*(int*)APList_rid.ap[i] &&
5391                      !*(int*)&APList_rid.ap[i][2]) break;
5392                 ptr += sprintf(ptr, "%pM\n", APList_rid.ap[i]);
5393         }
5394         if (i==0) ptr += sprintf(ptr, "Not using specific APs\n");
5395
5396         *ptr = '\0';
5397         data->readlen = strlen( data->rbuffer );
5398         return 0;
5399 }
5400
5401 static int proc_BSSList_open( struct inode *inode, struct file *file ) {
5402         struct proc_data *data;
5403         struct proc_dir_entry *dp = PDE(inode);
5404         struct net_device *dev = dp->data;
5405         struct airo_info *ai = dev->ml_priv;
5406         char *ptr;
5407         BSSListRid BSSList_rid;
5408         int rc;
5409         /* If doLoseSync is not 1, we won't do a Lose Sync */
5410         int doLoseSync = -1;
5411
5412         if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5413                 return -ENOMEM;
5414         data = (struct proc_data *)file->private_data;
5415         if ((data->rbuffer = kmalloc( 1024, GFP_KERNEL )) == NULL) {
5416                 kfree (file->private_data);
5417                 return -ENOMEM;
5418         }
5419         data->writelen = 0;
5420         data->maxwritelen = 0;
5421         data->wbuffer = NULL;
5422         data->on_close = NULL;
5423
5424         if (file->f_mode & FMODE_WRITE) {
5425                 if (!(file->f_mode & FMODE_READ)) {
5426                         Cmd cmd;
5427                         Resp rsp;
5428
5429                         if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
5430                         memset(&cmd, 0, sizeof(cmd));
5431                         cmd.cmd=CMD_LISTBSS;
5432                         if (down_interruptible(&ai->sem))
5433                                 return -ERESTARTSYS;
5434                         issuecommand(ai, &cmd, &rsp);
5435                         up(&ai->sem);
5436                         data->readlen = 0;
5437                         return 0;
5438                 }
5439                 doLoseSync = 1;
5440         }
5441         ptr = data->rbuffer;
5442         /* There is a race condition here if there are concurrent opens.
5443            Since it is a rare condition, we'll just live with it, otherwise
5444            we have to add a spin lock... */
5445         rc = readBSSListRid(ai, doLoseSync, &BSSList_rid);
5446         while(rc == 0 && BSSList_rid.index != cpu_to_le16(0xffff)) {
5447                 ptr += sprintf(ptr, "%pM %*s rssi = %d",
5448                                BSSList_rid.bssid,
5449                                 (int)BSSList_rid.ssidLen,
5450                                 BSSList_rid.ssid,
5451                                 le16_to_cpu(BSSList_rid.dBm));
5452                 ptr += sprintf(ptr, " channel = %d %s %s %s %s\n",
5453                                 le16_to_cpu(BSSList_rid.dsChannel),
5454                                 BSSList_rid.cap & CAP_ESS ? "ESS" : "",
5455                                 BSSList_rid.cap & CAP_IBSS ? "adhoc" : "",
5456                                 BSSList_rid.cap & CAP_PRIVACY ? "wep" : "",
5457                                 BSSList_rid.cap & CAP_SHORTHDR ? "shorthdr" : "");
5458                 rc = readBSSListRid(ai, 0, &BSSList_rid);
5459         }
5460         *ptr = '\0';
5461         data->readlen = strlen( data->rbuffer );
5462         return 0;
5463 }
5464
5465 static int proc_close( struct inode *inode, struct file *file )
5466 {
5467         struct proc_data *data = file->private_data;
5468
5469         if (data->on_close != NULL)
5470                 data->on_close(inode, file);
5471         kfree(data->rbuffer);
5472         kfree(data->wbuffer);
5473         kfree(data);
5474         return 0;
5475 }
5476
5477 /* Since the card doesn't automatically switch to the right WEP mode,
5478    we will make it do it.  If the card isn't associated, every secs we
5479    will switch WEP modes to see if that will help.  If the card is
5480    associated we will check every minute to see if anything has
5481    changed. */
5482 static void timer_func( struct net_device *dev ) {
5483         struct airo_info *apriv = dev->ml_priv;
5484
5485 /* We don't have a link so try changing the authtype */
5486         readConfigRid(apriv, 0);
5487         disable_MAC(apriv, 0);
5488         switch(apriv->config.authType) {
5489                 case AUTH_ENCRYPT:
5490 /* So drop to OPEN */
5491                         apriv->config.authType = AUTH_OPEN;
5492                         break;
5493                 case AUTH_SHAREDKEY:
5494                         if (apriv->keyindex < auto_wep) {
5495                                 set_wep_key(apriv, apriv->keyindex, NULL, 0, 0, 0);
5496                                 apriv->config.authType = AUTH_SHAREDKEY;
5497                                 apriv->keyindex++;
5498                         } else {
5499                                 /* Drop to ENCRYPT */
5500                                 apriv->keyindex = 0;
5501                                 set_wep_key(apriv, apriv->defindex, NULL, 0, 0, 0);
5502                                 apriv->config.authType = AUTH_ENCRYPT;
5503                         }
5504                         break;
5505                 default:  /* We'll escalate to SHAREDKEY */
5506                         apriv->config.authType = AUTH_SHAREDKEY;
5507         }
5508         set_bit (FLAG_COMMIT, &apriv->flags);
5509         writeConfigRid(apriv, 0);
5510         enable_MAC(apriv, 0);
5511         up(&apriv->sem);
5512
5513 /* Schedule check to see if the change worked */
5514         clear_bit(JOB_AUTOWEP, &apriv->jobs);
5515         apriv->expires = RUN_AT(HZ*3);
5516 }
5517
5518 #ifdef CONFIG_PCI
5519 static int __devinit airo_pci_probe(struct pci_dev *pdev,
5520                                     const struct pci_device_id *pent)
5521 {
5522         struct net_device *dev;
5523
5524         if (pci_enable_device(pdev))
5525                 return -ENODEV;
5526         pci_set_master(pdev);
5527
5528         if (pdev->device == 0x5000 || pdev->device == 0xa504)
5529                         dev = _init_airo_card(pdev->irq, pdev->resource[0].start, 0, pdev, &pdev->dev);
5530         else
5531                         dev = _init_airo_card(pdev->irq, pdev->resource[2].start, 0, pdev, &pdev->dev);
5532         if (!dev) {
5533                 pci_disable_device(pdev);
5534                 return -ENODEV;
5535         }
5536
5537         pci_set_drvdata(pdev, dev);
5538         return 0;
5539 }
5540
5541 static void __devexit airo_pci_remove(struct pci_dev *pdev)
5542 {
5543         struct net_device *dev = pci_get_drvdata(pdev);
5544
5545         airo_print_info(dev->name, "Unregistering...");
5546         stop_airo_card(dev, 1);
5547         pci_disable_device(pdev);
5548         pci_set_drvdata(pdev, NULL);
5549 }
5550
5551 static int airo_pci_suspend(struct pci_dev *pdev, pm_message_t state)
5552 {
5553         struct net_device *dev = pci_get_drvdata(pdev);
5554         struct airo_info *ai = dev->ml_priv;
5555         Cmd cmd;
5556         Resp rsp;
5557
5558         if (!ai->APList)
5559                 ai->APList = kmalloc(sizeof(APListRid), GFP_KERNEL);
5560         if (!ai->APList)
5561                 return -ENOMEM;
5562         if (!ai->SSID)
5563                 ai->SSID = kmalloc(sizeof(SsidRid), GFP_KERNEL);
5564         if (!ai->SSID)
5565                 return -ENOMEM;
5566         readAPListRid(ai, ai->APList);
5567         readSsidRid(ai, ai->SSID);
5568         memset(&cmd, 0, sizeof(cmd));
5569         /* the lock will be released at the end of the resume callback */
5570         if (down_interruptible(&ai->sem))
5571                 return -EAGAIN;
5572         disable_MAC(ai, 0);
5573         netif_device_detach(dev);
5574         ai->power = state;
5575         cmd.cmd = HOSTSLEEP;
5576         issuecommand(ai, &cmd, &rsp);
5577
5578         pci_enable_wake(pdev, pci_choose_state(pdev, state), 1);
5579         pci_save_state(pdev);
5580         return pci_set_power_state(pdev, pci_choose_state(pdev, state));
5581 }
5582
5583 static int airo_pci_resume(struct pci_dev *pdev)
5584 {
5585         struct net_device *dev = pci_get_drvdata(pdev);
5586         struct airo_info *ai = dev->ml_priv;
5587         pci_power_t prev_state = pdev->current_state;
5588
5589         pci_set_power_state(pdev, PCI_D0);
5590         pci_restore_state(pdev);
5591         pci_enable_wake(pdev, PCI_D0, 0);
5592
5593         if (prev_state != PCI_D1) {
5594                 reset_card(dev, 0);
5595                 mpi_init_descriptors(ai);
5596                 setup_card(ai, dev->dev_addr, 0);
5597                 clear_bit(FLAG_RADIO_OFF, &ai->flags);
5598                 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
5599         } else {
5600                 OUT4500(ai, EVACK, EV_AWAKEN);
5601                 OUT4500(ai, EVACK, EV_AWAKEN);
5602                 msleep(100);
5603         }
5604
5605         set_bit(FLAG_COMMIT, &ai->flags);
5606         disable_MAC(ai, 0);
5607         msleep(200);
5608         if (ai->SSID) {
5609                 writeSsidRid(ai, ai->SSID, 0);
5610                 kfree(ai->SSID);
5611                 ai->SSID = NULL;
5612         }
5613         if (ai->APList) {
5614                 writeAPListRid(ai, ai->APList, 0);
5615                 kfree(ai->APList);
5616                 ai->APList = NULL;
5617         }
5618         writeConfigRid(ai, 0);
5619         enable_MAC(ai, 0);
5620         ai->power = PMSG_ON;
5621         netif_device_attach(dev);
5622         netif_wake_queue(dev);
5623         enable_interrupts(ai);
5624         up(&ai->sem);
5625         return 0;
5626 }
5627 #endif
5628
5629 static int __init airo_init_module( void )
5630 {
5631         int i;
5632
5633         airo_entry = create_proc_entry("driver/aironet",
5634                                        S_IFDIR | airo_perm,
5635                                        NULL);
5636
5637         if (airo_entry) {
5638                 airo_entry->uid = proc_uid;
5639                 airo_entry->gid = proc_gid;
5640         }
5641
5642         for (i = 0; i < 4 && io[i] && irq[i]; i++) {
5643                 airo_print_info("", "Trying to configure ISA adapter at irq=%d "
5644                         "io=0x%x", irq[i], io[i] );
5645                 if (init_airo_card( irq[i], io[i], 0, NULL ))
5646                         /* do nothing */ ;
5647         }
5648
5649 #ifdef CONFIG_PCI
5650         airo_print_info("", "Probing for PCI adapters");
5651         i = pci_register_driver(&airo_driver);
5652         airo_print_info("", "Finished probing for PCI adapters");
5653
5654         if (i) {
5655                 remove_proc_entry("driver/aironet", NULL);
5656                 return i;
5657         }
5658 #endif
5659
5660         /* Always exit with success, as we are a library module
5661          * as well as a driver module
5662          */
5663         return 0;
5664 }
5665
5666 static void __exit airo_cleanup_module( void )
5667 {
5668         struct airo_info *ai;
5669         while(!list_empty(&airo_devices)) {
5670                 ai = list_entry(airo_devices.next, struct airo_info, dev_list);
5671                 airo_print_info(ai->dev->name, "Unregistering...");
5672                 stop_airo_card(ai->dev, 1);
5673         }
5674 #ifdef CONFIG_PCI
5675         pci_unregister_driver(&airo_driver);
5676 #endif
5677         remove_proc_entry("driver/aironet", NULL);
5678 }
5679
5680 /*
5681  * Initial Wireless Extension code for Aironet driver by :
5682  *      Jean Tourrilhes <jt@hpl.hp.com> - HPL - 17 November 00
5683  * Conversion to new driver API by :
5684  *      Jean Tourrilhes <jt@hpl.hp.com> - HPL - 26 March 02
5685  * Javier also did a good amount of work here, adding some new extensions
5686  * and fixing my code. Let's just say that without him this code just
5687  * would not work at all... - Jean II
5688  */
5689
5690 static u8 airo_rssi_to_dbm (tdsRssiEntry *rssi_rid, u8 rssi)
5691 {
5692         if (!rssi_rid)
5693                 return 0;
5694
5695         return (0x100 - rssi_rid[rssi].rssidBm);
5696 }
5697
5698 static u8 airo_dbm_to_pct (tdsRssiEntry *rssi_rid, u8 dbm)
5699 {
5700         int i;
5701
5702         if (!rssi_rid)
5703                 return 0;
5704
5705         for (i = 0; i < 256; i++)
5706                 if (rssi_rid[i].rssidBm == dbm)
5707                         return rssi_rid[i].rssipct;
5708
5709         return 0;
5710 }
5711
5712
5713 static int airo_get_quality (StatusRid *status_rid, CapabilityRid *cap_rid)
5714 {
5715         int quality = 0;
5716         u16 sq;
5717
5718         if ((status_rid->mode & cpu_to_le16(0x3f)) != cpu_to_le16(0x3f))
5719                 return 0;
5720
5721         if (!(cap_rid->hardCap & cpu_to_le16(8)))
5722                 return 0;
5723
5724         sq = le16_to_cpu(status_rid->signalQuality);
5725         if (memcmp(cap_rid->prodName, "350", 3))
5726                 if (sq > 0x20)
5727                         quality = 0;
5728                 else
5729                         quality = 0x20 - sq;
5730         else
5731                 if (sq > 0xb0)
5732                         quality = 0;
5733                 else if (sq < 0x10)
5734                         quality = 0xa0;
5735                 else
5736                         quality = 0xb0 - sq;
5737         return quality;
5738 }
5739
5740 #define airo_get_max_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x20 : 0xa0)
5741 #define airo_get_avg_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x10 : 0x50);
5742
5743 /*------------------------------------------------------------------*/
5744 /*
5745  * Wireless Handler : get protocol name
5746  */
5747 static int airo_get_name(struct net_device *dev,
5748                          struct iw_request_info *info,
5749                          char *cwrq,
5750                          char *extra)
5751 {
5752         strcpy(cwrq, "IEEE 802.11-DS");
5753         return 0;
5754 }
5755
5756 /*------------------------------------------------------------------*/
5757 /*
5758  * Wireless Handler : set frequency
5759  */
5760 static int airo_set_freq(struct net_device *dev,
5761                          struct iw_request_info *info,
5762                          struct iw_freq *fwrq,
5763                          char *extra)
5764 {
5765         struct airo_info *local = dev->ml_priv;
5766         int rc = -EINPROGRESS;          /* Call commit handler */
5767
5768         /* If setting by frequency, convert to a channel */
5769         if(fwrq->e == 1) {
5770                 int f = fwrq->m / 100000;
5771
5772                 /* Hack to fall through... */
5773                 fwrq->e = 0;
5774                 fwrq->m = ieee80211_freq_to_dsss_chan(f);
5775         }
5776         /* Setting by channel number */
5777         if((fwrq->m > 1000) || (fwrq->e > 0))
5778                 rc = -EOPNOTSUPP;
5779         else {
5780                 int channel = fwrq->m;
5781                 /* We should do a better check than that,
5782                  * based on the card capability !!! */
5783                 if((channel < 1) || (channel > 14)) {
5784                         airo_print_dbg(dev->name, "New channel value of %d is invalid!",
5785                                 fwrq->m);
5786                         rc = -EINVAL;
5787                 } else {
5788                         readConfigRid(local, 1);
5789                         /* Yes ! We can set it !!! */
5790                         local->config.channelSet = cpu_to_le16(channel);
5791                         set_bit (FLAG_COMMIT, &local->flags);
5792                 }
5793         }
5794         return rc;
5795 }
5796
5797 /*------------------------------------------------------------------*/
5798 /*
5799  * Wireless Handler : get frequency
5800  */
5801 static int airo_get_freq(struct net_device *dev,
5802                          struct iw_request_info *info,
5803                          struct iw_freq *fwrq,
5804                          char *extra)
5805 {
5806         struct airo_info *local = dev->ml_priv;
5807         StatusRid status_rid;           /* Card status info */
5808         int ch;
5809
5810         readConfigRid(local, 1);
5811         if ((local->config.opmode & MODE_CFG_MASK) == MODE_STA_ESS)
5812                 status_rid.channel = local->config.channelSet;
5813         else
5814                 readStatusRid(local, &status_rid, 1);
5815
5816         ch = le16_to_cpu(status_rid.channel);
5817         if((ch > 0) && (ch < 15)) {
5818                 fwrq->m = ieee80211_dsss_chan_to_freq(ch) * 100000;
5819                 fwrq->e = 1;
5820         } else {
5821                 fwrq->m = ch;
5822                 fwrq->e = 0;
5823         }
5824
5825         return 0;
5826 }
5827
5828 /*------------------------------------------------------------------*/
5829 /*
5830  * Wireless Handler : set ESSID
5831  */
5832 static int airo_set_essid(struct net_device *dev,
5833                           struct iw_request_info *info,
5834                           struct iw_point *dwrq,
5835                           char *extra)
5836 {
5837         struct airo_info *local = dev->ml_priv;
5838         SsidRid SSID_rid;               /* SSIDs */
5839
5840         /* Reload the list of current SSID */
5841         readSsidRid(local, &SSID_rid);
5842
5843         /* Check if we asked for `any' */
5844         if(dwrq->flags == 0) {
5845                 /* Just send an empty SSID list */
5846                 memset(&SSID_rid, 0, sizeof(SSID_rid));
5847         } else {
5848                 int     index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
5849
5850                 /* Check the size of the string */
5851                 if(dwrq->length > IW_ESSID_MAX_SIZE) {
5852                         return -E2BIG ;
5853                 }
5854                 /* Check if index is valid */
5855                 if((index < 0) || (index >= 4)) {
5856                         return -EINVAL;
5857                 }
5858
5859                 /* Set the SSID */
5860                 memset(SSID_rid.ssids[index].ssid, 0,
5861                        sizeof(SSID_rid.ssids[index].ssid));
5862                 memcpy(SSID_rid.ssids[index].ssid, extra, dwrq->length);
5863                 SSID_rid.ssids[index].len = cpu_to_le16(dwrq->length);
5864         }
5865         SSID_rid.len = cpu_to_le16(sizeof(SSID_rid));
5866         /* Write it to the card */
5867         disable_MAC(local, 1);
5868         writeSsidRid(local, &SSID_rid, 1);
5869         enable_MAC(local, 1);
5870
5871         return 0;
5872 }
5873
5874 /*------------------------------------------------------------------*/
5875 /*
5876  * Wireless Handler : get ESSID
5877  */
5878 static int airo_get_essid(struct net_device *dev,
5879                           struct iw_request_info *info,
5880                           struct iw_point *dwrq,
5881                           char *extra)
5882 {
5883         struct airo_info *local = dev->ml_priv;
5884         StatusRid status_rid;           /* Card status info */
5885
5886         readStatusRid(local, &status_rid, 1);
5887
5888         /* Note : if dwrq->flags != 0, we should
5889          * get the relevant SSID from the SSID list... */
5890
5891         /* Get the current SSID */
5892         memcpy(extra, status_rid.SSID, le16_to_cpu(status_rid.SSIDlen));
5893         /* If none, we may want to get the one that was set */
5894
5895         /* Push it out ! */
5896         dwrq->length = le16_to_cpu(status_rid.SSIDlen);
5897         dwrq->flags = 1; /* active */
5898
5899         return 0;
5900 }
5901
5902 /*------------------------------------------------------------------*/
5903 /*
5904  * Wireless Handler : set AP address
5905  */
5906 static int airo_set_wap(struct net_device *dev,
5907                         struct iw_request_info *info,
5908                         struct sockaddr *awrq,
5909                         char *extra)
5910 {
5911         struct airo_info *local = dev->ml_priv;
5912         Cmd cmd;
5913         Resp rsp;
5914         APListRid APList_rid;
5915         static const u8 any[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
5916         static const u8 off[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
5917
5918         if (awrq->sa_family != ARPHRD_ETHER)
5919                 return -EINVAL;
5920         else if (!memcmp(any, awrq->sa_data, ETH_ALEN) ||
5921                  !memcmp(off, awrq->sa_data, ETH_ALEN)) {
5922                 memset(&cmd, 0, sizeof(cmd));
5923                 cmd.cmd=CMD_LOSE_SYNC;
5924                 if (down_interruptible(&local->sem))
5925                         return -ERESTARTSYS;
5926                 issuecommand(local, &cmd, &rsp);
5927                 up(&local->sem);
5928         } else {
5929                 memset(&APList_rid, 0, sizeof(APList_rid));
5930                 APList_rid.len = cpu_to_le16(sizeof(APList_rid));
5931                 memcpy(APList_rid.ap[0], awrq->sa_data, ETH_ALEN);
5932                 disable_MAC(local, 1);
5933                 writeAPListRid(local, &APList_rid, 1);
5934                 enable_MAC(local, 1);
5935         }
5936         return 0;
5937 }
5938
5939 /*------------------------------------------------------------------*/
5940 /*
5941  * Wireless Handler : get AP address
5942  */
5943 static int airo_get_wap(struct net_device *dev,
5944                         struct iw_request_info *info,
5945                         struct sockaddr *awrq,
5946                         char *extra)
5947 {
5948         struct airo_info *local = dev->ml_priv;
5949         StatusRid status_rid;           /* Card status info */
5950
5951         readStatusRid(local, &status_rid, 1);
5952
5953         /* Tentative. This seems to work, wow, I'm lucky !!! */
5954         memcpy(awrq->sa_data, status_rid.bssid[0], ETH_ALEN);
5955         awrq->sa_family = ARPHRD_ETHER;
5956
5957         return 0;
5958 }
5959
5960 /*------------------------------------------------------------------*/
5961 /*
5962  * Wireless Handler : set Nickname
5963  */
5964 static int airo_set_nick(struct net_device *dev,
5965                          struct iw_request_info *info,
5966                          struct iw_point *dwrq,
5967                          char *extra)
5968 {
5969         struct airo_info *local = dev->ml_priv;
5970
5971         /* Check the size of the string */
5972         if(dwrq->length > 16) {
5973                 return -E2BIG;
5974         }
5975         readConfigRid(local, 1);
5976         memset(local->config.nodeName, 0, sizeof(local->config.nodeName));
5977         memcpy(local->config.nodeName, extra, dwrq->length);
5978         set_bit (FLAG_COMMIT, &local->flags);
5979
5980         return -EINPROGRESS;            /* Call commit handler */
5981 }
5982
5983 /*------------------------------------------------------------------*/
5984 /*
5985  * Wireless Handler : get Nickname
5986  */
5987 static int airo_get_nick(struct net_device *dev,
5988                          struct iw_request_info *info,
5989                          struct iw_point *dwrq,
5990                          char *extra)
5991 {
5992         struct airo_info *local = dev->ml_priv;
5993
5994         readConfigRid(local, 1);
5995         strncpy(extra, local->config.nodeName, 16);
5996         extra[16] = '\0';
5997         dwrq->length = strlen(extra);
5998
5999         return 0;
6000 }
6001
6002 /*------------------------------------------------------------------*/
6003 /*
6004  * Wireless Handler : set Bit-Rate
6005  */
6006 static int airo_set_rate(struct net_device *dev,
6007                          struct iw_request_info *info,
6008                          struct iw_param *vwrq,
6009                          char *extra)
6010 {
6011         struct airo_info *local = dev->ml_priv;
6012         CapabilityRid cap_rid;          /* Card capability info */
6013         u8      brate = 0;
6014         int     i;
6015
6016         /* First : get a valid bit rate value */
6017         readCapabilityRid(local, &cap_rid, 1);
6018
6019         /* Which type of value ? */
6020         if((vwrq->value < 8) && (vwrq->value >= 0)) {
6021                 /* Setting by rate index */
6022                 /* Find value in the magic rate table */
6023                 brate = cap_rid.supportedRates[vwrq->value];
6024         } else {
6025                 /* Setting by frequency value */
6026                 u8      normvalue = (u8) (vwrq->value/500000);
6027
6028                 /* Check if rate is valid */
6029                 for(i = 0 ; i < 8 ; i++) {
6030                         if(normvalue == cap_rid.supportedRates[i]) {
6031                                 brate = normvalue;
6032                                 break;
6033                         }
6034                 }
6035         }
6036         /* -1 designed the max rate (mostly auto mode) */
6037         if(vwrq->value == -1) {
6038                 /* Get the highest available rate */
6039                 for(i = 0 ; i < 8 ; i++) {
6040                         if(cap_rid.supportedRates[i] == 0)
6041                                 break;
6042                 }
6043                 if(i != 0)
6044                         brate = cap_rid.supportedRates[i - 1];
6045         }
6046         /* Check that it is valid */
6047         if(brate == 0) {
6048                 return -EINVAL;
6049         }
6050
6051         readConfigRid(local, 1);
6052         /* Now, check if we want a fixed or auto value */
6053         if(vwrq->fixed == 0) {
6054                 /* Fill all the rates up to this max rate */
6055                 memset(local->config.rates, 0, 8);
6056                 for(i = 0 ; i < 8 ; i++) {
6057                         local->config.rates[i] = cap_rid.supportedRates[i];
6058                         if(local->config.rates[i] == brate)
6059                                 break;
6060                 }
6061         } else {
6062                 /* Fixed mode */
6063                 /* One rate, fixed */
6064                 memset(local->config.rates, 0, 8);
6065                 local->config.rates[0] = brate;
6066         }
6067         set_bit (FLAG_COMMIT, &local->flags);
6068
6069         return -EINPROGRESS;            /* Call commit handler */
6070 }
6071
6072 /*---------------------------------