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