projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master' into upstream
[deliverable/linux.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/init.h>
23
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/proc_fs.h>
27 #include <linux/smp_lock.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
42 #include <linux/netdevice.h>
43 #include <linux/etherdevice.h>
44 #include <linux/skbuff.h>
45 #include <linux/if_arp.h>
46 #include <linux/ioport.h>
47 #include <linux/pci.h>
48 #include <asm/uaccess.h>
49 #include <net/ieee80211.h>
50
51 #include "airo.h"
52
53 #ifdef CONFIG_PCI
54 static struct pci_device_id card_ids[] = {
55 { 0x14b9, 1, PCI_ANY_ID, PCI_ANY_ID, },
56 { 0x14b9, 0x4500, PCI_ANY_ID, PCI_ANY_ID },
57 { 0x14b9, 0x4800, PCI_ANY_ID, PCI_ANY_ID, },
58 { 0x14b9, 0x0340, PCI_ANY_ID, PCI_ANY_ID, },
59 { 0x14b9, 0x0350, PCI_ANY_ID, PCI_ANY_ID, },
60 { 0x14b9, 0x5000, PCI_ANY_ID, PCI_ANY_ID, },
61 { 0x14b9, 0xa504, PCI_ANY_ID, PCI_ANY_ID, },
62 { 0, }
63 };
64 MODULE_DEVICE_TABLE(pci, card_ids);
65
66 static int airo_pci_probe(struct pci_dev *, const struct pci_device_id *);
67 static void airo_pci_remove(struct pci_dev *);
68 static int airo_pci_suspend(struct pci_dev *pdev, pm_message_t state);
69 static int airo_pci_resume(struct pci_dev *pdev);
70
71 static struct pci_driver airo_driver = {
72 .name = "airo",
73 .id_table = card_ids,
74 .probe = airo_pci_probe,
75 .remove = __devexit_p(airo_pci_remove),
76 .suspend = airo_pci_suspend,
77 .resume = airo_pci_resume,
78 };
79 #endif /* CONFIG_PCI */
80
81 /* Include Wireless Extension definition and check version - Jean II */
82 #include <linux/wireless.h>
83 #define WIRELESS_SPY // enable iwspy support
84 #include <net/iw_handler.h> // New driver API
85
86 #define CISCO_EXT // enable Cisco extensions
87 #ifdef CISCO_EXT
88 #include <linux/delay.h>
89 #endif
90
91 /* Hack to do some power saving */
92 #define POWER_ON_DOWN
93
94 /* As you can see this list is HUGH!
95 I really don't know what a lot of these counts are about, but they
96 are all here for completeness. If the IGNLABEL macro is put in
97 infront of the label, that statistic will not be included in the list
98 of statistics in the /proc filesystem */
99
100 #define IGNLABEL(comment) NULL
101 static char *statsLabels[] = {
102 "RxOverrun",
103 IGNLABEL("RxPlcpCrcErr"),
104 IGNLABEL("RxPlcpFormatErr"),
105 IGNLABEL("RxPlcpLengthErr"),
106 "RxMacCrcErr",
107 "RxMacCrcOk",
108 "RxWepErr",
109 "RxWepOk",
110 "RetryLong",
111 "RetryShort",
112 "MaxRetries",
113 "NoAck",
114 "NoCts",
115 "RxAck",
116 "RxCts",
117 "TxAck",
118 "TxRts",
119 "TxCts",
120 "TxMc",
121 "TxBc",
122 "TxUcFrags",
123 "TxUcPackets",
124 "TxBeacon",
125 "RxBeacon",
126 "TxSinColl",
127 "TxMulColl",
128 "DefersNo",
129 "DefersProt",
130 "DefersEngy",
131 "DupFram",
132 "RxFragDisc",
133 "TxAged",
134 "RxAged",
135 "LostSync-MaxRetry",
136 "LostSync-MissedBeacons",
137 "LostSync-ArlExceeded",
138 "LostSync-Deauth",
139 "LostSync-Disassoced",
140 "LostSync-TsfTiming",
141 "HostTxMc",
142 "HostTxBc",
143 "HostTxUc",
144 "HostTxFail",
145 "HostRxMc",
146 "HostRxBc",
147 "HostRxUc",
148 "HostRxDiscard",
149 IGNLABEL("HmacTxMc"),
150 IGNLABEL("HmacTxBc"),
151 IGNLABEL("HmacTxUc"),
152 IGNLABEL("HmacTxFail"),
153 IGNLABEL("HmacRxMc"),
154 IGNLABEL("HmacRxBc"),
155 IGNLABEL("HmacRxUc"),
156 IGNLABEL("HmacRxDiscard"),
157 IGNLABEL("HmacRxAccepted"),
158 "SsidMismatch",
159 "ApMismatch",
160 "RatesMismatch",
161 "AuthReject",
162 "AuthTimeout",
163 "AssocReject",
164 "AssocTimeout",
165 IGNLABEL("ReasonOutsideTable"),
166 IGNLABEL("ReasonStatus1"),
167 IGNLABEL("ReasonStatus2"),
168 IGNLABEL("ReasonStatus3"),
169 IGNLABEL("ReasonStatus4"),
170 IGNLABEL("ReasonStatus5"),
171 IGNLABEL("ReasonStatus6"),
172 IGNLABEL("ReasonStatus7"),
173 IGNLABEL("ReasonStatus8"),
174 IGNLABEL("ReasonStatus9"),
175 IGNLABEL("ReasonStatus10"),
176 IGNLABEL("ReasonStatus11"),
177 IGNLABEL("ReasonStatus12"),
178 IGNLABEL("ReasonStatus13"),
179 IGNLABEL("ReasonStatus14"),
180 IGNLABEL("ReasonStatus15"),
181 IGNLABEL("ReasonStatus16"),
182 IGNLABEL("ReasonStatus17"),
183 IGNLABEL("ReasonStatus18"),
184 IGNLABEL("ReasonStatus19"),
185 "RxMan",
186 "TxMan",
187 "RxRefresh",
188 "TxRefresh",
189 "RxPoll",
190 "TxPoll",
191 "HostRetries",
192 "LostSync-HostReq",
193 "HostTxBytes",
194 "HostRxBytes",
195 "ElapsedUsec",
196 "ElapsedSec",
197 "LostSyncBetterAP",
198 "PrivacyMismatch",
199 "Jammed",
200 "DiscRxNotWepped",
201 "PhyEleMismatch",
202 (char*)-1 };
203 #ifndef RUN_AT
204 #define RUN_AT(x) (jiffies+(x))
205 #endif
206
207
208 /* These variables are for insmod, since it seems that the rates
209 can only be set in setup_card. Rates should be a comma separated
210 (no spaces) list of rates (up to 8). */
211
212 static int rates[8];
213 static int basic_rate;
214 static char *ssids[3];
215
216 static int io[4];
217 static int irq[4];
218
219 static
220 int maxencrypt /* = 0 */; /* The highest rate that the card can encrypt at.
221 0 means no limit. For old cards this was 4 */
222
223 static int auto_wep /* = 0 */; /* If set, it tries to figure out the wep mode */
224 static int aux_bap /* = 0 */; /* Checks to see if the aux ports are needed to read
225 the bap, needed on some older cards and buses. */
226 static int adhoc;
227
228 static int probe = 1;
229
230 static int proc_uid /* = 0 */;
231
232 static int proc_gid /* = 0 */;
233
234 static int airo_perm = 0555;
235
236 static int proc_perm = 0644;
237
238 MODULE_AUTHOR("Benjamin Reed");
239 MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet \
240 cards. Direct support for ISA/PCI/MPI cards and support \
241 for PCMCIA when used with airo_cs.");
242 MODULE_LICENSE("Dual BSD/GPL");
243 MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340/350");
244 module_param_array(io, int, NULL, 0);
245 module_param_array(irq, int, NULL, 0);
246 module_param(basic_rate, int, 0);
247 module_param_array(rates, int, NULL, 0);
248 module_param_array(ssids, charp, NULL, 0);
249 module_param(auto_wep, int, 0);
250 MODULE_PARM_DESC(auto_wep, "If non-zero, the driver will keep looping through \
251 the authentication options until an association is made. The value of \
252 auto_wep is number of the wep keys to check. A value of 2 will try using \
253 the key at index 0 and index 1.");
254 module_param(aux_bap, int, 0);
255 MODULE_PARM_DESC(aux_bap, "If non-zero, the driver will switch into a mode \
256 than seems to work better for older cards with some older buses. Before \
257 switching it checks that the switch is needed.");
258 module_param(maxencrypt, int, 0);
259 MODULE_PARM_DESC(maxencrypt, "The maximum speed that the card can do \
260 encryption. Units are in 512kbs. Zero (default) means there is no limit. \
261 Older cards used to be limited to 2mbs (4).");
262 module_param(adhoc, int, 0);
263 MODULE_PARM_DESC(adhoc, "If non-zero, the card will start in adhoc mode.");
264 module_param(probe, int, 0);
265 MODULE_PARM_DESC(probe, "If zero, the driver won't start the card.");
266
267 module_param(proc_uid, int, 0);
268 MODULE_PARM_DESC(proc_uid, "The uid that the /proc files will belong to.");
269 module_param(proc_gid, int, 0);
270 MODULE_PARM_DESC(proc_gid, "The gid that the /proc files will belong to.");
271 module_param(airo_perm, int, 0);
272 MODULE_PARM_DESC(airo_perm, "The permission bits of /proc/[driver/]aironet.");
273 module_param(proc_perm, int, 0);
274 MODULE_PARM_DESC(proc_perm, "The permission bits of the files in /proc");
275
276 /* This is a kind of sloppy hack to get this information to OUT4500 and
277 IN4500. I would be extremely interested in the situation where this
278 doesn't work though!!! */
279 static int do8bitIO = 0;
280
281 /* Return codes */
282 #define SUCCESS 0
283 #define ERROR -1
284 #define NO_PACKET -2
285
286 /* Commands */
287 #define NOP2 0x0000
288 #define MAC_ENABLE 0x0001
289 #define MAC_DISABLE 0x0002
290 #define CMD_LOSE_SYNC 0x0003 /* Not sure what this does... */
291 #define CMD_SOFTRESET 0x0004
292 #define HOSTSLEEP 0x0005
293 #define CMD_MAGIC_PKT 0x0006
294 #define CMD_SETWAKEMASK 0x0007
295 #define CMD_READCFG 0x0008
296 #define CMD_SETMODE 0x0009
297 #define CMD_ALLOCATETX 0x000a
298 #define CMD_TRANSMIT 0x000b
299 #define CMD_DEALLOCATETX 0x000c
300 #define NOP 0x0010
301 #define CMD_WORKAROUND 0x0011
302 #define CMD_ALLOCATEAUX 0x0020
303 #define CMD_ACCESS 0x0021
304 #define CMD_PCIBAP 0x0022
305 #define CMD_PCIAUX 0x0023
306 #define CMD_ALLOCBUF 0x0028
307 #define CMD_GETTLV 0x0029
308 #define CMD_PUTTLV 0x002a
309 #define CMD_DELTLV 0x002b
310 #define CMD_FINDNEXTTLV 0x002c
311 #define CMD_PSPNODES 0x0030
312 #define CMD_SETCW 0x0031
313 #define CMD_SETPCF 0x0032
314 #define CMD_SETPHYREG 0x003e
315 #define CMD_TXTEST 0x003f
316 #define MAC_ENABLETX 0x0101
317 #define CMD_LISTBSS 0x0103
318 #define CMD_SAVECFG 0x0108
319 #define CMD_ENABLEAUX 0x0111
320 #define CMD_WRITERID 0x0121
321 #define CMD_USEPSPNODES 0x0130
322 #define MAC_ENABLERX 0x0201
323
324 /* Command errors */
325 #define ERROR_QUALIF 0x00
326 #define ERROR_ILLCMD 0x01
327 #define ERROR_ILLFMT 0x02
328 #define ERROR_INVFID 0x03
329 #define ERROR_INVRID 0x04
330 #define ERROR_LARGE 0x05
331 #define ERROR_NDISABL 0x06
332 #define ERROR_ALLOCBSY 0x07
333 #define ERROR_NORD 0x0B
334 #define ERROR_NOWR 0x0C
335 #define ERROR_INVFIDTX 0x0D
336 #define ERROR_TESTACT 0x0E
337 #define ERROR_TAGNFND 0x12
338 #define ERROR_DECODE 0x20
339 #define ERROR_DESCUNAV 0x21
340 #define ERROR_BADLEN 0x22
341 #define ERROR_MODE 0x80
342 #define ERROR_HOP 0x81
343 #define ERROR_BINTER 0x82
344 #define ERROR_RXMODE 0x83
345 #define ERROR_MACADDR 0x84
346 #define ERROR_RATES 0x85
347 #define ERROR_ORDER 0x86
348 #define ERROR_SCAN 0x87
349 #define ERROR_AUTH 0x88
350 #define ERROR_PSMODE 0x89
351 #define ERROR_RTYPE 0x8A
352 #define ERROR_DIVER 0x8B
353 #define ERROR_SSID 0x8C
354 #define ERROR_APLIST 0x8D
355 #define ERROR_AUTOWAKE 0x8E
356 #define ERROR_LEAP 0x8F
357
358 /* Registers */
359 #define COMMAND 0x00
360 #define PARAM0 0x02
361 #define PARAM1 0x04
362 #define PARAM2 0x06
363 #define STATUS 0x08
364 #define RESP0 0x0a
365 #define RESP1 0x0c
366 #define RESP2 0x0e
367 #define LINKSTAT 0x10
368 #define SELECT0 0x18
369 #define OFFSET0 0x1c
370 #define RXFID 0x20
371 #define TXALLOCFID 0x22
372 #define TXCOMPLFID 0x24
373 #define DATA0 0x36
374 #define EVSTAT 0x30
375 #define EVINTEN 0x32
376 #define EVACK 0x34
377 #define SWS0 0x28
378 #define SWS1 0x2a
379 #define SWS2 0x2c
380 #define SWS3 0x2e
381 #define AUXPAGE 0x3A
382 #define AUXOFF 0x3C
383 #define AUXDATA 0x3E
384
385 #define FID_TX 1
386 #define FID_RX 2
387 /* Offset into aux memory for descriptors */
388 #define AUX_OFFSET 0x800
389 /* Size of allocated packets */
390 #define PKTSIZE 1840
391 #define RIDSIZE 2048
392 /* Size of the transmit queue */
393 #define MAXTXQ 64
394
395 /* BAP selectors */
396 #define BAP0 0 // Used for receiving packets
397 #define BAP1 2 // Used for xmiting packets and working with RIDS
398
399 /* Flags */
400 #define COMMAND_BUSY 0x8000
401
402 #define BAP_BUSY 0x8000
403 #define BAP_ERR 0x4000
404 #define BAP_DONE 0x2000
405
406 #define PROMISC 0xffff
407 #define NOPROMISC 0x0000
408
409 #define EV_CMD 0x10
410 #define EV_CLEARCOMMANDBUSY 0x4000
411 #define EV_RX 0x01
412 #define EV_TX 0x02
413 #define EV_TXEXC 0x04
414 #define EV_ALLOC 0x08
415 #define EV_LINK 0x80
416 #define EV_AWAKE 0x100
417 #define EV_TXCPY 0x400
418 #define EV_UNKNOWN 0x800
419 #define EV_MIC 0x1000 /* Message Integrity Check Interrupt */
420 #define EV_AWAKEN 0x2000
421 #define STATUS_INTS (EV_AWAKE|EV_LINK|EV_TXEXC|EV_TX|EV_TXCPY|EV_RX|EV_MIC)
422
423 #ifdef CHECK_UNKNOWN_INTS
424 #define IGNORE_INTS ( EV_CMD | EV_UNKNOWN)
425 #else
426 #define IGNORE_INTS (~STATUS_INTS)
427 #endif
428
429 /* RID TYPES */
430 #define RID_RW 0x20
431
432 /* The RIDs */
433 #define RID_CAPABILITIES 0xFF00
434 #define RID_APINFO 0xFF01
435 #define RID_RADIOINFO 0xFF02
436 #define RID_UNKNOWN3 0xFF03
437 #define RID_RSSI 0xFF04
438 #define RID_CONFIG 0xFF10
439 #define RID_SSID 0xFF11
440 #define RID_APLIST 0xFF12
441 #define RID_DRVNAME 0xFF13
442 #define RID_ETHERENCAP 0xFF14
443 #define RID_WEP_TEMP 0xFF15
444 #define RID_WEP_PERM 0xFF16
445 #define RID_MODULATION 0xFF17
446 #define RID_OPTIONS 0xFF18
447 #define RID_ACTUALCONFIG 0xFF20 /*readonly*/
448 #define RID_FACTORYCONFIG 0xFF21
449 #define RID_UNKNOWN22 0xFF22
450 #define RID_LEAPUSERNAME 0xFF23
451 #define RID_LEAPPASSWORD 0xFF24
452 #define RID_STATUS 0xFF50
453 #define RID_BEACON_HST 0xFF51
454 #define RID_BUSY_HST 0xFF52
455 #define RID_RETRIES_HST 0xFF53
456 #define RID_UNKNOWN54 0xFF54
457 #define RID_UNKNOWN55 0xFF55
458 #define RID_UNKNOWN56 0xFF56
459 #define RID_MIC 0xFF57
460 #define RID_STATS16 0xFF60
461 #define RID_STATS16DELTA 0xFF61
462 #define RID_STATS16DELTACLEAR 0xFF62
463 #define RID_STATS 0xFF68
464 #define RID_STATSDELTA 0xFF69
465 #define RID_STATSDELTACLEAR 0xFF6A
466 #define RID_ECHOTEST_RID 0xFF70
467 #define RID_ECHOTEST_RESULTS 0xFF71
468 #define RID_BSSLISTFIRST 0xFF72
469 #define RID_BSSLISTNEXT 0xFF73
470 #define RID_WPA_BSSLISTFIRST 0xFF74
471 #define RID_WPA_BSSLISTNEXT 0xFF75
472
473 typedef struct {
474 u16 cmd;
475 u16 parm0;
476 u16 parm1;
477 u16 parm2;
478 } Cmd;
479
480 typedef struct {
481 u16 status;
482 u16 rsp0;
483 u16 rsp1;
484 u16 rsp2;
485 } Resp;
486
487 /*
488 * Rids and endian-ness: The Rids will always be in cpu endian, since
489 * this all the patches from the big-endian guys end up doing that.
490 * so all rid access should use the read/writeXXXRid routines.
491 */
492
493 /* This is redundant for x86 archs, but it seems necessary for ARM */
494 #pragma pack(1)
495
496 /* This structure came from an email sent to me from an engineer at
497 aironet for inclusion into this driver */
498 typedef struct {
499 u16 len;
500 u16 kindex;
501 u8 mac[ETH_ALEN];
502 u16 klen;
503 u8 key[16];
504 } WepKeyRid;
505
506 /* These structures are from the Aironet's PC4500 Developers Manual */
507 typedef struct {
508 u16 len;
509 u8 ssid[32];
510 } Ssid;
511
512 typedef struct {
513 u16 len;
514 Ssid ssids[3];
515 } SsidRid;
516
517 typedef struct {
518 u16 len;
519 u16 modulation;
520 #define MOD_DEFAULT 0
521 #define MOD_CCK 1
522 #define MOD_MOK 2
523 } ModulationRid;
524
525 typedef struct {
526 u16 len; /* sizeof(ConfigRid) */
527 u16 opmode; /* operating mode */
528 #define MODE_STA_IBSS 0
529 #define MODE_STA_ESS 1
530 #define MODE_AP 2
531 #define MODE_AP_RPTR 3
532 #define MODE_ETHERNET_HOST (0<<8) /* rx payloads converted */
533 #define MODE_LLC_HOST (1<<8) /* rx payloads left as is */
534 #define MODE_AIRONET_EXTEND (1<<9) /* enable Aironet extenstions */
535 #define MODE_AP_INTERFACE (1<<10) /* enable ap interface extensions */
536 #define MODE_ANTENNA_ALIGN (1<<11) /* enable antenna alignment */
537 #define MODE_ETHER_LLC (1<<12) /* enable ethernet LLC */
538 #define MODE_LEAF_NODE (1<<13) /* enable leaf node bridge */
539 #define MODE_CF_POLLABLE (1<<14) /* enable CF pollable */
540 #define MODE_MIC (1<<15) /* enable MIC */
541 u16 rmode; /* receive mode */
542 #define RXMODE_BC_MC_ADDR 0
543 #define RXMODE_BC_ADDR 1 /* ignore multicasts */
544 #define RXMODE_ADDR 2 /* ignore multicast and broadcast */
545 #define RXMODE_RFMON 3 /* wireless monitor mode */
546 #define RXMODE_RFMON_ANYBSS 4
547 #define RXMODE_LANMON 5 /* lan style monitor -- data packets only */
548 #define RXMODE_DISABLE_802_3_HEADER (1<<8) /* disables 802.3 header on rx */
549 #define RXMODE_NORMALIZED_RSSI (1<<9) /* return normalized RSSI */
550 u16 fragThresh;
551 u16 rtsThres;
552 u8 macAddr[ETH_ALEN];
553 u8 rates[8];
554 u16 shortRetryLimit;
555 u16 longRetryLimit;
556 u16 txLifetime; /* in kusec */
557 u16 rxLifetime; /* in kusec */
558 u16 stationary;
559 u16 ordering;
560 u16 u16deviceType; /* for overriding device type */
561 u16 cfpRate;
562 u16 cfpDuration;
563 u16 _reserved1[3];
564 /*---------- Scanning/Associating ----------*/
565 u16 scanMode;
566 #define SCANMODE_ACTIVE 0
567 #define SCANMODE_PASSIVE 1
568 #define SCANMODE_AIROSCAN 2
569 u16 probeDelay; /* in kusec */
570 u16 probeEnergyTimeout; /* in kusec */
571 u16 probeResponseTimeout;
572 u16 beaconListenTimeout;
573 u16 joinNetTimeout;
574 u16 authTimeout;
575 u16 authType;
576 #define AUTH_OPEN 0x1
577 #define AUTH_ENCRYPT 0x101
578 #define AUTH_SHAREDKEY 0x102
579 #define AUTH_ALLOW_UNENCRYPTED 0x200
580 u16 associationTimeout;
581 u16 specifiedApTimeout;
582 u16 offlineScanInterval;
583 u16 offlineScanDuration;
584 u16 linkLossDelay;
585 u16 maxBeaconLostTime;
586 u16 refreshInterval;
587 #define DISABLE_REFRESH 0xFFFF
588 u16 _reserved1a[1];
589 /*---------- Power save operation ----------*/
590 u16 powerSaveMode;
591 #define POWERSAVE_CAM 0
592 #define POWERSAVE_PSP 1
593 #define POWERSAVE_PSPCAM 2
594 u16 sleepForDtims;
595 u16 listenInterval;
596 u16 fastListenInterval;
597 u16 listenDecay;
598 u16 fastListenDelay;
599 u16 _reserved2[2];
600 /*---------- Ap/Ibss config items ----------*/
601 u16 beaconPeriod;
602 u16 atimDuration;
603 u16 hopPeriod;
604 u16 channelSet;
605 u16 channel;
606 u16 dtimPeriod;
607 u16 bridgeDistance;
608 u16 radioID;
609 /*---------- Radio configuration ----------*/
610 u16 radioType;
611 #define RADIOTYPE_DEFAULT 0
612 #define RADIOTYPE_802_11 1
613 #define RADIOTYPE_LEGACY 2
614 u8 rxDiversity;
615 u8 txDiversity;
616 u16 txPower;
617 #define TXPOWER_DEFAULT 0
618 u16 rssiThreshold;
619 #define RSSI_DEFAULT 0
620 u16 modulation;
621 #define PREAMBLE_AUTO 0
622 #define PREAMBLE_LONG 1
623 #define PREAMBLE_SHORT 2
624 u16 preamble;
625 u16 homeProduct;
626 u16 radioSpecific;
627 /*---------- Aironet Extensions ----------*/
628 u8 nodeName[16];
629 u16 arlThreshold;
630 u16 arlDecay;
631 u16 arlDelay;
632 u16 _reserved4[1];
633 /*---------- Aironet Extensions ----------*/
634 u8 magicAction;
635 #define MAGIC_ACTION_STSCHG 1
636 #define MAGIC_ACTION_RESUME 2
637 #define MAGIC_IGNORE_MCAST (1<<8)
638 #define MAGIC_IGNORE_BCAST (1<<9)
639 #define MAGIC_SWITCH_TO_PSP (0<<10)
640 #define MAGIC_STAY_IN_CAM (1<<10)
641 u8 magicControl;
642 u16 autoWake;
643 } ConfigRid;
644
645 typedef struct {
646 u16 len;
647 u8 mac[ETH_ALEN];
648 u16 mode;
649 u16 errorCode;
650 u16 sigQuality;
651 u16 SSIDlen;
652 char SSID[32];
653 char apName[16];
654 u8 bssid[4][ETH_ALEN];
655 u16 beaconPeriod;
656 u16 dimPeriod;
657 u16 atimDuration;
658 u16 hopPeriod;
659 u16 channelSet;
660 u16 channel;
661 u16 hopsToBackbone;
662 u16 apTotalLoad;
663 u16 generatedLoad;
664 u16 accumulatedArl;
665 u16 signalQuality;
666 u16 currentXmitRate;
667 u16 apDevExtensions;
668 u16 normalizedSignalStrength;
669 u16 shortPreamble;
670 u8 apIP[4];
671 u8 noisePercent; /* Noise percent in last second */
672 u8 noisedBm; /* Noise dBm in last second */
673 u8 noiseAvePercent; /* Noise percent in last minute */
674 u8 noiseAvedBm; /* Noise dBm in last minute */
675 u8 noiseMaxPercent; /* Highest noise percent in last minute */
676 u8 noiseMaxdBm; /* Highest noise dbm in last minute */
677 u16 load;
678 u8 carrier[4];
679 u16 assocStatus;
680 #define STAT_NOPACKETS 0
681 #define STAT_NOCARRIERSET 10
682 #define STAT_GOTCARRIERSET 11
683 #define STAT_WRONGSSID 20
684 #define STAT_BADCHANNEL 25
685 #define STAT_BADBITRATES 30
686 #define STAT_BADPRIVACY 35
687 #define STAT_APFOUND 40
688 #define STAT_APREJECTED 50
689 #define STAT_AUTHENTICATING 60
690 #define STAT_DEAUTHENTICATED 61
691 #define STAT_AUTHTIMEOUT 62
692 #define STAT_ASSOCIATING 70
693 #define STAT_DEASSOCIATED 71
694 #define STAT_ASSOCTIMEOUT 72
695 #define STAT_NOTAIROAP 73
696 #define STAT_ASSOCIATED 80
697 #define STAT_LEAPING 90
698 #define STAT_LEAPFAILED 91
699 #define STAT_LEAPTIMEDOUT 92
700 #define STAT_LEAPCOMPLETE 93
701 } StatusRid;
702
703 typedef struct {
704 u16 len;
705 u16 spacer;
706 u32 vals[100];
707 } StatsRid;
708
709
710 typedef struct {
711 u16 len;
712 u8 ap[4][ETH_ALEN];
713 } APListRid;
714
715 typedef struct {
716 u16 len;
717 char oui[3];
718 char zero;
719 u16 prodNum;
720 char manName[32];
721 char prodName[16];
722 char prodVer[8];
723 char factoryAddr[ETH_ALEN];
724 char aironetAddr[ETH_ALEN];
725 u16 radioType;
726 u16 country;
727 char callid[ETH_ALEN];
728 char supportedRates[8];
729 char rxDiversity;
730 char txDiversity;
731 u16 txPowerLevels[8];
732 u16 hardVer;
733 u16 hardCap;
734 u16 tempRange;
735 u16 softVer;
736 u16 softSubVer;
737 u16 interfaceVer;
738 u16 softCap;
739 u16 bootBlockVer;
740 u16 requiredHard;
741 u16 extSoftCap;
742 } CapabilityRid;
743
744
745 /* Only present on firmware >= 5.30.17 */
746 typedef struct {
747 u16 unknown[4];
748 u8 fixed[12]; /* WLAN management frame */
749 u8 iep[624];
750 } BSSListRidExtra;
751
752 typedef struct {
753 u16 len;
754 u16 index; /* First is 0 and 0xffff means end of list */
755 #define RADIO_FH 1 /* Frequency hopping radio type */
756 #define RADIO_DS 2 /* Direct sequence radio type */
757 #define RADIO_TMA 4 /* Proprietary radio used in old cards (2500) */
758 u16 radioType;
759 u8 bssid[ETH_ALEN]; /* Mac address of the BSS */
760 u8 zero;
761 u8 ssidLen;
762 u8 ssid[32];
763 u16 dBm;
764 #define CAP_ESS (1<<0)
765 #define CAP_IBSS (1<<1)
766 #define CAP_PRIVACY (1<<4)
767 #define CAP_SHORTHDR (1<<5)
768 u16 cap;
769 u16 beaconInterval;
770 u8 rates[8]; /* Same as rates for config rid */
771 struct { /* For frequency hopping only */
772 u16 dwell;
773 u8 hopSet;
774 u8 hopPattern;
775 u8 hopIndex;
776 u8 fill;
777 } fh;
778 u16 dsChannel;
779 u16 atimWindow;
780
781 /* Only present on firmware >= 5.30.17 */
782 BSSListRidExtra extra;
783 } BSSListRid;
784
785 typedef struct {
786 BSSListRid bss;
787 struct list_head list;
788 } BSSListElement;
789
790 typedef struct {
791 u8 rssipct;
792 u8 rssidBm;
793 } tdsRssiEntry;
794
795 typedef struct {
796 u16 len;
797 tdsRssiEntry x[256];
798 } tdsRssiRid;
799
800 typedef struct {
801 u16 len;
802 u16 state;
803 u16 multicastValid;
804 u8 multicast[16];
805 u16 unicastValid;
806 u8 unicast[16];
807 } MICRid;
808
809 typedef struct {
810 u16 typelen;
811
812 union {
813 u8 snap[8];
814 struct {
815 u8 dsap;
816 u8 ssap;
817 u8 control;
818 u8 orgcode[3];
819 u8 fieldtype[2];
820 } llc;
821 } u;
822 u32 mic;
823 u32 seq;
824 } MICBuffer;
825
826 typedef struct {
827 u8 da[ETH_ALEN];
828 u8 sa[ETH_ALEN];
829 } etherHead;
830
831 #pragma pack()
832
833 #define TXCTL_TXOK (1<<1) /* report if tx is ok */
834 #define TXCTL_TXEX (1<<2) /* report if tx fails */
835 #define TXCTL_802_3 (0<<3) /* 802.3 packet */
836 #define TXCTL_802_11 (1<<3) /* 802.11 mac packet */
837 #define TXCTL_ETHERNET (0<<4) /* payload has ethertype */
838 #define TXCTL_LLC (1<<4) /* payload is llc */
839 #define TXCTL_RELEASE (0<<5) /* release after completion */
840 #define TXCTL_NORELEASE (1<<5) /* on completion returns to host */
841
842 #define BUSY_FID 0x10000
843
844 #ifdef CISCO_EXT
845 #define AIROMAGIC 0xa55a
846 /* Warning : SIOCDEVPRIVATE may disapear during 2.5.X - Jean II */
847 #ifdef SIOCIWFIRSTPRIV
848 #ifdef SIOCDEVPRIVATE
849 #define AIROOLDIOCTL SIOCDEVPRIVATE
850 #define AIROOLDIDIFC AIROOLDIOCTL + 1
851 #endif /* SIOCDEVPRIVATE */
852 #else /* SIOCIWFIRSTPRIV */
853 #define SIOCIWFIRSTPRIV SIOCDEVPRIVATE
854 #endif /* SIOCIWFIRSTPRIV */
855 /* This may be wrong. When using the new SIOCIWFIRSTPRIV range, we probably
856 * should use only "GET" ioctls (last bit set to 1). "SET" ioctls are root
857 * only and don't return the modified struct ifreq to the application which
858 * is usually a problem. - Jean II */
859 #define AIROIOCTL SIOCIWFIRSTPRIV
860 #define AIROIDIFC AIROIOCTL + 1
861
862 /* Ioctl constants to be used in airo_ioctl.command */
863
864 #define AIROGCAP 0 // Capability rid
865 #define AIROGCFG 1 // USED A LOT
866 #define AIROGSLIST 2 // System ID list
867 #define AIROGVLIST 3 // List of specified AP's
868 #define AIROGDRVNAM 4 // NOTUSED
869 #define AIROGEHTENC 5 // NOTUSED
870 #define AIROGWEPKTMP 6
871 #define AIROGWEPKNV 7
872 #define AIROGSTAT 8
873 #define AIROGSTATSC32 9
874 #define AIROGSTATSD32 10
875 #define AIROGMICRID 11
876 #define AIROGMICSTATS 12
877 #define AIROGFLAGS 13
878 #define AIROGID 14
879 #define AIRORRID 15
880 #define AIRORSWVERSION 17
881
882 /* Leave gap of 40 commands after AIROGSTATSD32 for future */
883
884 #define AIROPCAP AIROGSTATSD32 + 40
885 #define AIROPVLIST AIROPCAP + 1
886 #define AIROPSLIST AIROPVLIST + 1
887 #define AIROPCFG AIROPSLIST + 1
888 #define AIROPSIDS AIROPCFG + 1
889 #define AIROPAPLIST AIROPSIDS + 1
890 #define AIROPMACON AIROPAPLIST + 1 /* Enable mac */
891 #define AIROPMACOFF AIROPMACON + 1 /* Disable mac */
892 #define AIROPSTCLR AIROPMACOFF + 1
893 #define AIROPWEPKEY AIROPSTCLR + 1
894 #define AIROPWEPKEYNV AIROPWEPKEY + 1
895 #define AIROPLEAPPWD AIROPWEPKEYNV + 1
896 #define AIROPLEAPUSR AIROPLEAPPWD + 1
897
898 /* Flash codes */
899
900 #define AIROFLSHRST AIROPWEPKEYNV + 40
901 #define AIROFLSHGCHR AIROFLSHRST + 1
902 #define AIROFLSHSTFL AIROFLSHGCHR + 1
903 #define AIROFLSHPCHR AIROFLSHSTFL + 1
904 #define AIROFLPUTBUF AIROFLSHPCHR + 1
905 #define AIRORESTART AIROFLPUTBUF + 1
906
907 #define FLASHSIZE 32768
908 #define AUXMEMSIZE (256 * 1024)
909
910 typedef struct aironet_ioctl {
911 unsigned short command; // What to do
912 unsigned short len; // Len of data
913 unsigned short ridnum; // rid number
914 unsigned char __user *data; // d-data
915 } aironet_ioctl;
916
917 static char swversion[] = "2.1";
918 #endif /* CISCO_EXT */
919
920 #define NUM_MODULES 2
921 #define MIC_MSGLEN_MAX 2400
922 #define EMMH32_MSGLEN_MAX MIC_MSGLEN_MAX
923 #define AIRO_DEF_MTU 2312
924
925 typedef struct {
926 u32 size; // size
927 u8 enabled; // MIC enabled or not
928 u32 rxSuccess; // successful packets received
929 u32 rxIncorrectMIC; // pkts dropped due to incorrect MIC comparison
930 u32 rxNotMICed; // pkts dropped due to not being MIC'd
931 u32 rxMICPlummed; // pkts dropped due to not having a MIC plummed
932 u32 rxWrongSequence; // pkts dropped due to sequence number violation
933 u32 reserve[32];
934 } mic_statistics;
935
936 typedef struct {
937 u32 coeff[((EMMH32_MSGLEN_MAX)+3)>>2];
938 u64 accum; // accumulated mic, reduced to u32 in final()
939 int position; // current position (byte offset) in message
940 union {
941 u8 d8[4];
942 u32 d32;
943 } part; // saves partial message word across update() calls
944 } emmh32_context;
945
946 typedef struct {
947 emmh32_context seed; // Context - the seed
948 u32 rx; // Received sequence number
949 u32 tx; // Tx sequence number
950 u32 window; // Start of window
951 u8 valid; // Flag to say if context is valid or not
952 u8 key[16];
953 } miccntx;
954
955 typedef struct {
956 miccntx mCtx; // Multicast context
957 miccntx uCtx; // Unicast context
958 } mic_module;
959
960 typedef struct {
961 unsigned int rid: 16;
962 unsigned int len: 15;
963 unsigned int valid: 1;
964 dma_addr_t host_addr;
965 } Rid;
966
967 typedef struct {
968 unsigned int offset: 15;
969 unsigned int eoc: 1;
970 unsigned int len: 15;
971 unsigned int valid: 1;
972 dma_addr_t host_addr;
973 } TxFid;
974
975 typedef struct {
976 unsigned int ctl: 15;
977 unsigned int rdy: 1;
978 unsigned int len: 15;
979 unsigned int valid: 1;
980 dma_addr_t host_addr;
981 } RxFid;
982
983 /*
984 * Host receive descriptor
985 */
986 typedef struct {
987 unsigned char __iomem *card_ram_off; /* offset into card memory of the
988 desc */
989 RxFid rx_desc; /* card receive descriptor */
990 char *virtual_host_addr; /* virtual address of host receive
991 buffer */
992 int pending;
993 } HostRxDesc;
994
995 /*
996 * Host transmit descriptor
997 */
998 typedef struct {
999 unsigned char __iomem *card_ram_off; /* offset into card memory of the
1000 desc */
1001 TxFid tx_desc; /* card transmit descriptor */
1002 char *virtual_host_addr; /* virtual address of host receive
1003 buffer */
1004 int pending;
1005 } HostTxDesc;
1006
1007 /*
1008 * Host RID descriptor
1009 */
1010 typedef struct {
1011 unsigned char __iomem *card_ram_off; /* offset into card memory of the
1012 descriptor */
1013 Rid rid_desc; /* card RID descriptor */
1014 char *virtual_host_addr; /* virtual address of host receive
1015 buffer */
1016 } HostRidDesc;
1017
1018 typedef struct {
1019 u16 sw0;
1020 u16 sw1;
1021 u16 status;
1022 u16 len;
1023 #define HOST_SET (1 << 0)
1024 #define HOST_INT_TX (1 << 1) /* Interrupt on successful TX */
1025 #define HOST_INT_TXERR (1 << 2) /* Interrupt on unseccessful TX */
1026 #define HOST_LCC_PAYLOAD (1 << 4) /* LLC payload, 0 = Ethertype */
1027 #define HOST_DONT_RLSE (1 << 5) /* Don't release buffer when done */
1028 #define HOST_DONT_RETRY (1 << 6) /* Don't retry trasmit */
1029 #define HOST_CLR_AID (1 << 7) /* clear AID failure */
1030 #define HOST_RTS (1 << 9) /* Force RTS use */
1031 #define HOST_SHORT (1 << 10) /* Do short preamble */
1032 u16 ctl;
1033 u16 aid;
1034 u16 retries;
1035 u16 fill;
1036 } TxCtlHdr;
1037
1038 typedef struct {
1039 u16 ctl;
1040 u16 duration;
1041 char addr1[6];
1042 char addr2[6];
1043 char addr3[6];
1044 u16 seq;
1045 char addr4[6];
1046 } WifiHdr;
1047
1048
1049 typedef struct {
1050 TxCtlHdr ctlhdr;
1051 u16 fill1;
1052 u16 fill2;
1053 WifiHdr wifihdr;
1054 u16 gaplen;
1055 u16 status;
1056 } WifiCtlHdr;
1057
1058 static WifiCtlHdr wifictlhdr8023 = {
1059 .ctlhdr = {
1060 .ctl = HOST_DONT_RLSE,
1061 }
1062 };
1063
1064 // Frequency list (map channels to frequencies)
1065 static const long frequency_list[] = { 2412, 2417, 2422, 2427, 2432, 2437, 2442,
1066 2447, 2452, 2457, 2462, 2467, 2472, 2484 };
1067
1068 // A few details needed for WEP (Wireless Equivalent Privacy)
1069 #define MAX_KEY_SIZE 13 // 128 (?) bits
1070 #define MIN_KEY_SIZE 5 // 40 bits RC4 - WEP
1071 typedef struct wep_key_t {
1072 u16 len;
1073 u8 key[16]; /* 40-bit and 104-bit keys */
1074 } wep_key_t;
1075
1076 /* Backward compatibility */
1077 #ifndef IW_ENCODE_NOKEY
1078 #define IW_ENCODE_NOKEY 0x0800 /* Key is write only, so not present */
1079 #define IW_ENCODE_MODE (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
1080 #endif /* IW_ENCODE_NOKEY */
1081
1082 /* List of Wireless Handlers (new API) */
1083 static const struct iw_handler_def airo_handler_def;
1084
1085 static const char version[] = "airo.c 0.6 (Ben Reed & Javier Achirica)";
1086
1087 struct airo_info;
1088
1089 static int get_dec_u16( char *buffer, int *start, int limit );
1090 static void OUT4500( struct airo_info *, u16 register, u16 value );
1091 static unsigned short IN4500( struct airo_info *, u16 register );
1092 static u16 setup_card(struct airo_info*, u8 *mac, int lock);
1093 static int enable_MAC( struct airo_info *ai, Resp *rsp, int lock );
1094 static void disable_MAC(struct airo_info *ai, int lock);
1095 static void enable_interrupts(struct airo_info*);
1096 static void disable_interrupts(struct airo_info*);
1097 static u16 issuecommand(struct airo_info*, Cmd *pCmd, Resp *pRsp);
1098 static int bap_setup(struct airo_info*, u16 rid, u16 offset, int whichbap);
1099 static int aux_bap_read(struct airo_info*, u16 *pu16Dst, int bytelen,
1100 int whichbap);
1101 static int fast_bap_read(struct airo_info*, u16 *pu16Dst, int bytelen,
1102 int whichbap);
1103 static int bap_write(struct airo_info*, const u16 *pu16Src, int bytelen,
1104 int whichbap);
1105 static int PC4500_accessrid(struct airo_info*, u16 rid, u16 accmd);
1106 static int PC4500_readrid(struct airo_info*, u16 rid, void *pBuf, int len, int lock);
1107 static int PC4500_writerid(struct airo_info*, u16 rid, const void
1108 *pBuf, int len, int lock);
1109 static int do_writerid( struct airo_info*, u16 rid, const void *rid_data,
1110 int len, int dummy );
1111 static u16 transmit_allocate(struct airo_info*, int lenPayload, int raw);
1112 static int transmit_802_3_packet(struct airo_info*, int len, char *pPacket);
1113 static int transmit_802_11_packet(struct airo_info*, int len, char *pPacket);
1114
1115 static int mpi_send_packet (struct net_device *dev);
1116 static void mpi_unmap_card(struct pci_dev *pci);
1117 static void mpi_receive_802_3(struct airo_info *ai);
1118 static void mpi_receive_802_11(struct airo_info *ai);
1119 static int waitbusy (struct airo_info *ai);
1120
1121 static irqreturn_t airo_interrupt( int irq, void* dev_id, struct pt_regs
1122 *regs);
1123 static int airo_thread(void *data);
1124 static void timer_func( struct net_device *dev );
1125 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
1126 static struct iw_statistics *airo_get_wireless_stats (struct net_device *dev);
1127 static void airo_read_wireless_stats (struct airo_info *local);
1128 #ifdef CISCO_EXT
1129 static int readrids(struct net_device *dev, aironet_ioctl *comp);
1130 static int writerids(struct net_device *dev, aironet_ioctl *comp);
1131 static int flashcard(struct net_device *dev, aironet_ioctl *comp);
1132 #endif /* CISCO_EXT */
1133 static void micinit(struct airo_info *ai);
1134 static int micsetup(struct airo_info *ai);
1135 static int encapsulate(struct airo_info *ai, etherHead *pPacket, MICBuffer *buffer, int len);
1136 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *pPacket, u16 payLen);
1137
1138 static u8 airo_rssi_to_dbm (tdsRssiEntry *rssi_rid, u8 rssi);
1139 static u8 airo_dbm_to_pct (tdsRssiEntry *rssi_rid, u8 dbm);
1140
1141 static void airo_networks_free(struct airo_info *ai);
1142
1143 struct airo_info {
1144 struct net_device_stats stats;
1145 struct net_device *dev;
1146 /* Note, we can have MAX_FIDS outstanding. FIDs are 16-bits, so we
1147 use the high bit to mark whether it is in use. */
1148 #define MAX_FIDS 6
1149 #define MPI_MAX_FIDS 1
1150 int fids[MAX_FIDS];
1151 ConfigRid config;
1152 char keyindex; // Used with auto wep
1153 char defindex; // Used with auto wep
1154 struct proc_dir_entry *proc_entry;
1155 spinlock_t aux_lock;
1156 #define FLAG_RADIO_OFF 0 /* User disabling of MAC */
1157 #define FLAG_RADIO_DOWN 1 /* ifup/ifdown disabling of MAC */
1158 #define FLAG_RADIO_MASK 0x03
1159 #define FLAG_ENABLED 2
1160 #define FLAG_ADHOC 3 /* Needed by MIC */
1161 #define FLAG_MIC_CAPABLE 4
1162 #define FLAG_UPDATE_MULTI 5
1163 #define FLAG_UPDATE_UNI 6
1164 #define FLAG_802_11 7
1165 #define FLAG_PROMISC 8 /* IFF_PROMISC 0x100 - include/linux/if.h */
1166 #define FLAG_PENDING_XMIT 9
1167 #define FLAG_PENDING_XMIT11 10
1168 #define FLAG_MPI 11
1169 #define FLAG_REGISTERED 12
1170 #define FLAG_COMMIT 13
1171 #define FLAG_RESET 14
1172 #define FLAG_FLASHING 15
1173 #define FLAG_WPA_CAPABLE 16
1174 unsigned long flags;
1175 #define JOB_DIE 0
1176 #define JOB_XMIT 1
1177 #define JOB_XMIT11 2
1178 #define JOB_STATS 3
1179 #define JOB_PROMISC 4
1180 #define JOB_MIC 5
1181 #define JOB_EVENT 6
1182 #define JOB_AUTOWEP 7
1183 #define JOB_WSTATS 8
1184 #define JOB_SCAN_RESULTS 9
1185 unsigned long jobs;
1186 int (*bap_read)(struct airo_info*, u16 *pu16Dst, int bytelen,
1187 int whichbap);
1188 unsigned short *flash;
1189 tdsRssiEntry *rssi;
1190 struct task_struct *task;
1191 struct semaphore sem;
1192 pid_t thr_pid;
1193 wait_queue_head_t thr_wait;
1194 struct completion thr_exited;
1195 unsigned long expires;
1196 struct {
1197 struct sk_buff *skb;
1198 int fid;
1199 } xmit, xmit11;
1200 struct net_device *wifidev;
1201 struct iw_statistics wstats; // wireless stats
1202 unsigned long scan_timeout; /* Time scan should be read */
1203 struct iw_spy_data spy_data;
1204 struct iw_public_data wireless_data;
1205 /* MIC stuff */
1206 struct crypto_tfm *tfm;
1207 mic_module mod[2];
1208 mic_statistics micstats;
1209 HostRxDesc rxfids[MPI_MAX_FIDS]; // rx/tx/config MPI350 descriptors
1210 HostTxDesc txfids[MPI_MAX_FIDS];
1211 HostRidDesc config_desc;
1212 unsigned long ridbus; // phys addr of config_desc
1213 struct sk_buff_head txq;// tx queue used by mpi350 code
1214 struct pci_dev *pci;
1215 unsigned char __iomem *pcimem;
1216 unsigned char __iomem *pciaux;
1217 unsigned char *shared;
1218 dma_addr_t shared_dma;
1219 pm_message_t power;
1220 SsidRid *SSID;
1221 APListRid *APList;
1222 #define PCI_SHARED_LEN 2*MPI_MAX_FIDS*PKTSIZE+RIDSIZE
1223 char proc_name[IFNAMSIZ];
1224
1225 /* WPA-related stuff */
1226 unsigned int bssListFirst;
1227 unsigned int bssListNext;
1228 unsigned int bssListRidLen;
1229
1230 struct list_head network_list;
1231 struct list_head network_free_list;
1232 BSSListElement *networks;
1233 };
1234
1235 static inline int bap_read(struct airo_info *ai, u16 *pu16Dst, int bytelen,
1236 int whichbap) {
1237 return ai->bap_read(ai, pu16Dst, bytelen, whichbap);
1238 }
1239
1240 static int setup_proc_entry( struct net_device *dev,
1241 struct airo_info *apriv );
1242 static int takedown_proc_entry( struct net_device *dev,
1243 struct airo_info *apriv );
1244
1245 static int cmdreset(struct airo_info *ai);
1246 static int setflashmode (struct airo_info *ai);
1247 static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime);
1248 static int flashputbuf(struct airo_info *ai);
1249 static int flashrestart(struct airo_info *ai,struct net_device *dev);
1250
1251 #define airo_print(type, name, fmt, args...) \
1252 { printk(type "airo(%s): " fmt "\n", name, ##args); }
1253
1254 #define airo_print_info(name, fmt, args...) \
1255 airo_print(KERN_INFO, name, fmt, ##args)
1256
1257 #define airo_print_dbg(name, fmt, args...) \
1258 airo_print(KERN_DEBUG, name, fmt, ##args)
1259
1260 #define airo_print_warn(name, fmt, args...) \
1261 airo_print(KERN_WARNING, name, fmt, ##args)
1262
1263 #define airo_print_err(name, fmt, args...) \
1264 airo_print(KERN_ERR, name, fmt, ##args)
1265
1266
1267 /***********************************************************************
1268 * MIC ROUTINES *
1269 ***********************************************************************
1270 */
1271
1272 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq);
1273 static void MoveWindow(miccntx *context, u32 micSeq);
1274 static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct crypto_tfm *);
1275 static void emmh32_init(emmh32_context *context);
1276 static void emmh32_update(emmh32_context *context, u8 *pOctets, int len);
1277 static void emmh32_final(emmh32_context *context, u8 digest[4]);
1278 static int flashpchar(struct airo_info *ai,int byte,int dwelltime);
1279
1280 /* micinit - Initialize mic seed */
1281
1282 static void micinit(struct airo_info *ai)
1283 {
1284 MICRid mic_rid;
1285
1286 clear_bit(JOB_MIC, &ai->jobs);
1287 PC4500_readrid(ai, RID_MIC, &mic_rid, sizeof(mic_rid), 0);
1288 up(&ai->sem);
1289
1290 ai->micstats.enabled = (mic_rid.state & 0x00FF) ? 1 : 0;
1291
1292 if (ai->micstats.enabled) {
1293 /* Key must be valid and different */
1294 if (mic_rid.multicastValid && (!ai->mod[0].mCtx.valid ||
1295 (memcmp (ai->mod[0].mCtx.key, mic_rid.multicast,
1296 sizeof(ai->mod[0].mCtx.key)) != 0))) {
1297 /* Age current mic Context */
1298 memcpy(&ai->mod[1].mCtx,&ai->mod[0].mCtx,sizeof(miccntx));
1299 /* Initialize new context */
1300 memcpy(&ai->mod[0].mCtx.key,mic_rid.multicast,sizeof(mic_rid.multicast));
1301 ai->mod[0].mCtx.window = 33; //Window always points to the middle
1302 ai->mod[0].mCtx.rx = 0; //Rx Sequence numbers
1303 ai->mod[0].mCtx.tx = 0; //Tx sequence numbers
1304 ai->mod[0].mCtx.valid = 1; //Key is now valid
1305
1306 /* Give key to mic seed */
1307 emmh32_setseed(&ai->mod[0].mCtx.seed,mic_rid.multicast,sizeof(mic_rid.multicast), ai->tfm);
1308 }
1309
1310 /* Key must be valid and different */
1311 if (mic_rid.unicastValid && (!ai->mod[0].uCtx.valid ||
1312 (memcmp(ai->mod[0].uCtx.key, mic_rid.unicast,
1313 sizeof(ai->mod[0].uCtx.key)) != 0))) {
1314 /* Age current mic Context */
1315 memcpy(&ai->mod[1].uCtx,&ai->mod[0].uCtx,sizeof(miccntx));
1316 /* Initialize new context */
1317 memcpy(&ai->mod[0].uCtx.key,mic_rid.unicast,sizeof(mic_rid.unicast));
1318
1319 ai->mod[0].uCtx.window = 33; //Window always points to the middle
1320 ai->mod[0].uCtx.rx = 0; //Rx Sequence numbers
1321 ai->mod[0].uCtx.tx = 0; //Tx sequence numbers
1322 ai->mod[0].uCtx.valid = 1; //Key is now valid
1323
1324 //Give key to mic seed
1325 emmh32_setseed(&ai->mod[0].uCtx.seed, mic_rid.unicast, sizeof(mic_rid.unicast), ai->tfm);
1326 }
1327 } else {
1328 /* So next time we have a valid key and mic is enabled, we will update
1329 * the sequence number if the key is the same as before.
1330 */
1331 ai->mod[0].uCtx.valid = 0;
1332 ai->mod[0].mCtx.valid = 0;
1333 }
1334 }
1335
1336 /* micsetup - Get ready for business */
1337
1338 static int micsetup(struct airo_info *ai) {
1339 int i;
1340
1341 if (ai->tfm == NULL)
1342 ai->tfm = crypto_alloc_tfm("aes", CRYPTO_TFM_REQ_MAY_SLEEP);
1343
1344 if (ai->tfm == NULL) {
1345 airo_print_err(ai->dev->name, "failed to load transform for AES");
1346 return ERROR;
1347 }
1348
1349 for (i=0; i < NUM_MODULES; i++) {
1350 memset(&ai->mod[i].mCtx,0,sizeof(miccntx));
1351 memset(&ai->mod[i].uCtx,0,sizeof(miccntx));
1352 }
1353 return SUCCESS;
1354 }
1355
1356 static char micsnap[] = {0xAA,0xAA,0x03,0x00,0x40,0x96,0x00,0x02};
1357
1358 /*===========================================================================
1359 * Description: Mic a packet
1360 *
1361 * Inputs: etherHead * pointer to an 802.3 frame
1362 *
1363 * Returns: BOOLEAN if successful, otherwise false.
1364 * PacketTxLen will be updated with the mic'd packets size.
1365 *
1366 * Caveats: It is assumed that the frame buffer will already
1367 * be big enough to hold the largets mic message possible.
1368 * (No memory allocation is done here).
1369 *
1370 * Author: sbraneky (10/15/01)
1371 * Merciless hacks by rwilcher (1/14/02)
1372 */
1373
1374 static int encapsulate(struct airo_info *ai ,etherHead *frame, MICBuffer *mic, int payLen)
1375 {
1376 miccntx *context;
1377
1378 // Determine correct context
1379 // If not adhoc, always use unicast key
1380
1381 if (test_bit(FLAG_ADHOC, &ai->flags) && (frame->da[0] & 0x1))
1382 context = &ai->mod[0].mCtx;
1383 else
1384 context = &ai->mod[0].uCtx;
1385
1386 if (!context->valid)
1387 return ERROR;
1388
1389 mic->typelen = htons(payLen + 16); //Length of Mic'd packet
1390
1391 memcpy(&mic->u.snap, micsnap, sizeof(micsnap)); // Add Snap
1392
1393 // Add Tx sequence
1394 mic->seq = htonl(context->tx);
1395 context->tx += 2;
1396
1397 emmh32_init(&context->seed); // Mic the packet
1398 emmh32_update(&context->seed,frame->da,ETH_ALEN * 2); // DA,SA
1399 emmh32_update(&context->seed,(u8*)&mic->typelen,10); // Type/Length and Snap
1400 emmh32_update(&context->seed,(u8*)&mic->seq,sizeof(mic->seq)); //SEQ
1401 emmh32_update(&context->seed,frame->da + ETH_ALEN * 2,payLen); //payload
1402 emmh32_final(&context->seed, (u8*)&mic->mic);
1403
1404 /* New Type/length ?????????? */
1405 mic->typelen = 0; //Let NIC know it could be an oversized packet
1406 return SUCCESS;
1407 }
1408
1409 typedef enum {
1410 NONE,
1411 NOMIC,
1412 NOMICPLUMMED,
1413 SEQUENCE,
1414 INCORRECTMIC,
1415 } mic_error;
1416
1417 /*===========================================================================
1418 * Description: Decapsulates a MIC'd packet and returns the 802.3 packet
1419 * (removes the MIC stuff) if packet is a valid packet.
1420 *
1421 * Inputs: etherHead pointer to the 802.3 packet
1422 *
1423 * Returns: BOOLEAN - TRUE if packet should be dropped otherwise FALSE
1424 *
1425 * Author: sbraneky (10/15/01)
1426 * Merciless hacks by rwilcher (1/14/02)
1427 *---------------------------------------------------------------------------
1428 */
1429
1430 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *eth, u16 payLen)
1431 {
1432 int i;
1433 u32 micSEQ;
1434 miccntx *context;
1435 u8 digest[4];
1436 mic_error micError = NONE;
1437
1438 // Check if the packet is a Mic'd packet
1439
1440 if (!ai->micstats.enabled) {
1441 //No Mic set or Mic OFF but we received a MIC'd packet.
1442 if (memcmp ((u8*)eth + 14, micsnap, sizeof(micsnap)) == 0) {
1443 ai->micstats.rxMICPlummed++;
1444 return ERROR;
1445 }
1446 return SUCCESS;
1447 }
1448
1449 if (ntohs(mic->typelen) == 0x888E)
1450 return SUCCESS;
1451
1452 if (memcmp (mic->u.snap, micsnap, sizeof(micsnap)) != 0) {
1453 // Mic enabled but packet isn't Mic'd
1454 ai->micstats.rxMICPlummed++;
1455 return ERROR;
1456 }
1457
1458 micSEQ = ntohl(mic->seq); //store SEQ as CPU order
1459
1460 //At this point we a have a mic'd packet and mic is enabled
1461 //Now do the mic error checking.
1462
1463 //Receive seq must be odd
1464 if ( (micSEQ & 1) == 0 ) {
1465 ai->micstats.rxWrongSequence++;
1466 return ERROR;
1467 }
1468
1469 for (i = 0; i < NUM_MODULES; i++) {
1470 int mcast = eth->da[0] & 1;
1471 //Determine proper context
1472 context = mcast ? &ai->mod[i].mCtx : &ai->mod[i].uCtx;
1473
1474 //Make sure context is valid
1475 if (!context->valid) {
1476 if (i == 0)
1477 micError = NOMICPLUMMED;
1478 continue;
1479 }
1480 //DeMic it
1481
1482 if (!mic->typelen)
1483 mic->typelen = htons(payLen + sizeof(MICBuffer) - 2);
1484
1485 emmh32_init(&context->seed);
1486 emmh32_update(&context->seed, eth->da, ETH_ALEN*2);
1487 emmh32_update(&context->seed, (u8 *)&mic->typelen, sizeof(mic->typelen)+sizeof(mic->u.snap));
1488 emmh32_update(&context->seed, (u8 *)&mic->seq,sizeof(mic->seq));
1489 emmh32_update(&context->seed, eth->da + ETH_ALEN*2,payLen);
1490 //Calculate MIC
1491 emmh32_final(&context->seed, digest);
1492
1493 if (memcmp(digest, &mic->mic, 4)) { //Make sure the mics match
1494 //Invalid Mic
1495 if (i == 0)
1496 micError = INCORRECTMIC;
1497 continue;
1498 }
1499
1500 //Check Sequence number if mics pass
1501 if (RxSeqValid(ai, context, mcast, micSEQ) == SUCCESS) {
1502 ai->micstats.rxSuccess++;
1503 return SUCCESS;
1504 }
1505 if (i == 0)
1506 micError = SEQUENCE;
1507 }
1508
1509 // Update statistics
1510 switch (micError) {
1511 case NOMICPLUMMED: ai->micstats.rxMICPlummed++; break;
1512 case SEQUENCE: ai->micstats.rxWrongSequence++; break;
1513 case INCORRECTMIC: ai->micstats.rxIncorrectMIC++; break;
1514 case NONE: break;
1515 case NOMIC: break;
1516 }
1517 return ERROR;
1518 }
1519
1520 /*===========================================================================
1521 * Description: Checks the Rx Seq number to make sure it is valid
1522 * and hasn't already been received
1523 *
1524 * Inputs: miccntx - mic context to check seq against
1525 * micSeq - the Mic seq number
1526 *
1527 * Returns: TRUE if valid otherwise FALSE.
1528 *
1529 * Author: sbraneky (10/15/01)
1530 * Merciless hacks by rwilcher (1/14/02)
1531 *---------------------------------------------------------------------------
1532 */
1533
1534 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq)
1535 {
1536 u32 seq,index;
1537
1538 //Allow for the ap being rebooted - if it is then use the next
1539 //sequence number of the current sequence number - might go backwards
1540
1541 if (mcast) {
1542 if (test_bit(FLAG_UPDATE_MULTI, &ai->flags)) {
1543 clear_bit (FLAG_UPDATE_MULTI, &ai->flags);
1544 context->window = (micSeq > 33) ? micSeq : 33;
1545 context->rx = 0; // Reset rx
1546 }
1547 } else if (test_bit(FLAG_UPDATE_UNI, &ai->flags)) {
1548 clear_bit (FLAG_UPDATE_UNI, &ai->flags);
1549 context->window = (micSeq > 33) ? micSeq : 33; // Move window
1550 context->rx = 0; // Reset rx
1551 }
1552
1553 //Make sequence number relative to START of window
1554 seq = micSeq - (context->window - 33);
1555
1556 //Too old of a SEQ number to check.
1557 if ((s32)seq < 0)
1558 return ERROR;
1559
1560 if ( seq > 64 ) {
1561 //Window is infinite forward
1562 MoveWindow(context,micSeq);
1563 return SUCCESS;
1564 }
1565
1566 // We are in the window. Now check the context rx bit to see if it was already sent
1567 seq >>= 1; //divide by 2 because we only have odd numbers
1568 index = 1 << seq; //Get an index number
1569
1570 if (!(context->rx & index)) {
1571 //micSEQ falls inside the window.
1572 //Add seqence number to the list of received numbers.
1573 context->rx |= index;
1574
1575 MoveWindow(context,micSeq);
1576
1577 return SUCCESS;
1578 }
1579 return ERROR;
1580 }
1581
1582 static void MoveWindow(miccntx *context, u32 micSeq)
1583 {
1584 u32 shift;
1585
1586 //Move window if seq greater than the middle of the window
1587 if (micSeq > context->window) {
1588 shift = (micSeq - context->window) >> 1;
1589
1590 //Shift out old
1591 if (shift < 32)
1592 context->rx >>= shift;
1593 else
1594 context->rx = 0;
1595
1596 context->window = micSeq; //Move window
1597 }
1598 }
1599
1600 /*==============================================*/
1601 /*========== EMMH ROUTINES ====================*/
1602 /*==============================================*/
1603
1604 /* mic accumulate */
1605 #define MIC_ACCUM(val) \
1606 context->accum += (u64)(val) * context->coeff[coeff_position++];
1607
1608 static unsigned char aes_counter[16];
1609
1610 /* expand the key to fill the MMH coefficient array */
1611 static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct crypto_tfm *tfm)
1612 {
1613 /* take the keying material, expand if necessary, truncate at 16-bytes */
1614 /* run through AES counter mode to generate context->coeff[] */
1615
1616 int i,j;
1617 u32 counter;
1618 u8 *cipher, plain[16];
1619 struct scatterlist sg[1];
1620
1621 crypto_cipher_setkey(tfm, pkey, 16);
1622 counter = 0;
1623 for (i = 0; i < (sizeof(context->coeff)/sizeof(context->coeff[0])); ) {
1624 aes_counter[15] = (u8)(counter >> 0);
1625 aes_counter[14] = (u8)(counter >> 8);
1626 aes_counter[13] = (u8)(counter >> 16);
1627 aes_counter[12] = (u8)(counter >> 24);
1628 counter++;
1629 memcpy (plain, aes_counter, 16);
1630 sg_set_buf(sg, plain, 16);
1631 crypto_cipher_encrypt(tfm, sg, sg, 16);
1632 cipher = kmap(sg->page) + sg->offset;
1633 for (j=0; (j<16) && (i< (sizeof(context->coeff)/sizeof(context->coeff[0]))); ) {
1634 context->coeff[i++] = ntohl(*(u32 *)&cipher[j]);
1635 j += 4;
1636 }
1637 }
1638 }
1639
1640 /* prepare for calculation of a new mic */
1641 static void emmh32_init(emmh32_context *context)
1642 {
1643 /* prepare for new mic calculation */
1644 context->accum = 0;
1645 context->position = 0;
1646 }
1647
1648 /* add some bytes to the mic calculation */
1649 static void emmh32_update(emmh32_context *context, u8 *pOctets, int len)
1650 {
1651 int coeff_position, byte_position;
1652
1653 if (len == 0) return;
1654
1655 coeff_position = context->position >> 2;
1656
1657 /* deal with partial 32-bit word left over from last update */
1658 byte_position = context->position & 3;
1659 if (byte_position) {
1660 /* have a partial word in part to deal with */
1661 do {
1662 if (len == 0) return;
1663 context->part.d8[byte_position++] = *pOctets++;
1664 context->position++;
1665 len--;
1666 } while (byte_position < 4);
1667 MIC_ACCUM(htonl(context->part.d32));
1668 }
1669
1670 /* deal with full 32-bit words */
1671 while (len >= 4) {
1672 MIC_ACCUM(htonl(*(u32 *)pOctets));
1673 context->position += 4;
1674 pOctets += 4;
1675 len -= 4;
1676 }
1677
1678 /* deal with partial 32-bit word that will be left over from this update */
1679 byte_position = 0;
1680 while (len > 0) {
1681 context->part.d8[byte_position++] = *pOctets++;
1682 context->position++;
1683 len--;
1684 }
1685 }
1686
1687 /* mask used to zero empty bytes for final partial word */
1688 static u32 mask32[4] = { 0x00000000L, 0xFF000000L, 0xFFFF0000L, 0xFFFFFF00L };
1689
1690 /* calculate the mic */
1691 static void emmh32_final(emmh32_context *context, u8 digest[4])
1692 {
1693 int coeff_position, byte_position;
1694 u32 val;
1695
1696 u64 sum, utmp;
1697 s64 stmp;
1698
1699 coeff_position = context->position >> 2;
1700
1701 /* deal with partial 32-bit word left over from last update */
1702 byte_position = context->position & 3;
1703 if (byte_position) {
1704 /* have a partial word in part to deal with */
1705 val = htonl(context->part.d32);
1706 MIC_ACCUM(val & mask32[byte_position]); /* zero empty bytes */
1707 }
1708
1709 /* reduce the accumulated u64 to a 32-bit MIC */
1710 sum = context->accum;
1711 stmp = (sum & 0xffffffffLL) - ((sum >> 32) * 15);
1712 utmp = (stmp & 0xffffffffLL) - ((stmp >> 32) * 15);
1713 sum = utmp & 0xffffffffLL;
1714 if (utmp > 0x10000000fLL)
1715 sum -= 15;
1716
1717 val = (u32)sum;
1718 digest[0] = (val>>24) & 0xFF;
1719 digest[1] = (val>>16) & 0xFF;
1720 digest[2] = (val>>8) & 0xFF;
1721 digest[3] = val & 0xFF;
1722 }
1723
1724 static int readBSSListRid(struct airo_info *ai, int first,
1725 BSSListRid *list) {
1726 int rc;
1727 Cmd cmd;
1728 Resp rsp;
1729
1730 if (first == 1) {
1731 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
1732 memset(&cmd, 0, sizeof(cmd));
1733 cmd.cmd=CMD_LISTBSS;
1734 if (down_interruptible(&ai->sem))
1735 return -ERESTARTSYS;
1736 issuecommand(ai, &cmd, &rsp);
1737 up(&ai->sem);
1738 /* Let the command take effect */
1739 ai->task = current;
1740 ssleep(3);
1741 ai->task = NULL;
1742 }
1743 rc = PC4500_readrid(ai, first ? ai->bssListFirst : ai->bssListNext,
1744 list, ai->bssListRidLen, 1);
1745
1746 list->len = le16_to_cpu(list->len);
1747 list->index = le16_to_cpu(list->index);
1748 list->radioType = le16_to_cpu(list->radioType);
1749 list->cap = le16_to_cpu(list->cap);
1750 list->beaconInterval = le16_to_cpu(list->beaconInterval);
1751 list->fh.dwell = le16_to_cpu(list->fh.dwell);
1752 list->dsChannel = le16_to_cpu(list->dsChannel);
1753 list->atimWindow = le16_to_cpu(list->atimWindow);
1754 list->dBm = le16_to_cpu(list->dBm);
1755 return rc;
1756 }
1757
1758 static int readWepKeyRid(struct airo_info*ai, WepKeyRid *wkr, int temp, int lock) {
1759 int rc = PC4500_readrid(ai, temp ? RID_WEP_TEMP : RID_WEP_PERM,
1760 wkr, sizeof(*wkr), lock);
1761
1762 wkr->len = le16_to_cpu(wkr->len);
1763 wkr->kindex = le16_to_cpu(wkr->kindex);
1764 wkr->klen = le16_to_cpu(wkr->klen);
1765 return rc;
1766 }
1767 /* In the writeXXXRid routines we copy the rids so that we don't screwup
1768 * the originals when we endian them... */
1769 static int writeWepKeyRid(struct airo_info*ai, WepKeyRid *pwkr, int perm, int lock) {
1770 int rc;
1771 WepKeyRid wkr = *pwkr;
1772
1773 wkr.len = cpu_to_le16(wkr.len);
1774 wkr.kindex = cpu_to_le16(wkr.kindex);
1775 wkr.klen = cpu_to_le16(wkr.klen);
1776 rc = PC4500_writerid(ai, RID_WEP_TEMP, &wkr, sizeof(wkr), lock);
1777 if (rc!=SUCCESS) airo_print_err(ai->dev->name, "WEP_TEMP set %x", rc);
1778 if (perm) {
1779 rc = PC4500_writerid(ai, RID_WEP_PERM, &wkr, sizeof(wkr), lock);
1780 if (rc!=SUCCESS) {
1781 airo_print_err(ai->dev->name, "WEP_PERM set %x", rc);
1782 }
1783 }
1784 return rc;
1785 }
1786
1787 static int readSsidRid(struct airo_info*ai, SsidRid *ssidr) {
1788 int i;
1789 int rc = PC4500_readrid(ai, RID_SSID, ssidr, sizeof(*ssidr), 1);
1790
1791 ssidr->len = le16_to_cpu(ssidr->len);
1792 for(i = 0; i < 3; i++) {
1793 ssidr->ssids[i].len = le16_to_cpu(ssidr->ssids[i].len);
1794 }
1795 return rc;
1796 }
1797 static int writeSsidRid(struct airo_info*ai, SsidRid *pssidr, int lock) {
1798 int rc;
1799 int i;
1800 SsidRid ssidr = *pssidr;
1801
1802 ssidr.len = cpu_to_le16(ssidr.len);
1803 for(i = 0; i < 3; i++) {
1804 ssidr.ssids[i].len = cpu_to_le16(ssidr.ssids[i].len);
1805 }
1806 rc = PC4500_writerid(ai, RID_SSID, &ssidr, sizeof(ssidr), lock);
1807 return rc;
1808 }
1809 static int readConfigRid(struct airo_info*ai, int lock) {
1810 int rc;
1811 u16 *s;
1812 ConfigRid cfg;
1813
1814 if (ai->config.len)
1815 return SUCCESS;
1816
1817 rc = PC4500_readrid(ai, RID_ACTUALCONFIG, &cfg, sizeof(cfg), lock);
1818 if (rc != SUCCESS)
1819 return rc;
1820
1821 for(s = &cfg.len; s <= &cfg.rtsThres; s++) *s = le16_to_cpu(*s);
1822
1823 for(s = &cfg.shortRetryLimit; s <= &cfg.radioType; s++)
1824 *s = le16_to_cpu(*s);
1825
1826 for(s = &cfg.txPower; s <= &cfg.radioSpecific; s++)
1827 *s = le16_to_cpu(*s);
1828
1829 for(s = &cfg.arlThreshold; s <= &cfg._reserved4[0]; s++)
1830 *s = cpu_to_le16(*s);
1831
1832 for(s = &cfg.autoWake; s <= &cfg.autoWake; s++)
1833 *s = cpu_to_le16(*s);
1834
1835 ai->config = cfg;
1836 return SUCCESS;
1837 }
1838 static inline void checkThrottle(struct airo_info *ai) {
1839 int i;
1840 /* Old hardware had a limit on encryption speed */
1841 if (ai->config.authType != AUTH_OPEN && maxencrypt) {
1842 for(i=0; i<8; i++) {
1843 if (ai->config.rates[i] > maxencrypt) {
1844 ai->config.rates[i] = 0;
1845 }
1846 }
1847 }
1848 }
1849 static int writeConfigRid(struct airo_info*ai, int lock) {
1850 u16 *s;
1851 ConfigRid cfgr;
1852
1853 if (!test_bit (FLAG_COMMIT, &ai->flags))
1854 return SUCCESS;
1855
1856 clear_bit (FLAG_COMMIT, &ai->flags);
1857 clear_bit (FLAG_RESET, &ai->flags);
1858 checkThrottle(ai);
1859 cfgr = ai->config;
1860
1861 if ((cfgr.opmode & 0xFF) == MODE_STA_IBSS)
1862 set_bit(FLAG_ADHOC, &ai->flags);
1863 else
1864 clear_bit(FLAG_ADHOC, &ai->flags);
1865
1866 for(s = &cfgr.len; s <= &cfgr.rtsThres; s++) *s = cpu_to_le16(*s);
1867
1868 for(s = &cfgr.shortRetryLimit; s <= &cfgr.radioType; s++)
1869 *s = cpu_to_le16(*s);
1870
1871 for(s = &cfgr.txPower; s <= &cfgr.radioSpecific; s++)
1872 *s = cpu_to_le16(*s);
1873
1874 for(s = &cfgr.arlThreshold; s <= &cfgr._reserved4[0]; s++)
1875 *s = cpu_to_le16(*s);
1876
1877 for(s = &cfgr.autoWake; s <= &cfgr.autoWake; s++)
1878 *s = cpu_to_le16(*s);
1879
1880 return PC4500_writerid( ai, RID_CONFIG, &cfgr, sizeof(cfgr), lock);
1881 }
1882 static int readStatusRid(struct airo_info*ai, StatusRid *statr, int lock) {
1883 int rc = PC4500_readrid(ai, RID_STATUS, statr, sizeof(*statr), lock);
1884 u16 *s;
1885
1886 statr->len = le16_to_cpu(statr->len);
1887 for(s = &statr->mode; s <= &statr->SSIDlen; s++) *s = le16_to_cpu(*s);
1888
1889 for(s = &statr->beaconPeriod; s <= &statr->shortPreamble; s++)
1890 *s = le16_to_cpu(*s);
1891 statr->load = le16_to_cpu(statr->load);
1892 statr->assocStatus = le16_to_cpu(statr->assocStatus);
1893 return rc;
1894 }
1895 static int readAPListRid(struct airo_info*ai, APListRid *aplr) {
1896 int rc = PC4500_readrid(ai, RID_APLIST, aplr, sizeof(*aplr), 1);
1897 aplr->len = le16_to_cpu(aplr->len);
1898 return rc;
1899 }
1900 static int writeAPListRid(struct airo_info*ai, APListRid *aplr, int lock) {
1901 int rc;
1902 aplr->len = cpu_to_le16(aplr->len);
1903 rc = PC4500_writerid(ai, RID_APLIST, aplr, sizeof(*aplr), lock);
1904 return rc;
1905 }
1906 static int readCapabilityRid(struct airo_info*ai, CapabilityRid *capr, int lock) {
1907 int rc = PC4500_readrid(ai, RID_CAPABILITIES, capr, sizeof(*capr), lock);
1908 u16 *s;
1909
1910 capr->len = le16_to_cpu(capr->len);
1911 capr->prodNum = le16_to_cpu(capr->prodNum);
1912 capr->radioType = le16_to_cpu(capr->radioType);
1913 capr->country = le16_to_cpu(capr->country);
1914 for(s = &capr->txPowerLevels[0]; s <= &capr->requiredHard; s++)
1915 *s = le16_to_cpu(*s);
1916 return rc;
1917 }
1918 static int readStatsRid(struct airo_info*ai, StatsRid *sr, int rid, int lock) {
1919 int rc = PC4500_readrid(ai, rid, sr, sizeof(*sr), lock);
1920 u32 *i;
1921
1922 sr->len = le16_to_cpu(sr->len);
1923 for(i = &sr->vals[0]; i <= &sr->vals[99]; i++) *i = le32_to_cpu(*i);
1924 return rc;
1925 }
1926
1927 static int airo_open(struct net_device *dev) {
1928 struct airo_info *info = dev->priv;
1929 Resp rsp;
1930
1931 if (test_bit(FLAG_FLASHING, &info->flags))
1932 return -EIO;
1933
1934 /* Make sure the card is configured.
1935 * Wireless Extensions may postpone config changes until the card
1936 * is open (to pipeline changes and speed-up card setup). If
1937 * those changes are not yet commited, do it now - Jean II */
1938 if (test_bit (FLAG_COMMIT, &info->flags)) {
1939 disable_MAC(info, 1);
1940 writeConfigRid(info, 1);
1941 }
1942
1943 if (info->wifidev != dev) {
1944 /* Power on the MAC controller (which may have been disabled) */
1945 clear_bit(FLAG_RADIO_DOWN, &info->flags);
1946 enable_interrupts(info);
1947 }
1948 enable_MAC(info, &rsp, 1);
1949
1950 netif_start_queue(dev);
1951 return 0;
1952 }
1953
1954 static int mpi_start_xmit(struct sk_buff *skb, struct net_device *dev) {
1955 int npacks, pending;
1956 unsigned long flags;
1957 struct airo_info *ai = dev->priv;
1958
1959 if (!skb) {
1960 airo_print_err(dev->name, "%s: skb == NULL!",__FUNCTION__);
1961 return 0;
1962 }
1963 npacks = skb_queue_len (&ai->txq);
1964
1965 if (npacks >= MAXTXQ - 1) {
1966 netif_stop_queue (dev);
1967 if (npacks > MAXTXQ) {
1968 ai->stats.tx_fifo_errors++;
1969 return 1;
1970 }
1971 skb_queue_tail (&ai->txq, skb);
1972 return 0;
1973 }
1974
1975 spin_lock_irqsave(&ai->aux_lock, flags);
1976 skb_queue_tail (&ai->txq, skb);
1977 pending = test_bit(FLAG_PENDING_XMIT, &ai->flags);
1978 spin_unlock_irqrestore(&ai->aux_lock,flags);
1979 netif_wake_queue (dev);
1980
1981 if (pending == 0) {
1982 set_bit(FLAG_PENDING_XMIT, &ai->flags);
1983 mpi_send_packet (dev);
1984 }
1985 return 0;
1986 }
1987
1988 /*
1989 * @mpi_send_packet
1990 *
1991 * Attempt to transmit a packet. Can be called from interrupt
1992 * or transmit . return number of packets we tried to send
1993 */
1994
1995 static int mpi_send_packet (struct net_device *dev)
1996 {
1997 struct sk_buff *skb;
1998 unsigned char *buffer;
1999 s16 len, *payloadLen;
2000 struct airo_info *ai = dev->priv;
2001 u8 *sendbuf;
2002
2003 /* get a packet to send */
2004
2005 if ((skb = skb_dequeue(&ai->txq)) == 0) {
2006 airo_print_err(dev->name,
2007 "%s: Dequeue'd zero in send_packet()",
2008 __FUNCTION__);
2009 return 0;
2010 }
2011
2012 /* check min length*/
2013 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2014 buffer = skb->data;
2015
2016 ai->txfids[0].tx_desc.offset = 0;
2017 ai->txfids[0].tx_desc.valid = 1;
2018 ai->txfids[0].tx_desc.eoc = 1;
2019 ai->txfids[0].tx_desc.len =len+sizeof(WifiHdr);
2020
2021 /*
2022 * Magic, the cards firmware needs a length count (2 bytes) in the host buffer
2023 * right after TXFID_HDR.The TXFID_HDR contains the status short so payloadlen
2024 * is immediatly after it. ------------------------------------------------
2025 * |TXFIDHDR+STATUS|PAYLOADLEN|802.3HDR|PACKETDATA|
2026 * ------------------------------------------------
2027 */
2028
2029 memcpy((char *)ai->txfids[0].virtual_host_addr,
2030 (char *)&wifictlhdr8023, sizeof(wifictlhdr8023));
2031
2032 payloadLen = (s16 *)(ai->txfids[0].virtual_host_addr +
2033 sizeof(wifictlhdr8023));
2034 sendbuf = ai->txfids[0].virtual_host_addr +
2035 sizeof(wifictlhdr8023) + 2 ;
2036
2037 /*
2038 * Firmware automaticly puts 802 header on so
2039 * we don't need to account for it in the length
2040 */
2041 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
2042 (ntohs(((u16 *)buffer)[6]) != 0x888E)) {
2043 MICBuffer pMic;
2044
2045 if (encapsulate(ai, (etherHead *)buffer, &pMic, len - sizeof(etherHead)) != SUCCESS)
2046 return ERROR;
2047
2048 *payloadLen = cpu_to_le16(len-sizeof(etherHead)+sizeof(pMic));
2049 ai->txfids[0].tx_desc.len += sizeof(pMic);
2050 /* copy data into airo dma buffer */
2051 memcpy (sendbuf, buffer, sizeof(etherHead));
2052 buffer += sizeof(etherHead);
2053 sendbuf += sizeof(etherHead);
2054 memcpy (sendbuf, &pMic, sizeof(pMic));
2055 sendbuf += sizeof(pMic);
2056 memcpy (sendbuf, buffer, len - sizeof(etherHead));
2057 } else {
2058 *payloadLen = cpu_to_le16(len - sizeof(etherHead));
2059
2060 dev->trans_start = jiffies;
2061
2062 /* copy data into airo dma buffer */
2063 memcpy(sendbuf, buffer, len);
2064 }
2065
2066 memcpy_toio(ai->txfids[0].card_ram_off,
2067 &ai->txfids[0].tx_desc, sizeof(TxFid));
2068
2069 OUT4500(ai, EVACK, 8);
2070
2071 dev_kfree_skb_any(skb);
2072 return 1;
2073 }
2074
2075 static void get_tx_error(struct airo_info *ai, s32 fid)
2076 {
2077 u16 status;
2078
2079 if (fid < 0)
2080 status = ((WifiCtlHdr *)ai->txfids[0].virtual_host_addr)->ctlhdr.status;
2081 else {
2082 if (bap_setup(ai, ai->fids[fid] & 0xffff, 4, BAP0) != SUCCESS)
2083 return;
2084 bap_read(ai, &status, 2, BAP0);
2085 }
2086 if (le16_to_cpu(status) & 2) /* Too many retries */
2087 ai->stats.tx_aborted_errors++;
2088 if (le16_to_cpu(status) & 4) /* Transmit lifetime exceeded */
2089 ai->stats.tx_heartbeat_errors++;
2090 if (le16_to_cpu(status) & 8) /* Aid fail */
2091 { }
2092 if (le16_to_cpu(status) & 0x10) /* MAC disabled */
2093 ai->stats.tx_carrier_errors++;
2094 if (le16_to_cpu(status) & 0x20) /* Association lost */
2095 { }
2096 /* We produce a TXDROP event only for retry or lifetime
2097 * exceeded, because that's the only status that really mean
2098 * that this particular node went away.
2099 * Other errors means that *we* screwed up. - Jean II */
2100 if ((le16_to_cpu(status) & 2) ||
2101 (le16_to_cpu(status) & 4)) {
2102 union iwreq_data wrqu;
2103 char junk[0x18];
2104
2105 /* Faster to skip over useless data than to do
2106 * another bap_setup(). We are at offset 0x6 and
2107 * need to go to 0x18 and read 6 bytes - Jean II */
2108 bap_read(ai, (u16 *) junk, 0x18, BAP0);
2109
2110 /* Copy 802.11 dest address.
2111 * We use the 802.11 header because the frame may
2112 * not be 802.3 or may be mangled...
2113 * In Ad-Hoc mode, it will be the node address.
2114 * In managed mode, it will be most likely the AP addr
2115 * User space will figure out how to convert it to
2116 * whatever it needs (IP address or else).
2117 * - Jean II */
2118 memcpy(wrqu.addr.sa_data, junk + 0x12, ETH_ALEN);
2119 wrqu.addr.sa_family = ARPHRD_ETHER;
2120
2121 /* Send event to user space */
2122 wireless_send_event(ai->dev, IWEVTXDROP, &wrqu, NULL);
2123 }
2124 }
2125
2126 static void airo_end_xmit(struct net_device *dev) {
2127 u16 status;
2128 int i;
2129 struct airo_info *priv = dev->priv;
2130 struct sk_buff *skb = priv->xmit.skb;
2131 int fid = priv->xmit.fid;
2132 u32 *fids = priv->fids;
2133
2134 clear_bit(JOB_XMIT, &priv->jobs);
2135 clear_bit(FLAG_PENDING_XMIT, &priv->flags);
2136 status = transmit_802_3_packet (priv, fids[fid], skb->data);
2137 up(&priv->sem);
2138
2139 i = 0;
2140 if ( status == SUCCESS ) {
2141 dev->trans_start = jiffies;
2142 for (; i < MAX_FIDS / 2 && (priv->fids[i] & 0xffff0000); i++);
2143 } else {
2144 priv->fids[fid] &= 0xffff;
2145 priv->stats.tx_window_errors++;
2146 }
2147 if (i < MAX_FIDS / 2)
2148 netif_wake_queue(dev);
2149 dev_kfree_skb(skb);
2150 }
2151
2152 static int airo_start_xmit(struct sk_buff *skb, struct net_device *dev) {
2153 s16 len;
2154 int i, j;
2155 struct airo_info *priv = dev->priv;
2156 u32 *fids = priv->fids;
2157
2158 if ( skb == NULL ) {
2159 airo_print_err(dev->name, "%s: skb == NULL!", __FUNCTION__);
2160 return 0;
2161 }
2162
2163 /* Find a vacant FID */
2164 for( i = 0; i < MAX_FIDS / 2 && (fids[i] & 0xffff0000); i++ );
2165 for( j = i + 1; j < MAX_FIDS / 2 && (fids[j] & 0xffff0000); j++ );
2166
2167 if ( j >= MAX_FIDS / 2 ) {
2168 netif_stop_queue(dev);
2169
2170 if (i == MAX_FIDS / 2) {
2171 priv->stats.tx_fifo_errors++;
2172 return 1;
2173 }
2174 }
2175 /* check min length*/
2176 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2177 /* Mark fid as used & save length for later */
2178 fids[i] |= (len << 16);
2179 priv->xmit.skb = skb;
2180 priv->xmit.fid = i;
2181 if (down_trylock(&priv->sem) != 0) {
2182 set_bit(FLAG_PENDING_XMIT, &priv->flags);
2183 netif_stop_queue(dev);
2184 set_bit(JOB_XMIT, &priv->jobs);
2185 wake_up_interruptible(&priv->thr_wait);
2186 } else
2187 airo_end_xmit(dev);
2188 return 0;
2189 }
2190
2191 static void airo_end_xmit11(struct net_device *dev) {
2192 u16 status;
2193 int i;
2194 struct airo_info *priv = dev->priv;
2195 struct sk_buff *skb = priv->xmit11.skb;
2196 int fid = priv->xmit11.fid;
2197 u32 *fids = priv->fids;
2198
2199 clear_bit(JOB_XMIT11, &priv->jobs);
2200 clear_bit(FLAG_PENDING_XMIT11, &priv->flags);
2201 status = transmit_802_11_packet (priv, fids[fid], skb->data);
2202 up(&priv->sem);
2203
2204 i = MAX_FIDS / 2;
2205 if ( status == SUCCESS ) {
2206 dev->trans_start = jiffies;
2207 for (; i < MAX_FIDS && (priv->fids[i] & 0xffff0000); i++);
2208 } else {
2209 priv->fids[fid] &= 0xffff;
2210 priv->stats.tx_window_errors++;
2211 }
2212 if (i < MAX_FIDS)
2213 netif_wake_queue(dev);
2214 dev_kfree_skb(skb);
2215 }
2216
2217 static int airo_start_xmit11(struct sk_buff *skb, struct net_device *dev) {
2218 s16 len;
2219 int i, j;
2220 struct airo_info *priv = dev->priv;
2221 u32 *fids = priv->fids;
2222
2223 if (test_bit(FLAG_MPI, &priv->flags)) {
2224 /* Not implemented yet for MPI350 */
2225 netif_stop_queue(dev);
2226 return -ENETDOWN;
2227 }
2228
2229 if ( skb == NULL ) {
2230 airo_print_err(dev->name, "%s: skb == NULL!", __FUNCTION__);
2231 return 0;
2232 }
2233
2234 /* Find a vacant FID */
2235 for( i = MAX_FIDS / 2; i < MAX_FIDS && (fids[i] & 0xffff0000); i++ );
2236 for( j = i + 1; j < MAX_FIDS && (fids[j] & 0xffff0000); j++ );
2237
2238 if ( j >= MAX_FIDS ) {
2239 netif_stop_queue(dev);
2240
2241 if (i == MAX_FIDS) {
2242 priv->stats.tx_fifo_errors++;
2243 return 1;
2244 }
2245 }
2246 /* check min length*/
2247 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2248 /* Mark fid as used & save length for later */
2249 fids[i] |= (len << 16);
2250 priv->xmit11.skb = skb;
2251 priv->xmit11.fid = i;
2252 if (down_trylock(&priv->sem) != 0) {
2253 set_bit(FLAG_PENDING_XMIT11, &priv->flags);
2254 netif_stop_queue(dev);
2255 set_bit(JOB_XMIT11, &priv->jobs);
2256 wake_up_interruptible(&priv->thr_wait);
2257 } else
2258 airo_end_xmit11(dev);
2259 return 0;
2260 }
2261
2262 static void airo_read_stats(struct airo_info *ai) {
2263 StatsRid stats_rid;
2264 u32 *vals = stats_rid.vals;
2265
2266 clear_bit(JOB_STATS, &ai->jobs);
2267 if (ai->power.event) {
2268 up(&ai->sem);
2269 return;
2270 }
2271 readStatsRid(ai, &stats_rid, RID_STATS, 0);
2272 up(&ai->sem);
2273
2274 ai->stats.rx_packets = vals[43] + vals[44] + vals[45];
2275 ai->stats.tx_packets = vals[39] + vals[40] + vals[41];
2276 ai->stats.rx_bytes = vals[92];
2277 ai->stats.tx_bytes = vals[91];
2278 ai->stats.rx_errors = vals[0] + vals[2] + vals[3] + vals[4];
2279 ai->stats.tx_errors = vals[42] + ai->stats.tx_fifo_errors;
2280 ai->stats.multicast = vals[43];
2281 ai->stats.collisions = vals[89];
2282
2283 /* detailed rx_errors: */
2284 ai->stats.rx_length_errors = vals[3];
2285 ai->stats.rx_crc_errors = vals[4];
2286 ai->stats.rx_frame_errors = vals[2];
2287 ai->stats.rx_fifo_errors = vals[0];
2288 }
2289
2290 static struct net_device_stats *airo_get_stats(struct net_device *dev)
2291 {
2292 struct airo_info *local = dev->priv;
2293
2294 if (!test_bit(JOB_STATS, &local->jobs)) {
2295 /* Get stats out of the card if available */
2296 if (down_trylock(&local->sem) != 0) {
2297 set_bit(JOB_STATS, &local->jobs);
2298 wake_up_interruptible(&local->thr_wait);
2299 } else
2300 airo_read_stats(local);
2301 }
2302
2303 return &local->stats;
2304 }
2305
2306 static void airo_set_promisc(struct airo_info *ai) {
2307 Cmd cmd;
2308 Resp rsp;
2309
2310 memset(&cmd, 0, sizeof(cmd));
2311 cmd.cmd=CMD_SETMODE;
2312 clear_bit(JOB_PROMISC, &ai->jobs);
2313 cmd.parm0=(ai->flags&IFF_PROMISC) ? PROMISC : NOPROMISC;
2314 issuecommand(ai, &cmd, &rsp);
2315 up(&ai->sem);
2316 }
2317
2318 static void airo_set_multicast_list(struct net_device *dev) {
2319 struct airo_info *ai = dev->priv;
2320
2321 if ((dev->flags ^ ai->flags) & IFF_PROMISC) {
2322 change_bit(FLAG_PROMISC, &ai->flags);
2323 if (down_trylock(&ai->sem) != 0) {
2324 set_bit(JOB_PROMISC, &ai->jobs);
2325 wake_up_interruptible(&ai->thr_wait);
2326 } else
2327 airo_set_promisc(ai);
2328 }
2329
2330 if ((dev->flags&IFF_ALLMULTI)||dev->mc_count>0) {
2331 /* Turn on multicast. (Should be already setup...) */
2332 }
2333 }
2334
2335 static int airo_set_mac_address(struct net_device *dev, void *p)
2336 {
2337 struct airo_info *ai = dev->priv;
2338 struct sockaddr *addr = p;
2339 Resp rsp;
2340
2341 readConfigRid(ai, 1);
2342 memcpy (ai->config.macAddr, addr->sa_data, dev->addr_len);
2343 set_bit (FLAG_COMMIT, &ai->flags);
2344 disable_MAC(ai, 1);
2345 writeConfigRid (ai, 1);
2346 enable_MAC(ai, &rsp, 1);
2347 memcpy (ai->dev->dev_addr, addr->sa_data, dev->addr_len);
2348 if (ai->wifidev)
2349 memcpy (ai->wifidev->dev_addr, addr->sa_data, dev->addr_len);
2350 return 0;
2351 }
2352
2353 static int airo_change_mtu(struct net_device *dev, int new_mtu)
2354 {
2355 if ((new_mtu < 68) || (new_mtu > 2400))
2356 return -EINVAL;
2357 dev->mtu = new_mtu;
2358 return 0;
2359 }
2360
2361
2362 static int airo_close(struct net_device *dev) {
2363 struct airo_info *ai = dev->priv;
2364
2365 netif_stop_queue(dev);
2366
2367 if (ai->wifidev != dev) {
2368 #ifdef POWER_ON_DOWN
2369 /* Shut power to the card. The idea is that the user can save
2370 * power when he doesn't need the card with "ifconfig down".
2371 * That's the method that is most friendly towards the network
2372 * stack (i.e. the network stack won't try to broadcast
2373 * anything on the interface and routes are gone. Jean II */
2374 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2375 disable_MAC(ai, 1);
2376 #endif
2377 disable_interrupts( ai );
2378 }
2379 return 0;
2380 }
2381
2382 static void del_airo_dev( struct net_device *dev );
2383
2384 void stop_airo_card( struct net_device *dev, int freeres )
2385 {
2386 struct airo_info *ai = dev->priv;
2387
2388 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2389 disable_MAC(ai, 1);
2390 disable_interrupts(ai);
2391 free_irq( dev->irq, dev );
2392 takedown_proc_entry( dev, ai );
2393 if (test_bit(FLAG_REGISTERED, &ai->flags)) {
2394 unregister_netdev( dev );
2395 if (ai->wifidev) {
2396 unregister_netdev(ai->wifidev);
2397 free_netdev(ai->wifidev);
2398 ai->wifidev = NULL;
2399 }
2400 clear_bit(FLAG_REGISTERED, &ai->flags);
2401 }
2402 set_bit(JOB_DIE, &ai->jobs);
2403 kill_proc(ai->thr_pid, SIGTERM, 1);
2404 wait_for_completion(&ai->thr_exited);
2405
2406 /*
2407 * Clean out tx queue
2408 */
2409 if (test_bit(FLAG_MPI, &ai->flags) && !skb_queue_empty(&ai->txq)) {
2410 struct sk_buff *skb = NULL;
2411 for (;(skb = skb_dequeue(&ai->txq));)
2412 dev_kfree_skb(skb);
2413 }
2414
2415 airo_networks_free (ai);
2416
2417 kfree(ai->flash);
2418 kfree(ai->rssi);
2419 kfree(ai->APList);
2420 kfree(ai->SSID);
2421 if (freeres) {
2422 /* PCMCIA frees this stuff, so only for PCI and ISA */
2423 release_region( dev->base_addr, 64 );
2424 if (test_bit(FLAG_MPI, &ai->flags)) {
2425 if (ai->pci)
2426 mpi_unmap_card(ai->pci);
2427 if (ai->pcimem)
2428 iounmap(ai->pcimem);
2429 if (ai->pciaux)
2430 iounmap(ai->pciaux);
2431 pci_free_consistent(ai->pci, PCI_SHARED_LEN,
2432 ai->shared, ai->shared_dma);
2433 }
2434 }
2435 crypto_free_tfm(ai->tfm);
2436 del_airo_dev( dev );
2437 free_netdev( dev );
2438 }
2439
2440 EXPORT_SYMBOL(stop_airo_card);
2441
2442 static int add_airo_dev( struct net_device *dev );
2443
2444 static int wll_header_parse(struct sk_buff *skb, unsigned char *haddr)
2445 {
2446 memcpy(haddr, skb->mac.raw + 10, ETH_ALEN);
2447 return ETH_ALEN;
2448 }
2449
2450 static void mpi_unmap_card(struct pci_dev *pci)
2451 {
2452 unsigned long mem_start = pci_resource_start(pci, 1);
2453 unsigned long mem_len = pci_resource_len(pci, 1);
2454 unsigned long aux_start = pci_resource_start(pci, 2);
2455 unsigned long aux_len = AUXMEMSIZE;
2456
2457 release_mem_region(aux_start, aux_len);
2458 release_mem_region(mem_start, mem_len);
2459 }
2460
2461 /*************************************************************
2462 * This routine assumes that descriptors have been setup .
2463 * Run at insmod time or after reset when the decriptors
2464 * have been initialized . Returns 0 if all is well nz
2465 * otherwise . Does not allocate memory but sets up card
2466 * using previously allocated descriptors.
2467 */
2468 static int mpi_init_descriptors (struct airo_info *ai)
2469 {
2470 Cmd cmd;
2471 Resp rsp;
2472 int i;
2473 int rc = SUCCESS;
2474
2475 /* Alloc card RX descriptors */
2476 netif_stop_queue(ai->dev);
2477
2478 memset(&rsp,0,sizeof(rsp));
2479 memset(&cmd,0,sizeof(cmd));
2480
2481 cmd.cmd = CMD_ALLOCATEAUX;
2482 cmd.parm0 = FID_RX;
2483 cmd.parm1 = (ai->rxfids[0].card_ram_off - ai->pciaux);
2484 cmd.parm2 = MPI_MAX_FIDS;
2485 rc=issuecommand(ai, &cmd, &rsp);
2486 if (rc != SUCCESS) {
2487 airo_print_err(ai->dev->name, "Couldn't allocate RX FID");
2488 return rc;
2489 }
2490
2491 for (i=0; i<MPI_MAX_FIDS; i++) {
2492 memcpy_toio(ai->rxfids[i].card_ram_off,
2493 &ai->rxfids[i].rx_desc, sizeof(RxFid));
2494 }
2495
2496 /* Alloc card TX descriptors */
2497
2498 memset(&rsp,0,sizeof(rsp));
2499 memset(&cmd,0,sizeof(cmd));
2500
2501 cmd.cmd = CMD_ALLOCATEAUX;
2502 cmd.parm0 = FID_TX;
2503 cmd.parm1 = (ai->txfids[0].card_ram_off - ai->pciaux);
2504 cmd.parm2 = MPI_MAX_FIDS;
2505
2506 for (i=0; i<MPI_MAX_FIDS; i++) {
2507 ai->txfids[i].tx_desc.valid = 1;
2508 memcpy_toio(ai->txfids[i].card_ram_off,
2509 &ai->txfids[i].tx_desc, sizeof(TxFid));
2510 }
2511 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2512
2513 rc=issuecommand(ai, &cmd, &rsp);
2514 if (rc != SUCCESS) {
2515 airo_print_err(ai->dev->name, "Couldn't allocate TX FID");
2516 return rc;
2517 }
2518
2519 /* Alloc card Rid descriptor */
2520 memset(&rsp,0,sizeof(rsp));
2521 memset(&cmd,0,sizeof(cmd));
2522
2523 cmd.cmd = CMD_ALLOCATEAUX;
2524 cmd.parm0 = RID_RW;
2525 cmd.parm1 = (ai->config_desc.card_ram_off - ai->pciaux);
2526 cmd.parm2 = 1; /* Magic number... */
2527 rc=issuecommand(ai, &cmd, &rsp);
2528 if (rc != SUCCESS) {
2529 airo_print_err(ai->dev->name, "Couldn't allocate RID");
2530 return rc;
2531 }
2532
2533 memcpy_toio(ai->config_desc.card_ram_off,
2534 &ai->config_desc.rid_desc, sizeof(Rid));
2535
2536 return rc;
2537 }
2538
2539 /*
2540 * We are setting up three things here:
2541 * 1) Map AUX memory for descriptors: Rid, TxFid, or RxFid.
2542 * 2) Map PCI memory for issueing commands.
2543 * 3) Allocate memory (shared) to send and receive ethernet frames.
2544 */
2545 static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci,
2546 const char *name)
2547 {
2548 unsigned long mem_start, mem_len, aux_start, aux_len;
2549 int rc = -1;
2550 int i;
2551 dma_addr_t busaddroff;
2552 unsigned char *vpackoff;
2553 unsigned char __iomem *pciaddroff;
2554
2555 mem_start = pci_resource_start(pci, 1);
2556 mem_len = pci_resource_len(pci, 1);
2557 aux_start = pci_resource_start(pci, 2);
2558 aux_len = AUXMEMSIZE;
2559
2560 if (!request_mem_region(mem_start, mem_len, name)) {
2561 airo_print_err(ai->dev->name, "Couldn't get region %x[%x] for %s",
2562 (int)mem_start, (int)mem_len, name);
2563 goto out;
2564 }
2565 if (!request_mem_region(aux_start, aux_len, name)) {
2566 airo_print_err(ai->dev->name, "Couldn't get region %x[%x] for %s",
2567 (int)aux_start, (int)aux_len, name);
2568 goto free_region1;
2569 }
2570
2571 ai->pcimem = ioremap(mem_start, mem_len);
2572 if (!ai->pcimem) {
2573 airo_print_err(ai->dev->name, "Couldn't map region %x[%x] for %s",
2574 (int)mem_start, (int)mem_len, name);
2575 goto free_region2;
2576 }
2577 ai->pciaux = ioremap(aux_start, aux_len);
2578 if (!ai->pciaux) {
2579 airo_print_err(ai->dev->name, "Couldn't map region %x[%x] for %s",
2580 (int)aux_start, (int)aux_len, name);
2581 goto free_memmap;
2582 }
2583
2584 /* Reserve PKTSIZE for each fid and 2K for the Rids */
2585 ai->shared = pci_alloc_consistent(pci, PCI_SHARED_LEN, &ai->shared_dma);
2586 if (!ai->shared) {
2587 airo_print_err(ai->dev->name, "Couldn't alloc_consistent %d",
2588 PCI_SHARED_LEN);
2589 goto free_auxmap;
2590 }
2591
2592 /*
2593 * Setup descriptor RX, TX, CONFIG
2594 */
2595 busaddroff = ai->shared_dma;
2596 pciaddroff = ai->pciaux + AUX_OFFSET;
2597 vpackoff = ai->shared;
2598
2599 /* RX descriptor setup */
2600 for(i = 0; i < MPI_MAX_FIDS; i++) {
2601 ai->rxfids[i].pending = 0;
2602 ai->rxfids[i].card_ram_off = pciaddroff;
2603 ai->rxfids[i].virtual_host_addr = vpackoff;
2604 ai->rxfids[i].rx_desc.host_addr = busaddroff;
2605 ai->rxfids[i].rx_desc.valid = 1;
2606 ai->rxfids[i].rx_desc.len = PKTSIZE;
2607 ai->rxfids[i].rx_desc.rdy = 0;
2608
2609 pciaddroff += sizeof(RxFid);
2610 busaddroff += PKTSIZE;
2611 vpackoff += PKTSIZE;
2612 }
2613
2614 /* TX descriptor setup */
2615 for(i = 0; i < MPI_MAX_FIDS; i++) {
2616 ai->txfids[i].card_ram_off = pciaddroff;
2617 ai->txfids[i].virtual_host_addr = vpackoff;
2618 ai->txfids[i].tx_desc.valid = 1;
2619 ai->txfids[i].tx_desc.host_addr = busaddroff;
2620 memcpy(ai->txfids[i].virtual_host_addr,
2621 &wifictlhdr8023, sizeof(wifictlhdr8023));
2622
2623 pciaddroff += sizeof(TxFid);
2624 busaddroff += PKTSIZE;
2625 vpackoff += PKTSIZE;
2626 }
2627 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2628
2629 /* Rid descriptor setup */
2630 ai->config_desc.card_ram_off = pciaddroff;
2631 ai->config_desc.virtual_host_addr = vpackoff;
2632 ai->config_desc.rid_desc.host_addr = busaddroff;
2633 ai->ridbus = busaddroff;
2634 ai->config_desc.rid_desc.rid = 0;
2635 ai->config_desc.rid_desc.len = RIDSIZE;
2636 ai->config_desc.rid_desc.valid = 1;
2637 pciaddroff += sizeof(Rid);
2638 busaddroff += RIDSIZE;
2639 vpackoff += RIDSIZE;
2640
2641 /* Tell card about descriptors */
2642 if (mpi_init_descriptors (ai) != SUCCESS)
2643 goto free_shared;
2644
2645 return 0;
2646 free_shared:
2647 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2648 free_auxmap:
2649 iounmap(ai->pciaux);
2650 free_memmap:
2651 iounmap(ai->pcimem);
2652 free_region2:
2653 release_mem_region(aux_start, aux_len);
2654 free_region1:
2655 release_mem_region(mem_start, mem_len);
2656 out:
2657 return rc;
2658 }
2659
2660 static void wifi_setup(struct net_device *dev)
2661 {
2662 dev->hard_header = NULL;
2663 dev->rebuild_header = NULL;
2664 dev->hard_header_cache = NULL;
2665 dev->header_cache_update= NULL;
2666
2667 dev->hard_header_parse = wll_header_parse;
2668 dev->hard_start_xmit = &airo_start_xmit11;
2669 dev->get_stats = &airo_get_stats;
2670 dev->set_mac_address = &airo_set_mac_address;
2671 dev->do_ioctl = &airo_ioctl;
2672 dev->wireless_handlers = &airo_handler_def;
2673 dev->change_mtu = &airo_change_mtu;
2674 dev->open = &airo_open;
2675 dev->stop = &airo_close;
2676
2677 dev->type = ARPHRD_IEEE80211;
2678 dev->hard_header_len = ETH_HLEN;
2679 dev->mtu = AIRO_DEF_MTU;
2680 dev->addr_len = ETH_ALEN;
2681 dev->tx_queue_len = 100;
2682
2683 memset(dev->broadcast,0xFF, ETH_ALEN);
2684
2685 dev->flags = IFF_BROADCAST|IFF_MULTICAST;
2686 }
2687
2688 static struct net_device *init_wifidev(struct airo_info *ai,
2689 struct net_device *ethdev)
2690 {
2691 int err;
2692 struct net_device *dev = alloc_netdev(0, "wifi%d", wifi_setup);
2693 if (!dev)
2694 return NULL;
2695 dev->priv = ethdev->priv;
2696 dev->irq = ethdev->irq;
2697 dev->base_addr = ethdev->base_addr;
2698 dev->wireless_data = ethdev->wireless_data;
2699 memcpy(dev->dev_addr, ethdev->dev_addr, dev->addr_len);
2700 err = register_netdev(dev);
2701 if (err<0) {
2702 free_netdev(dev);
2703 return NULL;
2704 }
2705 return dev;
2706 }
2707
2708 static int reset_card( struct net_device *dev , int lock) {
2709 struct airo_info *ai = dev->priv;
2710
2711 if (lock && down_interruptible(&ai->sem))
2712 return -1;
2713 waitbusy (ai);
2714 OUT4500(ai,COMMAND,CMD_SOFTRESET);
2715 msleep(200);
2716 waitbusy (ai);
2717 msleep(200);
2718 if (lock)
2719 up(&ai->sem);
2720 return 0;
2721 }
2722
2723 #define AIRO_MAX_NETWORK_COUNT 64
2724 static int airo_networks_allocate(struct airo_info *ai)
2725 {
2726 if (ai->networks)
2727 return 0;
2728
2729 ai->networks =
2730 kzalloc(AIRO_MAX_NETWORK_COUNT * sizeof(BSSListElement),
2731 GFP_KERNEL);
2732 if (!ai->networks) {
2733 airo_print_warn(ai->dev->name, "Out of memory allocating beacons");
2734 return -ENOMEM;
2735 }
2736
2737 return 0;
2738 }
2739
2740 static void airo_networks_free(struct airo_info *ai)
2741 {
2742 if (!ai->networks)
2743 return;
2744 kfree(ai->networks);
2745 ai->networks = NULL;
2746 }
2747
2748 static void airo_networks_initialize(struct airo_info *ai)
2749 {
2750 int i;
2751
2752 INIT_LIST_HEAD(&ai->network_free_list);
2753 INIT_LIST_HEAD(&ai->network_list);
2754 for (i = 0; i < AIRO_MAX_NETWORK_COUNT; i++)
2755 list_add_tail(&ai->networks[i].list,
2756 &ai->network_free_list);
2757 }
2758
2759 static int airo_test_wpa_capable(struct airo_info *ai)
2760 {
2761 int status;
2762 CapabilityRid cap_rid;
2763 const char *name = ai->dev->name;
2764
2765 status = readCapabilityRid(ai, &cap_rid, 1);
2766 if (status != SUCCESS) return 0;
2767
2768 /* Only firmware versions 5.30.17 or better can do WPA */
2769 if ((cap_rid.softVer > 0x530)
2770 || ((cap_rid.softVer == 0x530) && (cap_rid.softSubVer >= 17))) {
2771 airo_print_info(name, "WPA is supported.");
2772 return 1;
2773 }
2774
2775 /* No WPA support */
2776 airo_print_info(name, "WPA unsupported (only firmware versions 5.30.17"
2777 " and greater support WPA. Detected %s)", cap_rid.prodVer);
2778 return 0;
2779 }
2780
2781 static struct net_device *_init_airo_card( unsigned short irq, int port,
2782 int is_pcmcia, struct pci_dev *pci,
2783 struct device *dmdev )
2784 {
2785 struct net_device *dev;
2786 struct airo_info *ai;
2787 int i, rc;
2788
2789 /* Create the network device object. */
2790 dev = alloc_etherdev(sizeof(*ai));
2791 if (!dev) {
2792 airo_print_err("", "Couldn't alloc_etherdev");
2793 return NULL;
2794 }
2795 if (dev_alloc_name(dev, dev->name) < 0) {
2796 airo_print_err("", "Couldn't get name!");
2797 goto err_out_free;
2798 }
2799
2800 ai = dev->priv;
2801 ai->wifidev = NULL;
2802 ai->flags = 0;
2803 ai->jobs = 0;
2804 ai->dev = dev;
2805 if (pci && (pci->device == 0x5000 || pci->device == 0xa504)) {
2806 airo_print_dbg(dev->name, "Found an MPI350 card");
2807 set_bit(FLAG_MPI, &ai->flags);
2808 }
2809 spin_lock_init(&ai->aux_lock);
2810 sema_init(&ai->sem, 1);
2811 ai->config.len = 0;
2812 ai->pci = pci;
2813 init_waitqueue_head (&ai->thr_wait);
2814 init_completion (&ai->thr_exited);
2815 ai->thr_pid = kernel_thread(airo_thread, dev, CLONE_FS | CLONE_FILES);
2816 if (ai->thr_pid < 0)
2817 goto err_out_free;
2818 ai->tfm = NULL;
2819 rc = add_airo_dev( dev );
2820 if (rc)
2821 goto err_out_thr;
2822
2823 if (airo_networks_allocate (ai))
2824 goto err_out_unlink;
2825 airo_networks_initialize (ai);
2826
2827 /* The Airo-specific entries in the device structure. */
2828 if (test_bit(FLAG_MPI,&ai->flags)) {
2829 skb_queue_head_init (&ai->txq);
2830 dev->hard_start_xmit = &mpi_start_xmit;
2831 } else
2832 dev->hard_start_xmit = &airo_start_xmit;
2833 dev->get_stats = &airo_get_stats;
2834 dev->set_multicast_list = &airo_set_multicast_list;
2835 dev->set_mac_address = &airo_set_mac_address;
2836 dev->do_ioctl = &airo_ioctl;
2837 dev->wireless_handlers = &airo_handler_def;
2838 ai->wireless_data.spy_data = &ai->spy_data;
2839 dev->wireless_data = &ai->wireless_data;
2840 dev->change_mtu = &airo_change_mtu;
2841 dev->open = &airo_open;
2842 dev->stop = &airo_close;
2843 dev->irq = irq;
2844 dev->base_addr = port;
2845
2846 SET_NETDEV_DEV(dev, dmdev);
2847
2848 reset_card (dev, 1);
2849 msleep(400);
2850
2851 rc = request_irq( dev->irq, airo_interrupt, IRQF_SHARED, dev->name, dev );
2852 if (rc) {
2853 airo_print_err(dev->name, "register interrupt %d failed, rc %d",
2854 irq, rc);
2855 goto err_out_unlink;
2856 }
2857 if (!is_pcmcia) {
2858 if (!request_region( dev->base_addr, 64, dev->name )) {
2859 rc = -EBUSY;
2860 airo_print_err(dev->name, "Couldn't request region");
2861 goto err_out_irq;
2862 }
2863 }
2864
2865 if (test_bit(FLAG_MPI,&ai->flags)) {
2866 if (mpi_map_card(ai, pci, dev->name)) {
2867 airo_print_err(dev->name, "Could not map memory");
2868 goto err_out_res;
2869 }
2870 }
2871
2872 if (probe) {
2873 if ( setup_card( ai, dev->dev_addr, 1 ) != SUCCESS ) {
2874 airo_print_err(dev->name, "MAC could not be enabled" );
2875 rc = -EIO;
2876 goto err_out_map;
2877 }
2878 } else if (!test_bit(FLAG_MPI,&ai->flags)) {
2879 ai->bap_read = fast_bap_read;
2880 set_bit(FLAG_FLASHING, &ai->flags);
2881 }
2882
2883 /* Test for WPA support */
2884 if (airo_test_wpa_capable(ai)) {
2885 set_bit(FLAG_WPA_CAPABLE, &ai->flags);
2886 ai->bssListFirst = RID_WPA_BSSLISTFIRST;
2887 ai->bssListNext = RID_WPA_BSSLISTNEXT;
2888 ai->bssListRidLen = sizeof(BSSListRid);
2889 } else {
2890 ai->bssListFirst = RID_BSSLISTFIRST;
2891 ai->bssListNext = RID_BSSLISTNEXT;
2892 ai->bssListRidLen = sizeof(BSSListRid) - sizeof(BSSListRidExtra);
2893 }
2894
2895 rc = register_netdev(dev);
2896 if (rc) {
2897 airo_print_err(dev->name, "Couldn't register_netdev");
2898 goto err_out_map;
2899 }
2900 ai->wifidev = init_wifidev(ai, dev);
2901
2902 set_bit(FLAG_REGISTERED,&ai->flags);
2903 airo_print_info(dev->name, "MAC enabled %x:%x:%x:%x:%x:%x",
2904 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
2905 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5] );
2906
2907 /* Allocate the transmit buffers */
2908 if (probe && !test_bit(FLAG_MPI,&ai->flags))
2909 for( i = 0; i < MAX_FIDS; i++ )
2910 ai->fids[i] = transmit_allocate(ai,AIRO_DEF_MTU,i>=MAX_FIDS/2);
2911
2912 setup_proc_entry( dev, dev->priv ); /* XXX check for failure */
2913 netif_start_queue(dev);
2914 SET_MODULE_OWNER(dev);
2915 return dev;
2916
2917 err_out_map:
2918 if (test_bit(FLAG_MPI,&ai->flags) && pci) {
2919 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2920 iounmap(ai->pciaux);
2921 iounmap(ai->pcimem);
2922 mpi_unmap_card(ai->pci);
2923 }
2924 err_out_res:
2925 if (!is_pcmcia)
2926 release_region( dev->base_addr, 64 );
2927 err_out_irq:
2928 free_irq(dev->irq, dev);
2929 err_out_unlink:
2930 del_airo_dev(dev);
2931 err_out_thr:
2932 set_bit(JOB_DIE, &ai->jobs);
2933 kill_proc(ai->thr_pid, SIGTERM, 1);
2934 wait_for_completion(&ai->thr_exited);
2935 err_out_free:
2936 free_netdev(dev);
2937 return NULL;
2938 }
2939
2940 struct net_device *init_airo_card( unsigned short irq, int port, int is_pcmcia,
2941 struct device *dmdev)
2942 {
2943 return _init_airo_card ( irq, port, is_pcmcia, NULL, dmdev);
2944 }
2945
2946 EXPORT_SYMBOL(init_airo_card);
2947
2948 static int waitbusy (struct airo_info *ai) {
2949 int delay = 0;
2950 while ((IN4500 (ai, COMMAND) & COMMAND_BUSY) & (delay < 10000)) {
2951 udelay (10);
2952 if ((++delay % 20) == 0)
2953 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
2954 }
2955 return delay < 10000;
2956 }
2957
2958 int reset_airo_card( struct net_device *dev )
2959 {
2960 int i;
2961 struct airo_info *ai = dev->priv;
2962
2963 if (reset_card (dev, 1))
2964 return -1;
2965
2966 if ( setup_card(ai, dev->dev_addr, 1 ) != SUCCESS ) {
2967 airo_print_err(dev->name, "MAC could not be enabled");
2968 return -1;
2969 }
2970 airo_print_info(dev->name, "MAC enabled %x:%x:%x:%x:%x:%x",
2971 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
2972 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
2973 /* Allocate the transmit buffers if needed */
2974 if (!test_bit(FLAG_MPI,&ai->flags))
2975 for( i = 0; i < MAX_FIDS; i++ )
2976 ai->fids[i] = transmit_allocate (ai,AIRO_DEF_MTU,i>=MAX_FIDS/2);
2977
2978 enable_interrupts( ai );
2979 netif_wake_queue(dev);
2980 return 0;
2981 }
2982
2983 EXPORT_SYMBOL(reset_airo_card);
2984
2985 static void airo_send_event(struct net_device *dev) {
2986 struct airo_info *ai = dev->priv;
2987 union iwreq_data wrqu;
2988 StatusRid status_rid;
2989
2990 clear_bit(JOB_EVENT, &ai->jobs);
2991 PC4500_readrid(ai, RID_STATUS, &status_rid, sizeof(status_rid), 0);
2992 up(&ai->sem);
2993 wrqu.data.length = 0;
2994 wrqu.data.flags = 0;
2995 memcpy(wrqu.ap_addr.sa_data, status_rid.bssid[0], ETH_ALEN);
2996 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
2997
2998 /* Send event to user space */
2999 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
3000 }
3001
3002 static void airo_process_scan_results (struct airo_info *ai) {
3003 union iwreq_data wrqu;
3004 BSSListRid bss;
3005 int rc;
3006 BSSListElement * loop_net;
3007 BSSListElement * tmp_net;
3008
3009 /* Blow away current list of scan results */
3010 list_for_each_entry_safe (loop_net, tmp_net, &ai->network_list, list) {
3011 list_move_tail (&loop_net->list, &ai->network_free_list);
3012 /* Don't blow away ->list, just BSS data */
3013 memset (loop_net, 0, sizeof (loop_net->bss));
3014 }
3015
3016 /* Try to read the first entry of the scan result */
3017 rc = PC4500_readrid(ai, ai->bssListFirst, &bss, ai->bssListRidLen, 0);
3018 if((rc) || (bss.index == 0xffff)) {
3019 /* No scan results */
3020 goto out;
3021 }
3022
3023 /* Read and parse all entries */
3024 tmp_net = NULL;
3025 while((!rc) && (bss.index != 0xffff)) {
3026 /* Grab a network off the free list */
3027 if (!list_empty(&ai->network_free_list)) {
3028 tmp_net = list_entry(ai->network_free_list.next,
3029 BSSListElement, list);
3030 list_del(ai->network_free_list.next);
3031 }
3032
3033 if (tmp_net != NULL) {
3034 memcpy(tmp_net, &bss, sizeof(tmp_net->bss));
3035 list_add_tail(&tmp_net->list, &ai->network_list);
3036 tmp_net = NULL;
3037 }
3038
3039 /* Read next entry */
3040 rc = PC4500_readrid(ai, ai->bssListNext,
3041 &bss, ai->bssListRidLen, 0);
3042 }
3043
3044 out:
3045 ai->scan_timeout = 0;
3046 clear_bit(JOB_SCAN_RESULTS, &ai->jobs);
3047 up(&ai->sem);
3048
3049 /* Send an empty event to user space.
3050 * We don't send the received data on
3051 * the event because it would require
3052 * us to do complex transcoding, and
3053 * we want to minimise the work done in
3054 * the irq handler. Use a request to
3055 * extract the data - Jean II */
3056 wrqu.data.length = 0;
3057 wrqu.data.flags = 0;
3058 wireless_send_event(ai->dev, SIOCGIWSCAN, &wrqu, NULL);
3059 }
3060
3061 static int airo_thread(void *data) {
3062 struct net_device *dev = data;
3063 struct airo_info *ai = dev->priv;
3064 int locked;
3065
3066 daemonize("%s", dev->name);
3067 allow_signal(SIGTERM);
3068
3069 while(1) {
3070 if (signal_pending(current))
3071 flush_signals(current);
3072
3073 /* make swsusp happy with our thread */
3074 try_to_freeze();
3075
3076 if (test_bit(JOB_DIE, &ai->jobs))
3077 break;
3078
3079 if (ai->jobs) {
3080 locked = down_interruptible(&ai->sem);
3081 } else {
3082 wait_queue_t wait;
3083
3084 init_waitqueue_entry(&wait, current);
3085 add_wait_queue(&ai->thr_wait, &wait);
3086 for (;;) {
3087 set_current_state(TASK_INTERRUPTIBLE);
3088 if (ai->jobs)
3089 break;
3090 if (ai->expires || ai->scan_timeout) {
3091 if (ai->scan_timeout &&
3092 time_after_eq(jiffies,ai->scan_timeout)){
3093 set_bit(JOB_SCAN_RESULTS, &ai->jobs);
3094 break;
3095 } else if (ai->expires &&
3096 time_after_eq(jiffies,ai->expires)){
3097 set_bit(JOB_AUTOWEP, &ai->jobs);
3098 break;
3099 }
3100 if (!signal_pending(current)) {
3101 unsigned long wake_at;
3102 if (!ai->expires || !ai->scan_timeout) {
3103 wake_at = max(ai->expires,
3104 ai->scan_timeout);
3105 } else {
3106 wake_at = min(ai->expires,
3107 ai->scan_timeout);
3108 }
3109 schedule_timeout(wake_at - jiffies);
3110 continue;
3111 }
3112 } else if (!signal_pending(current)) {
3113 schedule();
3114 continue;
3115 }
3116 break;
3117 }
3118 current->state = TASK_RUNNING;
3119 remove_wait_queue(&ai->thr_wait, &wait);
3120 locked = 1;
3121 }
3122
3123 if (locked)
3124 continue;
3125
3126 if (test_bit(JOB_DIE, &ai->jobs)) {
3127 up(&ai->sem);
3128 break;
3129 }
3130
3131 if (ai->power.event || test_bit(FLAG_FLASHING, &ai->flags)) {
3132 up(&ai->sem);
3133 continue;
3134 }
3135
3136 if (test_bit(JOB_XMIT, &ai->jobs))
3137 airo_end_xmit(dev);
3138 else if (test_bit(JOB_XMIT11, &ai->jobs))
3139 airo_end_xmit11(dev);
3140 else if (test_bit(JOB_STATS, &ai->jobs))
3141 airo_read_stats(ai);
3142 else if (test_bit(JOB_WSTATS, &ai->jobs))
3143 airo_read_wireless_stats(ai);
3144 else if (test_bit(JOB_PROMISC, &ai->jobs))
3145 airo_set_promisc(ai);
3146 else if (test_bit(JOB_MIC, &ai->jobs))
3147 micinit(ai);
3148 else if (test_bit(JOB_EVENT, &ai->jobs))
3149 airo_send_event(dev);
3150 else if (test_bit(JOB_AUTOWEP, &ai->jobs))
3151 timer_func(dev);
3152 else if (test_bit(JOB_SCAN_RESULTS, &ai->jobs))
3153 airo_process_scan_results(ai);
3154 else /* Shouldn't get here, but we make sure to unlock */
3155 up(&ai->sem);
3156 }
3157 complete_and_exit (&ai->thr_exited, 0);
3158 }
3159
3160 static irqreturn_t airo_interrupt ( int irq, void* dev_id, struct pt_regs *regs) {
3161 struct net_device *dev = (struct net_device *)dev_id;
3162 u16 status;
3163 u16 fid;
3164 struct airo_info *apriv = dev->priv;
3165 u16 savedInterrupts = 0;
3166 int handled = 0;
3167
3168 if (!netif_device_present(dev))
3169 return IRQ_NONE;
3170
3171 for (;;) {
3172 status = IN4500( apriv, EVSTAT );
3173 if ( !(status & STATUS_INTS) || status == 0xffff ) break;
3174
3175 handled = 1;
3176
3177 if ( status & EV_AWAKE ) {
3178 OUT4500( apriv, EVACK, EV_AWAKE );
3179 OUT4500( apriv, EVACK, EV_AWAKE );
3180 }
3181
3182 if (!savedInterrupts) {
3183 savedInterrupts = IN4500( apriv, EVINTEN );
3184 OUT4500( apriv, EVINTEN, 0 );
3185 }
3186
3187 if ( status & EV_MIC ) {
3188 OUT4500( apriv, EVACK, EV_MIC );
3189 if (test_bit(FLAG_MIC_CAPABLE, &apriv->flags)) {
3190 set_bit(JOB_MIC, &apriv->jobs);
3191 wake_up_interruptible(&apriv->thr_wait);
3192 }
3193 }
3194 if ( status & EV_LINK ) {
3195 union iwreq_data wrqu;
3196 int scan_forceloss = 0;
3197 /* The link status has changed, if you want to put a
3198 monitor hook in, do it here. (Remember that
3199 interrupts are still disabled!)
3200 */
3201 u16 newStatus = IN4500(apriv, LINKSTAT);
3202 OUT4500( apriv, EVACK, EV_LINK);
3203 /* Here is what newStatus means: */
3204 #define NOBEACON 0x8000 /* Loss of sync - missed beacons */
3205 #define MAXRETRIES 0x8001 /* Loss of sync - max retries */
3206 #define MAXARL 0x8002 /* Loss of sync - average retry level exceeded*/
3207 #define FORCELOSS 0x8003 /* Loss of sync - host request */
3208 #define TSFSYNC 0x8004 /* Loss of sync - TSF synchronization */
3209 #define DEAUTH 0x8100 /* Deauthentication (low byte is reason code) */
3210 #define DISASS 0x8200 /* Disassociation (low byte is reason code) */
3211 #define ASSFAIL 0x8400 /* Association failure (low byte is reason
3212 code) */
3213 #define AUTHFAIL 0x0300 /* Authentication failure (low byte is reason
3214 code) */
3215 #define ASSOCIATED 0x0400 /* Associated */
3216 #define REASSOCIATED 0x0600 /* Reassociated? Only on firmware >= 5.30.17 */
3217 #define RC_RESERVED 0 /* Reserved return code */
3218 #define RC_NOREASON 1 /* Unspecified reason */
3219 #define RC_AUTHINV 2 /* Previous authentication invalid */
3220 #define RC_DEAUTH 3 /* Deauthenticated because sending station is
3221 leaving */
3222 #define RC_NOACT 4 /* Disassociated due to inactivity */
3223 #define RC_MAXLOAD 5 /* Disassociated because AP is unable to handle
3224 all currently associated stations */
3225 #define RC_BADCLASS2 6 /* Class 2 frame received from
3226 non-Authenticated station */
3227 #define RC_BADCLASS3 7 /* Class 3 frame received from
3228 non-Associated station */
3229 #define RC_STATLEAVE 8 /* Disassociated because sending station is
3230 leaving BSS */
3231 #define RC_NOAUTH 9 /* Station requesting (Re)Association is not
3232 Authenticated with the responding station */
3233 if (newStatus == FORCELOSS && apriv->scan_timeout > 0)
3234 scan_forceloss = 1;
3235 if(newStatus == ASSOCIATED || newStatus == REASSOCIATED) {
3236 if (auto_wep)
3237 apriv->expires = 0;
3238 if (apriv->task)
3239 wake_up_process (apriv->task);
3240 set_bit(FLAG_UPDATE_UNI, &apriv->flags);
3241 set_bit(FLAG_UPDATE_MULTI, &apriv->flags);
3242
3243 if (down_trylock(&apriv->sem) != 0) {
3244 set_bit(JOB_EVENT, &apriv->jobs);
3245 wake_up_interruptible(&apriv->thr_wait);
3246 } else
3247 airo_send_event(dev);
3248 } else if (!scan_forceloss) {
3249 if (auto_wep && !apriv->expires) {
3250 apriv->expires = RUN_AT(3*HZ);
3251 wake_up_interruptible(&apriv->thr_wait);
3252 }
3253
3254 /* Send event to user space */
3255 memset(wrqu.ap_addr.sa_data, '\0', ETH_ALEN);
3256 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
3257 wireless_send_event(dev, SIOCGIWAP, &wrqu,NULL);
3258 }
3259 }
3260
3261 /* Check to see if there is something to receive */
3262 if ( status & EV_RX ) {
3263 struct sk_buff *skb = NULL;
3264 u16 fc, len, hdrlen = 0;
3265 #pragma pack(1)
3266 struct {
3267 u16 status, len;
3268 u8 rssi[2];
3269 u8 rate;
3270 u8 freq;
3271 u16 tmp[4];
3272 } hdr;
3273 #pragma pack()
3274 u16 gap;
3275 u16 tmpbuf[4];
3276 u16 *buffer;
3277
3278 if (test_bit(FLAG_MPI,&apriv->flags)) {
3279 if (test_bit(FLAG_802_11, &apriv->flags))
3280 mpi_receive_802_11(apriv);
3281 else
3282 mpi_receive_802_3(apriv);
3283 OUT4500(apriv, EVACK, EV_RX);
3284 goto exitrx;
3285 }
3286
3287 fid = IN4500( apriv, RXFID );
3288
3289 /* Get the packet length */
3290 if (test_bit(FLAG_802_11, &apriv->flags)) {
3291 bap_setup (apriv, fid, 4, BAP0);
3292 bap_read (apriv, (u16*)&hdr, sizeof(hdr), BAP0);
3293 /* Bad CRC. Ignore packet */
3294 if (le16_to_cpu(hdr.status) & 2)
3295 hdr.len = 0;
3296 if (apriv->wifidev == NULL)
3297 hdr.len = 0;
3298 } else {
3299 bap_setup (apriv, fid, 0x36, BAP0);
3300 bap_read (apriv, (u16*)&hdr.len, 2, BAP0);
3301 }
3302 len = le16_to_cpu(hdr.len);
3303
3304 if (len > AIRO_DEF_MTU) {
3305 airo_print_err(apriv->dev->name, "Bad size %d", len);
3306 goto badrx;
3307 }
3308 if (len == 0)
3309 goto badrx;
3310
3311 if (test_bit(FLAG_802_11, &apriv->flags)) {
3312 bap_read (apriv, (u16*)&fc, sizeof(fc), BAP0);
3313 fc = le16_to_cpu(fc);
3314 switch (fc & 0xc) {
3315 case 4:
3316 if ((fc & 0xe0) == 0xc0)
3317 hdrlen = 10;
3318 else
3319 hdrlen = 16;
3320 break;
3321 case 8:
3322 if ((fc&0x300)==0x300){
3323 hdrlen = 30;
3324 break;
3325 }
3326 default:
3327 hdrlen = 24;
3328 }
3329 } else
3330 hdrlen = ETH_ALEN * 2;
3331
3332 skb = dev_alloc_skb( len + hdrlen + 2 + 2 );
3333 if ( !skb ) {
3334 apriv->stats.rx_dropped++;
3335 goto badrx;
3336 }
3337 skb_reserve(skb, 2); /* This way the IP header is aligned */
3338 buffer = (u16*)skb_put (skb, len + hdrlen);
3339 if (test_bit(FLAG_802_11, &apriv->flags)) {
3340 buffer[0] = fc;
3341 bap_read (apriv, buffer + 1, hdrlen - 2, BAP0);
3342 if (hdrlen == 24)
3343 bap_read (apriv, tmpbuf, 6, BAP0);
3344
3345 bap_read (apriv, &gap, sizeof(gap), BAP0);
3346 gap = le16_to_cpu(gap);
3347 if (gap) {
3348 if (gap <= 8) {
3349 bap_read (apriv, tmpbuf, gap, BAP0);
3350 } else {
3351 airo_print_err(apriv->dev->name, "gaplen too "
3352 "big. Problems will follow...");
3353 }
3354 }
3355 bap_read (apriv, buffer + hdrlen/2, len, BAP0);
3356 } else {
3357 MICBuffer micbuf;
3358 bap_read (apriv, buffer, ETH_ALEN*2, BAP0);
3359 if (apriv->micstats.enabled) {
3360 bap_read (apriv,(u16*)&micbuf,sizeof(micbuf),BAP0);
3361 if (ntohs(micbuf.typelen) > 0x05DC)
3362 bap_setup (apriv, fid, 0x44, BAP0);
3363 else {
3364 if (len <= sizeof(micbuf))
3365 goto badmic;
3366
3367 len -= sizeof(micbuf);
3368 skb_trim (skb, len + hdrlen);
3369 }
3370 }
3371 bap_read(apriv,buffer+ETH_ALEN,len,BAP0);
3372 if (decapsulate(apriv,&micbuf,(etherHead*)buffer,len)) {
3373 badmic:
3374 dev_kfree_skb_irq (skb);
3375 badrx:
3376 OUT4500( apriv, EVACK, EV_RX);
3377 goto exitrx;
3378 }
3379 }
3380 #ifdef WIRELESS_SPY
3381 if (apriv->spy_data.spy_number > 0) {
3382 char *sa;
3383 struct iw_quality wstats;
3384 /* Prepare spy data : addr + qual */
3385 if (!test_bit(FLAG_802_11, &apriv->flags)) {
3386 sa = (char*)buffer + 6;
3387 bap_setup (apriv, fid, 8, BAP0);
3388 bap_read (apriv, (u16*)hdr.rssi, 2, BAP0);
3389 } else
3390 sa = (char*)buffer + 10;
3391 wstats.qual = hdr.rssi[0];
3392 if (apriv->rssi)
3393 wstats.level = 0x100 - apriv->rssi[hdr.rssi[1]].rssidBm;
3394 else
3395 wstats.level = (hdr.rssi[1] + 321) / 2;
3396 wstats.noise = apriv->wstats.qual.noise;
3397 wstats.updated = IW_QUAL_LEVEL_UPDATED
3398 | IW_QUAL_QUAL_UPDATED
3399 | IW_QUAL_DBM;
3400 /* Update spy records */
3401 wireless_spy_update(dev, sa, &wstats);
3402 }
3403 #endif /* WIRELESS_SPY */
3404 OUT4500( apriv, EVACK, EV_RX);
3405
3406 if (test_bit(FLAG_802_11, &apriv->flags)) {
3407 skb->mac.raw = skb->data;
3408 skb->pkt_type = PACKET_OTHERHOST;
3409 skb->dev = apriv->wifidev;
3410 skb->protocol = htons(ETH_P_802_2);
3411 } else {
3412 skb->dev = dev;
3413 skb->protocol = eth_type_trans(skb,dev);
3414 }
3415 skb->dev->last_rx = jiffies;
3416 skb->ip_summed = CHECKSUM_NONE;
3417
3418 netif_rx( skb );
3419 }
3420 exitrx:
3421
3422 /* Check to see if a packet has been transmitted */
3423 if ( status & ( EV_TX|EV_TXCPY|EV_TXEXC ) ) {
3424 int i;
3425 int len = 0;
3426 int index = -1;
3427
3428 if (test_bit(FLAG_MPI,&apriv->flags)) {
3429 unsigned long flags;
3430
3431 if (status & EV_TXEXC)
3432 get_tx_error(apriv, -1);
3433 spin_lock_irqsave(&apriv->aux_lock, flags);
3434 if (!skb_queue_empty(&apriv->txq)) {
3435 spin_unlock_irqrestore(&apriv->aux_lock,flags);
3436 mpi_send_packet (dev);
3437 } else {
3438 clear_bit(FLAG_PENDING_XMIT, &apriv->flags);
3439 spin_unlock_irqrestore(&apriv->aux_lock,flags);
3440 netif_wake_queue (dev);
3441 }
3442 OUT4500( apriv, EVACK,
3443 status & (EV_TX|EV_TXCPY|EV_TXEXC));
3444 goto exittx;
3445 }
3446
3447 fid = IN4500(apriv, TXCOMPLFID);
3448
3449 for( i = 0; i < MAX_FIDS; i++ ) {
3450 if ( ( apriv->fids[i] & 0xffff ) == fid ) {
3451 len = apriv->fids[i] >> 16;
3452 index = i;
3453 }
3454 }
3455 if (index != -1) {
3456 if (status & EV_TXEXC)
3457 get_tx_error(apriv, index);
3458 OUT4500( apriv, EVACK, status & (EV_TX | EV_TXEXC));
3459 /* Set up to be used again */
3460 apriv->fids[index] &= 0xffff;
3461 if (index < MAX_FIDS / 2) {
3462 if (!test_bit(FLAG_PENDING_XMIT, &apriv->flags))
3463 netif_wake_queue(dev);
3464 } else {
3465 if (!test_bit(FLAG_PENDING_XMIT11, &apriv->flags))
3466 netif_wake_queue(apriv->wifidev);
3467 }
3468 } else {
3469 OUT4500( apriv, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3470 airo_print_err(apriv->dev->name, "Unallocated FID was "
3471 "used to xmit" );
3472 }
3473 }
3474 exittx:
3475 if ( status & ~STATUS_INTS & ~IGNORE_INTS )
3476 airo_print_warn(apriv->dev->name, "Got weird status %x",
3477 status & ~STATUS_INTS & ~IGNORE_INTS );
3478 }
3479
3480 if (savedInterrupts)
3481 OUT4500( apriv, EVINTEN, savedInterrupts );
3482
3483 /* done.. */
3484 return IRQ_RETVAL(handled);
3485 }
3486
3487 /*
3488 * Routines to talk to the card
3489 */
3490
3491 /*
3492 * This was originally written for the 4500, hence the name
3493 * NOTE: If use with 8bit mode and SMP bad things will happen!
3494 * Why would some one do 8 bit IO in an SMP machine?!?
3495 */
3496 static void OUT4500( struct airo_info *ai, u16 reg, u16 val ) {
3497 if (test_bit(FLAG_MPI,&ai->flags))
3498 reg <<= 1;
3499 if ( !do8bitIO )
3500 outw( val, ai->dev->base_addr + reg );
3501 else {
3502 outb( val & 0xff, ai->dev->base_addr + reg );
3503 outb( val >> 8, ai->dev->base_addr + reg + 1 );
3504 }
3505 }
3506
3507 static u16 IN4500( struct airo_info *ai, u16 reg ) {
3508 unsigned short rc;
3509
3510 if (test_bit(FLAG_MPI,&ai->flags))
3511 reg <<= 1;
3512 if ( !do8bitIO )
3513 rc = inw( ai->dev->base_addr + reg );
3514 else {
3515 rc = inb( ai->dev->base_addr + reg );
3516 rc += ((int)inb( ai->dev->base_addr + reg + 1 )) << 8;
3517 }
3518 return rc;
3519 }
3520
3521 static int enable_MAC( struct airo_info *ai, Resp *rsp, int lock ) {
3522 int rc;
3523 Cmd cmd;
3524
3525 /* FLAG_RADIO_OFF : Radio disabled via /proc or Wireless Extensions
3526 * FLAG_RADIO_DOWN : Radio disabled via "ifconfig ethX down"
3527 * Note : we could try to use !netif_running(dev) in enable_MAC()
3528 * instead of this flag, but I don't trust it *within* the
3529 * open/close functions, and testing both flags together is
3530 * "cheaper" - Jean II */
3531 if (ai->flags & FLAG_RADIO_MASK) return SUCCESS;
3532
3533 if (lock && down_interruptible(&ai->sem))
3534 return -ERESTARTSYS;
3535
3536 if (!test_bit(FLAG_ENABLED, &ai->flags)) {
3537 memset(&cmd, 0, sizeof(cmd));
3538 cmd.cmd = MAC_ENABLE;
3539 rc = issuecommand(ai, &cmd, rsp);
3540 if (rc == SUCCESS)
3541 set_bit(FLAG_ENABLED, &ai->flags);
3542 } else
3543 rc = SUCCESS;
3544
3545 if (lock)
3546 up(&ai->sem);
3547
3548 if (rc)
3549 airo_print_err(ai->dev->name, "%s: Cannot enable MAC, err=%d",
3550 __FUNCTION__, rc);
3551 return rc;
3552 }
3553
3554 static void disable_MAC( struct airo_info *ai, int lock ) {
3555 Cmd cmd;
3556 Resp rsp;
3557
3558 if (lock && down_interruptible(&ai->sem))
3559 return;
3560
3561 if (test_bit(FLAG_ENABLED, &ai->flags)) {
3562 memset(&cmd, 0, sizeof(cmd));
3563 cmd.cmd = MAC_DISABLE; // disable in case already enabled
3564 issuecommand(ai, &cmd, &rsp);
3565 clear_bit(FLAG_ENABLED, &ai->flags);
3566 }
3567 if (lock)
3568 up(&ai->sem);
3569 }
3570
3571 static void enable_interrupts( struct airo_info *ai ) {
3572 /* Enable the interrupts */
3573 OUT4500( ai, EVINTEN, STATUS_INTS );
3574 }
3575
3576 static void disable_interrupts( struct airo_info *ai ) {
3577 OUT4500( ai, EVINTEN, 0 );
3578 }
3579
3580 static void mpi_receive_802_3(struct airo_info *ai)
3581 {
3582 RxFid rxd;
3583 int len = 0;
3584 struct sk_buff *skb;
3585 char *buffer;
3586 int off = 0;
3587 MICBuffer micbuf;
3588
3589 memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3590 /* Make sure we got something */
3591 if (rxd.rdy && rxd.valid == 0) {
3592 len = rxd.len + 12;
3593 if (len < 12 || len > 2048)
3594 goto badrx;
3595
3596 skb = dev_alloc_skb(len);
3597 if (!skb) {
3598 ai->stats.rx_dropped++;
3599 goto badrx;
3600 }
3601 buffer = skb_put(skb,len);
3602 memcpy(buffer, ai->rxfids[0].virtual_host_addr, ETH_ALEN * 2);
3603 if (ai->micstats.enabled) {
3604 memcpy(&micbuf,
3605 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2,
3606 sizeof(micbuf));
3607 if (ntohs(micbuf.typelen) <= 0x05DC) {
3608 if (len <= sizeof(micbuf) + ETH_ALEN * 2)
3609 goto badmic;
3610
3611 off = sizeof(micbuf);
3612 skb_trim (skb, len - off);
3613 }
3614 }
3615 memcpy(buffer + ETH_ALEN * 2,
3616 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2 + off,
3617 len - ETH_ALEN * 2 - off);
3618 if (decapsulate (ai, &micbuf, (etherHead*)buffer, len - off - ETH_ALEN * 2)) {
3619 badmic:
3620 dev_kfree_skb_irq (skb);
3621 goto badrx;
3622 }
3623 #ifdef WIRELESS_SPY
3624 if (ai->spy_data.spy_number > 0) {
3625 char *sa;
3626 struct iw_quality wstats;
3627 /* Prepare spy data : addr + qual */
3628 sa = buffer + ETH_ALEN;
3629 wstats.qual = 0; /* XXX Where do I get that info from ??? */
3630 wstats.level = 0;
3631 wstats.updated = 0;
3632 /* Update spy records */
3633 wireless_spy_update(ai->dev, sa, &wstats);
3634 }
3635 #endif /* WIRELESS_SPY */
3636
3637 skb->dev = ai->dev;
3638 skb->ip_summed = CHECKSUM_NONE;
3639 skb->protocol = eth_type_trans(skb, ai->dev);
3640 skb->dev->last_rx = jiffies;
3641 netif_rx(skb);
3642 }
3643 badrx:
3644 if (rxd.valid == 0) {
3645 rxd.valid = 1;
3646 rxd.rdy = 0;
3647 rxd.len = PKTSIZE;
3648 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3649 }
3650 }
3651
3652 void mpi_receive_802_11 (struct airo_info *ai)
3653 {
3654 RxFid rxd;
3655 struct sk_buff *skb = NULL;
3656 u16 fc, len, hdrlen = 0;
3657 #pragma pack(1)
3658 struct {
3659 u16 status, len;
3660 u8 rssi[2];
3661 u8 rate;
3662 u8 freq;
3663 u16 tmp[4];
3664 } hdr;
3665 #pragma pack()
3666 u16 gap;
3667 u16 *buffer;
3668 char *ptr = ai->rxfids[0].virtual_host_addr+4;
3669
3670 memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3671 memcpy ((char *)&hdr, ptr, sizeof(hdr));
3672 ptr += sizeof(hdr);
3673 /* Bad CRC. Ignore packet */
3674 if (le16_to_cpu(hdr.status) & 2)
3675 hdr.len = 0;
3676 if (ai->wifidev == NULL)
3677 hdr.len = 0;
3678 len = le16_to_cpu(hdr.len);
3679 if (len > AIRO_DEF_MTU) {
3680 airo_print_err(ai->dev->name, "Bad size %d", len);
3681 goto badrx;
3682 }
3683 if (len == 0)
3684 goto badrx;
3685
3686 memcpy ((char *)&fc, ptr, sizeof(fc));
3687 fc = le16_to_cpu(fc);
3688 switch (fc & 0xc) {
3689 case 4:
3690 if ((fc & 0xe0) == 0xc0)
3691 hdrlen = 10;
3692 else
3693 hdrlen = 16;
3694 break;
3695 case 8:
3696 if ((fc&0x300)==0x300){
3697 hdrlen = 30;
3698 break;
3699 }
3700 default:
3701 hdrlen = 24;
3702 }
3703
3704 skb = dev_alloc_skb( len + hdrlen + 2 );
3705 if ( !skb ) {
3706 ai->stats.rx_dropped++;
3707 goto badrx;
3708 }
3709 buffer = (u16*)skb_put (skb, len + hdrlen);
3710 memcpy ((char *)buffer, ptr, hdrlen);
3711 ptr += hdrlen;
3712 if (hdrlen == 24)
3713 ptr += 6;
3714 memcpy ((char *)&gap, ptr, sizeof(gap));
3715 ptr += sizeof(gap);
3716 gap = le16_to_cpu(gap);
3717 if (gap) {
3718 if (gap <= 8)
3719 ptr += gap;
3720 else
3721 airo_print_err(ai->dev->name,
3722 "gaplen too big. Problems will follow...");
3723 }
3724 memcpy ((char *)buffer + hdrlen, ptr, len);
3725 ptr += len;
3726 #ifdef IW_WIRELESS_SPY /* defined in iw_handler.h */
3727 if (ai->spy_data.spy_number > 0) {
3728 char *sa;
3729 struct iw_quality wstats;
3730 /* Prepare spy data : addr + qual */
3731 sa = (char*)buffer + 10;
3732 wstats.qual = hdr.rssi[0];
3733 if (ai->rssi)
3734 wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3735 else
3736 wstats.level = (hdr.rssi[1] + 321) / 2;
3737 wstats.noise = ai->wstats.qual.noise;
3738 wstats.updated = IW_QUAL_QUAL_UPDATED
3739 | IW_QUAL_LEVEL_UPDATED
3740 | IW_QUAL_DBM;
3741 /* Update spy records */
3742 wireless_spy_update(ai->dev, sa, &wstats);
3743 }
3744 #endif /* IW_WIRELESS_SPY */
3745 skb->mac.raw = skb->data;
3746 skb->pkt_type = PACKET_OTHERHOST;
3747 skb->dev = ai->wifidev;
3748 skb->protocol = htons(ETH_P_802_2);
3749 skb->dev->last_rx = jiffies;
3750 skb->ip_summed = CHECKSUM_NONE;
3751 netif_rx( skb );
3752 badrx:
3753 if (rxd.valid == 0) {
3754 rxd.valid = 1;
3755 rxd.rdy = 0;
3756 rxd.len = PKTSIZE;
3757 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3758 }
3759 }
3760
3761 static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
3762 {
3763 Cmd cmd;
3764 Resp rsp;
3765 int status;
3766 int i;
3767 SsidRid mySsid;
3768 u16 lastindex;
3769 WepKeyRid wkr;
3770 int rc;
3771
3772 memset( &mySsid, 0, sizeof( mySsid ) );
3773 kfree (ai->flash);
3774 ai->flash = NULL;
3775
3776 /* The NOP is the first step in getting the card going */
3777 cmd.cmd = NOP;
3778 cmd.parm0 = cmd.parm1 = cmd.parm2 = 0;
3779 if (lock && down_interruptible(&ai->sem))
3780 return ERROR;
3781 if ( issuecommand( ai, &cmd, &rsp ) != SUCCESS ) {
3782 if (lock)
3783 up(&ai->sem);
3784 return ERROR;
3785 }
3786 disable_MAC( ai, 0);
3787
3788 // Let's figure out if we need to use the AUX port
3789 if (!test_bit(FLAG_MPI,&ai->flags)) {
3790 cmd.cmd = CMD_ENABLEAUX;
3791 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
3792 if (lock)
3793 up(&ai->sem);
3794 airo_print_err(ai->dev->name, "Error checking for AUX port");
3795 return ERROR;
3796 }
3797 if (!aux_bap || rsp.status & 0xff00) {
3798 ai->bap_read = fast_bap_read;
3799 airo_print_dbg(ai->dev->name, "Doing fast bap_reads");
3800 } else {
3801 ai->bap_read = aux_bap_read;
3802 airo_print_dbg(ai->dev->name, "Doing AUX bap_reads");
3803 }
3804 }
3805 if (lock)
3806 up(&ai->sem);
3807 if (ai->config.len == 0) {
3808 tdsRssiRid rssi_rid;
3809 CapabilityRid cap_rid;
3810
3811 kfree(ai->APList);
3812 ai->APList = NULL;
3813 kfree(ai->SSID);
3814 ai->SSID = NULL;
3815 // general configuration (read/modify/write)
3816 status = readConfigRid(ai, lock);
3817 if ( status != SUCCESS ) return ERROR;
3818
3819 status = readCapabilityRid(ai, &cap_rid, lock);
3820 if ( status != SUCCESS ) return ERROR;
3821
3822 status = PC4500_readrid(ai,RID_RSSI,&rssi_rid,sizeof(rssi_rid),lock);
3823 if ( status == SUCCESS ) {
3824 if (ai->rssi || (ai->rssi = kmalloc(512, GFP_KERNEL)) != NULL)
3825 memcpy(ai->rssi, (u8*)&rssi_rid + 2, 512); /* Skip RID length member */
3826 }
3827 else {
3828 kfree(ai->rssi);
3829 ai->rssi = NULL;
3830 if (cap_rid.softCap & 8)
3831 ai->config.rmode |= RXMODE_NORMALIZED_RSSI;
3832 else
3833 airo_print_warn(ai->dev->name, "unknown received signal "
3834 "level scale");
3835 }
3836 ai->config.opmode = adhoc ? MODE_STA_IBSS : MODE_STA_ESS;
3837 ai->config.authType = AUTH_OPEN;
3838 ai->config.modulation = MOD_CCK;
3839
3840 if ((cap_rid.len>=sizeof(cap_rid)) && (cap_rid.extSoftCap&1) &&
3841 (micsetup(ai) == SUCCESS)) {
3842 ai->config.opmode |= MODE_MIC;
3843 set_bit(FLAG_MIC_CAPABLE, &ai->flags);
3844 }
3845
3846 /* Save off the MAC */
3847 for( i = 0; i < ETH_ALEN; i++ ) {
3848 mac[i] = ai->config.macAddr[i];
3849 }
3850
3851 /* Check to see if there are any insmod configured
3852 rates to add */
3853 if ( rates[0] ) {
3854 int i = 0;
3855 memset(ai->config.rates,0,sizeof(ai->config.rates));
3856 for( i = 0; i < 8 && rates[i]; i++ ) {
3857 ai->config.rates[i] = rates[i];
3858 }
3859 }
3860 if ( basic_rate > 0 ) {
3861 int i;
3862 for( i = 0; i < 8; i++ ) {
3863 if ( ai->config.rates[i] == basic_rate ||
3864 !ai->config.rates ) {
3865 ai->config.rates[i] = basic_rate | 0x80;
3866 break;
3867 }
3868 }
3869 }
3870 set_bit (FLAG_COMMIT, &ai->flags);
3871 }
3872
3873 /* Setup the SSIDs if present */
3874 if ( ssids[0] ) {
3875 int i;
3876 for( i = 0; i < 3 && ssids[i]; i++ ) {
3877 mySsid.ssids[i].len = strlen(ssids[i]);
3878 if ( mySsid.ssids[i].len > 32 )
3879 mySsid.ssids[i].len = 32;
3880 memcpy(mySsid.ssids[i].ssid, ssids[i],
3881 mySsid.ssids[i].len);
3882 }
3883 mySsid.len = sizeof(mySsid);
3884 }
3885
3886 status = writeConfigRid(ai, lock);
3887 if ( status != SUCCESS ) return ERROR;
3888
3889 /* Set up the SSID list */
3890 if ( ssids[0] ) {
3891 status = writeSsidRid(ai, &mySsid, lock);
3892 if ( status != SUCCESS ) return ERROR;
3893 }
3894
3895 status = enable_MAC(ai, &rsp, lock);
3896 if ( status != SUCCESS || (rsp.status & 0xFF00) != 0) {
3897 airo_print_err(ai->dev->name, "Bad MAC enable reason = %x, rid = %x,"
3898 " offset = %d", rsp.rsp0, rsp.rsp1, rsp.rsp2 );
3899 return ERROR;
3900 }
3901
3902 /* Grab the initial wep key, we gotta save it for auto_wep */
3903 rc = readWepKeyRid(ai, &wkr, 1, lock);
3904 if (rc == SUCCESS) do {
3905 lastindex = wkr.kindex;
3906 if (wkr.kindex == 0xffff) {
3907 ai->defindex = wkr.mac[0];
3908 }
3909 rc = readWepKeyRid(ai, &wkr, 0, lock);
3910 } while(lastindex != wkr.kindex);
3911
3912 if (auto_wep) {
3913 ai->expires = RUN_AT(3*HZ);
3914 wake_up_interruptible(&ai->thr_wait);
3915 }
3916
3917 return SUCCESS;
3918 }
3919
3920 static u16 issuecommand(struct airo_info *ai, Cmd *pCmd, Resp *pRsp) {
3921 // Im really paranoid about letting it run forever!
3922 int max_tries = 600000;
3923
3924 if (IN4500(ai, EVSTAT) & EV_CMD)
3925 OUT4500(ai, EVACK, EV_CMD);
3926
3927 OUT4500(ai, PARAM0, pCmd->parm0);
3928 OUT4500(ai, PARAM1, pCmd->parm1);
3929 OUT4500(ai, PARAM2, pCmd->parm2);
3930 OUT4500(ai, COMMAND, pCmd->cmd);
3931
3932 while (max_tries-- && (IN4500(ai, EVSTAT) & EV_CMD) == 0) {
3933 if ((IN4500(ai, COMMAND)) == pCmd->cmd)
3934 // PC4500 didn't notice command, try again
3935 OUT4500(ai, COMMAND, pCmd->cmd);
3936 if (!in_atomic() && (max_tries & 255) == 0)
3937 schedule();
3938 }
3939
3940 if ( max_tries == -1 ) {
3941 airo_print_err(ai->dev->name,
3942 "Max tries exceeded when issueing command");
3943 if (IN4500(ai, COMMAND) & COMMAND_BUSY)
3944 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3945 return ERROR;
3946 }
3947
3948 // command completed
3949 pRsp->status = IN4500(ai, STATUS);
3950 pRsp->rsp0 = IN4500(ai, RESP0);
3951 pRsp->rsp1 = IN4500(ai, RESP1);
3952 pRsp->rsp2 = IN4500(ai, RESP2);
3953 if ((pRsp->status & 0xff00)!=0 && pCmd->cmd != CMD_SOFTRESET)
3954 airo_print_err(ai->dev->name,
3955 "cmd:%x status:%x rsp0:%x rsp1:%x rsp2:%x",
3956 pCmd->cmd, pRsp->status, pRsp->rsp0, pRsp->rsp1,
3957 pRsp->rsp2);
3958
3959 // clear stuck command busy if necessary
3960 if (IN4500(ai, COMMAND) & COMMAND_BUSY) {
3961 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3962 }
3963 // acknowledge processing the status/response
3964 OUT4500(ai, EVACK, EV_CMD);
3965
3966 return SUCCESS;
3967 }
3968
3969 /* Sets up the bap to start exchange data. whichbap should
3970 * be one of the BAP0 or BAP1 defines. Locks should be held before
3971 * calling! */
3972 static int bap_setup(struct airo_info *ai, u16 rid, u16 offset, int whichbap )
3973 {
3974 int timeout = 50;
3975 int max_tries = 3;
3976
3977 OUT4500(ai, SELECT0+whichbap, rid);
3978 OUT4500(ai, OFFSET0+whichbap, offset);
3979 while (1) {
3980 int status = IN4500(ai, OFFSET0+whichbap);
3981 if (status & BAP_BUSY) {
3982 /* This isn't really a timeout, but its kinda
3983 close */
3984 if (timeout--) {
3985 continue;
3986 }
3987 } else if ( status & BAP_ERR ) {
3988 /* invalid rid or offset */
3989 airo_print_err(ai->dev->name, "BAP error %x %d",
3990 status, whichbap );
3991 return ERROR;
3992 } else if (status & BAP_DONE) { // success
3993 return SUCCESS;
3994 }
3995 if ( !(max_tries--) ) {
3996 airo_print_err(ai->dev->name,
3997 "airo: BAP setup error too many retries\n");
3998 return ERROR;
3999 }
4000 // -- PC4500 missed it, try again
4001 OUT4500(ai, SELECT0+whichbap, rid);
4002 OUT4500(ai, OFFSET0+whichbap, offset);
4003 timeout = 50;
4004 }
4005 }
4006
4007 /* should only be called by aux_bap_read. This aux function and the
4008 following use concepts not documented in the developers guide. I
4009 got them from a patch given to my by Aironet */
4010 static u16 aux_setup(struct airo_info *ai, u16 page,
4011 u16 offset, u16 *len)
4012 {
4013 u16 next;
4014
4015 OUT4500(ai, AUXPAGE, page);
4016 OUT4500(ai, AUXOFF, 0);
4017 next = IN4500(ai, AUXDATA);
4018 *len = IN4500(ai, AUXDATA)&0xff;
4019 if (offset != 4) OUT4500(ai, AUXOFF, offset);
4020 return next;
4021 }
4022
4023 /* requires call to bap_setup() first */
4024 static int aux_bap_read(struct airo_info *ai, u16 *pu16Dst,
4025 int bytelen, int whichbap)
4026 {
4027 u16 len;
4028 u16 page;
4029 u16 offset;
4030 u16 next;
4031 int words;
4032 int i;
4033 unsigned long flags;
4034
4035 spin_lock_irqsave(&ai->aux_lock, flags);
4036 page = IN4500(ai, SWS0+whichbap);
4037 offset = IN4500(ai, SWS2+whichbap);
4038 next = aux_setup(ai, page, offset, &len);
4039 words = (bytelen+1)>>1;
4040
4041 for (i=0; i<words;) {
4042 int count;
4043 count = (len>>1) < (words-i) ? (len>>1) : (words-i);
4044 if ( !do8bitIO )
4045 insw( ai->dev->base_addr+DATA0+whichbap,
4046 pu16Dst+i,count );
4047 else
4048 insb( ai->dev->base_addr+DATA0+whichbap,
4049 pu16Dst+i, count << 1 );
4050 i += count;
4051 if (i<words) {
4052 next = aux_setup(ai, next, 4, &len);
4053 }
4054 }
4055 spin_unlock_irqrestore(&ai->aux_lock, flags);
4056 return SUCCESS;
4057 }
4058
4059
4060 /* requires call to bap_setup() first */
4061 static int fast_bap_read(struct airo_info *ai, u16 *pu16Dst,
4062 int bytelen, int whichbap)
4063 {
4064 bytelen = (bytelen + 1) & (~1); // round up to even value
4065 if ( !do8bitIO )
4066 insw( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen>>1 );
4067 else
4068 insb( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen );
4069 return SUCCESS;
4070 }
4071
4072 /* requires call to bap_setup() first */
4073 static int bap_write(struct airo_info *ai, const u16 *pu16Src,
4074 int bytelen, int whichbap)
4075 {
4076 bytelen = (bytelen + 1) & (~1); // round up to even value
4077 if ( !do8bitIO )
4078 outsw( ai->dev->base_addr+DATA0+whichbap,
4079 pu16Src, bytelen>>1 );
4080 else
4081 outsb( ai->dev->base_addr+DATA0+whichbap, pu16Src, bytelen );
4082 return SUCCESS;
4083 }
4084
4085 static int PC4500_accessrid(struct airo_info *ai, u16 rid, u16 accmd)
4086 {
4087 Cmd cmd; /* for issuing commands */
4088 Resp rsp; /* response from commands */
4089 u16 status;
4090
4091 memset(&cmd, 0, sizeof(cmd));
4092 cmd.cmd = accmd;
4093 cmd.parm0 = rid;
4094 status = issuecommand(ai, &cmd, &rsp);
4095 if (status != 0) return status;
4096 if ( (rsp.status & 0x7F00) != 0) {
4097 return (accmd << 8) + (rsp.rsp0 & 0xFF);
4098 }
4099 return 0;
4100 }
4101
4102 /* Note, that we are using BAP1 which is also used by transmit, so
4103 * we must get a lock. */
4104 static int PC4500_readrid(struct airo_info *ai, u16 rid, void *pBuf, int len, int lock)
4105 {
4106 u16 status;
4107 int rc = SUCCESS;
4108
4109 if (lock) {
4110 if (down_interruptible(&ai->sem))
4111 return ERROR;
4112 }
4113 if (test_bit(FLAG_MPI,&ai->flags)) {
4114 Cmd cmd;
4115 Resp rsp;
4116
4117 memset(&cmd, 0, sizeof(cmd));
4118 memset(&rsp, 0, sizeof(rsp));
4119 ai->config_desc.rid_desc.valid = 1;
4120 ai->config_desc.rid_desc.len = RIDSIZE;
4121 ai->config_desc.rid_desc.rid = 0;
4122 ai->config_desc.rid_desc.host_addr = ai->ridbus;
4123
4124 cmd.cmd = CMD_ACCESS;
4125 cmd.parm0 = rid;
4126
4127 memcpy_toio(ai->config_desc.card_ram_off,
4128 &ai->config_desc.rid_desc, sizeof(Rid));
4129
4130 rc = issuecommand(ai, &cmd, &rsp);
4131
4132 if (rsp.status & 0x7f00)
4133 rc = rsp.rsp0;
4134 if (!rc)
4135 memcpy(pBuf, ai->config_desc.virtual_host_addr, len);
4136 goto done;
4137 } else {
4138 if ((status = PC4500_accessrid(ai, rid, CMD_ACCESS))!=SUCCESS) {
4139 rc = status;
4140 goto done;
4141 }
4142 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4143 rc = ERROR;
4144 goto done;
4145 }
4146 // read the rid length field
4147 bap_read(ai, pBuf, 2, BAP1);
4148 // length for remaining part of rid
4149 len = min(len, (int)le16_to_cpu(*(u16*)pBuf)) - 2;
4150
4151 if ( len <= 2 ) {
4152 airo_print_err(ai->dev->name,
4153 "Rid %x has a length of %d which is too short",
4154 (int)rid, (int)len );
4155 rc = ERROR;
4156 goto done;
4157 }
4158 // read remainder of the rid
4159 rc = bap_read(ai, ((u16*)pBuf)+1, len, BAP1);
4160 }
4161 done:
4162 if (lock)
4163 up(&ai->sem);
4164 return rc;
4165 }
4166
4167 /* Note, that we are using BAP1 which is also used by transmit, so
4168 * make sure this isnt called when a transmit is happening */
4169 static int PC4500_writerid(struct airo_info *ai, u16 rid,
4170 const void *pBuf, int len, int lock)
4171 {
4172 u16 status;
4173 int rc = SUCCESS;
4174
4175 *(u16*)pBuf = cpu_to_le16((u16)len);
4176
4177 if (lock) {
4178 if (down_interruptible(&ai->sem))
4179 return ERROR;
4180 }
4181 if (test_bit(FLAG_MPI,&ai->flags)) {
4182 Cmd cmd;
4183 Resp rsp;
4184
4185 if (test_bit(FLAG_ENABLED, &ai->flags) && (RID_WEP_TEMP != rid))
4186 airo_print_err(ai->dev->name,
4187 "%s: MAC should be disabled (rid=%04x)",
4188 __FUNCTION__, rid);
4189 memset(&cmd, 0, sizeof(cmd));
4190 memset(&rsp, 0, sizeof(rsp));
4191
4192 ai->config_desc.rid_desc.valid = 1;
4193 ai->config_desc.rid_desc.len = *((u16 *)pBuf);
4194 ai->config_desc.rid_desc.rid = 0;
4195
4196 cmd.cmd = CMD_WRITERID;
4197 cmd.parm0 = rid;
4198
4199 memcpy_toio(ai->config_desc.card_ram_off,
4200 &ai->config_desc.rid_desc, sizeof(Rid));
4201
4202 if (len < 4 || len > 2047) {
4203 airo_print_err(ai->dev->name, "%s: len=%d", __FUNCTION__, len);
4204 rc = -1;
4205 } else {
4206 memcpy((char *)ai->config_desc.virtual_host_addr,
4207 pBuf, len);
4208
4209 rc = issuecommand(ai, &cmd, &rsp);
4210 if ((rc & 0xff00) != 0) {
4211 airo_print_err(ai->dev->name, "%s: Write rid Error %d",
4212 __FUNCTION__, rc);
4213 airo_print_err(ai->dev->name, "%s: Cmd=%04x",
4214 __FUNCTION__, cmd.cmd);
4215 }
4216
4217 if ((rsp.status & 0x7f00))
4218 rc = rsp.rsp0;
4219 }
4220 } else {
4221 // --- first access so that we can write the rid data
4222 if ( (status = PC4500_accessrid(ai, rid, CMD_ACCESS)) != 0) {
4223 rc = status;
4224 goto done;
4225 }
4226 // --- now write the rid data
4227 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4228 rc = ERROR;
4229 goto done;
4230 }
4231 bap_write(ai, pBuf, len, BAP1);
4232 // ---now commit the rid data
4233 rc = PC4500_accessrid(ai, rid, 0x100|CMD_ACCESS);
4234 }
4235 done:
4236 if (lock)
4237 up(&ai->sem);
4238 return rc;
4239 }
4240
4241 /* Allocates a FID to be used for transmitting packets. We only use
4242 one for now. */
4243 static u16 transmit_allocate(struct airo_info *ai, int lenPayload, int raw)
4244 {
4245 unsigned int loop = 3000;
4246 Cmd cmd;
4247 Resp rsp;
4248 u16 txFid;
4249 u16 txControl;
4250
4251 cmd.cmd = CMD_ALLOCATETX;
4252 cmd.parm0 = lenPayload;
4253 if (down_interruptible(&ai->sem))
4254 return ERROR;
4255 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
4256 txFid = ERROR;
4257 goto done;
4258 }
4259 if ( (rsp.status & 0xFF00) != 0) {
4260 txFid = ERROR;
4261 goto done;
4262 }
4263 /* wait for the allocate event/indication
4264 * It makes me kind of nervous that this can just sit here and spin,
4265 * but in practice it only loops like four times. */
4266 while (((IN4500(ai, EVSTAT) & EV_ALLOC) == 0) && --loop);
4267 if (!loop) {
4268 txFid = ERROR;
4269 goto done;
4270 }
4271
4272 // get the allocated fid and acknowledge
4273 txFid = IN4500(ai, TXALLOCFID);
4274 OUT4500(ai, EVACK, EV_ALLOC);
4275
4276 /* The CARD is pretty cool since it converts the ethernet packet
4277 * into 802.11. Also note that we don't release the FID since we
4278 * will be using the same one over and over again. */
4279 /* We only have to setup the control once since we are not
4280 * releasing the fid. */
4281 if (raw)
4282 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_11
4283 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4284 else
4285 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_3
4286 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4287 if (bap_setup(ai, txFid, 0x0008, BAP1) != SUCCESS)
4288 txFid = ERROR;
4289 else
4290 bap_write(ai, &txControl, sizeof(txControl), BAP1);
4291
4292 done:
4293 up(&ai->sem);
4294
4295 return txFid;
4296 }
4297
4298 /* In general BAP1 is dedicated to transmiting packets. However,
4299 since we need a BAP when accessing RIDs, we also use BAP1 for that.
4300 Make sure the BAP1 spinlock is held when this is called. */
4301 static int transmit_802_3_packet(struct airo_info *ai, int len, char *pPacket)
4302 {
4303 u16 payloadLen;
4304 Cmd cmd;
4305 Resp rsp;
4306 int miclen = 0;
4307 u16 txFid = len;
4308 MICBuffer pMic;
4309
4310 len >>= 16;
4311
4312 if (len <= ETH_ALEN * 2) {
4313 airo_print_warn(ai->dev->name, "Short packet %d", len);
4314 return ERROR;
4315 }
4316 len -= ETH_ALEN * 2;
4317
4318 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
4319 (ntohs(((u16 *)pPacket)[6]) != 0x888E)) {
4320 if (encapsulate(ai,(etherHead *)pPacket,&pMic,len) != SUCCESS)
4321 return ERROR;
4322 miclen = sizeof(pMic);
4323 }
4324 // packet is destination[6], source[6], payload[len-12]
4325 // write the payload length and dst/src/payload
4326 if (bap_setup(ai, txFid, 0x0036, BAP1) != SUCCESS) return ERROR;
4327 /* The hardware addresses aren't counted as part of the payload, so
4328 * we have to subtract the 12 bytes for the addresses off */
4329 payloadLen = cpu_to_le16(len + miclen);
4330 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4331 bap_write(ai, (const u16*)pPacket, sizeof(etherHead), BAP1);
4332 if (miclen)
4333 bap_write(ai, (const u16*)&pMic, miclen, BAP1);
4334 bap_write(ai, (const u16*)(pPacket + sizeof(etherHead)), len, BAP1);
4335 // issue the transmit command
4336 memset( &cmd, 0, sizeof( cmd ) );
4337 cmd.cmd = CMD_TRANSMIT;
4338 cmd.parm0 = txFid;
4339 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4340 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4341 return SUCCESS;
4342 }
4343
4344 static int transmit_802_11_packet(struct airo_info *ai, int len, char *pPacket)
4345 {
4346 u16 fc, payloadLen;
4347 Cmd cmd;
4348 Resp rsp;
4349 int hdrlen;
4350 struct {
4351 u8 addr4[ETH_ALEN];
4352 u16 gaplen;
4353 u8 gap[6];
4354 } gap;
4355 u16 txFid = len;
4356 len >>= 16;
4357 gap.gaplen = 6;
4358
4359 fc = le16_to_cpu(*(const u16*)pPacket);
4360 switch (fc & 0xc) {
4361 case 4:
4362 if ((fc & 0xe0) == 0xc0)
4363 hdrlen = 10;
4364 else
4365 hdrlen = 16;
4366 break;
4367 case 8:
4368 if ((fc&0x300)==0x300){
4369 hdrlen = 30;
4370 break;
4371 }
4372 default:
4373 hdrlen = 24;
4374 }
4375
4376 if (len < hdrlen) {
4377 airo_print_warn(ai->dev->name, "Short packet %d", len);
4378 return ERROR;
4379 }
4380
4381 /* packet is 802.11 header + payload
4382 * write the payload length and dst/src/payload */
4383 if (bap_setup(ai, txFid, 6, BAP1) != SUCCESS) return ERROR;
4384 /* The 802.11 header aren't counted as part of the payload, so
4385 * we have to subtract the header bytes off */
4386 payloadLen = cpu_to_le16(len-hdrlen);
4387 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4388 if (bap_setup(ai, txFid, 0x0014, BAP1) != SUCCESS) return ERROR;
4389 bap_write(ai, (const u16*)pPacket, hdrlen, BAP1);
4390 bap_write(ai, hdrlen == 30 ?
4391 (const u16*)&gap.gaplen : (const u16*)&gap, 38 - hdrlen, BAP1);
4392
4393 bap_write(ai, (const u16*)(pPacket + hdrlen), len - hdrlen, BAP1);
4394 // issue the transmit command
4395 memset( &cmd, 0, sizeof( cmd ) );
4396 cmd.cmd = CMD_TRANSMIT;
4397 cmd.parm0 = txFid;
4398 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4399 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4400 return SUCCESS;
4401 }
4402
4403 /*
4404 * This is the proc_fs routines. It is a bit messier than I would
4405 * like! Feel free to clean it up!
4406 */
4407
4408 static ssize_t proc_read( struct file *file,
4409 char __user *buffer,
4410 size_t len,
4411 loff_t *offset);
4412
4413 static ssize_t proc_write( struct file *file,
4414 const char __user *buffer,
4415 size_t len,
4416 loff_t *offset );
4417 static int proc_close( struct inode *inode, struct file *file );
4418
4419 static int proc_stats_open( struct inode *inode, struct file *file );
4420 static int proc_statsdelta_open( struct inode *inode, struct file *file );
4421 static int proc_status_open( struct inode *inode, struct file *file );
4422 static int proc_SSID_open( struct inode *inode, struct file *file );
4423 static int proc_APList_open( struct inode *inode, struct file *file );
4424 static int proc_BSSList_open( struct inode *inode, struct file *file );
4425 static int proc_config_open( struct inode *inode, struct file *file );
4426 static int proc_wepkey_open( struct inode *inode, struct file *file );
4427
4428 static struct file_operations proc_statsdelta_ops = {
4429 .read = proc_read,
4430 .open = proc_statsdelta_open,
4431 .release = proc_close
4432 };
4433
4434 static struct file_operations proc_stats_ops = {
4435 .read = proc_read,
4436 .open = proc_stats_open,
4437 .release = proc_close
4438 };
4439
4440 static struct file_operations proc_status_ops = {
4441 .read = proc_read,
4442 .open = proc_status_open,
4443 .release = proc_close
4444 };
4445
4446 static struct file_operations proc_SSID_ops = {
4447 .read = proc_read,
4448 .write = proc_write,
4449 .open = proc_SSID_open,
4450 .release = proc_close
4451 };
4452
4453 static struct file_operations proc_BSSList_ops = {
4454 .read = proc_read,
4455 .write = proc_write,
4456 .open = proc_BSSList_open,
4457 .release = proc_close
4458 };
4459
4460 static struct file_operations proc_APList_ops = {
4461 .read = proc_read,
4462 .write = proc_write,
4463 .open = proc_APList_open,
4464 .release = proc_close
4465 };
4466
4467 static struct file_operations proc_config_ops = {
4468 .read = proc_read,
4469 .write = proc_write,
4470 .open = proc_config_open,
4471 .release = proc_close
4472 };
4473
4474 static struct file_operations proc_wepkey_ops = {
4475 .read = proc_read,
4476 .write = proc_write,
4477 .open = proc_wepkey_open,
4478 .release = proc_close
4479 };
4480
4481 static struct proc_dir_entry *airo_entry;
4482
4483 struct proc_data {
4484 int release_buffer;
4485 int readlen;
4486 char *rbuffer;
4487 int writelen;
4488 int maxwritelen;
4489 char *wbuffer;
4490 void (*on_close) (struct inode *, struct file *);
4491 };
4492
4493 #ifndef SETPROC_OPS
4494 #define SETPROC_OPS(entry, ops) (entry)->proc_fops = &(ops)
4495 #endif
4496
4497 static int setup_proc_entry( struct net_device *dev,
4498 struct airo_info *apriv ) {
4499 struct proc_dir_entry *entry;
4500 /* First setup the device directory */
4501 strcpy(apriv->proc_name,dev->name);
4502 apriv->proc_entry = create_proc_entry(apriv->proc_name,
4503 S_IFDIR|airo_perm,
4504 airo_entry);
4505 apriv->proc_entry->uid = proc_uid;
4506 apriv->proc_entry->gid = proc_gid;
4507 apriv->proc_entry->owner = THIS_MODULE;
4508
4509 /* Setup the StatsDelta */
4510 entry = create_proc_entry("StatsDelta",
4511 S_IFREG | (S_IRUGO&proc_perm),
4512 apriv->proc_entry);
4513 entry->uid = proc_uid;
4514 entry->gid = proc_gid;
4515 entry->data = dev;
4516 entry->owner = THIS_MODULE;
4517 SETPROC_OPS(entry, proc_statsdelta_ops);
4518
4519 /* Setup the Stats */
4520 entry = create_proc_entry("Stats",
4521 S_IFREG | (S_IRUGO&proc_perm),
4522 apriv->proc_entry);
4523 entry->uid = proc_uid;
4524 entry->gid = proc_gid;
4525 entry->data = dev;
4526 entry->owner = THIS_MODULE;
4527 SETPROC_OPS(entry, proc_stats_ops);
4528
4529 /* Setup the Status */
4530 entry = create_proc_entry("Status",
4531 S_IFREG | (S_IRUGO&proc_perm),
4532 apriv->proc_entry);
4533 entry->uid = proc_uid;
4534 entry->gid = proc_gid;
4535 entry->data = dev;
4536 entry->owner = THIS_MODULE;
4537 SETPROC_OPS(entry, proc_status_ops);
4538
4539 /* Setup the Config */
4540 entry = create_proc_entry("Config",
4541 S_IFREG | proc_perm,
4542 apriv->proc_entry);
4543 entry->uid = proc_uid;
4544 entry->gid = proc_gid;
4545 entry->data = dev;
4546 entry->owner = THIS_MODULE;
4547 SETPROC_OPS(entry, proc_config_ops);
4548
4549 /* Setup the SSID */
4550 entry = create_proc_entry("SSID",
4551 S_IFREG | proc_perm,
4552 apriv->proc_entry);
4553 entry->uid = proc_uid;
4554 entry->gid = proc_gid;
4555 entry->data = dev;
4556 entry->owner = THIS_MODULE;
4557 SETPROC_OPS(entry, proc_SSID_ops);
4558
4559 /* Setup the APList */
4560 entry = create_proc_entry("APList",
4561 S_IFREG | proc_perm,
4562 apriv->proc_entry);
4563 entry->uid = proc_uid;
4564 entry->gid = proc_gid;
4565 entry->data = dev;
4566 entry->owner = THIS_MODULE;
4567 SETPROC_OPS(entry, proc_APList_ops);
4568
4569 /* Setup the BSSList */
4570 entry = create_proc_entry("BSSList",
4571 S_IFREG | proc_perm,
4572 apriv->proc_entry);
4573 entry->uid = proc_uid;
4574 entry->gid = proc_gid;
4575 entry->data = dev;
4576 entry->owner = THIS_MODULE;
4577 SETPROC_OPS(entry, proc_BSSList_ops);
4578
4579 /* Setup the WepKey */
4580 entry = create_proc_entry("WepKey",
4581 S_IFREG | proc_perm,
4582 apriv->proc_entry);
4583 entry->uid = proc_uid;
4584 entry->gid = proc_gid;
4585 entry->data = dev;
4586 entry->owner = THIS_MODULE;
4587 SETPROC_OPS(entry, proc_wepkey_ops);
4588
4589 return 0;
4590 }
4591
4592 static int takedown_proc_entry( struct net_device *dev,
4593 struct airo_info *apriv ) {
4594 if ( !apriv->proc_entry->namelen ) return 0;
4595 remove_proc_entry("Stats",apriv->proc_entry);
4596 remove_proc_entry("StatsDelta",apriv->proc_entry);
4597 remove_proc_entry("Status",apriv->proc_entry);
4598 remove_proc_entry("Config",apriv->proc_entry);
4599 remove_proc_entry("SSID",apriv->proc_entry);
4600 remove_proc_entry("APList",apriv->proc_entry);
4601 remove_proc_entry("BSSList",apriv->proc_entry);
4602 remove_proc_entry("WepKey",apriv->proc_entry);
4603 remove_proc_entry(apriv->proc_name,airo_entry);
4604 return 0;
4605 }
4606
4607 /*
4608 * What we want from the proc_fs is to be able to efficiently read
4609 * and write the configuration. To do this, we want to read the
4610 * configuration when the file is opened and write it when the file is
4611 * closed. So basically we allocate a read buffer at open and fill it
4612 * with data, and allocate a write buffer and read it at close.
4613 */
4614
4615 /*
4616 * The read routine is generic, it relies on the preallocated rbuffer
4617 * to supply the data.
4618 */
4619 static ssize_t proc_read( struct file *file,
4620 char __user *buffer,
4621 size_t len,
4622 loff_t *offset )
4623 {
4624 loff_t pos = *offset;
4625 struct proc_data *priv = (struct proc_data*)file->private_data;
4626
4627 if (!priv->rbuffer)
4628 return -EINVAL;
4629
4630 if (pos < 0)
4631 return -EINVAL;
4632 if (pos >= priv->readlen)
4633 return 0;
4634 if (len > priv->readlen - pos)
4635 len = priv->readlen - pos;
4636 if (copy_to_user(buffer, priv->rbuffer + pos, len))
4637 return -EFAULT;
4638 *offset = pos + len;
4639 return len;
4640 }
4641
4642 /*
4643 * The write routine is generic, it fills in a preallocated rbuffer
4644 * to supply the data.
4645 */
4646 static ssize_t proc_write( struct file *file,
4647 const char __user *buffer,
4648 size_t len,
4649 loff_t *offset )
4650 {
4651 loff_t pos = *offset;
4652 struct proc_data *priv = (struct proc_data*)file->private_data;
4653
4654 if (!priv->wbuffer)
4655 return -EINVAL;
4656
4657 if (pos < 0)
4658 return -EINVAL;
4659 if (pos >= priv->maxwritelen)
4660 return 0;
4661 if (len > priv->maxwritelen - pos)
4662 len = priv->maxwritelen - pos;
4663 if (copy_from_user(priv->wbuffer + pos, buffer, len))
4664 return -EFAULT;
4665 if ( pos + len > priv->writelen )
4666 priv->writelen = len + file->f_pos;
4667 *offset = pos + len;
4668 return len;
4669 }
4670
4671 static int proc_status_open( struct inode *inode, struct file *file ) {
4672 struct proc_data *data;
4673 struct proc_dir_entry *dp = PDE(inode);
4674 struct net_device *dev = dp->data;
4675 struct airo_info *apriv = dev->priv;
4676 CapabilityRid cap_rid;
4677 StatusRid status_rid;
4678 int i;
4679
4680 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4681 return -ENOMEM;
4682 data = (struct proc_data *)file->private_data;
4683 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4684 kfree (file->private_data);
4685 return -ENOMEM;
4686 }
4687
4688 readStatusRid(apriv, &status_rid, 1);
4689 readCapabilityRid(apriv, &cap_rid, 1);
4690
4691 i = sprintf(data->rbuffer, "Status: %s%s%s%s%s%s%s%s%s\n",
4692 status_rid.mode & 1 ? "CFG ": "",
4693 status_rid.mode & 2 ? "ACT ": "",
4694 status_rid.mode & 0x10 ? "SYN ": "",
4695 status_rid.mode & 0x20 ? "LNK ": "",
4696 status_rid.mode & 0x40 ? "LEAP ": "",
4697 status_rid.mode & 0x80 ? "PRIV ": "",
4698 status_rid.mode & 0x100 ? "KEY ": "",
4699 status_rid.mode & 0x200 ? "WEP ": "",
4700 status_rid.mode & 0x8000 ? "ERR ": "");
4701 sprintf( data->rbuffer+i, "Mode: %x\n"
4702 "Signal Strength: %d\n"
4703 "Signal Quality: %d\n"
4704 "SSID: %-.*s\n"
4705 "AP: %-.16s\n"
4706 "Freq: %d\n"
4707 "BitRate: %dmbs\n"
4708 "Driver Version: %s\n"
4709 "Device: %s\nManufacturer: %s\nFirmware Version: %s\n"
4710 "Radio type: %x\nCountry: %x\nHardware Version: %x\n"
4711 "Software Version: %x\nSoftware Subversion: %x\n"
4712 "Boot block version: %x\n",
4713 (int)status_rid.mode,
4714 (int)status_rid.normalizedSignalStrength,
4715 (int)status_rid.signalQuality,
4716 (int)status_rid.SSIDlen,
4717 status_rid.SSID,
4718 status_rid.apName,
4719 (int)status_rid.channel,
4720 (int)status_rid.currentXmitRate/2,
4721 version,
4722 cap_rid.prodName,
4723 cap_rid.manName,
4724 cap_rid.prodVer,
4725 cap_rid.radioType,
4726 cap_rid.country,
4727 cap_rid.hardVer,
4728 (int)cap_rid.softVer,
4729 (int)cap_rid.softSubVer,
4730 (int)cap_rid.bootBlockVer );
4731 data->readlen = strlen( data->rbuffer );
4732 return 0;
4733 }
4734
4735 static int proc_stats_rid_open(struct inode*, struct file*, u16);
4736 static int proc_statsdelta_open( struct inode *inode,
4737 struct file *file ) {
4738 if (file->f_mode&FMODE_WRITE) {
4739 return proc_stats_rid_open(inode, file, RID_STATSDELTACLEAR);
4740 }
4741 return proc_stats_rid_open(inode, file, RID_STATSDELTA);
4742 }
4743
4744 static int proc_stats_open( struct inode *inode, struct file *file ) {
4745 return proc_stats_rid_open(inode, file, RID_STATS);
4746 }
4747
4748 static int proc_stats_rid_open( struct inode *inode,
4749 struct file *file,
4750 u16 rid ) {
4751 struct proc_data *data;
4752 struct proc_dir_entry *dp = PDE(inode);
4753 struct net_device *dev = dp->data;
4754 struct airo_info *apriv = dev->priv;
4755 StatsRid stats;
4756 int i, j;
4757 u32 *vals = stats.vals;
4758
4759 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4760 return -ENOMEM;
4761 data = (struct proc_data *)file->private_data;
4762 if ((data->rbuffer = kmalloc( 4096, GFP_KERNEL )) == NULL) {
4763 kfree (file->private_data);
4764 return -ENOMEM;
4765 }
4766
4767 readStatsRid(apriv, &stats, rid, 1);
4768
4769 j = 0;
4770 for(i=0; statsLabels[i]!=(char *)-1 &&
4771 i*4<stats.len; i++){
4772 if (!statsLabels[i]) continue;
4773 if (j+strlen(statsLabels[i])+16>4096) {
4774 airo_print_warn(apriv->dev->name,
4775 "Potentially disasterous buffer overflow averted!");
4776 break;
4777 }
4778 j+=sprintf(data->rbuffer+j, "%s: %u\n", statsLabels[i], vals[i]);
4779 }
4780 if (i*4>=stats.len){
4781 airo_print_warn(apriv->dev->name, "Got a short rid");
4782 }
4783 data->readlen = j;
4784 return 0;
4785 }
4786
4787 static int get_dec_u16( char *buffer, int *start, int limit ) {
4788 u16 value;
4789 int valid = 0;
4790 for( value = 0; buffer[*start] >= '0' &&
4791 buffer[*start] <= '9' &&
4792 *start < limit; (*start)++ ) {
4793 valid = 1;
4794 value *= 10;
4795 value += buffer[*start] - '0';
4796 }
4797 if ( !valid ) return -1;
4798 return value;
4799 }
4800
4801 static int airo_config_commit(struct net_device *dev,
4802 struct iw_request_info *info, void *zwrq,
4803 char *extra);
4804
4805 static void proc_config_on_close( struct inode *inode, struct file *file ) {
4806 struct proc_data *data = file->private_data;
4807 struct proc_dir_entry *dp = PDE(inode);
4808 struct net_device *dev = dp->data;
4809 struct airo_info *ai = dev->priv;
4810 char *line;
4811
4812 if ( !data->writelen ) return;
4813
4814 readConfigRid(ai, 1);
4815 set_bit (FLAG_COMMIT, &ai->flags);
4816
4817 line = data->wbuffer;
4818 while( line[0] ) {
4819 /*** Mode processing */
4820 if ( !strncmp( line, "Mode: ", 6 ) ) {
4821 line += 6;
4822 if ((ai->config.rmode & 0xff) >= RXMODE_RFMON)
4823 set_bit (FLAG_RESET, &ai->flags);
4824 ai->config.rmode &= 0xfe00;
4825 clear_bit (FLAG_802_11, &ai->flags);
4826 ai->config.opmode &= 0xFF00;
4827 ai->config.scanMode = SCANMODE_ACTIVE;
4828 if ( line[0] == 'a' ) {
4829 ai->config.opmode |= 0;
4830 } else {
4831 ai->config.opmode |= 1;
4832 if ( line[0] == 'r' ) {
4833 ai->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
4834 ai->config.scanMode = SCANMODE_PASSIVE;
4835 set_bit (FLAG_802_11, &ai->flags);
4836 } else if ( line[0] == 'y' ) {
4837 ai->config.rmode |= RXMODE_RFMON_ANYBSS | RXMODE_DISABLE_802_3_HEADER;
4838 ai->config.scanMode = SCANMODE_PASSIVE;
4839 set_bit (FLAG_802_11, &ai->flags);
4840 } else if ( line[0] == 'l' )
4841 ai->config.rmode |= RXMODE_LANMON;
4842 }
4843 set_bit (FLAG_COMMIT, &ai->flags);
4844 }
4845
4846 /*** Radio status */
4847 else if (!strncmp(line,"Radio: ", 7)) {
4848 line += 7;
4849 if (!strncmp(line,"off",3)) {
4850 set_bit (FLAG_RADIO_OFF, &ai->flags);
4851 } else {
4852 clear_bit (FLAG_RADIO_OFF, &ai->flags);
4853 }
4854 }
4855 /*** NodeName processing */
4856 else if ( !strncmp( line, "NodeName: ", 10 ) ) {
4857 int j;
4858
4859 line += 10;
4860 memset( ai->config.nodeName, 0, 16 );
4861 /* Do the name, assume a space between the mode and node name */
4862 for( j = 0; j < 16 && line[j] != '\n'; j++ ) {
4863 ai->config.nodeName[j] = line[j];
4864 }
4865 set_bit (FLAG_COMMIT, &ai->flags);
4866 }
4867
4868 /*** PowerMode processing */
4869 else if ( !strncmp( line, "PowerMode: ", 11 ) ) {
4870 line += 11;
4871 if ( !strncmp( line, "PSPCAM", 6 ) ) {
4872 ai->config.powerSaveMode = POWERSAVE_PSPCAM;
4873 set_bit (FLAG_COMMIT, &ai->flags);
4874 } else if ( !strncmp( line, "PSP", 3 ) ) {
4875 ai->config.powerSaveMode = POWERSAVE_PSP;
4876 set_bit (FLAG_COMMIT, &ai->flags);
4877 } else {
4878 ai->config.powerSaveMode = POWERSAVE_CAM;
4879 set_bit (FLAG_COMMIT, &ai->flags);
4880 }
4881 } else if ( !strncmp( line, "DataRates: ", 11 ) ) {
4882 int v, i = 0, k = 0; /* i is index into line,
4883 k is index to rates */
4884
4885 line += 11;
4886 while((v = get_dec_u16(line, &i, 3))!=-1) {
4887 ai->config.rates[k++] = (u8)v;
4888 line += i + 1;
4889 i = 0;
4890 }
4891 set_bit (FLAG_COMMIT, &ai->flags);
4892 } else if ( !strncmp( line, "Channel: ", 9 ) ) {
4893 int v, i = 0;
4894 line += 9;
4895 v = get_dec_u16(line, &i, i+3);
4896 if ( v != -1 ) {
4897 ai->config.channelSet = (u16)v;
4898 set_bit (FLAG_COMMIT, &ai->flags);
4899 }
4900 } else if ( !strncmp( line, "XmitPower: ", 11 ) ) {
4901 int v, i = 0;
4902 line += 11;
4903 v = get_dec_u16(line, &i, i+3);
4904 if ( v != -1 ) {
4905 ai->config.txPower = (u16)v;
4906 set_bit (FLAG_COMMIT, &ai->flags);
4907 }
4908 } else if ( !strncmp( line, "WEP: ", 5 ) ) {
4909 line += 5;
4910 switch( line[0] ) {
4911 case 's':
4912 ai->config.authType = (u16)AUTH_SHAREDKEY;
4913 break;
4914 case 'e':
4915 ai->config.authType = (u16)AUTH_ENCRYPT;
4916 break;
4917 default:
4918 ai->config.authType = (u16)AUTH_OPEN;
4919 break;
4920 }
4921 set_bit (FLAG_COMMIT, &ai->flags);
4922 } else if ( !strncmp( line, "LongRetryLimit: ", 16 ) ) {
4923 int v, i = 0;
4924
4925 line += 16;
4926 v = get_dec_u16(line, &i, 3);
4927 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4928 ai->config.longRetryLimit = (u16)v;
4929 set_bit (FLAG_COMMIT, &ai->flags);
4930 } else if ( !strncmp( line, "ShortRetryLimit: ", 17 ) ) {
4931 int v, i = 0;
4932
4933 line += 17;
4934 v = get_dec_u16(line, &i, 3);
4935 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4936 ai->config.shortRetryLimit = (u16)v;
4937 set_bit (FLAG_COMMIT, &ai->flags);
4938 } else if ( !strncmp( line, "RTSThreshold: ", 14 ) ) {
4939 int v, i = 0;
4940
4941 line += 14;
4942 v = get_dec_u16(line, &i, 4);
4943 v = (v<0) ? 0 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v);
4944 ai->config.rtsThres = (u16)v;
4945 set_bit (FLAG_COMMIT, &ai->flags);
4946 } else if ( !strncmp( line, "TXMSDULifetime: ", 16 ) ) {
4947 int v, i = 0;
4948
4949 line += 16;
4950 v = get_dec_u16(line, &i, 5);
4951 v = (v<0) ? 0 : v;
4952 ai->config.txLifetime = (u16)v;
4953 set_bit (FLAG_COMMIT, &ai->flags);
4954 } else if ( !strncmp( line, "RXMSDULifetime: ", 16 ) ) {
4955 int v, i = 0;
4956
4957 line += 16;
4958 v = get_dec_u16(line, &i, 5);
4959 v = (v<0) ? 0 : v;
4960 ai->config.rxLifetime = (u16)v;
4961 set_bit (FLAG_COMMIT, &ai->flags);
4962 } else if ( !strncmp( line, "TXDiversity: ", 13 ) ) {
4963 ai->config.txDiversity =
4964 (line[13]=='l') ? 1 :
4965 ((line[13]=='r')? 2: 3);
4966 set_bit (FLAG_COMMIT, &ai->flags);
4967 } else if ( !strncmp( line, "RXDiversity: ", 13 ) ) {
4968 ai->config.rxDiversity =
4969 (line[13]=='l') ? 1 :
4970 ((line[13]=='r')? 2: 3);
4971 set_bit (FLAG_COMMIT, &ai->flags);
4972 } else if ( !strncmp( line, "FragThreshold: ", 15 ) ) {
4973 int v, i = 0;
4974
4975 line += 15;
4976 v = get_dec_u16(line, &i, 4);
4977 v = (v<256) ? 256 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v);
4978 v = v & 0xfffe; /* Make sure its even */
4979 ai->config.fragThresh = (u16)v;
4980 set_bit (FLAG_COMMIT, &ai->flags);
4981 } else if (!strncmp(line, "Modulation: ", 12)) {
4982 line += 12;
4983 switch(*line) {
4984 case 'd': ai->config.modulation=MOD_DEFAULT; set_bit(FLAG_COMMIT, &ai->flags); break;
4985 case 'c': ai->config.modulation=MOD_CCK; set_bit(FLAG_COMMIT, &ai->flags); break;
4986 case 'm': ai->config.modulation=MOD_MOK; set_bit(FLAG_COMMIT, &ai->flags); break;
4987 default: airo_print_warn(ai->dev->name, "Unknown modulation");
4988 }
4989 } else if (!strncmp(line, "Preamble: ", 10)) {
4990 line += 10;
4991 switch(*line) {
4992 case 'a': ai->config.preamble=PREAMBLE_AUTO; set_bit(FLAG_COMMIT, &ai->flags); break;
4993 case 'l': ai->config.preamble=PREAMBLE_LONG; set_bit(FLAG_COMMIT, &ai->flags); break;
4994 case 's': ai->config.preamble=PREAMBLE_SHORT; set_bit(FLAG_COMMIT, &ai->flags); break;
4995 default: airo_print_warn(ai->dev->name, "Unknown preamble");
4996 }
4997 } else {
4998 airo_print_warn(ai->dev->name, "Couldn't figure out %s", line);
4999 }
5000 while( line[0] && line[0] != '\n' ) line++;
5001 if ( line[0] ) line++;
5002 }
5003 airo_config_commit(dev, NULL, NULL, NULL);
5004 }
5005
5006 static char *get_rmode(u16 mode) {
5007 switch(mode&0xff) {
5008 case RXMODE_RFMON: return "rfmon";
5009 case RXMODE_RFMON_ANYBSS: return "yna (any) bss rfmon";
5010 case RXMODE_LANMON: return "lanmon";
5011 }
5012 return "ESS";
5013 }
5014
5015 static int proc_config_open( struct inode *inode, struct file *file ) {
5016 struct proc_data *data;
5017 struct proc_dir_entry *dp = PDE(inode);
5018 struct net_device *dev = dp->data;
5019 struct airo_info *ai = dev->priv;
5020 int i;
5021
5022 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5023 return -ENOMEM;
5024 data = (struct proc_data *)file->private_data;
5025 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
5026 kfree (file->private_data);
5027 return -ENOMEM;
5028 }
5029 if ((data->wbuffer = kzalloc( 2048, GFP_KERNEL )) == NULL) {
5030 kfree (data->rbuffer);
5031 kfree (file->private_data);
5032 return -ENOMEM;
5033 }
5034 data->maxwritelen = 2048;
5035 data->on_close = proc_config_on_close;
5036
5037 readConfigRid(ai, 1);
5038
5039 i = sprintf( data->rbuffer,
5040 "Mode: %s\n"
5041 "Radio: %s\n"
5042 "NodeName: %-16s\n"
5043 "PowerMode: %s\n"
5044 "DataRates: %d %d %d %d %d %d %d %d\n"
5045 "Channel: %d\n"
5046 "XmitPower: %d\n",
5047 (ai->config.opmode & 0xFF) == 0 ? "adhoc" :
5048 (ai->config.opmode & 0xFF) == 1 ? get_rmode(ai->config.rmode):
5049 (ai->config.opmode & 0xFF) == 2 ? "AP" :
5050 (ai->config.opmode & 0xFF) == 3 ? "AP RPTR" : "Error",
5051 test_bit(FLAG_RADIO_OFF, &ai->flags) ? "off" : "on",
5052 ai->config.nodeName,
5053 ai->config.powerSaveMode == 0 ? "CAM" :
5054 ai->config.powerSaveMode == 1 ? "PSP" :
5055 ai->config.powerSaveMode == 2 ? "PSPCAM" : "Error",
5056 (int)ai->config.rates[0],
5057 (int)ai->config.rates[1],
5058 (int)ai->config.rates[2],
5059 (int)ai->config.rates[3],
5060 (int)ai->config.rates[4],
5061 (int)ai->config.rates[5],
5062 (int)ai->config.rates[6],
5063 (int)ai->config.rates[7],
5064 (int)ai->config.channelSet,
5065 (int)ai->config.txPower
5066 );
5067 sprintf( data->rbuffer + i,
5068 "LongRetryLimit: %d\n"
5069 "ShortRetryLimit: %d\n"
5070 "RTSThreshold: %d\n"
5071 "TXMSDULifetime: %d\n"
5072 "RXMSDULifetime: %d\n"
5073 "TXDiversity: %s\n"
5074 "RXDiversity: %s\n"
5075 "FragThreshold: %d\n"
5076 "WEP: %s\n"
5077 "Modulation: %s\n"
5078 "Preamble: %s\n",
5079 (int)ai->config.longRetryLimit,
5080 (int)ai->config.shortRetryLimit,
5081 (int)ai->config.rtsThres,
5082 (int)ai->config.txLifetime,
5083 (int)ai->config.rxLifetime,
5084 ai->config.txDiversity == 1 ? "left" :
5085 ai->config.txDiversity == 2 ? "right" : "both",
5086 ai->config.rxDiversity == 1 ? "left" :
5087 ai->config.rxDiversity == 2 ? "right" : "both",
5088 (int)ai->config.fragThresh,
5089 ai->config.authType == AUTH_ENCRYPT ? "encrypt" :
5090 ai->config.authType == AUTH_SHAREDKEY ? "shared" : "open",
5091 ai->config.modulation == 0 ? "default" :
5092 ai->config.modulation == MOD_CCK ? "cck" :
5093 ai->config.modulation == MOD_MOK ? "mok" : "error",
5094 ai->config.preamble == PREAMBLE_AUTO ? "auto" :
5095 ai->config.preamble == PREAMBLE_LONG ? "long" :
5096 ai->config.preamble == PREAMBLE_SHORT ? "short" : "error"
5097 );
5098 data->readlen = strlen( data->rbuffer );
5099 return 0;
5100 }
5101
5102 static void proc_SSID_on_close( struct inode *inode, struct file *file ) {
5103 struct proc_data *data = (struct proc_data *)file->private_data;
5104 struct proc_dir_entry *dp = PDE(inode);
5105 struct net_device *dev = dp->data;
5106 struct airo_info *ai = dev->priv;
5107 SsidRid SSID_rid;
5108 Resp rsp;
5109 int i;
5110 int offset = 0;
5111
5112 if ( !data->writelen ) return;
5113
5114 memset( &SSID_rid, 0, sizeof( SSID_rid ) );
5115
5116 for( i = 0; i < 3; i++ ) {
5117 int j;
5118 for( j = 0; j+offset < data->writelen && j < 32 &&
5119 data->wbuffer[offset+j] != '\n'; j++ ) {
5120 SSID_rid.ssids[i].ssid[j] = data->wbuffer[offset+j];
5121 }
5122 if ( j == 0 ) break;
5123 SSID_rid.ssids[i].len = j;
5124 offset += j;
5125 while( data->wbuffer[offset] != '\n' &&
5126 offset < data->writelen ) offset++;
5127 offset++;
5128 }
5129 if (i)
5130 SSID_rid.len = sizeof(SSID_rid);
5131 disable_MAC(ai, 1);
5132 writeSsidRid(ai, &SSID_rid, 1);
5133 enable_MAC(ai, &rsp, 1);
5134 }
5135
5136 static inline u8 hexVal(char c) {
5137 if (c>='0' && c<='9') return c -= '0';
5138 if (c>='a' && c<='f') return c -= 'a'-10;
5139 if (c>='A' && c<='F') return c -= 'A'-10;
5140 return 0;
5141 }
5142
5143 static void proc_APList_on_close( struct inode *inode, struct file *file ) {
5144 struct proc_data *data = (struct proc_data *)file->private_data;
5145 struct proc_dir_entry *dp = PDE(inode);
5146 struct net_device *dev = dp->data;
5147 struct airo_info *ai = dev->priv;
5148 APListRid APList_rid;
5149 Resp rsp;
5150 int i;
5151
5152 if ( !data->writelen ) return;
5153
5154 memset( &APList_rid, 0, sizeof(APList_rid) );
5155 APList_rid.len = sizeof(APList_rid);
5156
5157 for( i = 0; i < 4 && data->writelen >= (i+1)*6*3; i++ ) {
5158 int j;
5159 for( j = 0; j < 6*3 && data->wbuffer[j+i*6*3]; j++ ) {
5160 switch(j%3) {
5161 case 0:
5162 APList_rid.ap[i][j/3]=
5163 hexVal(data->wbuffer[j+i*6*3])<<4;
5164 break;
5165 case 1:
5166 APList_rid.ap[i][j/3]|=
5167 hexVal(data->wbuffer[j+i*6*3]);
5168 break;
5169 }
5170 }
5171 }
5172 disable_MAC(ai, 1);
5173 writeAPListRid(ai, &APList_rid, 1);
5174 enable_MAC(ai, &rsp, 1);
5175 }
5176
5177 /* This function wraps PC4500_writerid with a MAC disable */
5178 static int do_writerid( struct airo_info *ai, u16 rid, const void *rid_data,
5179 int len, int dummy ) {
5180 int rc;
5181 Resp rsp;
5182
5183 disable_MAC(ai, 1);
5184 rc = PC4500_writerid(ai, rid, rid_data, len, 1);
5185 enable_MAC(ai, &rsp, 1);
5186 return rc;
5187 }
5188
5189 /* Returns the length of the key at the index. If index == 0xffff
5190 * the index of the transmit key is returned. If the key doesn't exist,
5191 * -1 will be returned.
5192 */
5193 static int get_wep_key(struct airo_info *ai, u16 index) {
5194 WepKeyRid wkr;
5195 int rc;
5196 u16 lastindex;
5197
5198 rc = readWepKeyRid(ai, &wkr, 1, 1);
5199 if (rc == SUCCESS) do {
5200 lastindex = wkr.kindex;
5201 if (wkr.kindex == index) {
5202 if (index == 0xffff) {
5203 return wkr.mac[0];
5204 }
5205 return wkr.klen;
5206 }
5207 readWepKeyRid(ai, &wkr, 0, 1);
5208 } while(lastindex != wkr.kindex);
5209 return -1;
5210 }
5211
5212 static int set_wep_key(struct airo_info *ai, u16 index,
5213 const char *key, u16 keylen, int perm, int lock ) {
5214 static const unsigned char macaddr[ETH_ALEN] = { 0x01, 0, 0, 0, 0, 0 };
5215 WepKeyRid wkr;
5216 Resp rsp;
5217
5218 memset(&wkr, 0, sizeof(wkr));
5219 if (keylen == 0) {
5220 // We are selecting which key to use
5221 wkr.len = sizeof(wkr);
5222 wkr.kindex = 0xffff;
5223 wkr.mac[0] = (char)index;
5224 if (perm) ai->defindex = (char)index;
5225 } else {
5226 // We are actually setting the key
5227 wkr.len = sizeof(wkr);
5228 wkr.kindex = index;
5229 wkr.klen = keylen;
5230 memcpy( wkr.key, key, keylen );
5231 memcpy( wkr.mac, macaddr, ETH_ALEN );
5232 }
5233
5234 if (perm) disable_MAC(ai, lock);
5235 writeWepKeyRid(ai, &wkr, perm, lock);
5236 if (perm) enable_MAC(ai, &rsp, lock);
5237 return 0;
5238 }
5239
5240 static void proc_wepkey_on_close( struct inode *inode, struct file *file ) {
5241 struct proc_data *data;
5242 struct proc_dir_entry *dp = PDE(inode);
5243 struct net_device *dev = dp->data;
5244 struct airo_info *ai = dev->priv;
5245 int i;
5246 char key[16];
5247 u16 index = 0;
5248 int j = 0;
5249
5250 memset(key, 0, sizeof(key));
5251
5252 data = (struct proc_data *)file->private_data;
5253 if ( !data->writelen ) return;
5254
5255 if (data->wbuffer[0] >= '0' && data->wbuffer[0] <= '3' &&
5256 (data->wbuffer[1] == ' ' || data->wbuffer[1] == '\n')) {
5257 index = data->wbuffer[0] - '0';
5258 if (data->wbuffer[1] == '\n') {
5259 set_wep_key(ai, index, NULL, 0, 1, 1);
5260 return;
5261 }
5262 j = 2;
5263 } else {
5264 airo_print_err(ai->dev->name, "WepKey passed invalid key index");
5265 return;
5266 }
5267
5268 for( i = 0; i < 16*3 && data->wbuffer[i+j]; i++ ) {
5269 switch(i%3) {
5270 case 0:
5271 key[i/3] = hexVal(data->wbuffer[i+j])<<4;
5272 break;
5273 case 1:
5274 key[i/3] |= hexVal(data->wbuffer[i+j]);
5275 break;
5276 }
5277 }
5278 set_wep_key(ai, index, key, i/3, 1, 1);
5279 }
5280
5281 static int proc_wepkey_open( struct inode *inode, struct file *file ) {
5282 struct proc_data *data;
5283 struct proc_dir_entry *dp = PDE(inode);
5284 struct net_device *dev = dp->data;
5285 struct airo_info *ai = dev->priv;
5286 char *ptr;
5287 WepKeyRid wkr;
5288 u16 lastindex;
5289 int j=0;
5290 int rc;
5291
5292 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5293 return -ENOMEM;
5294 memset(&wkr, 0, sizeof(wkr));
5295 data = (struct proc_data *)file->private_data;
5296 if ((data->rbuffer = kzalloc( 180, GFP_KERNEL )) == NULL) {
5297 kfree (file->private_data);
5298 return -ENOMEM;
5299 }
5300 data->writelen = 0;
5301 data->maxwritelen = 80;
5302 if ((data->wbuffer = kzalloc( 80, GFP_KERNEL )) == NULL) {
5303 kfree (data->rbuffer);
5304 kfree (file->private_data);
5305 return -ENOMEM;
5306 }
5307 data->on_close = proc_wepkey_on_close;
5308
5309 ptr = data->rbuffer;
5310 strcpy(ptr, "No wep keys\n");
5311 rc = readWepKeyRid(ai, &wkr, 1, 1);
5312 if (rc == SUCCESS) do {
5313 lastindex = wkr.kindex;
5314 if (wkr.kindex == 0xffff) {
5315 j += sprintf(ptr+j, "Tx key = %d\n",
5316 (int)wkr.mac[0]);
5317 } else {
5318 j += sprintf(ptr+j, "Key %d set with length = %d\n",
5319 (int)wkr.kindex, (int)wkr.klen);
5320 }
5321 readWepKeyRid(ai, &wkr, 0, 1);
5322 } while((lastindex != wkr.kindex) && (j < 180-30));
5323
5324 data->readlen = strlen( data->rbuffer );
5325 return 0;
5326 }
5327
5328 static int proc_SSID_open( struct inode *inode, struct file *file ) {
5329 struct proc_data *data;
5330 struct proc_dir_entry *dp = PDE(inode);
5331 struct net_device *dev = dp->data;
5332 struct airo_info *ai = dev->priv;
5333 int i;
5334 char *ptr;
5335 SsidRid SSID_rid;
5336
5337 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5338 return -ENOMEM;
5339 data = (struct proc_data *)file->private_data;
5340 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5341 kfree (file->private_data);
5342 return -ENOMEM;
5343 }
5344 data->writelen = 0;
5345 data->maxwritelen = 33*3;
5346 if ((data->wbuffer = kzalloc( 33*3, GFP_KERNEL )) == NULL) {
5347 kfree (data->rbuffer);
5348 kfree (file->private_data);
5349 return -ENOMEM;
5350 }
5351 data->on_close = proc_SSID_on_close;
5352
5353 readSsidRid(ai, &SSID_rid);
5354 ptr = data->rbuffer;
5355 for( i = 0; i < 3; i++ ) {
5356 int j;
5357 if ( !SSID_rid.ssids[i].len ) break;
5358 for( j = 0; j < 32 &&
5359 j < SSID_rid.ssids[i].len &&
5360 SSID_rid.ssids[i].ssid[j]; j++ ) {
5361 *ptr++ = SSID_rid.ssids[i].ssid[j];
5362 }
5363 *ptr++ = '\n';
5364 }
5365 *ptr = '\0';
5366 data->readlen = strlen( data->rbuffer );
5367 return 0;
5368 }
5369
5370 static int proc_APList_open( struct inode *inode, struct file *file ) {
5371 struct proc_data *data;
5372 struct proc_dir_entry *dp = PDE(inode);
5373 struct net_device *dev = dp->data;
5374 struct airo_info *ai = dev->priv;
5375 int i;
5376 char *ptr;
5377 APListRid APList_rid;
5378
5379 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5380 return -ENOMEM;
5381 data = (struct proc_data *)file->private_data;
5382 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5383 kfree (file->private_data);
5384 return -ENOMEM;
5385 }
5386 data->writelen = 0;
5387 data->maxwritelen = 4*6*3;
5388 if ((data->wbuffer = kzalloc( data->maxwritelen, GFP_KERNEL )) == NULL) {
5389 kfree (data->rbuffer);
5390 kfree (file->private_data);
5391 return -ENOMEM;
5392 }
5393 data->on_close = proc_APList_on_close;
5394
5395 readAPListRid(ai, &APList_rid);
5396 ptr = data->rbuffer;
5397 for( i = 0; i < 4; i++ ) {
5398 // We end when we find a zero MAC
5399 if ( !*(int*)APList_rid.ap[i] &&
5400 !*(int*)&APList_rid.ap[i][2]) break;
5401 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x\n",
5402 (int)APList_rid.ap[i][0],
5403 (int)APList_rid.ap[i][1],
5404 (int)APList_rid.ap[i][2],
5405 (int)APList_rid.ap[i][3],
5406 (int)APList_rid.ap[i][4],
5407 (int)APList_rid.ap[i][5]);
5408 }
5409 if (i==0) ptr += sprintf(ptr, "Not using specific APs\n");
5410
5411 *ptr = '\0';
5412 data->readlen = strlen( data->rbuffer );
5413 return 0;
5414 }
5415
5416 static int proc_BSSList_open( struct inode *inode, struct file *file ) {
5417 struct proc_data *data;
5418 struct proc_dir_entry *dp = PDE(inode);
5419 struct net_device *dev = dp->data;
5420 struct airo_info *ai = dev->priv;
5421 char *ptr;
5422 BSSListRid BSSList_rid;
5423 int rc;
5424 /* If doLoseSync is not 1, we won't do a Lose Sync */
5425 int doLoseSync = -1;
5426
5427 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5428 return -ENOMEM;
5429 data = (struct proc_data *)file->private_data;
5430 if ((data->rbuffer = kmalloc( 1024, GFP_KERNEL )) == NULL) {
5431 kfree (file->private_data);
5432 return -ENOMEM;
5433 }
5434 data->writelen = 0;
5435 data->maxwritelen = 0;
5436 data->wbuffer = NULL;
5437 data->on_close = NULL;
5438
5439 if (file->f_mode & FMODE_WRITE) {
5440 if (!(file->f_mode & FMODE_READ)) {
5441 Cmd cmd;
5442 Resp rsp;
5443
5444 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
5445 memset(&cmd, 0, sizeof(cmd));
5446 cmd.cmd=CMD_LISTBSS;
5447 if (down_interruptible(&ai->sem))
5448 return -ERESTARTSYS;
5449 issuecommand(ai, &cmd, &rsp);
5450 up(&ai->sem);
5451 data->readlen = 0;
5452 return 0;
5453 }
5454 doLoseSync = 1;
5455 }
5456 ptr = data->rbuffer;
5457 /* There is a race condition here if there are concurrent opens.
5458 Since it is a rare condition, we'll just live with it, otherwise
5459 we have to add a spin lock... */
5460 rc = readBSSListRid(ai, doLoseSync, &BSSList_rid);
5461 while(rc == 0 && BSSList_rid.index != 0xffff) {
5462 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x %*s rssi = %d",
5463 (int)BSSList_rid.bssid[0],
5464 (int)BSSList_rid.bssid[1],
5465 (int)BSSList_rid.bssid[2],
5466 (int)BSSList_rid.bssid[3],
5467 (int)BSSList_rid.bssid[4],
5468 (int)BSSList_rid.bssid[5],
5469 (int)BSSList_rid.ssidLen,
5470 BSSList_rid.ssid,
5471 (int)BSSList_rid.dBm);
5472 ptr += sprintf(ptr, " channel = %d %s %s %s %s\n",
5473 (int)BSSList_rid.dsChannel,
5474 BSSList_rid.cap & CAP_ESS ? "ESS" : "",
5475 BSSList_rid.cap & CAP_IBSS ? "adhoc" : "",
5476 BSSList_rid.cap & CAP_PRIVACY ? "wep" : "",
5477 BSSList_rid.cap & CAP_SHORTHDR ? "shorthdr" : "");
5478 rc = readBSSListRid(ai, 0, &BSSList_rid);
5479 }
5480 *ptr = '\0';
5481 data->readlen = strlen( data->rbuffer );
5482 return 0;
5483 }
5484
5485 static int proc_close( struct inode *inode, struct file *file )
5486 {
5487 struct proc_data *data = file->private_data;
5488
5489 if (data->on_close != NULL)
5490 data->on_close(inode, file);
5491 kfree(data->rbuffer);
5492 kfree(data->wbuffer);
5493 kfree(data);
5494 return 0;
5495 }
5496
5497 static struct net_device_list {
5498 struct net_device *dev;
5499 struct net_device_list *next;
5500 } *airo_devices;
5501
5502 /* Since the card doesn't automatically switch to the right WEP mode,
5503 we will make it do it. If the card isn't associated, every secs we
5504 will switch WEP modes to see if that will help. If the card is
5505 associated we will check every minute to see if anything has
5506 changed. */
5507 static void timer_func( struct net_device *dev ) {
5508 struct airo_info *apriv = dev->priv;
5509 Resp rsp;
5510
5511 /* We don't have a link so try changing the authtype */
5512 readConfigRid(apriv, 0);
5513 disable_MAC(apriv, 0);
5514 switch(apriv->config.authType) {
5515 case AUTH_ENCRYPT:
5516 /* So drop to OPEN */
5517 apriv->config.authType = AUTH_OPEN;
5518 break;
5519 case AUTH_SHAREDKEY:
5520 if (apriv->keyindex < auto_wep) {
5521 set_wep_key(apriv, apriv->keyindex, NULL, 0, 0, 0);
5522 apriv->config.authType = AUTH_SHAREDKEY;
5523 apriv->keyindex++;
5524 } else {
5525 /* Drop to ENCRYPT */
5526 apriv->keyindex = 0;
5527 set_wep_key(apriv, apriv->defindex, NULL, 0, 0, 0);
5528 apriv->config.authType = AUTH_ENCRYPT;
5529 }
5530 break;
5531 default: /* We'll escalate to SHAREDKEY */
5532 apriv->config.authType = AUTH_SHAREDKEY;
5533 }
5534 set_bit (FLAG_COMMIT, &apriv->flags);
5535 writeConfigRid(apriv, 0);
5536 enable_MAC(apriv, &rsp, 0);
5537 up(&apriv->sem);
5538
5539 /* Schedule check to see if the change worked */
5540 clear_bit(JOB_AUTOWEP, &apriv->jobs);
5541 apriv->expires = RUN_AT(HZ*3);
5542 }
5543
5544 static int add_airo_dev( struct net_device *dev ) {
5545 struct net_device_list *node = kmalloc( sizeof( *node ), GFP_KERNEL );
5546 if ( !node )
5547 return -ENOMEM;
5548
5549 node->dev = dev;
5550 node->next = airo_devices;
5551 airo_devices = node;
5552
5553 return 0;
5554 }
5555
5556 static void del_airo_dev( struct net_device *dev ) {
5557 struct net_device_list **p = &airo_devices;
5558 while( *p && ( (*p)->dev != dev ) )
5559 p = &(*p)->next;
5560 if ( *p && (*p)->dev == dev )
5561 *p = (*p)->next;
5562 }
5563
5564 #ifdef CONFIG_PCI
5565 static int __devinit airo_pci_probe(struct pci_dev *pdev,
5566 const struct pci_device_id *pent)
5567 {
5568 struct net_device *dev;
5569
5570 if (pci_enable_device(pdev))
5571 return -ENODEV;
5572 pci_set_master(pdev);
5573
5574 if (pdev->device == 0x5000 || pdev->device == 0xa504)
5575 dev = _init_airo_card(pdev->irq, pdev->resource[0].start, 0, pdev, &pdev->dev);
5576 else
5577 dev = _init_airo_card(pdev->irq, pdev->resource[2].start, 0, pdev, &pdev->dev);
5578 if (!dev)
5579 return -ENODEV;
5580
5581 pci_set_drvdata(pdev, dev);
5582 return 0;
5583 }
5584
5585 static void __devexit airo_pci_remove(struct pci_dev *pdev)
5586 {
5587 }
5588
5589 static int airo_pci_suspend(struct pci_dev *pdev, pm_message_t state)
5590 {
5591 struct net_device *dev = pci_get_drvdata(pdev);
5592 struct airo_info *ai = dev->priv;
5593 Cmd cmd;
5594 Resp rsp;
5595
5596 if ((ai->APList == NULL) &&
5597 (ai->APList = kmalloc(sizeof(APListRid), GFP_KERNEL)) == NULL)
5598 return -ENOMEM;
5599 if ((ai->SSID == NULL) &&
5600 (ai->SSID = kmalloc(sizeof(SsidRid), GFP_KERNEL)) == NULL)
5601 return -ENOMEM;
5602 readAPListRid(ai, ai->APList);
5603 readSsidRid(ai, ai->SSID);
5604 memset(&cmd, 0, sizeof(cmd));
5605 /* the lock will be released at the end of the resume callback */
5606 if (down_interruptible(&ai->sem))
5607 return -EAGAIN;
5608 disable_MAC(ai, 0);
5609 netif_device_detach(dev);
5610 ai->power = state;
5611 cmd.cmd=HOSTSLEEP;
5612 issuecommand(ai, &cmd, &rsp);
5613
5614 pci_enable_wake(pdev, pci_choose_state(pdev, state), 1);
5615 pci_save_state(pdev);
5616 return pci_set_power_state(pdev, pci_choose_state(pdev, state));
5617 }
5618
5619 static int airo_pci_resume(struct pci_dev *pdev)
5620 {
5621 struct net_device *dev = pci_get_drvdata(pdev);
5622 struct airo_info *ai = dev->priv;
5623 Resp rsp;
5624 pci_power_t prev_state = pdev->current_state;
5625
5626 pci_set_power_state(pdev, PCI_D0);
5627 pci_restore_state(pdev);
5628 pci_enable_wake(pdev, PCI_D0, 0);
5629
5630 if (prev_state != PCI_D1) {
5631 reset_card(dev, 0);
5632 mpi_init_descriptors(ai);
5633 setup_card(ai, dev->dev_addr, 0);
5634 clear_bit(FLAG_RADIO_OFF, &ai->flags);
5635 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
5636 } else {
5637 OUT4500(ai, EVACK, EV_AWAKEN);
5638 OUT4500(ai, EVACK, EV_AWAKEN);
5639 msleep(100);
5640 }
5641
5642 set_bit (FLAG_COMMIT, &ai->flags);
5643 disable_MAC(ai, 0);
5644 msleep(200);
5645 if (ai->SSID) {
5646 writeSsidRid(ai, ai->SSID, 0);
5647 kfree(ai->SSID);
5648 ai->SSID = NULL;
5649 }
5650 if (ai->APList) {
5651 writeAPListRid(ai, ai->APList, 0);
5652 kfree(ai->APList);
5653 ai->APList = NULL;
5654 }
5655 writeConfigRid(ai, 0);
5656 enable_MAC(ai, &rsp, 0);
5657 ai->power = PMSG_ON;
5658 netif_device_attach(dev);
5659 netif_wake_queue(dev);
5660 enable_interrupts(ai);
5661 up(&ai->sem);
5662 return 0;
5663 }
5664 #endif
5665
5666 static int __init airo_init_module( void )
5667 {
5668 int i, have_isa_dev = 0;
5669
5670 airo_entry = create_proc_entry("aironet",
5671 S_IFDIR | airo_perm,
5672 proc_root_driver);
5673 airo_entry->uid = proc_uid;
5674 airo_entry->gid = proc_gid;
5675
5676 for( i = 0; i < 4 && io[i] && irq[i]; i++ ) {
5677 airo_print_info("", "Trying to configure ISA adapter at irq=%d "
5678 "io=0x%x", irq[i], io[i] );
5679 if (init_airo_card( irq[i], io[i], 0, NULL ))
5680 have_isa_dev = 1;
5681 }
5682
5683 #ifdef CONFIG_PCI
5684 airo_print_info("", "Probing for PCI adapters");
5685 pci_register_driver(&airo_driver);
5686 airo_print_info("", "Finished probing for PCI adapters");
5687 #endif
5688
5689 /* Always exit with success, as we are a library module
5690 * as well as a driver module
5691 */
5692 return 0;
5693 }
5694
5695 static void __exit airo_cleanup_module( void )
5696 {
5697 while( airo_devices ) {
5698 airo_print_info(airo_devices->dev->name, "Unregistering...\n");
5699 stop_airo_card( airo_devices->dev, 1 );
5700 }
5701 #ifdef CONFIG_PCI
5702 pci_unregister_driver(&airo_driver);
5703 #endif
5704 remove_proc_entry("aironet", proc_root_driver);
5705 }
5706
5707 /*
5708 * Initial Wireless Extension code for Aironet driver by :
5709 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 17 November 00
5710 * Conversion to new driver API by :
5711 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 26 March 02
5712 * Javier also did a good amount of work here, adding some new extensions
5713 * and fixing my code. Let's just say that without him this code just
5714 * would not work at all... - Jean II
5715 */
5716
5717 static u8 airo_rssi_to_dbm (tdsRssiEntry *rssi_rid, u8 rssi)
5718 {
5719 if( !rssi_rid )
5720 return 0;
5721
5722 return (0x100 - rssi_rid[rssi].rssidBm);
5723 }
5724
5725 static u8 airo_dbm_to_pct (tdsRssiEntry *rssi_rid, u8 dbm)
5726 {
5727 int i;
5728
5729 if( !rssi_rid )
5730 return 0;
5731
5732 for( i = 0; i < 256; i++ )
5733 if (rssi_rid[i].rssidBm == dbm)
5734 return rssi_rid[i].rssipct;
5735
5736 return 0;
5737 }
5738
5739
5740 static int airo_get_quality (StatusRid *status_rid, CapabilityRid *cap_rid)
5741 {
5742 int quality = 0;
5743
5744 if ((status_rid->mode & 0x3f) == 0x3f && (cap_rid->hardCap & 8)) {
5745 if (memcmp(cap_rid->prodName, "350", 3))
5746 if (status_rid->signalQuality > 0x20)
5747 quality = 0;
5748 else
5749 quality = 0x20 - status_rid->signalQuality;
5750 else
5751 if (status_rid->signalQuality > 0xb0)
5752 quality = 0;
5753 else if (status_rid->signalQuality < 0x10)
5754 quality = 0xa0;
5755 else
5756 quality = 0xb0 - status_rid->signalQuality;
5757 }
5758 return quality;
5759 }
5760
5761 #define airo_get_max_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x20 : 0xa0)
5762 #define airo_get_avg_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x10 : 0x50);
5763
5764 /*------------------------------------------------------------------*/
5765 /*
5766 * Wireless Handler : get protocol name
5767 */
5768 static int airo_get_name(struct net_device *dev,
5769 struct iw_request_info *info,
5770 char *cwrq,
5771 char *extra)
5772 {
5773 strcpy(cwrq, "IEEE 802.11-DS");
5774 return 0;
5775 }
5776
5777 /*------------------------------------------------------------------*/
5778 /*
5779 * Wireless Handler : set frequency
5780 */
5781 static int airo_set_freq(struct net_device *dev,
5782 struct iw_request_info *info,
5783 struct iw_freq *fwrq,
5784 char *extra)
5785 {
5786 struct airo_info *local = dev->priv;
5787 int rc = -EINPROGRESS; /* Call commit handler */
5788
5789 /* If setting by frequency, convert to a channel */
5790 if((fwrq->e == 1) &&
5791 (fwrq->m >= (int) 2.412e8) &&
5792 (fwrq->m <= (int) 2.487e8)) {
5793 int f = fwrq->m / 100000;
5794 int c = 0;
5795 while((c < 14) && (f != frequency_list[c]))
5796 c++;
5797 /* Hack to fall through... */
5798 fwrq->e = 0;
5799 fwrq->m = c + 1;
5800 }
5801 /* Setting by channel number */
5802 if((fwrq->m > 1000) || (fwrq->e > 0))
5803 rc = -EOPNOTSUPP;
5804 else {
5805 int channel = fwrq->m;
5806 /* We should do a better check than that,
5807 * based on the card capability !!! */
5808 if((channel < 1) || (channel > 14)) {
5809 airo_print_dbg(dev->name, "New channel value of %d is invalid!",
5810 fwrq->m);
5811 rc = -EINVAL;
5812 } else {
5813 readConfigRid(local, 1);
5814 /* Yes ! We can set it !!! */
5815 local->config.channelSet = (u16) channel;
5816 set_bit (FLAG_COMMIT, &local->flags);
5817 }
5818 }
5819 return rc;
5820 }
5821
5822 /*------------------------------------------------------------------*/
5823 /*
5824 * Wireless Handler : get frequency
5825 */
5826 static int airo_get_freq(struct net_device *dev,
5827 struct iw_request_info *info,
5828 struct iw_freq *fwrq,
5829 char *extra)
5830 {
5831 struct airo_info *local = dev->priv;
5832 StatusRid status_rid; /* Card status info */
5833 int ch;
5834
5835 readConfigRid(local, 1);
5836 if ((local->config.opmode & 0xFF) == MODE_STA_ESS)
5837 status_rid.channel = local->config.channelSet;
5838 else
5839 readStatusRid(local, &status_rid, 1);
5840
5841 ch = (int)status_rid.channel;
5842 if((ch > 0) && (ch < 15)) {
5843 fwrq->m = frequency_list[ch - 1] * 100000;
5844 fwrq->e = 1;
5845 } else {
5846 fwrq->m = ch;
5847 fwrq->e = 0;
5848 }
5849
5850 return 0;
5851 }
5852
5853 /*------------------------------------------------------------------*/
5854 /*
5855 * Wireless Handler : set ESSID
5856 */
5857 static int airo_set_essid(struct net_device *dev,
5858 struct iw_request_info *info,
5859 struct iw_point *dwrq,
5860 char *extra)
5861 {
5862 struct airo_info *local = dev->priv;
5863 Resp rsp;
5864 SsidRid SSID_rid; /* SSIDs */
5865
5866 /* Reload the list of current SSID */
5867 readSsidRid(local, &SSID_rid);
5868
5869 /* Check if we asked for `any' */
5870 if(dwrq->flags == 0) {
5871 /* Just send an empty SSID list */
5872 memset(&SSID_rid, 0, sizeof(SSID_rid));
5873 } else {
5874 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
5875
5876 /* Check the size of the string */
5877 if(dwrq->length > IW_ESSID_MAX_SIZE+1) {
5878 return -E2BIG ;
5879 }
5880 /* Check if index is valid */
5881 if((index < 0) || (index >= 4)) {
5882 return -EINVAL;
5883 }
5884
5885 /* Set the SSID */
5886 memset(SSID_rid.ssids[index].ssid, 0,
5887 sizeof(SSID_rid.ssids[index].ssid));
5888 memcpy(SSID_rid.ssids[index].ssid, extra, dwrq->length);
5889 SSID_rid.ssids[index].len = dwrq->length - 1;
5890 }
5891 SSID_rid.len = sizeof(SSID_rid);
5892 /* Write it to the card */
5893 disable_MAC(local, 1);
5894 writeSsidRid(local, &SSID_rid, 1);
5895 enable_MAC(local, &rsp, 1);
5896
5897 return 0;
5898 }
5899
5900 /*------------------------------------------------------------------*/
5901 /*
5902 * Wireless Handler : get ESSID
5903 */
5904 static int airo_get_essid(struct net_device *dev,
5905 struct iw_request_info *info,
5906 struct iw_point *dwrq,
5907 char *extra)
5908 {
5909 struct airo_info *local = dev->priv;
5910 StatusRid status_rid; /* Card status info */
5911
5912 readStatusRid(local, &status_rid, 1);
5913
5914 /* Note : if dwrq->flags != 0, we should
5915 * get the relevant SSID from the SSID list... */
5916
5917 /* Get the current SSID */
5918 memcpy(extra, status_rid.SSID, status_rid.SSIDlen);
5919 extra[status_rid.SSIDlen] = '\0';
5920 /* If none, we may want to get the one that was set */
5921
5922 /* Push it out ! */
5923 dwrq->length = status_rid.SSIDlen;
5924 dwrq->flags = 1; /* active */
5925
5926 return 0;
5927 }
5928
5929 /*------------------------------------------------------------------*/
5930 /*
5931 * Wireless Handler : set AP address
5932 */
5933 static int airo_set_wap(struct net_device *dev,
5934 struct iw_request_info *info,
5935 struct sockaddr *awrq,
5936 char *extra)
5937 {
5938 struct airo_info *local = dev->priv;
5939 Cmd cmd;
5940 Resp rsp;
5941 APListRid APList_rid;
5942 static const u8 any[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
5943 static const u8 off[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
5944
5945 if (awrq->sa_family != ARPHRD_ETHER)
5946 return -EINVAL;
5947 else if (!memcmp(any, awrq->sa_data, ETH_ALEN) ||
5948 !memcmp(off, awrq->sa_data, ETH_ALEN)) {
5949 memset(&cmd, 0, sizeof(cmd));
5950 cmd.cmd=CMD_LOSE_SYNC;
5951 if (down_interruptible(&local->sem))
5952 return -ERESTARTSYS;
5953 issuecommand(local, &cmd, &rsp);
5954 up(&local->sem);
5955 } else {
5956 memset(&APList_rid, 0, sizeof(APList_rid));
5957 APList_rid.len = sizeof(APList_rid);
5958 memcpy(APList_rid.ap[0], awrq->sa_data, ETH_ALEN);
5959 disable_MAC(local, 1);
5960 writeAPListRid(local, &APList_rid, 1);
5961 enable_MAC(local, &rsp, 1);
5962 }
5963 return 0;
5964 }
5965
5966 /*------------------------------------------------------------------*/
5967 /*
5968 * Wireless Handler : get AP address
5969 */
5970 static int airo_get_wap(struct net_device *dev,
5971 struct iw_request_info *info,
5972 struct sockaddr *awrq,
5973 char *extra)
5974 {
5975 struct airo_info *local = dev->priv;
5976 StatusRid status_rid; /* Card status info */
5977
5978 readStatusRid(local, &status_rid, 1);
5979
5980 /* Tentative. This seems to work, wow, I'm lucky !!! */
5981 memcpy(awrq->sa_data, status_rid.bssid[0], ETH_ALEN);
5982 awrq->sa_family = ARPHRD_ETHER;
5983
5984 return 0;
5985 }
5986
5987 /*------------------------------------------------------------------*/
5988 /*
5989 * Wireless Handler : set Nickname
5990 */
5991 static int airo_set_nick(struct net_device *dev,
5992 struct iw_request_info *info,
5993 struct iw_point *dwrq,
5994 char *extra)
5995 {
5996 struct airo_info *local = dev->priv;
5997
5998 /* Check the size of the string */
5999 if(dwrq->length > 16 + 1) {
6000 return -E2BIG;
6001 }
6002 readConfigRid(local, 1);
6003 memset(local->config.nodeName, 0, sizeof(local->config.nodeName));
6004 memcpy(local->config.nodeName, extra, dwrq->length);
6005 set_bit (FLAG_COMMIT, &local->flags);
6006
6007 return -EINPROGRESS; /* Call commit handler */
6008 }
6009
6010 /*------------------------------------------------------------------*/
6011 /*
6012 * Wireless Handler : get Nickname
6013 */
6014 static int airo_get_nick(struct net_device *dev,
6015 struct iw_request_info *info,
6016 struct iw_point *dwrq,
6017 char *extra)
6018 {
6019 struct airo_info *local = dev->priv;
6020
6021 readConfigRid(local, 1);
6022 strncpy(extra, local->config.nodeName, 16);
6023 extra[16] = '\0';
6024 dwrq->length = strlen(extra) + 1;
6025
6026 return 0;
6027 }
6028
6029 /*------------------------------------------------------------------*/
6030 /*
6031 * Wireless Handler : set Bit-Rate
6032 */
6033 static int airo_set_rate(struct net_device *dev,
6034 struct iw_request_info *info,
6035 struct iw_param *vwrq,
6036 char *extra)
6037 {
6038 struct airo_info *local = dev->priv;
6039 CapabilityRid cap_rid; /* Card capability info */
6040 u8 brate = 0;
6041 int i;
6042
6043 /* First : get a valid bit rate value */
6044 readCapabilityRid(local, &cap_rid, 1);
6045
6046 /* Which type of value ? */
6047 if((vwrq->value < 8) && (vwrq->value >= 0)) {
6048 /* Setting by rate index */
6049 /* Find value in the magic rate table */
6050 brate = cap_rid.supportedRates[vwrq->value];
6051 } else {
6052 /* Setting by frequency value */
6053 u8 normvalue = (u8) (vwrq->value/500000);
6054
6055 /* Check if rate is valid */
6056 for(i = 0 ; i < 8 ; i++) {
6057 if(normvalue == cap_rid.supportedRates[i]) {
6058 brate = normvalue;
6059 break;
6060 }
6061 }
6062 }
6063 /* -1 designed the max rate (mostly auto mode) */
6064 if(vwrq->value == -1) {
6065 /* Get the highest available rate */
6066 for(i = 0 ; i < 8 ; i++) {
6067 if(cap_rid.supportedRates[i] == 0)
6068 break;
6069 }
6070 if(i != 0)
6071 brate = cap_rid.supportedRates[i - 1];
6072 }
6073 /* Check that it is valid */
6074 if(brate == 0) {
6075 return -EINVAL;
6076 }
6077
6078 readConfigRid(local, 1);
6079 /* Now, check if we want a fixed or auto value */
6080 if(vwrq->fixed == 0) {
6081 /* Fill all the rates up to this max rate */
6082 memset(local->config.rates, 0, 8);
6083 for(i = 0 ; i < 8 ; i++) {
6084 local->config.rates[i] = cap_rid.supportedRates[i];
6085 if(local->config.rates[i] == brate)
6086 break;
6087 }
6088 } else {
6089 /* Fixed mode */
6090 /* One rate, fixed */
6091 memset(local->config.rates, 0, 8);
6092 local->config.rates[0] = brate;
6093 }
6094 set_bit (FLAG_COMMIT, &local->flags);
6095
6096 return -EINPROGRESS; /* Call commit handler */
6097 }
6098
6099 /*------------------------------------------------------------------*/
6100 /*
6101 * Wireless Handler : get Bit-Rate
6102 */
6103 static int airo_get_rate(struct net_device *dev,
6104 struct iw_request_info *info,
6105 struct iw_param *vwrq,
6106 char *extra)
6107 {
6108 struct airo_info *local = dev->priv;
6109 StatusRid status_rid; /* Card status info */
6110
6111 readStatusRid(local, &status_rid, 1);
6112
6113 vwrq->value = status_rid.currentXmitRate * 500000;
6114 /* If more than one rate, set auto */
6115 readConfigRid(local, 1);
6116 vwrq->fixed = (local->config.rates[1] == 0);
6117
6118 return 0;
6119 }
6120
6121 /*------------------------------------------------------------------*/
6122 /*
6123 * Wireless Handler : set RTS threshold
6124 */
6125 static int airo_set_rts(struct net_device *dev,
6126 struct iw_request_info *info,
6127 struct iw_param *vwrq,
6128 char *extra)
6129 {
6130 struct airo_info *local = dev->priv;
6131 int rthr = vwrq->value;
6132
6133 if(vwrq->disabled)
6134 rthr = AIRO_DEF_MTU;
6135 if((rthr < 0) || (rthr > AIRO_DEF_MTU)) {
6136 return -EINVAL;
6137 }
6138 readConfigRid(local, 1);
6139 local->config.rtsThres = rthr;
6140 set_bit (FLAG_COMMIT, &local->flags);
6141
6142 return -EINPROGRESS; /* Call commit handler */
6143 }
6144
6145 /*------------------------------------------------------------------*/
6146 /*
6147 * Wireless Handler : get RTS threshold
6148 */
6149 static int airo_get_rts(struct net_device *dev,
6150 struct iw_request_info *info,
6151 struct iw_param *vwrq,
6152 char *extra)
6153 {
6154 struct airo_info *local = dev->priv;
6155
6156 readConfigRid(local, 1);
6157 vwrq->value = local->config.rtsThres;
6158 vwrq->disabled = (vwrq->value >= AIRO_DEF_MTU);
6159 vwrq->fixed = 1;
6160
6161 return 0;
6162 }
6163
6164 /*------------------------------------------------------------------*/
6165 /*
6166 * Wireless Handler : set Fragmentation threshold
6167 */
6168 static int airo_set_frag(struct net_device *dev,
6169 struct iw_request_info *info,
6170 struct iw_param *vwrq,
6171 char *extra)
6172 {
6173 struct airo_info *local = dev->priv;
6174 int fthr = vwrq->value;
6175
6176 if(vwrq->disabled)
6177 fthr = AIRO_DEF_MTU;
6178 if((fthr < 256) || (fthr > AIRO_DEF_MTU)) {
6179 return -EINVAL;
6180 }
6181 fthr &= ~0x1; /* Get an even value - is it really needed ??? */
6182 readConfigRid(local, 1);
6183 local->config.fragThresh = (u16)fthr;
6184 set_bit (FLAG_COMMIT, &local->flags);
6185
6186 return -EINPROGRESS; /* Call commit handler */
6187 }
6188
6189 /*------------------------------------------------------------------*/
6190 /*
6191 * Wireless Handler : get Fragmentation threshold
6192 */
6193 static int airo_get_frag(struct net_device *dev,
6194 struct iw_request_info *info,
6195 struct iw_param *vwrq,
6196 char *extra)
6197 {
6198 struct airo_info *local = dev->priv;
6199
6200 readConfigRid(local, 1);
6201 vwrq->value = local->config.fragThresh;
6202 vwrq->disabled = (vwrq->value >= AIRO_DEF_MTU);
6203 vwrq->fixed = 1;
6204
6205 return 0;
6206 }
6207
6208 /*------------------------------------------------------------------*/
6209 /*
6210 * Wireless Handler : set Mode of Operation
6211 */
6212 static int airo_set_mode(struct net_device *dev,
6213 struct iw_request_info *info,
6214 __u32 *uwrq,
6215 char *extra)
6216 {
6217 struct airo_info *local = dev->priv;
6218 int reset = 0;
6219
6220 readConfigRid(local, 1);
6221 if ((local->config.rmode & 0xff) >= RXMODE_RFMON)
6222 reset = 1;
6223
6224 switch(*uwrq) {
6225 case IW_MODE_ADHOC:
6226 local->config.opmode &= 0xFF00;
6227 local->config.opmode |= MODE_STA_IBSS;
6228 local->config.rmode &= 0xfe00;
6229 local->config.scanMode = SCANMODE_ACTIVE;
6230 clear_bit (FLAG_802_11, &local->flags);
6231 break;
6232 case IW_MODE_INFRA:
6233 local->config.opmode &= 0xFF00;
6234 local->config.opmode |= MODE_STA_ESS;
6235 local->config.rmode &= 0xfe00;
6236 local->config.scanMode = SCANMODE_ACTIVE;
6237 clear_bit (FLAG_802_11, &local->flags);
6238 break;
6239 case IW_MODE_MASTER:
6240 local->config.opmode &= 0xFF00;
6241 local->config.opmode |= MODE_AP;
6242 local->config.rmode &= 0xfe00;
6243 local->config.scanMode = SCANMODE_ACTIVE;
6244 clear_bit (FLAG_802_11, &local->flags);
6245 break;
6246 case IW_MODE_REPEAT:
6247 local->config.opmode &= 0xFF00;
6248 local->config.opmode |= MODE_AP_RPTR;
6249 local->config.rmode &= 0xfe00;
6250 local->config.scanMode = SCANMODE_ACTIVE;
6251 clear_bit (FLAG_802_11, &local->flags);
6252 break;
6253 case IW_MODE_MONITOR:
6254 local->config.opmode &= 0xFF00;
6255 local->config.opmode |= MODE_STA_ESS;
6256 local->config.rmode &= 0xfe00;
6257 local->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
6258 local->config.scanMode = SCANMODE_PASSIVE;
6259 set_bit (FLAG_802_11, &local->flags);
6260 break;
6261 default:
6262 return -EINVAL;
6263 }
6264 if (reset)
6265 set_bit (FLAG_RESET, &local->flags);
6266 set_bit (FLAG_COMMIT, &local->flags);
6267
6268 return -EINPROGRESS; /* Call commit handler */
6269 }
6270
6271 /*------------------------------------------------------------------*/
6272 /*
6273 * Wireless Handler : get Mode of Operation
6274 */
6275 static int airo_get_mode(struct net_device *dev,
6276 struct iw_request_info *info,
6277 __u32 *uwrq,
6278 char *extra)
6279 {
6280 struct airo_info *local = dev->priv;
6281
6282 readConfigRid(local, 1);
6283 /* If not managed, assume it's ad-hoc */
6284 switch (local->config.opmode & 0xFF) {
6285 case MODE_STA_ESS:
6286 *uwrq = IW_MODE_INFRA;
6287 break;
6288 case MODE_AP:
6289 *uwrq = IW_MODE_MASTER;
6290 break;
6291 case MODE_AP_RPTR:
6292 *uwrq = IW_MODE_REPEAT;
6293 break;
6294 default:
6295 *uwrq = IW_MODE_ADHOC;
6296 }
6297
6298 return 0;
6299 }
6300
6301 /*------------------------------------------------------------------*/
6302 /*
6303 * Wireless Handler : set Encryption Key
6304 */
6305 static int airo_set_encode(struct net_device *dev,
6306 struct iw_request_info *info,
6307 struct iw_point *dwrq,
6308 char *extra)
6309 {
6310 struct airo_info *local = dev->priv;
6311 CapabilityRid cap_rid; /* Card capability info */
6312 int perm = ( dwrq->flags & IW_ENCODE_TEMP ? 0 : 1 );
6313 u16 currentAuthType = local->config.authType;
6314
6315 /* Is WEP supported ? */
6316 readCapabilityRid(local, &cap_rid, 1);
6317 /* Older firmware doesn't support this...
6318 if(!(cap_rid.softCap & 2)) {
6319 return -EOPNOTSUPP;
6320 } */
6321 readConfigRid(local, 1);
6322
6323 /* Basic checking: do we have a key to set ?
6324 * Note : with the new API, it's impossible to get a NULL pointer.
6325 * Therefore, we need to check a key size == 0 instead.
6326 * New version of iwconfig properly set the IW_ENCODE_NOKEY flag
6327 * when no key is present (only change flags), but older versions
6328 * don't do it. - Jean II */
6329 if (dwrq->length > 0) {
6330 wep_key_t key;
6331 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6332 int current_index = get_wep_key(local, 0xffff);
6333 /* Check the size of the key */
6334 if (dwrq->length > MAX_KEY_SIZE) {
6335 return -EINVAL;
6336 }
6337 /* Check the index (none -> use current) */
6338 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4:1)))
6339 index = current_index;
6340 /* Set the length */
6341 if (dwrq->length > MIN_KEY_SIZE)
6342 key.len = MAX_KEY_SIZE;
6343 else
6344 if (dwrq->length > 0)
6345 key.len = MIN_KEY_SIZE;
6346 else
6347 /* Disable the key */
6348 key.len = 0;
6349 /* Check if the key is not marked as invalid */
6350 if(!(dwrq->flags & IW_ENCODE_NOKEY)) {
6351 /* Cleanup */
6352 memset(key.key, 0, MAX_KEY_SIZE);
6353 /* Copy the key in the driver */
6354 memcpy(key.key, extra, dwrq->length);
6355 /* Send the key to the card */
6356 set_wep_key(local, index, key.key, key.len, perm, 1);
6357 }
6358 /* WE specify that if a valid key is set, encryption
6359 * should be enabled (user may turn it off later)
6360 * This is also how "iwconfig ethX key on" works */
6361 if((index == current_index) && (key.len > 0) &&
6362 (local->config.authType == AUTH_OPEN)) {
6363 local->config.authType = AUTH_ENCRYPT;
6364 }
6365 } else {
6366 /* Do we want to just set the transmit key index ? */
6367 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6368 if ((index >= 0) && (index < ((cap_rid.softCap & 0x80)?4:1))) {
6369 set_wep_key(local, index, NULL, 0, perm, 1);
6370 } else
6371 /* Don't complain if only change the mode */
6372 if(!dwrq->flags & IW_ENCODE_MODE) {
6373 return -EINVAL;
6374 }
6375 }
6376 /* Read the flags */
6377 if(dwrq->flags & IW_ENCODE_DISABLED)
6378 local->config.authType = AUTH_OPEN; // disable encryption
6379 if(dwrq->flags & IW_ENCODE_RESTRICTED)
6380 local->config.authType = AUTH_SHAREDKEY; // Only Both
6381 if(dwrq->flags & IW_ENCODE_OPEN)
6382 local->config.authType = AUTH_ENCRYPT; // Only Wep
6383 /* Commit the changes to flags if needed */
6384 if (local->config.authType != currentAuthType)
6385 set_bit (FLAG_COMMIT, &local->flags);
6386 return -EINPROGRESS; /* Call commit handler */
6387 }
6388
6389 /*------------------------------------------------------------------*/
6390 /*
6391 * Wireless Handler : get Encryption Key
6392 */
6393 static int airo_get_encode(struct net_device *dev,
6394 struct iw_request_info *info,
6395 struct iw_point *dwrq,
6396 char *extra)
6397 {
6398 struct airo_info *local = dev->priv;
6399 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6400 CapabilityRid cap_rid; /* Card capability info */
6401
6402 /* Is it supported ? */
6403 readCapabilityRid(local, &cap_rid, 1);
6404 if(!(cap_rid.softCap & 2)) {
6405 return -EOPNOTSUPP;
6406 }
6407 readConfigRid(local, 1);
6408 /* Check encryption mode */
6409 switch(local->config.authType) {
6410 case AUTH_ENCRYPT:
6411 dwrq->flags = IW_ENCODE_OPEN;
6412 break;
6413 case AUTH_SHAREDKEY:
6414 dwrq->flags = IW_ENCODE_RESTRICTED;
6415 break;
6416 default:
6417 case AUTH_OPEN:
6418 dwrq->flags = IW_ENCODE_DISABLED;
6419 break;
6420 }
6421 /* We can't return the key, so set the proper flag and return zero */
6422 dwrq->flags |= IW_ENCODE_NOKEY;
6423 memset(extra, 0, 16);
6424
6425 /* Which key do we want ? -1 -> tx index */
6426 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4 : 1)))
6427 index = get_wep_key(local, 0xffff);
6428 dwrq->flags |= index + 1;
6429 /* Copy the key to the user buffer */
6430 dwrq->length = get_wep_key(local, index);
6431 if (dwrq->length > 16) {
6432 dwrq->length=0;
6433 }
6434 return 0;
6435 }
6436
6437 /*------------------------------------------------------------------*/
6438 /*
6439 * Wireless Handler : set extended Encryption parameters
6440 */
6441 static int airo_set_encodeext(struct net_device *dev,
6442 struct iw_request_info *info,
6443 union iwreq_data *wrqu,
6444 char *extra)
6445 {
6446 struct airo_info *local = dev->priv;
6447 struct iw_point *encoding = &wrqu->encoding;
6448 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6449 CapabilityRid cap_rid; /* Card capability info */
6450 int perm = ( encoding->flags & IW_ENCODE_TEMP ? 0 : 1 );
6451 u16 currentAuthType = local->config.authType;
6452 int idx, key_len, alg = ext->alg, set_key = 1;
6453 wep_key_t key;
6454
6455 /* Is WEP supported ? */
6456 readCapabilityRid(local, &cap_rid, 1);
6457 /* Older firmware doesn't support this...
6458 if(!(cap_rid.softCap & 2)) {
6459 return -EOPNOTSUPP;
6460 } */
6461 readConfigRid(local, 1);
6462
6463 /* Determine and validate the key index */
6464 idx = encoding->flags & IW_ENCODE_INDEX;
6465 if (idx) {
6466 if (idx < 1 || idx > ((cap_rid.softCap & 0x80) ? 4:1))
6467 return -EINVAL;
6468 idx--;
6469 } else
6470 idx = get_wep_key(local, 0xffff);
6471
6472 if (encoding->flags & IW_ENCODE_DISABLED)
6473 alg = IW_ENCODE_ALG_NONE;
6474
6475 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
6476 /* Only set transmit key index here, actual
6477 * key is set below if needed.
6478 */
6479 set_wep_key(local, idx, NULL, 0, perm, 1);
6480 set_key = ext->key_len > 0 ? 1 : 0;
6481 }
6482
6483 if (set_key) {
6484 /* Set the requested key first */
6485 memset(key.key, 0, MAX_KEY_SIZE);
6486 switch (alg) {
6487 case IW_ENCODE_ALG_NONE:
6488 key.len = 0;
6489 break;
6490 case IW_ENCODE_ALG_WEP:
6491 if (ext->key_len > MIN_KEY_SIZE) {
6492 key.len = MAX_KEY_SIZE;
6493 } else if (ext->key_len > 0) {
6494 key.len = MIN_KEY_SIZE;
6495 } else {
6496 return -EINVAL;
6497 }
6498 key_len = min (ext->key_len, key.len);
6499 memcpy(key.key, ext->key, key_len);
6500 break;
6501 default:
6502 return -EINVAL;
6503 }
6504 /* Send the key to the card */
6505 set_wep_key(local, idx, key.key, key.len, perm, 1);
6506 }
6507
6508 /* Read the flags */
6509 if(encoding->flags & IW_ENCODE_DISABLED)
6510 local->config.authType = AUTH_OPEN; // disable encryption
6511 if(encoding->flags & IW_ENCODE_RESTRICTED)
6512 local->config.authType = AUTH_SHAREDKEY; // Only Both
6513 if(encoding->flags & IW_ENCODE_OPEN)
6514 local->config.authType = AUTH_ENCRYPT; // Only Wep
6515 /* Commit the changes to flags if needed */
6516 if (local->config.authType != currentAuthType)
6517 set_bit (FLAG_COMMIT, &local->flags);
6518
6519 return -EINPROGRESS;
6520 }
6521
6522
6523 /*------------------------------------------------------------------*/
6524 /*
6525 * Wireless Handler : get extended Encryption parameters
6526 */
6527 static int airo_get_encodeext(struct net_device *dev,
6528 struct iw_request_info *info,
6529 union iwreq_data *wrqu,
6530 char *extra)
6531 {
6532 struct airo_info *local = dev->priv;
6533 struct iw_point *encoding = &wrqu->encoding;
6534 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6535 CapabilityRid cap_rid; /* Card capability info */
6536 int idx, max_key_len;
6537
6538 /* Is it supported ? */
6539 readCapabilityRid(local, &cap_rid, 1);
6540 if(!(cap_rid.softCap & 2)) {
6541 return -EOPNOTSUPP;
6542 }
6543 readConfigRid(local, 1);
6544
6545 max_key_len = encoding->length - sizeof(*ext);
6546 if (max_key_len < 0)
6547 return -EINVAL;
6548
6549 idx = encoding->flags & IW_ENCODE_INDEX;
6550 if (idx) {
6551 if (idx < 1 || idx > ((cap_rid.softCap & 0x80) ? 4:1))
6552 return -EINVAL;
6553 idx--;
6554 } else
6555 idx = get_wep_key(local, 0xffff);
6556
6557 encoding->flags = idx + 1;
6558 memset(ext, 0, sizeof(*ext));
6559
6560 /* Check encryption mode */
6561 switch(local->config.authType) {
6562 case AUTH_ENCRYPT:
6563 encoding->flags = IW_ENCODE_ALG_WEP | IW_ENCODE_ENABLED;
6564 break;
6565 case AUTH_SHAREDKEY:
6566 encoding->flags = IW_ENCODE_ALG_WEP | IW_ENCODE_ENABLED;
6567 break;
6568 default:
6569 case AUTH_OPEN:
6570 encoding->flags = IW_ENCODE_ALG_NONE | IW_ENCODE_DISABLED;
6571 break;
6572 }
6573 /* We can't return the key, so set the proper flag and return zero */
6574 encoding->flags |= IW_ENCODE_NOKEY;
6575 memset(extra, 0, 16);
6576
6577 /* Copy the key to the user buffer */
6578 ext->key_len = get_wep_key(local, idx);
6579 if (ext->key_len > 16) {
6580 ext->key_len=0;
6581 }
6582
6583 return 0;
6584 }
6585
6586
6587 /*------------------------------------------------------------------*/
6588 /*
6589 * Wireless Handler : set extended authentication parameters
6590 */
6591 static int airo_set_auth(struct net_device *dev,
6592 struct iw_request_info *info,
6593 union iwreq_data *wrqu, char *extra)
6594 {
6595 struct airo_info *local = dev->priv;
6596 struct iw_param *param = &wrqu->param;
6597 u16 currentAuthType = local->config.authType;
6598
6599 switch (param->flags & IW_AUTH_INDEX) {
6600 case IW_AUTH_WPA_VERSION:
6601 case IW_AUTH_CIPHER_PAIRWISE:
6602 case IW_AUTH_CIPHER_GROUP:
6603 case IW_AUTH_KEY_MGMT:
6604 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6605 case IW_AUTH_PRIVACY_INVOKED:
6606 /*
6607 * airo does not use these parameters
6608 */
6609 break;
6610
6611 case IW_AUTH_DROP_UNENCRYPTED:
6612 if (param->value) {
6613 /* Only change auth type if unencrypted */
6614 if (currentAuthType == AUTH_OPEN)
6615 local->config.authType = AUTH_ENCRYPT;
6616 } else {
6617 local->config.authType = AUTH_OPEN;
6618 }
6619
6620 /* Commit the changes to flags if needed */
6621 if (local->config.authType != currentAuthType)
6622 set_bit (FLAG_COMMIT, &local->flags);
6623 break;
6624
6625 case IW_AUTH_80211_AUTH_ALG: {
6626 /* FIXME: What about AUTH_OPEN? This API seems to
6627 * disallow setting our auth to AUTH_OPEN.
6628 */
6629 if (param->value & IW_AUTH_ALG_SHARED_KEY) {
6630 local->config.authType = AUTH_SHAREDKEY;
6631 } else if (param->value & IW_AUTH_ALG_OPEN_SYSTEM) {
6632 local->config.authType = AUTH_ENCRYPT;
6633 } else
6634 return -EINVAL;
6635 break;
6636
6637 /* Commit the changes to flags if needed */
6638 if (local->config.authType != currentAuthType)
6639 set_bit (FLAG_COMMIT, &local->flags);
6640 }
6641
6642 case IW_AUTH_WPA_ENABLED:
6643 /* Silently accept disable of WPA */
6644 if (param->value > 0)
6645 return -EOPNOTSUPP;
6646 break;
6647
6648 default:
6649 return -EOPNOTSUPP;
6650 }
6651 return -EINPROGRESS;
6652 }
6653
6654
6655 /*------------------------------------------------------------------*/
6656 /*
6657 * Wireless Handler : get extended authentication parameters
6658 */
6659 static int airo_get_auth(struct net_device *dev,
6660 struct iw_request_info *info,
6661 union iwreq_data *wrqu, char *extra)
6662 {
6663 struct airo_info *local = dev->priv;
6664 struct iw_param *param = &wrqu->param;
6665 u16 currentAuthType = local->config.authType;
6666
6667 switch (param->flags & IW_AUTH_INDEX) {
6668 case IW_AUTH_DROP_UNENCRYPTED:
6669 switch (currentAuthType) {
6670 case AUTH_SHAREDKEY:
6671 case AUTH_ENCRYPT:
6672 param->value = 1;
6673 break;
6674 default:
6675 param->value = 0;
6676 break;
6677 }
6678 break;
6679
6680 case IW_AUTH_80211_AUTH_ALG:
6681 switch (currentAuthType) {
6682 case AUTH_SHAREDKEY:
6683 param->value = IW_AUTH_ALG_SHARED_KEY;
6684 break;
6685 case AUTH_ENCRYPT:
6686 default:
6687 param->value = IW_AUTH_ALG_OPEN_SYSTEM;
6688 break;
6689 }
6690 break;
6691
6692 case IW_AUTH_WPA_ENABLED:
6693 param->value = 0;
6694 break;
6695
6696 default:
6697 return -EOPNOTSUPP;
6698 }
6699 return 0;
6700 }
6701
6702
6703 /*------------------------------------------------------------------*/
6704 /*
6705 * Wireless Handler : set Tx-Power
6706 */
6707 static int airo_set_txpow(struct net_device *dev,
6708 struct iw_request_info *info,
6709 struct iw_param *vwrq,
6710 char *extra)
6711 {
6712 struct airo_info *local = dev->priv;
6713 CapabilityRid cap_rid; /* Card capability info */
6714 int i;
6715 int rc = -EINVAL;
6716
6717 readCapabilityRid(local, &cap_rid, 1);
6718
6719 if (vwrq->disabled) {
6720 set_bit (FLAG_RADIO_OFF, &local->flags);
6721 set_bit (FLAG_COMMIT, &local->flags);
6722 return -EINPROGRESS; /* Call commit handler */
6723 }
6724 if (vwrq->flags != IW_TXPOW_MWATT) {
6725 return -EINVAL;
6726 }
6727 clear_bit (FLAG_RADIO_OFF, &local->flags);
6728 for (i = 0; cap_rid.txPowerLevels[i] && (i < 8); i++)
6729 if ((vwrq->value==cap_rid.txPowerLevels[i])) {
6730 readConfigRid(local, 1);
6731 local->config.txPower = vwrq->value;
6732 set_bit (FLAG_COMMIT, &local->flags);
6733 rc = -EINPROGRESS; /* Call commit handler */
6734 break;
6735 }
6736 return rc;
6737 }
6738
6739 /*------------------------------------------------------------------*/
6740 /*
6741 * Wireless Handler : get Tx-Power
6742 */
6743 static int airo_get_txpow(struct net_device *dev,
6744 struct iw_request_info *info,
6745 struct iw_param *vwrq,
6746 char *extra)
6747 {
6748 struct airo_info *local = dev->priv;
6749
6750 readConfigRid(local, 1);
6751 vwrq->value = local->config.txPower;
6752 vwrq->fixed = 1; /* No power control */
6753 vwrq->disabled = test_bit(FLAG_RADIO_OFF, &local->flags);
6754 vwrq->flags = IW_TXPOW_MWATT;
6755
6756 return 0;
6757 }
6758
6759 /*------------------------------------------------------------------*/
6760 /*
6761 * Wireless Handler : set Retry limits
6762 */
6763 static int airo_set_retry(struct net_device *dev,
6764 struct iw_request_info *info,
6765 struct iw_param *vwrq,
6766 char *extra)
6767 {
6768 struct airo_info *local = dev->priv;
6769 int rc = -EINVAL;
6770
6771 if(vwrq->disabled) {
6772 return -EINVAL;
6773 }
6774 readConfigRid(local, 1);
6775 if(vwrq->flags & IW_RETRY_LIMIT) {
6776 if(vwrq->flags & IW_RETRY_MAX)
6777 local->config.longRetryLimit = vwrq->value;
6778 else if (vwrq->flags & IW_RETRY_MIN)
6779 local->config.shortRetryLimit = vwrq->value;
6780 else {
6781 /* No modifier : set both */
6782 local->config.longRetryLimit = vwrq->value;
6783 local->config.shortRetryLimit = vwrq->value;
6784 }
6785 set_bit (FLAG_COMMIT, &local->flags);
6786 rc = -EINPROGRESS; /* Call commit handler */
6787 }
6788 if(vwrq->flags & IW_RETRY_LIFETIME) {
6789 local->config.txLifetime = vwrq->value / 1024;
6790 set_bit (FLAG_COMMIT, &local->flags);
6791 rc = -EINPROGRESS; /* Call commit handler */
6792 }
6793 return rc;
6794 }
6795
6796 /*------------------------------------------------------------------*/
6797 /*
6798 * Wireless Handler : get Retry limits
6799 */
6800 static int airo_get_retry(struct net_device *dev,
6801 struct iw_request_info *info,
6802 struct iw_param *vwrq,
6803 char *extra)
6804 {
6805 struct airo_info *local = dev->priv;
6806
6807 vwrq->disabled = 0; /* Can't be disabled */
6808
6809 readConfigRid(local, 1);
6810 /* Note : by default, display the min retry number */
6811 if((vwrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
6812 vwrq->flags = IW_RETRY_LIFETIME;
6813 vwrq->value = (int)local->config.txLifetime * 1024;
6814 } else if((vwrq->flags & IW_RETRY_MAX)) {
6815 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
6816 vwrq->value = (int)local->config.longRetryLimit;
6817 } else {
6818 vwrq->flags = IW_RETRY_LIMIT;
6819 vwrq->value = (int)local->config.shortRetryLimit;
6820 if((int)local->config.shortRetryLimit != (int)local->config.longRetryLimit)
6821 vwrq->flags |= IW_RETRY_MIN;
6822 }
6823
6824 return 0;
6825 }
6826
6827 /*------------------------------------------------------------------*/
6828 /*
6829 * Wireless Handler : get range info
6830 */
6831 static int airo_get_range(struct net_device *dev,
6832 struct iw_request_info *info,
6833 struct iw_point *dwrq,
6834 char *extra)
6835 {
6836 struct airo_info *local = dev->priv;
6837 struct iw_range *range = (struct iw_range *) extra;
6838 CapabilityRid cap_rid; /* Card capability info */
6839 int i;
6840 int k;
6841
6842 readCapabilityRid(local, &cap_rid, 1);
6843
6844 dwrq->length = sizeof(struct iw_range);
6845 memset(range, 0, sizeof(*range));
6846 range->min_nwid = 0x0000;
6847 range->max_nwid = 0x0000;
6848 range->num_channels = 14;
6849 /* Should be based on cap_rid.country to give only
6850 * what the current card support */
6851 k = 0;
6852 for(i = 0; i < 14; i++) {
6853 range->freq[k].i = i + 1; /* List index */
6854 range->freq[k].m = frequency_list[i] * 100000;
6855 range->freq[k++].e = 1; /* Values in table in MHz -> * 10^5 * 10 */
6856 }
6857 range->num_frequency = k;
6858
6859 range->sensitivity = 65535;
6860
6861 /* Hum... Should put the right values there */
6862 if (local->rssi)
6863 range->max_qual.qual = 100; /* % */
6864 else
6865 range->max_qual.qual = airo_get_max_quality(&cap_rid);
6866 range->max_qual.level = 0x100 - 120; /* -120 dBm */
6867 range->max_qual.noise = 0x100 - 120; /* -120 dBm */
6868
6869 /* Experimental measurements - boundary 11/5.5 Mb/s */
6870 /* Note : with or without the (local->rssi), results
6871 * are somewhat different. - Jean II */
6872 if (local->rssi) {
6873 range->avg_qual.qual = 50; /* % */
6874 range->avg_qual.level = 0x100 - 70; /* -70 dBm */
6875 } else {
6876 range->avg_qual.qual = airo_get_avg_quality(&cap_rid);
6877 range->avg_qual.level = 0x100 - 80; /* -80 dBm */
6878 }
6879 range->avg_qual.noise = 0x100 - 85; /* -85 dBm */
6880
6881 for(i = 0 ; i < 8 ; i++) {
6882 range->bitrate[i] = cap_rid.supportedRates[i] * 500000;
6883 if(range->bitrate[i] == 0)
6884 break;
6885 }
6886 range->num_bitrates = i;
6887
6888 /* Set an indication of the max TCP throughput
6889 * in bit/s that we can expect using this interface.
6890 * May be use for QoS stuff... Jean II */
6891 if(i > 2)
6892 range->throughput = 5000 * 1000;
6893 else
6894 range->throughput = 1500 * 1000;
6895
6896 range->min_rts = 0;
6897 range->max_rts = AIRO_DEF_MTU;
6898 range->min_frag = 256;
6899 range->max_frag = AIRO_DEF_MTU;
6900
6901 if(cap_rid.softCap & 2) {
6902 // WEP: RC4 40 bits
6903 range->encoding_size[0] = 5;
6904 // RC4 ~128 bits
6905 if (cap_rid.softCap & 0x100) {
6906 range->encoding_size[1] = 13;
6907 range->num_encoding_sizes = 2;
6908 } else
6909 range->num_encoding_sizes = 1;
6910 range->max_encoding_tokens = (cap_rid.softCap & 0x80) ? 4 : 1;
6911 } else {
6912 range->num_encoding_sizes = 0;
6913 range->max_encoding_tokens = 0;
6914 }
6915 range->min_pmp = 0;
6916 range->max_pmp = 5000000; /* 5 secs */
6917 range->min_pmt = 0;
6918 range->max_pmt = 65535 * 1024; /* ??? */
6919 range->pmp_flags = IW_POWER_PERIOD;
6920 range->pmt_flags = IW_POWER_TIMEOUT;
6921 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
6922
6923 /* Transmit Power - values are in mW */
6924 for(i = 0 ; i < 8 ; i++) {
6925 range->txpower[i] = cap_rid.txPowerLevels[i];
6926 if(range->txpower[i] == 0)
6927 break;
6928 }
6929 range->num_txpower = i;
6930 range->txpower_capa = IW_TXPOW_MWATT;
6931 range->we_version_source = 19;
6932 range->we_version_compiled = WIRELESS_EXT;
6933 range->retry_capa = IW_RETRY_LIMIT | IW_RETRY_LIFETIME;
6934 range->retry_flags = IW_RETRY_LIMIT;
6935 range->r_time_flags = IW_RETRY_LIFETIME;
6936 range->min_retry = 1;
6937 range->max_retry = 65535;
6938 range->min_r_time = 1024;
6939 range->max_r_time = 65535 * 1024;
6940
6941 /* Event capability (kernel + driver) */
6942 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
6943 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
6944 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
6945 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
6946 range->event_capa[1] = IW_EVENT_CAPA_K_1;
6947 range->event_capa[4] = IW_EVENT_CAPA_MASK(IWEVTXDROP);
6948 return 0;
6949 }
6950
6951 /*------------------------------------------------------------------*/
6952 /*
6953 * Wireless Handler : set Power Management
6954 */
6955 static int airo_set_power(struct net_device *dev,
6956 struct iw_request_info *info,
6957 struct iw_param *vwrq,
6958 char *extra)
6959 {
6960 struct airo_info *local = dev->priv;
6961
6962 readConfigRid(local, 1);
6963 if (vwrq->disabled) {
6964 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6965 return -EINVAL;
6966 }
6967 local->config.powerSaveMode = POWERSAVE_CAM;
6968 local->config.rmode &= 0xFF00;
6969 local->config.rmode |= RXMODE_BC_MC_ADDR;
6970 set_bit (FLAG_COMMIT, &local->flags);
6971 return -EINPROGRESS; /* Call commit handler */
6972 }
6973 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
6974 local->config.fastListenDelay = (vwrq->value + 500) / 1024;
6975 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6976 set_bit (FLAG_COMMIT, &local->flags);
6977 } else if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
6978 local->config.fastListenInterval = local->config.listenInterval = (vwrq->value + 500) / 1024;
6979 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6980 set_bit (FLAG_COMMIT, &local->flags);
6981 }
6982 switch (vwrq->flags & IW_POWER_MODE) {
6983 case IW_POWER_UNICAST_R:
6984 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6985 return -EINVAL;
6986 }
6987 local->config.rmode &= 0xFF00;
6988 local->config.rmode |= RXMODE_ADDR;
6989 set_bit (FLAG_COMMIT, &local->flags);
6990 break;
6991 case IW_POWER_ALL_R:
6992 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6993 return -EINVAL;
6994 }
6995 local->config.rmode &= 0xFF00;
6996 local->config.rmode |= RXMODE_BC_MC_ADDR;
6997 set_bit (FLAG_COMMIT, &local->flags);
6998 case IW_POWER_ON:
6999 break;
7000 default:
7001 return -EINVAL;
7002 }
7003 // Note : we may want to factor local->need_commit here
7004 // Note2 : may also want to factor RXMODE_RFMON test
7005 return -EINPROGRESS; /* Call commit handler */
7006 }
7007
7008 /*------------------------------------------------------------------*/
7009 /*
7010 * Wireless Handler : get Power Management
7011 */
7012 static int airo_get_power(struct net_device *dev,
7013 struct iw_request_info *info,
7014 struct iw_param *vwrq,
7015 char *extra)
7016 {
7017 struct airo_info *local = dev->priv;
7018 int mode;
7019
7020 readConfigRid(local, 1);
7021 mode = local->config.powerSaveMode;
7022 if ((vwrq->disabled = (mode == POWERSAVE_CAM)))
7023 return 0;
7024 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
7025 vwrq->value = (int)local->config.fastListenDelay * 1024;
7026 vwrq->flags = IW_POWER_TIMEOUT;
7027 } else {
7028 vwrq->value = (int)local->config.fastListenInterval * 1024;
7029 vwrq->flags = IW_POWER_PERIOD;
7030 }
7031 if ((local->config.rmode & 0xFF) == RXMODE_ADDR)
7032 vwrq->flags |= IW_POWER_UNICAST_R;
7033 else
7034 vwrq->flags |= IW_POWER_ALL_R;
7035
7036 return 0;
7037 }
7038
7039 /*------------------------------------------------------------------*/
7040 /*
7041 * Wireless Handler : set Sensitivity
7042 */
7043 static int airo_set_sens(struct net_device *dev,
7044 struct iw_request_info *info,
7045 struct iw_param *vwrq,
7046 char *extra)
7047 {
7048 struct airo_info *local = dev->priv;
7049
7050 readConfigRid(local, 1);
7051 local->config.rssiThreshold = vwrq->disabled ? RSSI_DEFAULT : vwrq->value;
7052 set_bit (FLAG_COMMIT, &local->flags);
7053
7054 return -EINPROGRESS; /* Call commit handler */
7055 }
7056
7057 /*------------------------------------------------------------------*/
7058 /*
7059 * Wireless Handler : get Sensitivity
7060 */
7061 static int airo_get_sens(struct net_device *dev,
7062 struct iw_request_info *info,
7063 struct iw_param *vwrq,
7064 char *extra)
7065 {
7066 struct airo_info *local = dev->priv;
7067
7068 readConfigRid(local, 1);
7069 vwrq->value = local->config.rssiThreshold;
7070 vwrq->disabled = (vwrq->value == 0);
7071 vwrq->fixed = 1;
7072
7073 return 0;
7074 }
7075
7076 /*------------------------------------------------------------------*/
7077 /*
7078 * Wireless Handler : get AP List
7079 * Note : this is deprecated in favor of IWSCAN
7080 */
7081 static int airo_get_aplist(struct net_device *dev,
7082 struct iw_request_info *info,
7083 struct iw_point *dwrq,
7084 char *extra)
7085 {
7086 struct airo_info *local = dev->priv;
7087 struct sockaddr *address = (struct sockaddr *) extra;
7088 struct iw_quality qual[IW_MAX_AP];
7089 BSSListRid BSSList;
7090 int i;
7091 int loseSync = capable(CAP_NET_ADMIN) ? 1: -1;
7092
7093 for (i = 0; i < IW_MAX_AP; i++) {
7094 if (readBSSListRid(local, loseSync, &BSSList))
7095 break;
7096 loseSync = 0;
7097 memcpy(address[i].sa_data, BSSList.bssid, ETH_ALEN);
7098 address[i].sa_family = ARPHRD_ETHER;
7099 if (local->rssi) {
7100 qual[i].level = 0x100 - BSSList.dBm;
7101 qual[i].qual = airo_dbm_to_pct( local->rssi, BSSList.dBm );
7102 qual[i].updated = IW_QUAL_QUAL_UPDATED
7103 | IW_QUAL_LEVEL_UPDATED
7104 | IW_QUAL_DBM;
7105 } else {
7106 qual[i].level = (BSSList.dBm + 321) / 2;
7107 qual[i].qual = 0;
7108 qual[i].updated = IW_QUAL_QUAL_INVALID
7109 | IW_QUAL_LEVEL_UPDATED
7110 | IW_QUAL_DBM;
7111 }
7112 qual[i].noise = local->wstats.qual.noise;
7113 if (BSSList.index == 0xffff)
7114 break;
7115 }
7116 if (!i) {
7117 StatusRid status_rid; /* Card status info */
7118 readStatusRid(local, &status_rid, 1);
7119 for (i = 0;
7120 i < min(IW_MAX_AP, 4) &&
7121 (status_rid.bssid[i][0]
7122 & status_rid.bssid[i][1]
7123 & status_rid.bssid[i][2]
7124 & status_rid.bssid[i][3]
7125 & status_rid.bssid[i][4]
7126 & status_rid.bssid[i][5])!=0xff &&
7127 (status_rid.bssid[i][0]
7128 | status_rid.bssid[i][1]
7129 | status_rid.bssid[i][2]
7130 | status_rid.bssid[i][3]
7131 | status_rid.bssid[i][4]
7132 | status_rid.bssid[i][5]);
7133 i++) {
7134 memcpy(address[i].sa_data,
7135 status_rid.bssid[i], ETH_ALEN);
7136 address[i].sa_family = ARPHRD_ETHER;
7137 }
7138 } else {
7139 dwrq->flags = 1; /* Should be define'd */
7140 memcpy(extra + sizeof(struct sockaddr)*i,
7141 &qual, sizeof(struct iw_quality)*i);
7142 }
7143 dwrq->length = i;
7144
7145 return 0;
7146 }
7147
7148 /*------------------------------------------------------------------*/
7149 /*
7150 * Wireless Handler : Initiate Scan
7151 */
7152 static int airo_set_scan(struct net_device *dev,
7153 struct iw_request_info *info,
7154 struct iw_param *vwrq,
7155 char *extra)
7156 {
7157 struct airo_info *ai = dev->priv;
7158 Cmd cmd;
7159 Resp rsp;
7160 int wake = 0;
7161
7162 /* Note : you may have realised that, as this is a SET operation,
7163 * this is privileged and therefore a normal user can't
7164 * perform scanning.
7165 * This is not an error, while the device perform scanning,
7166 * traffic doesn't flow, so it's a perfect DoS...
7167 * Jean II */
7168 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
7169
7170 if (down_interruptible(&ai->sem))
7171 return -ERESTARTSYS;
7172
7173 /* If there's already a scan in progress, don't
7174 * trigger another one. */
7175 if (ai->scan_timeout > 0)
7176 goto out;
7177
7178 /* Initiate a scan command */
7179 ai->scan_timeout = RUN_AT(3*HZ);
7180 memset(&cmd, 0, sizeof(cmd));
7181 cmd.cmd=CMD_LISTBSS;
7182 issuecommand(ai, &cmd, &rsp);
7183 wake = 1;
7184
7185 out:
7186 up(&ai->sem);
7187 if (wake)
7188 wake_up_interruptible(&ai->thr_wait);
7189 return 0;
7190 }
7191
7192 /*------------------------------------------------------------------*/
7193 /*
7194 * Translate scan data returned from the card to a card independent
7195 * format that the Wireless Tools will understand - Jean II
7196 */
7197 static inline char *airo_translate_scan(struct net_device *dev,
7198 char *current_ev,
7199 char *end_buf,
7200 BSSListRid *bss)
7201 {
7202 struct airo_info *ai = dev->priv;
7203 struct iw_event iwe; /* Temporary buffer */
7204 u16 capabilities;
7205 char * current_val; /* For rates */
7206 int i;
7207 char * buf;
7208
7209 /* First entry *MUST* be the AP MAC address */
7210 iwe.cmd = SIOCGIWAP;
7211 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
7212 memcpy(iwe.u.ap_addr.sa_data, bss->bssid, ETH_ALEN);
7213 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_ADDR_LEN);
7214
7215 /* Other entries will be displayed in the order we give them */
7216
7217 /* Add the ESSID */
7218 iwe.u.data.length = bss->ssidLen;
7219 if(iwe.u.data.length > 32)
7220 iwe.u.data.length = 32;
7221 iwe.cmd = SIOCGIWESSID;
7222 iwe.u.data.flags = 1;
7223 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, bss->ssid);
7224
7225 /* Add mode */
7226 iwe.cmd = SIOCGIWMODE;
7227 capabilities = le16_to_cpu(bss->cap);
7228 if(capabilities & (CAP_ESS | CAP_IBSS)) {
7229 if(capabilities & CAP_ESS)
7230 iwe.u.mode = IW_MODE_MASTER;
7231 else
7232 iwe.u.mode = IW_MODE_ADHOC;
7233 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_UINT_LEN);
7234 }
7235
7236 /* Add frequency */
7237 iwe.cmd = SIOCGIWFREQ;
7238 iwe.u.freq.m = le16_to_cpu(bss->dsChannel);
7239 /* iwe.u.freq.m containt the channel (starting 1), our
7240 * frequency_list array start at index 0...
7241 */
7242 iwe.u.freq.m = frequency_list[iwe.u.freq.m - 1] * 100000;
7243 iwe.u.freq.e = 1;
7244 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_FREQ_LEN);
7245
7246 /* Add quality statistics */
7247 iwe.cmd = IWEVQUAL;
7248 if (ai->rssi) {
7249 iwe.u.qual.level = 0x100 - bss->dBm;
7250 iwe.u.qual.qual = airo_dbm_to_pct( ai->rssi, bss->dBm );
7251 iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED
7252 | IW_QUAL_LEVEL_UPDATED
7253 | IW_QUAL_DBM;
7254 } else {
7255 iwe.u.qual.level = (bss->dBm + 321) / 2;
7256 iwe.u.qual.qual = 0;
7257 iwe.u.qual.updated = IW_QUAL_QUAL_INVALID
7258 | IW_QUAL_LEVEL_UPDATED
7259 | IW_QUAL_DBM;
7260 }
7261 iwe.u.qual.noise = ai->wstats.qual.noise;
7262 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
7263
7264 /* Add encryption capability */
7265 iwe.cmd = SIOCGIWENCODE;
7266 if(capabilities & CAP_PRIVACY)
7267 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
7268 else
7269 iwe.u.data.flags = IW_ENCODE_DISABLED;
7270 iwe.u.data.length = 0;
7271 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, bss->ssid);
7272
7273 /* Rate : stuffing multiple values in a single event require a bit
7274 * more of magic - Jean II */
7275 current_val = current_ev + IW_EV_LCP_LEN;
7276
7277 iwe.cmd = SIOCGIWRATE;
7278 /* Those two flags are ignored... */
7279 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
7280 /* Max 8 values */
7281 for(i = 0 ; i < 8 ; i++) {
7282 /* NULL terminated */
7283 if(bss->rates[i] == 0)
7284 break;
7285 /* Bit rate given in 500 kb/s units (+ 0x80) */
7286 iwe.u.bitrate.value = ((bss->rates[i] & 0x7f) * 500000);
7287 /* Add new value to event */
7288 current_val = iwe_stream_add_value(current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
7289 }
7290 /* Check if we added any event */
7291 if((current_val - current_ev) > IW_EV_LCP_LEN)
7292 current_ev = current_val;
7293
7294 /* Beacon interval */
7295 buf = kmalloc(30, GFP_KERNEL);
7296 if (buf) {
7297 iwe.cmd = IWEVCUSTOM;
7298 sprintf(buf, "bcn_int=%d", bss->beaconInterval);
7299 iwe.u.data.length = strlen(buf);
7300 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, buf);
7301 kfree(buf);
7302 }
7303
7304 /* Put WPA/RSN Information Elements into the event stream */
7305 if (test_bit(FLAG_WPA_CAPABLE, &ai->flags)) {
7306 unsigned int num_null_ies = 0;
7307 u16 length = sizeof (bss->extra.iep);
7308 struct ieee80211_info_element *info_element =
7309 (struct ieee80211_info_element *) &bss->extra.iep;
7310
7311 while ((length >= sizeof(*info_element)) && (num_null_ies < 2)) {
7312 if (sizeof(*info_element) + info_element->len > length) {
7313 /* Invalid element, don't continue parsing IE */
7314 break;
7315 }
7316
7317 switch (info_element->id) {
7318 case MFIE_TYPE_SSID:
7319 /* Two zero-length SSID elements
7320 * mean we're done parsing elements */
7321 if (!info_element->len)
7322 num_null_ies++;
7323 break;
7324
7325 case MFIE_TYPE_GENERIC:
7326 if (info_element->len >= 4 &&
7327 info_element->data[0] == 0x00 &&
7328 info_element->data[1] == 0x50 &&
7329 info_element->data[2] == 0xf2 &&
7330 info_element->data[3] == 0x01) {
7331 iwe.cmd = IWEVGENIE;
7332 iwe.u.data.length = min(info_element->len + 2,
7333 MAX_WPA_IE_LEN);
7334 current_ev = iwe_stream_add_point(current_ev, end_buf,
7335 &iwe, (char *) info_element);
7336 }
7337 break;
7338
7339 case MFIE_TYPE_RSN:
7340 iwe.cmd = IWEVGENIE;
7341 iwe.u.data.length = min(info_element->len + 2,
7342 MAX_WPA_IE_LEN);
7343 current_ev = iwe_stream_add_point(current_ev, end_buf,
7344 &iwe, (char *) info_element);
7345 break;
7346
7347 default:
7348 break;
7349 }
7350
7351 length -= sizeof(*info_element) + info_element->len;
7352 info_element =
7353 (struct ieee80211_info_element *)&info_element->
7354 data[info_element->len];
7355 }
7356 }
7357 return current_ev;
7358 }
7359
7360 /*------------------------------------------------------------------*/
7361 /*
7362 * Wireless Handler : Read Scan Results
7363 */
7364 static int airo_get_scan(struct net_device *dev,
7365 struct iw_request_info *info,
7366 struct iw_point *dwrq,
7367 char *extra)
7368 {
7369 struct airo_info *ai = dev->priv;
7370 BSSListElement *net;
7371 int err = 0;
7372 char *current_ev = extra;
7373
7374 /* If a scan is in-progress, return -EAGAIN */
7375 if (ai->scan_timeout > 0)
7376 return -EAGAIN;
7377
7378 if (down_interruptible(&ai->sem))
7379 return -EAGAIN;
7380
7381 list_for_each_entry (net, &ai->network_list, list) {
7382 /* Translate to WE format this entry */
7383 current_ev = airo_translate_scan(dev, current_ev,
7384 extra + dwrq->length,
7385 &net->bss);
7386
7387 /* Check if there is space for one more entry */
7388 if((extra + dwrq->length - current_ev) <= IW_EV_ADDR_LEN) {
7389 /* Ask user space to try again with a bigger buffer */
7390 err = -E2BIG;
7391 goto out;
7392 }
7393 }
7394
7395 /* Length of data */
7396 dwrq->length = (current_ev - extra);
7397 dwrq->flags = 0; /* todo */
7398
7399 out:
7400 up(&ai->sem);
7401 return err;
7402 }
7403
7404 /*------------------------------------------------------------------*/
7405 /*
7406 * Commit handler : called after a bunch of SET operations
7407 */
7408 static int airo_config_commit(struct net_device *dev,
7409 struct iw_request_info *info, /* NULL */
7410 void *zwrq, /* NULL */
7411 char *extra) /* NULL */
7412 {
7413 struct airo_info *local = dev->priv;
7414 Resp rsp;
7415
7416 if (!test_bit (FLAG_COMMIT, &local->flags))
7417 return 0;
7418
7419 /* Some of the "SET" function may have modified some of the
7420 * parameters. It's now time to commit them in the card */
7421 disable_MAC(local, 1);
7422 if (test_bit (FLAG_RESET, &local->flags)) {
7423 APListRid APList_rid;
7424 SsidRid SSID_rid;
7425
7426 readAPListRid(local, &APList_rid);
7427 readSsidRid(local, &SSID_rid);
7428 if (test_bit(FLAG_MPI,&local->flags))
7429 setup_card(local, dev->dev_addr, 1 );
7430 else
7431 reset_airo_card(dev);
7432 disable_MAC(local, 1);
7433 writeSsidRid(local, &SSID_rid, 1);
7434 writeAPListRid(local, &APList_rid, 1);
7435 }
7436 if (down_interruptible(&local->sem))
7437 return -ERESTARTSYS;
7438 writeConfigRid(local, 0);
7439 enable_MAC(local, &rsp, 0);
7440 if (test_bit (FLAG_RESET, &local->flags))
7441 airo_set_promisc(local);
7442 else
7443 up(&local->sem);
7444
7445 return 0;
7446 }
7447
7448 /*------------------------------------------------------------------*/
7449 /*
7450 * Structures to export the Wireless Handlers
7451 */
7452
7453 static const struct iw_priv_args airo_private_args[] = {
7454 /*{ cmd, set_args, get_args, name } */
7455 { AIROIOCTL, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
7456 IW_PRIV_TYPE_BYTE | 2047, "airoioctl" },
7457 { AIROIDIFC, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
7458 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "airoidifc" },
7459 };
7460
7461 static const iw_handler airo_handler[] =
7462 {
7463 (iw_handler) airo_config_commit, /* SIOCSIWCOMMIT */
7464 (iw_handler) airo_get_name, /* SIOCGIWNAME */
7465 (iw_handler) NULL, /* SIOCSIWNWID */
7466 (iw_handler) NULL, /* SIOCGIWNWID */
7467 (iw_handler) airo_set_freq, /* SIOCSIWFREQ */
7468 (iw_handler) airo_get_freq, /* SIOCGIWFREQ */
7469 (iw_handler) airo_set_mode, /* SIOCSIWMODE */
7470 (iw_handler) airo_get_mode, /* SIOCGIWMODE */
7471 (iw_handler) airo_set_sens, /* SIOCSIWSENS */
7472 (iw_handler) airo_get_sens, /* SIOCGIWSENS */
7473 (iw_handler) NULL, /* SIOCSIWRANGE */
7474 (iw_handler) airo_get_range, /* SIOCGIWRANGE */
7475 (iw_handler) NULL, /* SIOCSIWPRIV */
7476 (iw_handler) NULL, /* SIOCGIWPRIV */
7477 (iw_handler) NULL, /* SIOCSIWSTATS */
7478 (iw_handler) NULL, /* SIOCGIWSTATS */
7479 iw_handler_set_spy, /* SIOCSIWSPY */
7480 iw_handler_get_spy, /* SIOCGIWSPY */
7481 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
7482 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
7483 (iw_handler) airo_set_wap, /* SIOCSIWAP */
7484 (iw_handler) airo_get_wap, /* SIOCGIWAP */
7485 (iw_handler) NULL, /* -- hole -- */
7486 (iw_handler) airo_get_aplist, /* SIOCGIWAPLIST */
7487 (iw_handler) airo_set_scan, /* SIOCSIWSCAN */
7488 (iw_handler) airo_get_scan, /* SIOCGIWSCAN */
7489 (iw_handler) airo_set_essid, /* SIOCSIWESSID */
7490 (iw_handler) airo_get_essid, /* SIOCGIWESSID */
7491 (iw_handler) airo_set_nick, /* SIOCSIWNICKN */
7492 (iw_handler) airo_get_nick, /* SIOCGIWNICKN */
7493 (iw_handler) NULL, /* -- hole -- */
7494 (iw_handler) NULL, /* -- hole -- */
7495 (iw_handler) airo_set_rate, /* SIOCSIWRATE */
7496 (iw_handler) airo_get_rate, /* SIOCGIWRATE */
7497 (iw_handler) airo_set_rts, /* SIOCSIWRTS */
7498 (iw_handler) airo_get_rts, /* SIOCGIWRTS */
7499 (iw_handler) airo_set_frag, /* SIOCSIWFRAG */
7500 (iw_handler) airo_get_frag, /* SIOCGIWFRAG */
7501 (iw_handler) airo_set_txpow, /* SIOCSIWTXPOW */
7502 (iw_handler) airo_get_txpow, /* SIOCGIWTXPOW */
7503 (iw_handler) airo_set_retry, /* SIOCSIWRETRY */
7504 (iw_handler) airo_get_retry, /* SIOCGIWRETRY */
7505 (iw_handler) airo_set_encode, /* SIOCSIWENCODE */
7506 (iw_handler) airo_get_encode, /* SIOCGIWENCODE */
7507 (iw_handler) airo_set_power, /* SIOCSIWPOWER */
7508 (iw_handler) airo_get_power, /* SIOCGIWPOWER */
7509 (iw_handler) NULL, /* -- hole -- */
7510 (iw_handler) NULL, /* -- hole -- */
7511 (iw_handler) NULL, /* SIOCSIWGENIE */
7512 (iw_handler) NULL, /* SIOCGIWGENIE */
7513 (iw_handler) airo_set_auth, /* SIOCSIWAUTH */
7514 (iw_handler) airo_get_auth, /* SIOCGIWAUTH */
7515 (iw_handler) airo_set_encodeext, /* SIOCSIWENCODEEXT */
7516 (iw_handler) airo_get_encodeext, /* SIOCGIWENCODEEXT */
7517 (iw_handler) NULL, /* SIOCSIWPMKSA */
7518 };
7519
7520 /* Note : don't describe AIROIDIFC and AIROOLDIDIFC in here.
7521 * We want to force the use of the ioctl code, because those can't be
7522 * won't work the iw_handler code (because they simultaneously read
7523 * and write data and iw_handler can't do that).
7524 * Note that it's perfectly legal to read/write on a single ioctl command,
7525 * you just can't use iwpriv and need to force it via the ioctl handler.
7526 * Jean II */
7527 static const iw_handler airo_private_handler[] =
7528 {
7529 NULL, /* SIOCIWFIRSTPRIV */
7530 };
7531
7532 static const struct iw_handler_def airo_handler_def =
7533 {
7534 .num_standard = sizeof(airo_handler)/sizeof(iw_handler),
7535 .num_private = sizeof(airo_private_handler)/sizeof(iw_handler),
7536 .num_private_args = sizeof(airo_private_args)/sizeof(struct iw_priv_args),
7537 .standard = airo_handler,
7538 .private = airo_private_handler,
7539 .private_args = airo_private_args,
7540 .get_wireless_stats = airo_get_wireless_stats,
7541 };
7542
7543 /*
7544 * This defines the configuration part of the Wireless Extensions
7545 * Note : irq and spinlock protection will occur in the subroutines
7546 *
7547 * TODO :
7548 * o Check input value more carefully and fill correct values in range
7549 * o Test and shakeout the bugs (if any)
7550 *
7551 * Jean II
7552 *
7553 * Javier Achirica did a great job of merging code from the unnamed CISCO
7554 * developer that added support for flashing the card.
7555 */
7556 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
7557 {
7558 int rc = 0;
7559 struct airo_info *ai = (struct airo_info *)dev->priv;
7560
7561 if (ai->power.event)
7562 return 0;
7563
7564 switch (cmd) {
7565 #ifdef CISCO_EXT
7566 case AIROIDIFC:
7567 #ifdef AIROOLDIDIFC
7568 case AIROOLDIDIFC:
7569 #endif
7570 {
7571 int val = AIROMAGIC;
7572 aironet_ioctl com;
7573 if (copy_from_user(&com,rq->ifr_data,sizeof(com)))
7574 rc = -EFAULT;
7575 else if (copy_to_user(com.data,(char *)&val,sizeof(val)))
7576 rc = -EFAULT;
7577 }
7578 break;
7579
7580 case AIROIOCTL:
7581 #ifdef AIROOLDIOCTL
7582 case AIROOLDIOCTL:
7583 #endif
7584 /* Get the command struct and hand it off for evaluation by
7585 * the proper subfunction
7586 */
7587 {
7588 aironet_ioctl com;
7589 if (copy_from_user(&com,rq->ifr_data,sizeof(com))) {
7590 rc = -EFAULT;
7591 break;
7592 }
7593
7594 /* Separate R/W functions bracket legality here
7595 */
7596 if ( com.command == AIRORSWVERSION ) {
7597 if (copy_to_user(com.data, swversion, sizeof(swversion)))
7598 rc = -EFAULT;
7599 else
7600 rc = 0;
7601 }
7602 else if ( com.command <= AIRORRID)
7603 rc = readrids(dev,&com);
7604 else if ( com.command >= AIROPCAP && com.command <= (AIROPLEAPUSR+2) )
7605 rc = writerids(dev,&com);
7606 else if ( com.command >= AIROFLSHRST && com.command <= AIRORESTART )
7607 rc = flashcard(dev,&com);
7608 else
7609 rc = -EINVAL; /* Bad command in ioctl */
7610 }
7611 break;
7612 #endif /* CISCO_EXT */
7613
7614 // All other calls are currently unsupported
7615 default:
7616 rc = -EOPNOTSUPP;
7617 }
7618 return rc;
7619 }
7620
7621 /*
7622 * Get the Wireless stats out of the driver
7623 * Note : irq and spinlock protection will occur in the subroutines
7624 *
7625 * TODO :
7626 * o Check if work in Ad-Hoc mode (otherwise, use SPY, as in wvlan_cs)
7627 *
7628 * Jean
7629 */
7630 static void airo_read_wireless_stats(struct airo_info *local)
7631 {
7632 StatusRid status_rid;
7633 StatsRid stats_rid;
7634 CapabilityRid cap_rid;
7635 u32 *vals = stats_rid.vals;
7636
7637 /* Get stats out of the card */
7638 clear_bit(JOB_WSTATS, &local->jobs);
7639 if (local->power.event) {
7640 up(&local->sem);
7641 return;
7642 }
7643 readCapabilityRid(local, &cap_rid, 0);
7644 readStatusRid(local, &status_rid, 0);
7645 readStatsRid(local, &stats_rid, RID_STATS, 0);
7646 up(&local->sem);
7647
7648 /* The status */
7649 local->wstats.status = status_rid.mode;
7650
7651 /* Signal quality and co */
7652 if (local->rssi) {
7653 local->wstats.qual.level = airo_rssi_to_dbm( local->rssi, status_rid.sigQuality );
7654 /* normalizedSignalStrength appears to be a percentage */
7655 local->wstats.qual.qual = status_rid.normalizedSignalStrength;
7656 } else {
7657 local->wstats.qual.level = (status_rid.normalizedSignalStrength + 321) / 2;
7658 local->wstats.qual.qual = airo_get_quality(&status_rid, &cap_rid);
7659 }
7660 if (status_rid.len >= 124) {
7661 local->wstats.qual.noise = 0x100 - status_rid.noisedBm;
7662 local->wstats.qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
7663 } else {
7664 local->wstats.qual.noise = 0;
7665 local->wstats.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_INVALID | IW_QUAL_DBM;
7666 }
7667
7668 /* Packets discarded in the wireless adapter due to wireless
7669 * specific problems */
7670 local->wstats.discard.nwid = vals[56] + vals[57] + vals[58];/* SSID Mismatch */
7671 local->wstats.discard.code = vals[6];/* RxWepErr */
7672 local->wstats.discard.fragment = vals[30];
7673 local->wstats.discard.retries = vals[10];
7674 local->wstats.discard.misc = vals[1] + vals[32];
7675 local->wstats.miss.beacon = vals[34];
7676 }
7677
7678 static struct iw_statistics *airo_get_wireless_stats(struct net_device *dev)
7679 {
7680 struct airo_info *local = dev->priv;
7681
7682 if (!test_bit(JOB_WSTATS, &local->jobs)) {
7683 /* Get stats out of the card if available */
7684 if (down_trylock(&local->sem) != 0) {
7685 set_bit(JOB_WSTATS, &local->jobs);
7686 wake_up_interruptible(&local->thr_wait);
7687 } else
7688 airo_read_wireless_stats(local);
7689 }
7690
7691 return &local->wstats;
7692 }
7693
7694 #ifdef CISCO_EXT
7695 /*
7696 * This just translates from driver IOCTL codes to the command codes to
7697 * feed to the radio's host interface. Things can be added/deleted
7698 * as needed. This represents the READ side of control I/O to
7699 * the card
7700 */
7701 static int readrids(struct net_device *dev, aironet_ioctl *comp) {
7702 unsigned short ridcode;
7703 unsigned char *iobuf;
7704 int len;
7705 struct airo_info *ai = dev->priv;
7706 Resp rsp;
7707
7708 if (test_bit(FLAG_FLASHING, &ai->flags))
7709 return -EIO;
7710
7711 switch(comp->command)
7712 {
7713 case AIROGCAP: ridcode = RID_CAPABILITIES; break;
7714 case AIROGCFG: ridcode = RID_CONFIG;
7715 if (test_bit(FLAG_COMMIT, &ai->flags)) {
7716 disable_MAC (ai, 1);
7717 writeConfigRid (ai, 1);
7718 enable_MAC (ai, &rsp, 1);
7719 }
7720 break;
7721 case AIROGSLIST: ridcode = RID_SSID; break;
7722 case AIROGVLIST: ridcode = RID_APLIST; break;
7723 case AIROGDRVNAM: ridcode = RID_DRVNAME; break;
7724 case AIROGEHTENC: ridcode = RID_ETHERENCAP; break;
7725 case AIROGWEPKTMP: ridcode = RID_WEP_TEMP;
7726 /* Only super-user can read WEP keys */
7727 if (!capable(CAP_NET_ADMIN))
7728 return -EPERM;
7729 break;
7730 case AIROGWEPKNV: ridcode = RID_WEP_PERM;
7731 /* Only super-user can read WEP keys */
7732 if (!capable(CAP_NET_ADMIN))
7733 return -EPERM;
7734 break;
7735 case AIROGSTAT: ridcode = RID_STATUS; break;
7736 case AIROGSTATSD32: ridcode = RID_STATSDELTA; break;
7737 case AIROGSTATSC32: ridcode = RID_STATS; break;
7738 case AIROGMICSTATS:
7739 if (copy_to_user(comp->data, &ai->micstats,
7740 min((int)comp->len,(int)sizeof(ai->micstats))))
7741 return -EFAULT;
7742 return 0;
7743 case AIRORRID: ridcode = comp->ridnum; break;
7744 default:
7745 return -EINVAL;
7746 break;
7747 }
7748
7749 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7750 return -ENOMEM;
7751
7752 PC4500_readrid(ai,ridcode,iobuf,RIDSIZE, 1);
7753 /* get the count of bytes in the rid docs say 1st 2 bytes is it.
7754 * then return it to the user
7755 * 9/22/2000 Honor user given length
7756 */
7757 len = comp->len;
7758
7759 if (copy_to_user(comp->data, iobuf, min(len, (int)RIDSIZE))) {
7760 kfree (iobuf);
7761 return -EFAULT;
7762 }
7763 kfree (iobuf);
7764 return 0;
7765 }
7766
7767 /*
7768 * Danger Will Robinson write the rids here
7769 */
7770
7771 static int writerids(struct net_device *dev, aironet_ioctl *comp) {
7772 struct airo_info *ai = dev->priv;
7773 int ridcode;
7774 int enabled;
7775 Resp rsp;
7776 static int (* writer)(struct airo_info *, u16 rid, const void *, int, int);
7777 unsigned char *iobuf;
7778
7779 /* Only super-user can write RIDs */
7780 if (!capable(CAP_NET_ADMIN))
7781 return -EPERM;
7782
7783 if (test_bit(FLAG_FLASHING, &ai->flags))
7784 return -EIO;
7785
7786 ridcode = 0;
7787 writer = do_writerid;
7788
7789 switch(comp->command)
7790 {
7791 case AIROPSIDS: ridcode = RID_SSID; break;
7792 case AIROPCAP: ridcode = RID_CAPABILITIES; break;
7793 case AIROPAPLIST: ridcode = RID_APLIST; break;
7794 case AIROPCFG: ai->config.len = 0;
7795 clear_bit(FLAG_COMMIT, &ai->flags);
7796 ridcode = RID_CONFIG; break;
7797 case AIROPWEPKEYNV: ridcode = RID_WEP_PERM; break;
7798 case AIROPLEAPUSR: ridcode = RID_LEAPUSERNAME; break;
7799 case AIROPLEAPPWD: ridcode = RID_LEAPPASSWORD; break;
7800 case AIROPWEPKEY: ridcode = RID_WEP_TEMP; writer = PC4500_writerid;
7801 break;
7802 case AIROPLEAPUSR+1: ridcode = 0xFF2A; break;
7803 case AIROPLEAPUSR+2: ridcode = 0xFF2B; break;
7804
7805 /* this is not really a rid but a command given to the card
7806 * same with MAC off
7807 */
7808 case AIROPMACON:
7809 if (enable_MAC(ai, &rsp, 1) != 0)
7810 return -EIO;
7811 return 0;
7812
7813 /*
7814 * Evidently this code in the airo driver does not get a symbol
7815 * as disable_MAC. it's probably so short the compiler does not gen one.
7816 */
7817 case AIROPMACOFF:
7818 disable_MAC(ai, 1);
7819 return 0;
7820
7821 /* This command merely clears the counts does not actually store any data
7822 * only reads rid. But as it changes the cards state, I put it in the
7823 * writerid routines.
7824 */
7825 case AIROPSTCLR:
7826 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7827 return -ENOMEM;
7828
7829 PC4500_readrid(ai,RID_STATSDELTACLEAR,iobuf,RIDSIZE, 1);
7830
7831 enabled = ai->micstats.enabled;
7832 memset(&ai->micstats,0,sizeof(ai->micstats));
7833 ai->micstats.enabled = enabled;
7834
7835 if (copy_to_user(comp->data, iobuf,
7836 min((int)comp->len, (int)RIDSIZE))) {
7837 kfree (iobuf);
7838 return -EFAULT;
7839 }
7840 kfree (iobuf);
7841 return 0;
7842
7843 default:
7844 return -EOPNOTSUPP; /* Blarg! */
7845 }
7846 if(comp->len > RIDSIZE)
7847 return -EINVAL;
7848
7849 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7850 return -ENOMEM;
7851
7852 if (copy_from_user(iobuf,comp->data,comp->len)) {
7853 kfree (iobuf);
7854 return -EFAULT;
7855 }
7856
7857 if (comp->command == AIROPCFG) {
7858 ConfigRid *cfg = (ConfigRid *)iobuf;
7859
7860 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags))
7861 cfg->opmode |= MODE_MIC;
7862
7863 if ((cfg->opmode & 0xFF) == MODE_STA_IBSS)
7864 set_bit (FLAG_ADHOC, &ai->flags);
7865 else
7866 clear_bit (FLAG_ADHOC, &ai->flags);
7867 }
7868
7869 if((*writer)(ai, ridcode, iobuf,comp->len,1)) {
7870 kfree (iobuf);
7871 return -EIO;
7872 }
7873 kfree (iobuf);
7874 return 0;
7875 }
7876
7877 /*****************************************************************************
7878 * Ancillary flash / mod functions much black magic lurkes here *
7879 *****************************************************************************
7880 */
7881
7882 /*
7883 * Flash command switch table
7884 */
7885
7886 static int flashcard(struct net_device *dev, aironet_ioctl *comp) {
7887 int z;
7888
7889 /* Only super-user can modify flash */
7890 if (!capable(CAP_NET_ADMIN))
7891 return -EPERM;
7892
7893 switch(comp->command)
7894 {
7895 case AIROFLSHRST:
7896 return cmdreset((struct airo_info *)dev->priv);
7897
7898 case AIROFLSHSTFL:
7899 if (!((struct airo_info *)dev->priv)->flash &&
7900 (((struct airo_info *)dev->priv)->flash = kmalloc (FLASHSIZE, GFP_KERNEL)) == NULL)
7901 return -ENOMEM;
7902 return setflashmode((struct airo_info *)dev->priv);
7903
7904 case AIROFLSHGCHR: /* Get char from aux */
7905 if(comp->len != sizeof(int))
7906 return -EINVAL;
7907 if (copy_from_user(&z,comp->data,comp->len))
7908 return -EFAULT;
7909 return flashgchar((struct airo_info *)dev->priv,z,8000);
7910
7911 case AIROFLSHPCHR: /* Send char to card. */
7912 if(comp->len != sizeof(int))
7913 return -EINVAL;
7914 if (copy_from_user(&z,comp->data,comp->len))
7915 return -EFAULT;
7916 return flashpchar((struct airo_info *)dev->priv,z,8000);
7917
7918 case AIROFLPUTBUF: /* Send 32k to card */
7919 if (!((struct airo_info *)dev->priv)->flash)
7920 return -ENOMEM;
7921 if(comp->len > FLASHSIZE)
7922 return -EINVAL;
7923 if(copy_from_user(((struct airo_info *)dev->priv)->flash,comp->data,comp->len))
7924 return -EFAULT;
7925
7926 flashputbuf((struct airo_info *)dev->priv);
7927 return 0;
7928
7929 case AIRORESTART:
7930 if(flashrestart((struct airo_info *)dev->priv,dev))
7931 return -EIO;
7932 return 0;
7933 }
7934 return -EINVAL;
7935 }
7936
7937 #define FLASH_COMMAND 0x7e7e
7938
7939 /*
7940 * STEP 1)
7941 * Disable MAC and do soft reset on
7942 * card.
7943 */
7944
7945 static int cmdreset(struct airo_info *ai) {
7946 disable_MAC(ai, 1);
7947
7948 if(!waitbusy (ai)){
7949 airo_print_info(ai->dev->name, "Waitbusy hang before RESET");
7950 return -EBUSY;
7951 }
7952
7953 OUT4500(ai,COMMAND,CMD_SOFTRESET);
7954
7955 ssleep(1); /* WAS 600 12/7/00 */
7956
7957 if(!waitbusy (ai)){
7958 airo_print_info(ai->dev->name, "Waitbusy hang AFTER RESET");
7959 return -EBUSY;
7960 }
7961 return 0;
7962 }
7963
7964 /* STEP 2)
7965 * Put the card in legendary flash
7966 * mode
7967 */
7968
7969 static int setflashmode (struct airo_info *ai) {
7970 set_bit (FLAG_FLASHING, &ai->flags);
7971
7972 OUT4500(ai, SWS0, FLASH_COMMAND);
7973 OUT4500(ai, SWS1, FLASH_COMMAND);
7974 if (probe) {
7975 OUT4500(ai, SWS0, FLASH_COMMAND);
7976 OUT4500(ai, COMMAND,0x10);
7977 } else {
7978 OUT4500(ai, SWS2, FLASH_COMMAND);
7979 OUT4500(ai, SWS3, FLASH_COMMAND);
7980 OUT4500(ai, COMMAND,0);
7981 }
7982 msleep(500); /* 500ms delay */
7983
7984 if(!waitbusy(ai)) {
7985 clear_bit (FLAG_FLASHING, &ai->flags);
7986 airo_print_info(ai->dev->name, "Waitbusy hang after setflash mode");
7987 return -EIO;
7988 }
7989 return 0;
7990 }
7991
7992 /* Put character to SWS0 wait for dwelltime
7993 * x 50us for echo .
7994 */
7995
7996 static int flashpchar(struct airo_info *ai,int byte,int dwelltime) {
7997 int echo;
7998 int waittime;
7999
8000 byte |= 0x8000;
8001
8002 if(dwelltime == 0 )
8003 dwelltime = 200;
8004
8005 waittime=dwelltime;
8006
8007 /* Wait for busy bit d15 to go false indicating buffer empty */
8008 while ((IN4500 (ai, SWS0) & 0x8000) && waittime > 0) {
8009 udelay (50);
8010 waittime -= 50;
8011 }
8012
8013 /* timeout for busy clear wait */
8014 if(waittime <= 0 ){
8015 airo_print_info(ai->dev->name, "flash putchar busywait timeout!");
8016 return -EBUSY;
8017 }
8018
8019 /* Port is clear now write byte and wait for it to echo back */
8020 do {
8021 OUT4500(ai,SWS0,byte);
8022 udelay(50);
8023 dwelltime -= 50;
8024 echo = IN4500(ai,SWS1);
8025 } while (dwelltime >= 0 && echo != byte);
8026
8027 OUT4500(ai,SWS1,0);
8028
8029 return (echo == byte) ? 0 : -EIO;
8030 }
8031
8032 /*
8033 * Get a character from the card matching matchbyte
8034 * Step 3)
8035 */
8036 static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime){
8037 int rchar;
8038 unsigned char rbyte=0;
8039
8040 do {
8041 rchar = IN4500(ai,SWS1);
8042
8043 if(dwelltime && !(0x8000 & rchar)){
8044 dwelltime -= 10;
8045 mdelay(10);
8046 continue;
8047 }
8048 rbyte = 0xff & rchar;
8049
8050 if( (rbyte == matchbyte) && (0x8000 & rchar) ){
8051 OUT4500(ai,SWS1,0);
8052 return 0;
8053 }
8054 if( rbyte == 0x81 || rbyte == 0x82 || rbyte == 0x83 || rbyte == 0x1a || 0xffff == rchar)
8055 break;
8056 OUT4500(ai,SWS1,0);
8057
8058 }while(dwelltime > 0);
8059 return -EIO;
8060 }
8061
8062 /*
8063 * Transfer 32k of firmware data from user buffer to our buffer and
8064 * send to the card
8065 */
8066
8067 static int flashputbuf(struct airo_info *ai){
8068 int nwords;
8069
8070 /* Write stuff */
8071 if (test_bit(FLAG_MPI,&ai->flags))
8072 memcpy_toio(ai->pciaux + 0x8000, ai->flash, FLASHSIZE);
8073 else {
8074 OUT4500(ai,AUXPAGE,0x100);
8075 OUT4500(ai,AUXOFF,0);
8076
8077 for(nwords=0;nwords != FLASHSIZE / 2;nwords++){
8078 OUT4500(ai,AUXDATA,ai->flash[nwords] & 0xffff);
8079 }
8080 }
8081 OUT4500(ai,SWS0,0x8000);
8082
8083 return 0;
8084 }
8085
8086 /*
8087 *
8088 */
8089 static int flashrestart(struct airo_info *ai,struct net_device *dev){
8090 int i,status;
8091
8092 ssleep(1); /* Added 12/7/00 */
8093 clear_bit (FLAG_FLASHING, &ai->flags);
8094 if (test_bit(FLAG_MPI, &ai->flags)) {
8095 status = mpi_init_descriptors(ai);
8096 if (status != SUCCESS)
8097 return status;
8098 }
8099 status = setup_card(ai, dev->dev_addr, 1);
8100
8101 if (!test_bit(FLAG_MPI,&ai->flags))
8102 for( i = 0; i < MAX_FIDS; i++ ) {
8103 ai->fids[i] = transmit_allocate
8104 ( ai, AIRO_DEF_MTU, i >= MAX_FIDS / 2 );
8105 }
8106
8107 ssleep(1); /* Added 12/7/00 */
8108 return status;
8109 }
8110 #endif /* CISCO_EXT */
8111
8112 /*
8113 This program is free software; you can redistribute it and/or
8114 modify it under the terms of the GNU General Public License
8115 as published by the Free Software Foundation; either version 2
8116 of the License, or (at your option) any later version.
8117
8118 This program is distributed in the hope that it will be useful,
8119 but WITHOUT ANY WARRANTY; without even the implied warranty of
8120 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
8121 GNU General Public License for more details.
8122
8123 In addition:
8124
8125 Redistribution and use in source and binary forms, with or without
8126 modification, are permitted provided that the following conditions
8127 are met:
8128
8129 1. Redistributions of source code must retain the above copyright
8130 notice, this list of conditions and the following disclaimer.
8131 2. Redistributions in binary form must reproduce the above copyright
8132 notice, this list of conditions and the following disclaimer in the
8133 documentation and/or other materials provided with the distribution.
8134 3. The name of the author may not be used to endorse or promote
8135 products derived from this software without specific prior written
8136 permission.
8137
8138 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
8139 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
8140 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
8141 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
8142 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
8143 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
8144 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
8145 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
8146 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
8147 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
8148 POSSIBILITY OF SUCH DAMAGE.
8149 */
8150
8151 module_init(airo_init_module);
8152 module_exit(airo_cleanup_module);
Linux kernel - Deliverables
This page took 0.434385 seconds and 6 git commands to generate.