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