1 /*======================================================================
3 Aironet driver for 4500 and 4800 series cards
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
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>.
20 ======================================================================*/
22 #include <linux/init.h>
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/proc_fs.h>
27 #include <linux/smp_lock.h>
29 #include <linux/sched.h>
30 #include <linux/ptrace.h>
31 #include <linux/slab.h>
32 #include <linux/string.h>
33 #include <linux/timer.h>
34 #include <linux/interrupt.h>
36 #include <linux/bitops.h>
37 #include <linux/scatterlist.h>
38 #include <linux/crypto.h>
40 #include <asm/system.h>
42 #include <linux/netdevice.h>
43 #include <linux/etherdevice.h>
44 #include <linux/skbuff.h>
45 #include <linux/if_arp.h>
46 #include <linux/ioport.h>
47 #include <linux/pci.h>
48 #include <asm/uaccess.h>
49 #include <net/ieee80211.h>
54 static struct pci_device_id card_ids[] = {
55 { 0x14b9, 1, PCI_ANY_ID, PCI_ANY_ID, },
56 { 0x14b9, 0x4500, PCI_ANY_ID, PCI_ANY_ID },
57 { 0x14b9, 0x4800, PCI_ANY_ID, PCI_ANY_ID, },
58 { 0x14b9, 0x0340, PCI_ANY_ID, PCI_ANY_ID, },
59 { 0x14b9, 0x0350, PCI_ANY_ID, PCI_ANY_ID, },
60 { 0x14b9, 0x5000, PCI_ANY_ID, PCI_ANY_ID, },
61 { 0x14b9, 0xa504, PCI_ANY_ID, PCI_ANY_ID, },
64 MODULE_DEVICE_TABLE(pci, card_ids);
66 static int airo_pci_probe(struct pci_dev *, const struct pci_device_id *);
67 static void airo_pci_remove(struct pci_dev *);
68 static int airo_pci_suspend(struct pci_dev *pdev, pm_message_t state);
69 static int airo_pci_resume(struct pci_dev *pdev);
71 static struct pci_driver airo_driver = {
74 .probe = airo_pci_probe,
75 .remove = __devexit_p(airo_pci_remove),
76 .suspend = airo_pci_suspend,
77 .resume = airo_pci_resume,
79 #endif /* CONFIG_PCI */
81 /* Include Wireless Extension definition and check version - Jean II */
82 #include <linux/wireless.h>
83 #define WIRELESS_SPY // enable iwspy support
84 #include <net/iw_handler.h> // New driver API
86 #define CISCO_EXT // enable Cisco extensions
88 #include <linux/delay.h>
91 /* Hack to do some power saving */
94 /* As you can see this list is HUGH!
95 I really don't know what a lot of these counts are about, but they
96 are all here for completeness. If the IGNLABEL macro is put in
97 infront of the label, that statistic will not be included in the list
98 of statistics in the /proc filesystem */
100 #define IGNLABEL(comment) NULL
101 static char *statsLabels[] = {
103 IGNLABEL("RxPlcpCrcErr"),
104 IGNLABEL("RxPlcpFormatErr"),
105 IGNLABEL("RxPlcpLengthErr"),
136 "LostSync-MissedBeacons",
137 "LostSync-ArlExceeded",
139 "LostSync-Disassoced",
140 "LostSync-TsfTiming",
149 IGNLABEL("HmacTxMc"),
150 IGNLABEL("HmacTxBc"),
151 IGNLABEL("HmacTxUc"),
152 IGNLABEL("HmacTxFail"),
153 IGNLABEL("HmacRxMc"),
154 IGNLABEL("HmacRxBc"),
155 IGNLABEL("HmacRxUc"),
156 IGNLABEL("HmacRxDiscard"),
157 IGNLABEL("HmacRxAccepted"),
165 IGNLABEL("ReasonOutsideTable"),
166 IGNLABEL("ReasonStatus1"),
167 IGNLABEL("ReasonStatus2"),
168 IGNLABEL("ReasonStatus3"),
169 IGNLABEL("ReasonStatus4"),
170 IGNLABEL("ReasonStatus5"),
171 IGNLABEL("ReasonStatus6"),
172 IGNLABEL("ReasonStatus7"),
173 IGNLABEL("ReasonStatus8"),
174 IGNLABEL("ReasonStatus9"),
175 IGNLABEL("ReasonStatus10"),
176 IGNLABEL("ReasonStatus11"),
177 IGNLABEL("ReasonStatus12"),
178 IGNLABEL("ReasonStatus13"),
179 IGNLABEL("ReasonStatus14"),
180 IGNLABEL("ReasonStatus15"),
181 IGNLABEL("ReasonStatus16"),
182 IGNLABEL("ReasonStatus17"),
183 IGNLABEL("ReasonStatus18"),
184 IGNLABEL("ReasonStatus19"),
204 #define RUN_AT(x) (jiffies+(x))
208 /* These variables are for insmod, since it seems that the rates
209 can only be set in setup_card. Rates should be a comma separated
210 (no spaces) list of rates (up to 8). */
213 static int basic_rate;
214 static char *ssids[3];
220 int maxencrypt /* = 0 */; /* The highest rate that the card can encrypt at.
221 0 means no limit. For old cards this was 4 */
223 static int auto_wep /* = 0 */; /* If set, it tries to figure out the wep mode */
224 static int aux_bap /* = 0 */; /* Checks to see if the aux ports are needed to read
225 the bap, needed on some older cards and buses. */
228 static int probe = 1;
230 static int proc_uid /* = 0 */;
232 static int proc_gid /* = 0 */;
234 static int airo_perm = 0555;
236 static int proc_perm = 0644;
238 MODULE_AUTHOR("Benjamin Reed");
239 MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet \
240 cards. Direct support for ISA/PCI/MPI cards and support \
241 for PCMCIA when used with airo_cs.");
242 MODULE_LICENSE("Dual BSD/GPL");
243 MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340/350");
244 module_param_array(io, int, NULL, 0);
245 module_param_array(irq, int, NULL, 0);
246 module_param(basic_rate, int, 0);
247 module_param_array(rates, int, NULL, 0);
248 module_param_array(ssids, charp, NULL, 0);
249 module_param(auto_wep, int, 0);
250 MODULE_PARM_DESC(auto_wep, "If non-zero, the driver will keep looping through \
251 the authentication options until an association is made. The value of \
252 auto_wep is number of the wep keys to check. A value of 2 will try using \
253 the key at index 0 and index 1.");
254 module_param(aux_bap, int, 0);
255 MODULE_PARM_DESC(aux_bap, "If non-zero, the driver will switch into a mode \
256 than seems to work better for older cards with some older buses. Before \
257 switching it checks that the switch is needed.");
258 module_param(maxencrypt, int, 0);
259 MODULE_PARM_DESC(maxencrypt, "The maximum speed that the card can do \
260 encryption. Units are in 512kbs. Zero (default) means there is no limit. \
261 Older cards used to be limited to 2mbs (4).");
262 module_param(adhoc, int, 0);
263 MODULE_PARM_DESC(adhoc, "If non-zero, the card will start in adhoc mode.");
264 module_param(probe, int, 0);
265 MODULE_PARM_DESC(probe, "If zero, the driver won't start the card.");
267 module_param(proc_uid, int, 0);
268 MODULE_PARM_DESC(proc_uid, "The uid that the /proc files will belong to.");
269 module_param(proc_gid, int, 0);
270 MODULE_PARM_DESC(proc_gid, "The gid that the /proc files will belong to.");
271 module_param(airo_perm, int, 0);
272 MODULE_PARM_DESC(airo_perm, "The permission bits of /proc/[driver/]aironet.");
273 module_param(proc_perm, int, 0);
274 MODULE_PARM_DESC(proc_perm, "The permission bits of the files in /proc");
276 /* This is a kind of sloppy hack to get this information to OUT4500 and
277 IN4500. I would be extremely interested in the situation where this
278 doesn't work though!!! */
279 static int do8bitIO = 0;
288 #define MAC_ENABLE 0x0001
289 #define MAC_DISABLE 0x0002
290 #define CMD_LOSE_SYNC 0x0003 /* Not sure what this does... */
291 #define CMD_SOFTRESET 0x0004
292 #define HOSTSLEEP 0x0005
293 #define CMD_MAGIC_PKT 0x0006
294 #define CMD_SETWAKEMASK 0x0007
295 #define CMD_READCFG 0x0008
296 #define CMD_SETMODE 0x0009
297 #define CMD_ALLOCATETX 0x000a
298 #define CMD_TRANSMIT 0x000b
299 #define CMD_DEALLOCATETX 0x000c
301 #define CMD_WORKAROUND 0x0011
302 #define CMD_ALLOCATEAUX 0x0020
303 #define CMD_ACCESS 0x0021
304 #define CMD_PCIBAP 0x0022
305 #define CMD_PCIAUX 0x0023
306 #define CMD_ALLOCBUF 0x0028
307 #define CMD_GETTLV 0x0029
308 #define CMD_PUTTLV 0x002a
309 #define CMD_DELTLV 0x002b
310 #define CMD_FINDNEXTTLV 0x002c
311 #define CMD_PSPNODES 0x0030
312 #define CMD_SETCW 0x0031
313 #define CMD_SETPCF 0x0032
314 #define CMD_SETPHYREG 0x003e
315 #define CMD_TXTEST 0x003f
316 #define MAC_ENABLETX 0x0101
317 #define CMD_LISTBSS 0x0103
318 #define CMD_SAVECFG 0x0108
319 #define CMD_ENABLEAUX 0x0111
320 #define CMD_WRITERID 0x0121
321 #define CMD_USEPSPNODES 0x0130
322 #define MAC_ENABLERX 0x0201
325 #define ERROR_QUALIF 0x00
326 #define ERROR_ILLCMD 0x01
327 #define ERROR_ILLFMT 0x02
328 #define ERROR_INVFID 0x03
329 #define ERROR_INVRID 0x04
330 #define ERROR_LARGE 0x05
331 #define ERROR_NDISABL 0x06
332 #define ERROR_ALLOCBSY 0x07
333 #define ERROR_NORD 0x0B
334 #define ERROR_NOWR 0x0C
335 #define ERROR_INVFIDTX 0x0D
336 #define ERROR_TESTACT 0x0E
337 #define ERROR_TAGNFND 0x12
338 #define ERROR_DECODE 0x20
339 #define ERROR_DESCUNAV 0x21
340 #define ERROR_BADLEN 0x22
341 #define ERROR_MODE 0x80
342 #define ERROR_HOP 0x81
343 #define ERROR_BINTER 0x82
344 #define ERROR_RXMODE 0x83
345 #define ERROR_MACADDR 0x84
346 #define ERROR_RATES 0x85
347 #define ERROR_ORDER 0x86
348 #define ERROR_SCAN 0x87
349 #define ERROR_AUTH 0x88
350 #define ERROR_PSMODE 0x89
351 #define ERROR_RTYPE 0x8A
352 #define ERROR_DIVER 0x8B
353 #define ERROR_SSID 0x8C
354 #define ERROR_APLIST 0x8D
355 #define ERROR_AUTOWAKE 0x8E
356 #define ERROR_LEAP 0x8F
367 #define LINKSTAT 0x10
371 #define TXALLOCFID 0x22
372 #define TXCOMPLFID 0x24
387 /* Offset into aux memory for descriptors */
388 #define AUX_OFFSET 0x800
389 /* Size of allocated packets */
392 /* Size of the transmit queue */
396 #define BAP0 0 // Used for receiving packets
397 #define BAP1 2 // Used for xmiting packets and working with RIDS
400 #define COMMAND_BUSY 0x8000
402 #define BAP_BUSY 0x8000
403 #define BAP_ERR 0x4000
404 #define BAP_DONE 0x2000
406 #define PROMISC 0xffff
407 #define NOPROMISC 0x0000
410 #define EV_CLEARCOMMANDBUSY 0x4000
413 #define EV_TXEXC 0x04
414 #define EV_ALLOC 0x08
416 #define EV_AWAKE 0x100
417 #define EV_TXCPY 0x400
418 #define EV_UNKNOWN 0x800
419 #define EV_MIC 0x1000 /* Message Integrity Check Interrupt */
420 #define EV_AWAKEN 0x2000
421 #define STATUS_INTS (EV_AWAKE|EV_LINK|EV_TXEXC|EV_TX|EV_TXCPY|EV_RX|EV_MIC)
423 #ifdef CHECK_UNKNOWN_INTS
424 #define IGNORE_INTS ( EV_CMD | EV_UNKNOWN)
426 #define IGNORE_INTS (~STATUS_INTS)
433 #define RID_CAPABILITIES 0xFF00
434 #define RID_APINFO 0xFF01
435 #define RID_RADIOINFO 0xFF02
436 #define RID_UNKNOWN3 0xFF03
437 #define RID_RSSI 0xFF04
438 #define RID_CONFIG 0xFF10
439 #define RID_SSID 0xFF11
440 #define RID_APLIST 0xFF12
441 #define RID_DRVNAME 0xFF13
442 #define RID_ETHERENCAP 0xFF14
443 #define RID_WEP_TEMP 0xFF15
444 #define RID_WEP_PERM 0xFF16
445 #define RID_MODULATION 0xFF17
446 #define RID_OPTIONS 0xFF18
447 #define RID_ACTUALCONFIG 0xFF20 /*readonly*/
448 #define RID_FACTORYCONFIG 0xFF21
449 #define RID_UNKNOWN22 0xFF22
450 #define RID_LEAPUSERNAME 0xFF23
451 #define RID_LEAPPASSWORD 0xFF24
452 #define RID_STATUS 0xFF50
453 #define RID_BEACON_HST 0xFF51
454 #define RID_BUSY_HST 0xFF52
455 #define RID_RETRIES_HST 0xFF53
456 #define RID_UNKNOWN54 0xFF54
457 #define RID_UNKNOWN55 0xFF55
458 #define RID_UNKNOWN56 0xFF56
459 #define RID_MIC 0xFF57
460 #define RID_STATS16 0xFF60
461 #define RID_STATS16DELTA 0xFF61
462 #define RID_STATS16DELTACLEAR 0xFF62
463 #define RID_STATS 0xFF68
464 #define RID_STATSDELTA 0xFF69
465 #define RID_STATSDELTACLEAR 0xFF6A
466 #define RID_ECHOTEST_RID 0xFF70
467 #define RID_ECHOTEST_RESULTS 0xFF71
468 #define RID_BSSLISTFIRST 0xFF72
469 #define RID_BSSLISTNEXT 0xFF73
470 #define RID_WPA_BSSLISTFIRST 0xFF74
471 #define RID_WPA_BSSLISTNEXT 0xFF75
488 * Rids and endian-ness: The Rids will always be in cpu endian, since
489 * this all the patches from the big-endian guys end up doing that.
490 * so all rid access should use the read/writeXXXRid routines.
493 /* This is redundant for x86 archs, but it seems necessary for ARM */
496 /* This structure came from an email sent to me from an engineer at
497 aironet for inclusion into this driver */
506 /* These structures are from the Aironet's PC4500 Developers Manual */
520 #define MOD_DEFAULT 0
526 u16 len; /* sizeof(ConfigRid) */
527 u16 opmode; /* operating mode */
528 #define MODE_STA_IBSS 0
529 #define MODE_STA_ESS 1
531 #define MODE_AP_RPTR 3
532 #define MODE_ETHERNET_HOST (0<<8) /* rx payloads converted */
533 #define MODE_LLC_HOST (1<<8) /* rx payloads left as is */
534 #define MODE_AIRONET_EXTEND (1<<9) /* enable Aironet extenstions */
535 #define MODE_AP_INTERFACE (1<<10) /* enable ap interface extensions */
536 #define MODE_ANTENNA_ALIGN (1<<11) /* enable antenna alignment */
537 #define MODE_ETHER_LLC (1<<12) /* enable ethernet LLC */
538 #define MODE_LEAF_NODE (1<<13) /* enable leaf node bridge */
539 #define MODE_CF_POLLABLE (1<<14) /* enable CF pollable */
540 #define MODE_MIC (1<<15) /* enable MIC */
541 u16 rmode; /* receive mode */
542 #define RXMODE_BC_MC_ADDR 0
543 #define RXMODE_BC_ADDR 1 /* ignore multicasts */
544 #define RXMODE_ADDR 2 /* ignore multicast and broadcast */
545 #define RXMODE_RFMON 3 /* wireless monitor mode */
546 #define RXMODE_RFMON_ANYBSS 4
547 #define RXMODE_LANMON 5 /* lan style monitor -- data packets only */
548 #define RXMODE_DISABLE_802_3_HEADER (1<<8) /* disables 802.3 header on rx */
549 #define RXMODE_NORMALIZED_RSSI (1<<9) /* return normalized RSSI */
552 u8 macAddr[ETH_ALEN];
556 u16 txLifetime; /* in kusec */
557 u16 rxLifetime; /* in kusec */
560 u16 u16deviceType; /* for overriding device type */
564 /*---------- Scanning/Associating ----------*/
566 #define SCANMODE_ACTIVE 0
567 #define SCANMODE_PASSIVE 1
568 #define SCANMODE_AIROSCAN 2
569 u16 probeDelay; /* in kusec */
570 u16 probeEnergyTimeout; /* in kusec */
571 u16 probeResponseTimeout;
572 u16 beaconListenTimeout;
576 #define AUTH_OPEN 0x1
577 #define AUTH_ENCRYPT 0x101
578 #define AUTH_SHAREDKEY 0x102
579 #define AUTH_ALLOW_UNENCRYPTED 0x200
580 u16 associationTimeout;
581 u16 specifiedApTimeout;
582 u16 offlineScanInterval;
583 u16 offlineScanDuration;
585 u16 maxBeaconLostTime;
587 #define DISABLE_REFRESH 0xFFFF
589 /*---------- Power save operation ----------*/
591 #define POWERSAVE_CAM 0
592 #define POWERSAVE_PSP 1
593 #define POWERSAVE_PSPCAM 2
596 u16 fastListenInterval;
600 /*---------- Ap/Ibss config items ----------*/
609 /*---------- Radio configuration ----------*/
611 #define RADIOTYPE_DEFAULT 0
612 #define RADIOTYPE_802_11 1
613 #define RADIOTYPE_LEGACY 2
617 #define TXPOWER_DEFAULT 0
619 #define RSSI_DEFAULT 0
621 #define PREAMBLE_AUTO 0
622 #define PREAMBLE_LONG 1
623 #define PREAMBLE_SHORT 2
627 /*---------- Aironet Extensions ----------*/
633 /*---------- Aironet Extensions ----------*/
635 #define MAGIC_ACTION_STSCHG 1
636 #define MAGIC_ACTION_RESUME 2
637 #define MAGIC_IGNORE_MCAST (1<<8)
638 #define MAGIC_IGNORE_BCAST (1<<9)
639 #define MAGIC_SWITCH_TO_PSP (0<<10)
640 #define MAGIC_STAY_IN_CAM (1<<10)
654 u8 bssid[4][ETH_ALEN];
668 u16 normalizedSignalStrength;
671 u8 noisePercent; /* Noise percent in last second */
672 u8 noisedBm; /* Noise dBm in last second */
673 u8 noiseAvePercent; /* Noise percent in last minute */
674 u8 noiseAvedBm; /* Noise dBm in last minute */
675 u8 noiseMaxPercent; /* Highest noise percent in last minute */
676 u8 noiseMaxdBm; /* Highest noise dbm in last minute */
680 #define STAT_NOPACKETS 0
681 #define STAT_NOCARRIERSET 10
682 #define STAT_GOTCARRIERSET 11
683 #define STAT_WRONGSSID 20
684 #define STAT_BADCHANNEL 25
685 #define STAT_BADBITRATES 30
686 #define STAT_BADPRIVACY 35
687 #define STAT_APFOUND 40
688 #define STAT_APREJECTED 50
689 #define STAT_AUTHENTICATING 60
690 #define STAT_DEAUTHENTICATED 61
691 #define STAT_AUTHTIMEOUT 62
692 #define STAT_ASSOCIATING 70
693 #define STAT_DEASSOCIATED 71
694 #define STAT_ASSOCTIMEOUT 72
695 #define STAT_NOTAIROAP 73
696 #define STAT_ASSOCIATED 80
697 #define STAT_LEAPING 90
698 #define STAT_LEAPFAILED 91
699 #define STAT_LEAPTIMEDOUT 92
700 #define STAT_LEAPCOMPLETE 93
723 char factoryAddr[ETH_ALEN];
724 char aironetAddr[ETH_ALEN];
727 char callid[ETH_ALEN];
728 char supportedRates[8];
731 u16 txPowerLevels[8];
745 /* Only present on firmware >= 5.30.17 */
748 u8 fixed[12]; /* WLAN management frame */
754 u16 index; /* First is 0 and 0xffff means end of list */
755 #define RADIO_FH 1 /* Frequency hopping radio type */
756 #define RADIO_DS 2 /* Direct sequence radio type */
757 #define RADIO_TMA 4 /* Proprietary radio used in old cards (2500) */
759 u8 bssid[ETH_ALEN]; /* Mac address of the BSS */
764 #define CAP_ESS (1<<0)
765 #define CAP_IBSS (1<<1)
766 #define CAP_PRIVACY (1<<4)
767 #define CAP_SHORTHDR (1<<5)
770 u8 rates[8]; /* Same as rates for config rid */
771 struct { /* For frequency hopping only */
781 /* Only present on firmware >= 5.30.17 */
782 BSSListRidExtra extra;
787 struct list_head list;
833 #define TXCTL_TXOK (1<<1) /* report if tx is ok */
834 #define TXCTL_TXEX (1<<2) /* report if tx fails */
835 #define TXCTL_802_3 (0<<3) /* 802.3 packet */
836 #define TXCTL_802_11 (1<<3) /* 802.11 mac packet */
837 #define TXCTL_ETHERNET (0<<4) /* payload has ethertype */
838 #define TXCTL_LLC (1<<4) /* payload is llc */
839 #define TXCTL_RELEASE (0<<5) /* release after completion */
840 #define TXCTL_NORELEASE (1<<5) /* on completion returns to host */
842 #define BUSY_FID 0x10000
845 #define AIROMAGIC 0xa55a
846 /* Warning : SIOCDEVPRIVATE may disapear during 2.5.X - Jean II */
847 #ifdef SIOCIWFIRSTPRIV
848 #ifdef SIOCDEVPRIVATE
849 #define AIROOLDIOCTL SIOCDEVPRIVATE
850 #define AIROOLDIDIFC AIROOLDIOCTL + 1
851 #endif /* SIOCDEVPRIVATE */
852 #else /* SIOCIWFIRSTPRIV */
853 #define SIOCIWFIRSTPRIV SIOCDEVPRIVATE
854 #endif /* SIOCIWFIRSTPRIV */
855 /* This may be wrong. When using the new SIOCIWFIRSTPRIV range, we probably
856 * should use only "GET" ioctls (last bit set to 1). "SET" ioctls are root
857 * only and don't return the modified struct ifreq to the application which
858 * is usually a problem. - Jean II */
859 #define AIROIOCTL SIOCIWFIRSTPRIV
860 #define AIROIDIFC AIROIOCTL + 1
862 /* Ioctl constants to be used in airo_ioctl.command */
864 #define AIROGCAP 0 // Capability rid
865 #define AIROGCFG 1 // USED A LOT
866 #define AIROGSLIST 2 // System ID list
867 #define AIROGVLIST 3 // List of specified AP's
868 #define AIROGDRVNAM 4 // NOTUSED
869 #define AIROGEHTENC 5 // NOTUSED
870 #define AIROGWEPKTMP 6
871 #define AIROGWEPKNV 7
873 #define AIROGSTATSC32 9
874 #define AIROGSTATSD32 10
875 #define AIROGMICRID 11
876 #define AIROGMICSTATS 12
877 #define AIROGFLAGS 13
880 #define AIRORSWVERSION 17
882 /* Leave gap of 40 commands after AIROGSTATSD32 for future */
884 #define AIROPCAP AIROGSTATSD32 + 40
885 #define AIROPVLIST AIROPCAP + 1
886 #define AIROPSLIST AIROPVLIST + 1
887 #define AIROPCFG AIROPSLIST + 1
888 #define AIROPSIDS AIROPCFG + 1
889 #define AIROPAPLIST AIROPSIDS + 1
890 #define AIROPMACON AIROPAPLIST + 1 /* Enable mac */
891 #define AIROPMACOFF AIROPMACON + 1 /* Disable mac */
892 #define AIROPSTCLR AIROPMACOFF + 1
893 #define AIROPWEPKEY AIROPSTCLR + 1
894 #define AIROPWEPKEYNV AIROPWEPKEY + 1
895 #define AIROPLEAPPWD AIROPWEPKEYNV + 1
896 #define AIROPLEAPUSR AIROPLEAPPWD + 1
900 #define AIROFLSHRST AIROPWEPKEYNV + 40
901 #define AIROFLSHGCHR AIROFLSHRST + 1
902 #define AIROFLSHSTFL AIROFLSHGCHR + 1
903 #define AIROFLSHPCHR AIROFLSHSTFL + 1
904 #define AIROFLPUTBUF AIROFLSHPCHR + 1
905 #define AIRORESTART AIROFLPUTBUF + 1
907 #define FLASHSIZE 32768
908 #define AUXMEMSIZE (256 * 1024)
910 typedef struct aironet_ioctl {
911 unsigned short command; // What to do
912 unsigned short len; // Len of data
913 unsigned short ridnum; // rid number
914 unsigned char __user *data; // d-data
917 static char swversion[] = "2.1";
918 #endif /* CISCO_EXT */
920 #define NUM_MODULES 2
921 #define MIC_MSGLEN_MAX 2400
922 #define EMMH32_MSGLEN_MAX MIC_MSGLEN_MAX
923 #define AIRO_DEF_MTU 2312
927 u8 enabled; // MIC enabled or not
928 u32 rxSuccess; // successful packets received
929 u32 rxIncorrectMIC; // pkts dropped due to incorrect MIC comparison
930 u32 rxNotMICed; // pkts dropped due to not being MIC'd
931 u32 rxMICPlummed; // pkts dropped due to not having a MIC plummed
932 u32 rxWrongSequence; // pkts dropped due to sequence number violation
937 u32 coeff[((EMMH32_MSGLEN_MAX)+3)>>2];
938 u64 accum; // accumulated mic, reduced to u32 in final()
939 int position; // current position (byte offset) in message
943 } part; // saves partial message word across update() calls
947 emmh32_context seed; // Context - the seed
948 u32 rx; // Received sequence number
949 u32 tx; // Tx sequence number
950 u32 window; // Start of window
951 u8 valid; // Flag to say if context is valid or not
956 miccntx mCtx; // Multicast context
957 miccntx uCtx; // Unicast context
961 unsigned int rid: 16;
962 unsigned int len: 15;
963 unsigned int valid: 1;
964 dma_addr_t host_addr;
968 unsigned int offset: 15;
970 unsigned int len: 15;
971 unsigned int valid: 1;
972 dma_addr_t host_addr;
976 unsigned int ctl: 15;
978 unsigned int len: 15;
979 unsigned int valid: 1;
980 dma_addr_t host_addr;
984 * Host receive descriptor
987 unsigned char __iomem *card_ram_off; /* offset into card memory of the
989 RxFid rx_desc; /* card receive descriptor */
990 char *virtual_host_addr; /* virtual address of host receive
996 * Host transmit descriptor
999 unsigned char __iomem *card_ram_off; /* offset into card memory of the
1001 TxFid tx_desc; /* card transmit descriptor */
1002 char *virtual_host_addr; /* virtual address of host receive
1008 * Host RID descriptor
1011 unsigned char __iomem *card_ram_off; /* offset into card memory of the
1013 Rid rid_desc; /* card RID descriptor */
1014 char *virtual_host_addr; /* virtual address of host receive
1023 #define HOST_SET (1 << 0)
1024 #define HOST_INT_TX (1 << 1) /* Interrupt on successful TX */
1025 #define HOST_INT_TXERR (1 << 2) /* Interrupt on unseccessful TX */
1026 #define HOST_LCC_PAYLOAD (1 << 4) /* LLC payload, 0 = Ethertype */
1027 #define HOST_DONT_RLSE (1 << 5) /* Don't release buffer when done */
1028 #define HOST_DONT_RETRY (1 << 6) /* Don't retry trasmit */
1029 #define HOST_CLR_AID (1 << 7) /* clear AID failure */
1030 #define HOST_RTS (1 << 9) /* Force RTS use */
1031 #define HOST_SHORT (1 << 10) /* Do short preamble */
1058 static WifiCtlHdr wifictlhdr8023 = {
1060 .ctl = HOST_DONT_RLSE,
1064 // Frequency list (map channels to frequencies)
1065 static const long frequency_list[] = { 2412, 2417, 2422, 2427, 2432, 2437, 2442,
1066 2447, 2452, 2457, 2462, 2467, 2472, 2484 };
1068 // A few details needed for WEP (Wireless Equivalent Privacy)
1069 #define MAX_KEY_SIZE 13 // 128 (?) bits
1070 #define MIN_KEY_SIZE 5 // 40 bits RC4 - WEP
1071 typedef struct wep_key_t {
1073 u8 key[16]; /* 40-bit and 104-bit keys */
1076 /* Backward compatibility */
1077 #ifndef IW_ENCODE_NOKEY
1078 #define IW_ENCODE_NOKEY 0x0800 /* Key is write only, so not present */
1079 #define IW_ENCODE_MODE (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
1080 #endif /* IW_ENCODE_NOKEY */
1082 /* List of Wireless Handlers (new API) */
1083 static const struct iw_handler_def airo_handler_def;
1085 static const char version[] = "airo.c 0.6 (Ben Reed & Javier Achirica)";
1089 static int get_dec_u16( char *buffer, int *start, int limit );
1090 static void OUT4500( struct airo_info *, u16 register, u16 value );
1091 static unsigned short IN4500( struct airo_info *, u16 register );
1092 static u16 setup_card(struct airo_info*, u8 *mac, int lock);
1093 static int enable_MAC( struct airo_info *ai, Resp *rsp, int lock );
1094 static void disable_MAC(struct airo_info *ai, int lock);
1095 static void enable_interrupts(struct airo_info*);
1096 static void disable_interrupts(struct airo_info*);
1097 static u16 issuecommand(struct airo_info*, Cmd *pCmd, Resp *pRsp);
1098 static int bap_setup(struct airo_info*, u16 rid, u16 offset, int whichbap);
1099 static int aux_bap_read(struct airo_info*, u16 *pu16Dst, int bytelen,
1101 static int fast_bap_read(struct airo_info*, u16 *pu16Dst, int bytelen,
1103 static int bap_write(struct airo_info*, const u16 *pu16Src, int bytelen,
1105 static int PC4500_accessrid(struct airo_info*, u16 rid, u16 accmd);
1106 static int PC4500_readrid(struct airo_info*, u16 rid, void *pBuf, int len, int lock);
1107 static int PC4500_writerid(struct airo_info*, u16 rid, const void
1108 *pBuf, int len, int lock);
1109 static int do_writerid( struct airo_info*, u16 rid, const void *rid_data,
1110 int len, int dummy );
1111 static u16 transmit_allocate(struct airo_info*, int lenPayload, int raw);
1112 static int transmit_802_3_packet(struct airo_info*, int len, char *pPacket);
1113 static int transmit_802_11_packet(struct airo_info*, int len, char *pPacket);
1115 static int mpi_send_packet (struct net_device *dev);
1116 static void mpi_unmap_card(struct pci_dev *pci);
1117 static void mpi_receive_802_3(struct airo_info *ai);
1118 static void mpi_receive_802_11(struct airo_info *ai);
1119 static int waitbusy (struct airo_info *ai);
1121 static irqreturn_t airo_interrupt( int irq, void* dev_id, struct pt_regs
1123 static int airo_thread(void *data);
1124 static void timer_func( struct net_device *dev );
1125 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
1126 static struct iw_statistics *airo_get_wireless_stats (struct net_device *dev);
1127 static void airo_read_wireless_stats (struct airo_info *local);
1129 static int readrids(struct net_device *dev, aironet_ioctl *comp);
1130 static int writerids(struct net_device *dev, aironet_ioctl *comp);
1131 static int flashcard(struct net_device *dev, aironet_ioctl *comp);
1132 #endif /* CISCO_EXT */
1133 static void micinit(struct airo_info *ai);
1134 static int micsetup(struct airo_info *ai);
1135 static int encapsulate(struct airo_info *ai, etherHead *pPacket, MICBuffer *buffer, int len);
1136 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *pPacket, u16 payLen);
1138 static u8 airo_rssi_to_dbm (tdsRssiEntry *rssi_rid, u8 rssi);
1139 static u8 airo_dbm_to_pct (tdsRssiEntry *rssi_rid, u8 dbm);
1141 static void airo_networks_free(struct airo_info *ai);
1144 struct net_device_stats stats;
1145 struct net_device *dev;
1146 /* Note, we can have MAX_FIDS outstanding. FIDs are 16-bits, so we
1147 use the high bit to mark whether it is in use. */
1149 #define MPI_MAX_FIDS 1
1152 char keyindex; // Used with auto wep
1153 char defindex; // Used with auto wep
1154 struct proc_dir_entry *proc_entry;
1155 spinlock_t aux_lock;
1156 #define FLAG_RADIO_OFF 0 /* User disabling of MAC */
1157 #define FLAG_RADIO_DOWN 1 /* ifup/ifdown disabling of MAC */
1158 #define FLAG_RADIO_MASK 0x03
1159 #define FLAG_ENABLED 2
1160 #define FLAG_ADHOC 3 /* Needed by MIC */
1161 #define FLAG_MIC_CAPABLE 4
1162 #define FLAG_UPDATE_MULTI 5
1163 #define FLAG_UPDATE_UNI 6
1164 #define FLAG_802_11 7
1165 #define FLAG_PROMISC 8 /* IFF_PROMISC 0x100 - include/linux/if.h */
1166 #define FLAG_PENDING_XMIT 9
1167 #define FLAG_PENDING_XMIT11 10
1169 #define FLAG_REGISTERED 12
1170 #define FLAG_COMMIT 13
1171 #define FLAG_RESET 14
1172 #define FLAG_FLASHING 15
1173 #define FLAG_WPA_CAPABLE 16
1174 unsigned long flags;
1177 #define JOB_XMIT11 2
1179 #define JOB_PROMISC 4
1182 #define JOB_AUTOWEP 7
1183 #define JOB_WSTATS 8
1184 #define JOB_SCAN_RESULTS 9
1186 int (*bap_read)(struct airo_info*, u16 *pu16Dst, int bytelen,
1188 unsigned short *flash;
1190 struct task_struct *task;
1191 struct semaphore sem;
1193 wait_queue_head_t thr_wait;
1194 struct completion thr_exited;
1195 unsigned long expires;
1197 struct sk_buff *skb;
1200 struct net_device *wifidev;
1201 struct iw_statistics wstats; // wireless stats
1202 unsigned long scan_timeout; /* Time scan should be read */
1203 struct iw_spy_data spy_data;
1204 struct iw_public_data wireless_data;
1206 struct crypto_tfm *tfm;
1208 mic_statistics micstats;
1209 HostRxDesc rxfids[MPI_MAX_FIDS]; // rx/tx/config MPI350 descriptors
1210 HostTxDesc txfids[MPI_MAX_FIDS];
1211 HostRidDesc config_desc;
1212 unsigned long ridbus; // phys addr of config_desc
1213 struct sk_buff_head txq;// tx queue used by mpi350 code
1214 struct pci_dev *pci;
1215 unsigned char __iomem *pcimem;
1216 unsigned char __iomem *pciaux;
1217 unsigned char *shared;
1218 dma_addr_t shared_dma;
1222 #define PCI_SHARED_LEN 2*MPI_MAX_FIDS*PKTSIZE+RIDSIZE
1223 char proc_name[IFNAMSIZ];
1225 /* WPA-related stuff */
1226 unsigned int bssListFirst;
1227 unsigned int bssListNext;
1228 unsigned int bssListRidLen;
1230 struct list_head network_list;
1231 struct list_head network_free_list;
1232 BSSListElement *networks;
1235 static inline int bap_read(struct airo_info *ai, u16 *pu16Dst, int bytelen,
1237 return ai->bap_read(ai, pu16Dst, bytelen, whichbap);
1240 static int setup_proc_entry( struct net_device *dev,
1241 struct airo_info *apriv );
1242 static int takedown_proc_entry( struct net_device *dev,
1243 struct airo_info *apriv );
1245 static int cmdreset(struct airo_info *ai);
1246 static int setflashmode (struct airo_info *ai);
1247 static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime);
1248 static int flashputbuf(struct airo_info *ai);
1249 static int flashrestart(struct airo_info *ai,struct net_device *dev);
1251 #define airo_print(type, name, fmt, args...) \
1252 { printk(type "airo(%s): " fmt "\n", name, ##args); }
1254 #define airo_print_info(name, fmt, args...) \
1255 airo_print(KERN_INFO, name, fmt, ##args)
1257 #define airo_print_dbg(name, fmt, args...) \
1258 airo_print(KERN_DEBUG, name, fmt, ##args)
1260 #define airo_print_warn(name, fmt, args...) \
1261 airo_print(KERN_WARNING, name, fmt, ##args)
1263 #define airo_print_err(name, fmt, args...) \
1264 airo_print(KERN_ERR, name, fmt, ##args)
1267 /***********************************************************************
1269 ***********************************************************************
1272 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq);
1273 static void MoveWindow(miccntx *context, u32 micSeq);
1274 static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct crypto_tfm *);
1275 static void emmh32_init(emmh32_context *context);
1276 static void emmh32_update(emmh32_context *context, u8 *pOctets, int len);
1277 static void emmh32_final(emmh32_context *context, u8 digest[4]);
1278 static int flashpchar(struct airo_info *ai,int byte,int dwelltime);
1280 /* micinit - Initialize mic seed */
1282 static void micinit(struct airo_info *ai)
1286 clear_bit(JOB_MIC, &ai->jobs);
1287 PC4500_readrid(ai, RID_MIC, &mic_rid, sizeof(mic_rid), 0);
1290 ai->micstats.enabled = (mic_rid.state & 0x00FF) ? 1 : 0;
1292 if (ai->micstats.enabled) {
1293 /* Key must be valid and different */
1294 if (mic_rid.multicastValid && (!ai->mod[0].mCtx.valid ||
1295 (memcmp (ai->mod[0].mCtx.key, mic_rid.multicast,
1296 sizeof(ai->mod[0].mCtx.key)) != 0))) {
1297 /* Age current mic Context */
1298 memcpy(&ai->mod[1].mCtx,&ai->mod[0].mCtx,sizeof(miccntx));
1299 /* Initialize new context */
1300 memcpy(&ai->mod[0].mCtx.key,mic_rid.multicast,sizeof(mic_rid.multicast));
1301 ai->mod[0].mCtx.window = 33; //Window always points to the middle
1302 ai->mod[0].mCtx.rx = 0; //Rx Sequence numbers
1303 ai->mod[0].mCtx.tx = 0; //Tx sequence numbers
1304 ai->mod[0].mCtx.valid = 1; //Key is now valid
1306 /* Give key to mic seed */
1307 emmh32_setseed(&ai->mod[0].mCtx.seed,mic_rid.multicast,sizeof(mic_rid.multicast), ai->tfm);
1310 /* Key must be valid and different */
1311 if (mic_rid.unicastValid && (!ai->mod[0].uCtx.valid ||
1312 (memcmp(ai->mod[0].uCtx.key, mic_rid.unicast,
1313 sizeof(ai->mod[0].uCtx.key)) != 0))) {
1314 /* Age current mic Context */
1315 memcpy(&ai->mod[1].uCtx,&ai->mod[0].uCtx,sizeof(miccntx));
1316 /* Initialize new context */
1317 memcpy(&ai->mod[0].uCtx.key,mic_rid.unicast,sizeof(mic_rid.unicast));
1319 ai->mod[0].uCtx.window = 33; //Window always points to the middle
1320 ai->mod[0].uCtx.rx = 0; //Rx Sequence numbers
1321 ai->mod[0].uCtx.tx = 0; //Tx sequence numbers
1322 ai->mod[0].uCtx.valid = 1; //Key is now valid
1324 //Give key to mic seed
1325 emmh32_setseed(&ai->mod[0].uCtx.seed, mic_rid.unicast, sizeof(mic_rid.unicast), ai->tfm);
1328 /* So next time we have a valid key and mic is enabled, we will update
1329 * the sequence number if the key is the same as before.
1331 ai->mod[0].uCtx.valid = 0;
1332 ai->mod[0].mCtx.valid = 0;
1336 /* micsetup - Get ready for business */
1338 static int micsetup(struct airo_info *ai) {
1341 if (ai->tfm == NULL)
1342 ai->tfm = crypto_alloc_tfm("aes", CRYPTO_TFM_REQ_MAY_SLEEP);
1344 if (ai->tfm == NULL) {
1345 airo_print_err(ai->dev->name, "failed to load transform for AES");
1349 for (i=0; i < NUM_MODULES; i++) {
1350 memset(&ai->mod[i].mCtx,0,sizeof(miccntx));
1351 memset(&ai->mod[i].uCtx,0,sizeof(miccntx));
1356 static char micsnap[] = {0xAA,0xAA,0x03,0x00,0x40,0x96,0x00,0x02};
1358 /*===========================================================================
1359 * Description: Mic a packet
1361 * Inputs: etherHead * pointer to an 802.3 frame
1363 * Returns: BOOLEAN if successful, otherwise false.
1364 * PacketTxLen will be updated with the mic'd packets size.
1366 * Caveats: It is assumed that the frame buffer will already
1367 * be big enough to hold the largets mic message possible.
1368 * (No memory allocation is done here).
1370 * Author: sbraneky (10/15/01)
1371 * Merciless hacks by rwilcher (1/14/02)
1374 static int encapsulate(struct airo_info *ai ,etherHead *frame, MICBuffer *mic, int payLen)
1378 // Determine correct context
1379 // If not adhoc, always use unicast key
1381 if (test_bit(FLAG_ADHOC, &ai->flags) && (frame->da[0] & 0x1))
1382 context = &ai->mod[0].mCtx;
1384 context = &ai->mod[0].uCtx;
1386 if (!context->valid)
1389 mic->typelen = htons(payLen + 16); //Length of Mic'd packet
1391 memcpy(&mic->u.snap, micsnap, sizeof(micsnap)); // Add Snap
1394 mic->seq = htonl(context->tx);
1397 emmh32_init(&context->seed); // Mic the packet
1398 emmh32_update(&context->seed,frame->da,ETH_ALEN * 2); // DA,SA
1399 emmh32_update(&context->seed,(u8*)&mic->typelen,10); // Type/Length and Snap
1400 emmh32_update(&context->seed,(u8*)&mic->seq,sizeof(mic->seq)); //SEQ
1401 emmh32_update(&context->seed,frame->da + ETH_ALEN * 2,payLen); //payload
1402 emmh32_final(&context->seed, (u8*)&mic->mic);
1404 /* New Type/length ?????????? */
1405 mic->typelen = 0; //Let NIC know it could be an oversized packet
1417 /*===========================================================================
1418 * Description: Decapsulates a MIC'd packet and returns the 802.3 packet
1419 * (removes the MIC stuff) if packet is a valid packet.
1421 * Inputs: etherHead pointer to the 802.3 packet
1423 * Returns: BOOLEAN - TRUE if packet should be dropped otherwise FALSE
1425 * Author: sbraneky (10/15/01)
1426 * Merciless hacks by rwilcher (1/14/02)
1427 *---------------------------------------------------------------------------
1430 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *eth, u16 payLen)
1436 mic_error micError = NONE;
1438 // Check if the packet is a Mic'd packet
1440 if (!ai->micstats.enabled) {
1441 //No Mic set or Mic OFF but we received a MIC'd packet.
1442 if (memcmp ((u8*)eth + 14, micsnap, sizeof(micsnap)) == 0) {
1443 ai->micstats.rxMICPlummed++;
1449 if (ntohs(mic->typelen) == 0x888E)
1452 if (memcmp (mic->u.snap, micsnap, sizeof(micsnap)) != 0) {
1453 // Mic enabled but packet isn't Mic'd
1454 ai->micstats.rxMICPlummed++;
1458 micSEQ = ntohl(mic->seq); //store SEQ as CPU order
1460 //At this point we a have a mic'd packet and mic is enabled
1461 //Now do the mic error checking.
1463 //Receive seq must be odd
1464 if ( (micSEQ & 1) == 0 ) {
1465 ai->micstats.rxWrongSequence++;
1469 for (i = 0; i < NUM_MODULES; i++) {
1470 int mcast = eth->da[0] & 1;
1471 //Determine proper context
1472 context = mcast ? &ai->mod[i].mCtx : &ai->mod[i].uCtx;
1474 //Make sure context is valid
1475 if (!context->valid) {
1477 micError = NOMICPLUMMED;
1483 mic->typelen = htons(payLen + sizeof(MICBuffer) - 2);
1485 emmh32_init(&context->seed);
1486 emmh32_update(&context->seed, eth->da, ETH_ALEN*2);
1487 emmh32_update(&context->seed, (u8 *)&mic->typelen, sizeof(mic->typelen)+sizeof(mic->u.snap));
1488 emmh32_update(&context->seed, (u8 *)&mic->seq,sizeof(mic->seq));
1489 emmh32_update(&context->seed, eth->da + ETH_ALEN*2,payLen);
1491 emmh32_final(&context->seed, digest);
1493 if (memcmp(digest, &mic->mic, 4)) { //Make sure the mics match
1496 micError = INCORRECTMIC;
1500 //Check Sequence number if mics pass
1501 if (RxSeqValid(ai, context, mcast, micSEQ) == SUCCESS) {
1502 ai->micstats.rxSuccess++;
1506 micError = SEQUENCE;
1509 // Update statistics
1511 case NOMICPLUMMED: ai->micstats.rxMICPlummed++; break;
1512 case SEQUENCE: ai->micstats.rxWrongSequence++; break;
1513 case INCORRECTMIC: ai->micstats.rxIncorrectMIC++; break;
1520 /*===========================================================================
1521 * Description: Checks the Rx Seq number to make sure it is valid
1522 * and hasn't already been received
1524 * Inputs: miccntx - mic context to check seq against
1525 * micSeq - the Mic seq number
1527 * Returns: TRUE if valid otherwise FALSE.
1529 * Author: sbraneky (10/15/01)
1530 * Merciless hacks by rwilcher (1/14/02)
1531 *---------------------------------------------------------------------------
1534 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq)
1538 //Allow for the ap being rebooted - if it is then use the next
1539 //sequence number of the current sequence number - might go backwards
1542 if (test_bit(FLAG_UPDATE_MULTI, &ai->flags)) {
1543 clear_bit (FLAG_UPDATE_MULTI, &ai->flags);
1544 context->window = (micSeq > 33) ? micSeq : 33;
1545 context->rx = 0; // Reset rx
1547 } else if (test_bit(FLAG_UPDATE_UNI, &ai->flags)) {
1548 clear_bit (FLAG_UPDATE_UNI, &ai->flags);
1549 context->window = (micSeq > 33) ? micSeq : 33; // Move window
1550 context->rx = 0; // Reset rx
1553 //Make sequence number relative to START of window
1554 seq = micSeq - (context->window - 33);
1556 //Too old of a SEQ number to check.
1561 //Window is infinite forward
1562 MoveWindow(context,micSeq);
1566 // We are in the window. Now check the context rx bit to see if it was already sent
1567 seq >>= 1; //divide by 2 because we only have odd numbers
1568 index = 1 << seq; //Get an index number
1570 if (!(context->rx & index)) {
1571 //micSEQ falls inside the window.
1572 //Add seqence number to the list of received numbers.
1573 context->rx |= index;
1575 MoveWindow(context,micSeq);
1582 static void MoveWindow(miccntx *context, u32 micSeq)
1586 //Move window if seq greater than the middle of the window
1587 if (micSeq > context->window) {
1588 shift = (micSeq - context->window) >> 1;
1592 context->rx >>= shift;
1596 context->window = micSeq; //Move window
1600 /*==============================================*/
1601 /*========== EMMH ROUTINES ====================*/
1602 /*==============================================*/
1604 /* mic accumulate */
1605 #define MIC_ACCUM(val) \
1606 context->accum += (u64)(val) * context->coeff[coeff_position++];
1608 static unsigned char aes_counter[16];
1610 /* expand the key to fill the MMH coefficient array */
1611 static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct crypto_tfm *tfm)
1613 /* take the keying material, expand if necessary, truncate at 16-bytes */
1614 /* run through AES counter mode to generate context->coeff[] */
1618 u8 *cipher, plain[16];
1619 struct scatterlist sg[1];
1621 crypto_cipher_setkey(tfm, pkey, 16);
1623 for (i = 0; i < (sizeof(context->coeff)/sizeof(context->coeff[0])); ) {
1624 aes_counter[15] = (u8)(counter >> 0);
1625 aes_counter[14] = (u8)(counter >> 8);
1626 aes_counter[13] = (u8)(counter >> 16);
1627 aes_counter[12] = (u8)(counter >> 24);
1629 memcpy (plain, aes_counter, 16);
1630 sg_set_buf(sg, plain, 16);
1631 crypto_cipher_encrypt(tfm, sg, sg, 16);
1632 cipher = kmap(sg->page) + sg->offset;
1633 for (j=0; (j<16) && (i< (sizeof(context->coeff)/sizeof(context->coeff[0]))); ) {
1634 context->coeff[i++] = ntohl(*(u32 *)&cipher[j]);
1640 /* prepare for calculation of a new mic */
1641 static void emmh32_init(emmh32_context *context)
1643 /* prepare for new mic calculation */
1645 context->position = 0;
1648 /* add some bytes to the mic calculation */
1649 static void emmh32_update(emmh32_context *context, u8 *pOctets, int len)
1651 int coeff_position, byte_position;
1653 if (len == 0) return;
1655 coeff_position = context->position >> 2;
1657 /* deal with partial 32-bit word left over from last update */
1658 byte_position = context->position & 3;
1659 if (byte_position) {
1660 /* have a partial word in part to deal with */
1662 if (len == 0) return;
1663 context->part.d8[byte_position++] = *pOctets++;
1664 context->position++;
1666 } while (byte_position < 4);
1667 MIC_ACCUM(htonl(context->part.d32));
1670 /* deal with full 32-bit words */
1672 MIC_ACCUM(htonl(*(u32 *)pOctets));
1673 context->position += 4;
1678 /* deal with partial 32-bit word that will be left over from this update */
1681 context->part.d8[byte_position++] = *pOctets++;
1682 context->position++;
1687 /* mask used to zero empty bytes for final partial word */
1688 static u32 mask32[4] = { 0x00000000L, 0xFF000000L, 0xFFFF0000L, 0xFFFFFF00L };
1690 /* calculate the mic */
1691 static void emmh32_final(emmh32_context *context, u8 digest[4])
1693 int coeff_position, byte_position;
1699 coeff_position = context->position >> 2;
1701 /* deal with partial 32-bit word left over from last update */
1702 byte_position = context->position & 3;
1703 if (byte_position) {
1704 /* have a partial word in part to deal with */
1705 val = htonl(context->part.d32);
1706 MIC_ACCUM(val & mask32[byte_position]); /* zero empty bytes */
1709 /* reduce the accumulated u64 to a 32-bit MIC */
1710 sum = context->accum;
1711 stmp = (sum & 0xffffffffLL) - ((sum >> 32) * 15);
1712 utmp = (stmp & 0xffffffffLL) - ((stmp >> 32) * 15);
1713 sum = utmp & 0xffffffffLL;
1714 if (utmp > 0x10000000fLL)
1718 digest[0] = (val>>24) & 0xFF;
1719 digest[1] = (val>>16) & 0xFF;
1720 digest[2] = (val>>8) & 0xFF;
1721 digest[3] = val & 0xFF;
1724 static int readBSSListRid(struct airo_info *ai, int first,
1731 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
1732 memset(&cmd, 0, sizeof(cmd));
1733 cmd.cmd=CMD_LISTBSS;
1734 if (down_interruptible(&ai->sem))
1735 return -ERESTARTSYS;
1736 issuecommand(ai, &cmd, &rsp);
1738 /* Let the command take effect */
1743 rc = PC4500_readrid(ai, first ? ai->bssListFirst : ai->bssListNext,
1744 list, ai->bssListRidLen, 1);
1746 list->len = le16_to_cpu(list->len);
1747 list->index = le16_to_cpu(list->index);
1748 list->radioType = le16_to_cpu(list->radioType);
1749 list->cap = le16_to_cpu(list->cap);
1750 list->beaconInterval = le16_to_cpu(list->beaconInterval);
1751 list->fh.dwell = le16_to_cpu(list->fh.dwell);
1752 list->dsChannel = le16_to_cpu(list->dsChannel);
1753 list->atimWindow = le16_to_cpu(list->atimWindow);
1754 list->dBm = le16_to_cpu(list->dBm);
1758 static int readWepKeyRid(struct airo_info*ai, WepKeyRid *wkr, int temp, int lock) {
1759 int rc = PC4500_readrid(ai, temp ? RID_WEP_TEMP : RID_WEP_PERM,
1760 wkr, sizeof(*wkr), lock);
1762 wkr->len = le16_to_cpu(wkr->len);
1763 wkr->kindex = le16_to_cpu(wkr->kindex);
1764 wkr->klen = le16_to_cpu(wkr->klen);
1767 /* In the writeXXXRid routines we copy the rids so that we don't screwup
1768 * the originals when we endian them... */
1769 static int writeWepKeyRid(struct airo_info*ai, WepKeyRid *pwkr, int perm, int lock) {
1771 WepKeyRid wkr = *pwkr;
1773 wkr.len = cpu_to_le16(wkr.len);
1774 wkr.kindex = cpu_to_le16(wkr.kindex);
1775 wkr.klen = cpu_to_le16(wkr.klen);
1776 rc = PC4500_writerid(ai, RID_WEP_TEMP, &wkr, sizeof(wkr), lock);
1777 if (rc!=SUCCESS) airo_print_err(ai->dev->name, "WEP_TEMP set %x", rc);
1779 rc = PC4500_writerid(ai, RID_WEP_PERM, &wkr, sizeof(wkr), lock);
1781 airo_print_err(ai->dev->name, "WEP_PERM set %x", rc);
1787 static int readSsidRid(struct airo_info*ai, SsidRid *ssidr) {
1789 int rc = PC4500_readrid(ai, RID_SSID, ssidr, sizeof(*ssidr), 1);
1791 ssidr->len = le16_to_cpu(ssidr->len);
1792 for(i = 0; i < 3; i++) {
1793 ssidr->ssids[i].len = le16_to_cpu(ssidr->ssids[i].len);
1797 static int writeSsidRid(struct airo_info*ai, SsidRid *pssidr, int lock) {
1800 SsidRid ssidr = *pssidr;
1802 ssidr.len = cpu_to_le16(ssidr.len);
1803 for(i = 0; i < 3; i++) {
1804 ssidr.ssids[i].len = cpu_to_le16(ssidr.ssids[i].len);
1806 rc = PC4500_writerid(ai, RID_SSID, &ssidr, sizeof(ssidr), lock);
1809 static int readConfigRid(struct airo_info*ai, int lock) {
1817 rc = PC4500_readrid(ai, RID_ACTUALCONFIG, &cfg, sizeof(cfg), lock);
1821 for(s = &cfg.len; s <= &cfg.rtsThres; s++) *s = le16_to_cpu(*s);
1823 for(s = &cfg.shortRetryLimit; s <= &cfg.radioType; s++)
1824 *s = le16_to_cpu(*s);
1826 for(s = &cfg.txPower; s <= &cfg.radioSpecific; s++)
1827 *s = le16_to_cpu(*s);
1829 for(s = &cfg.arlThreshold; s <= &cfg._reserved4[0]; s++)
1830 *s = cpu_to_le16(*s);
1832 for(s = &cfg.autoWake; s <= &cfg.autoWake; s++)
1833 *s = cpu_to_le16(*s);
1838 static inline void checkThrottle(struct airo_info *ai) {
1840 /* Old hardware had a limit on encryption speed */
1841 if (ai->config.authType != AUTH_OPEN && maxencrypt) {
1842 for(i=0; i<8; i++) {
1843 if (ai->config.rates[i] > maxencrypt) {
1844 ai->config.rates[i] = 0;
1849 static int writeConfigRid(struct airo_info*ai, int lock) {
1853 if (!test_bit (FLAG_COMMIT, &ai->flags))
1856 clear_bit (FLAG_COMMIT, &ai->flags);
1857 clear_bit (FLAG_RESET, &ai->flags);
1861 if ((cfgr.opmode & 0xFF) == MODE_STA_IBSS)
1862 set_bit(FLAG_ADHOC, &ai->flags);
1864 clear_bit(FLAG_ADHOC, &ai->flags);
1866 for(s = &cfgr.len; s <= &cfgr.rtsThres; s++) *s = cpu_to_le16(*s);
1868 for(s = &cfgr.shortRetryLimit; s <= &cfgr.radioType; s++)
1869 *s = cpu_to_le16(*s);
1871 for(s = &cfgr.txPower; s <= &cfgr.radioSpecific; s++)
1872 *s = cpu_to_le16(*s);
1874 for(s = &cfgr.arlThreshold; s <= &cfgr._reserved4[0]; s++)
1875 *s = cpu_to_le16(*s);
1877 for(s = &cfgr.autoWake; s <= &cfgr.autoWake; s++)
1878 *s = cpu_to_le16(*s);
1880 return PC4500_writerid( ai, RID_CONFIG, &cfgr, sizeof(cfgr), lock);
1882 static int readStatusRid(struct airo_info*ai, StatusRid *statr, int lock) {
1883 int rc = PC4500_readrid(ai, RID_STATUS, statr, sizeof(*statr), lock);
1886 statr->len = le16_to_cpu(statr->len);
1887 for(s = &statr->mode; s <= &statr->SSIDlen; s++) *s = le16_to_cpu(*s);
1889 for(s = &statr->beaconPeriod; s <= &statr->shortPreamble; s++)
1890 *s = le16_to_cpu(*s);
1891 statr->load = le16_to_cpu(statr->load);
1892 statr->assocStatus = le16_to_cpu(statr->assocStatus);
1895 static int readAPListRid(struct airo_info*ai, APListRid *aplr) {
1896 int rc = PC4500_readrid(ai, RID_APLIST, aplr, sizeof(*aplr), 1);
1897 aplr->len = le16_to_cpu(aplr->len);
1900 static int writeAPListRid(struct airo_info*ai, APListRid *aplr, int lock) {
1902 aplr->len = cpu_to_le16(aplr->len);
1903 rc = PC4500_writerid(ai, RID_APLIST, aplr, sizeof(*aplr), lock);
1906 static int readCapabilityRid(struct airo_info*ai, CapabilityRid *capr, int lock) {
1907 int rc = PC4500_readrid(ai, RID_CAPABILITIES, capr, sizeof(*capr), lock);
1910 capr->len = le16_to_cpu(capr->len);
1911 capr->prodNum = le16_to_cpu(capr->prodNum);
1912 capr->radioType = le16_to_cpu(capr->radioType);
1913 capr->country = le16_to_cpu(capr->country);
1914 for(s = &capr->txPowerLevels[0]; s <= &capr->requiredHard; s++)
1915 *s = le16_to_cpu(*s);
1918 static int readStatsRid(struct airo_info*ai, StatsRid *sr, int rid, int lock) {
1919 int rc = PC4500_readrid(ai, rid, sr, sizeof(*sr), lock);
1922 sr->len = le16_to_cpu(sr->len);
1923 for(i = &sr->vals[0]; i <= &sr->vals[99]; i++) *i = le32_to_cpu(*i);
1927 static int airo_open(struct net_device *dev) {
1928 struct airo_info *info = dev->priv;
1931 if (test_bit(FLAG_FLASHING, &info->flags))
1934 /* Make sure the card is configured.
1935 * Wireless Extensions may postpone config changes until the card
1936 * is open (to pipeline changes and speed-up card setup). If
1937 * those changes are not yet commited, do it now - Jean II */
1938 if (test_bit (FLAG_COMMIT, &info->flags)) {
1939 disable_MAC(info, 1);
1940 writeConfigRid(info, 1);
1943 if (info->wifidev != dev) {
1944 /* Power on the MAC controller (which may have been disabled) */
1945 clear_bit(FLAG_RADIO_DOWN, &info->flags);
1946 enable_interrupts(info);
1948 enable_MAC(info, &rsp, 1);
1950 netif_start_queue(dev);
1954 static int mpi_start_xmit(struct sk_buff *skb, struct net_device *dev) {
1955 int npacks, pending;
1956 unsigned long flags;
1957 struct airo_info *ai = dev->priv;
1960 airo_print_err(dev->name, "%s: skb == NULL!",__FUNCTION__);
1963 npacks = skb_queue_len (&ai->txq);
1965 if (npacks >= MAXTXQ - 1) {
1966 netif_stop_queue (dev);
1967 if (npacks > MAXTXQ) {
1968 ai->stats.tx_fifo_errors++;
1971 skb_queue_tail (&ai->txq, skb);
1975 spin_lock_irqsave(&ai->aux_lock, flags);
1976 skb_queue_tail (&ai->txq, skb);
1977 pending = test_bit(FLAG_PENDING_XMIT, &ai->flags);
1978 spin_unlock_irqrestore(&ai->aux_lock,flags);
1979 netif_wake_queue (dev);
1982 set_bit(FLAG_PENDING_XMIT, &ai->flags);
1983 mpi_send_packet (dev);
1991 * Attempt to transmit a packet. Can be called from interrupt
1992 * or transmit . return number of packets we tried to send
1995 static int mpi_send_packet (struct net_device *dev)
1997 struct sk_buff *skb;
1998 unsigned char *buffer;
1999 s16 len, *payloadLen;
2000 struct airo_info *ai = dev->priv;
2003 /* get a packet to send */
2005 if ((skb = skb_dequeue(&ai->txq)) == 0) {
2006 airo_print_err(dev->name,
2007 "%s: Dequeue'd zero in send_packet()",
2012 /* check min length*/
2013 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2016 ai->txfids[0].tx_desc.offset = 0;
2017 ai->txfids[0].tx_desc.valid = 1;
2018 ai->txfids[0].tx_desc.eoc = 1;
2019 ai->txfids[0].tx_desc.len =len+sizeof(WifiHdr);
2022 * Magic, the cards firmware needs a length count (2 bytes) in the host buffer
2023 * right after TXFID_HDR.The TXFID_HDR contains the status short so payloadlen
2024 * is immediatly after it. ------------------------------------------------
2025 * |TXFIDHDR+STATUS|PAYLOADLEN|802.3HDR|PACKETDATA|
2026 * ------------------------------------------------
2029 memcpy((char *)ai->txfids[0].virtual_host_addr,
2030 (char *)&wifictlhdr8023, sizeof(wifictlhdr8023));
2032 payloadLen = (s16 *)(ai->txfids[0].virtual_host_addr +
2033 sizeof(wifictlhdr8023));
2034 sendbuf = ai->txfids[0].virtual_host_addr +
2035 sizeof(wifictlhdr8023) + 2 ;
2038 * Firmware automaticly puts 802 header on so
2039 * we don't need to account for it in the length
2041 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
2042 (ntohs(((u16 *)buffer)[6]) != 0x888E)) {
2045 if (encapsulate(ai, (etherHead *)buffer, &pMic, len - sizeof(etherHead)) != SUCCESS)
2048 *payloadLen = cpu_to_le16(len-sizeof(etherHead)+sizeof(pMic));
2049 ai->txfids[0].tx_desc.len += sizeof(pMic);
2050 /* copy data into airo dma buffer */
2051 memcpy (sendbuf, buffer, sizeof(etherHead));
2052 buffer += sizeof(etherHead);
2053 sendbuf += sizeof(etherHead);
2054 memcpy (sendbuf, &pMic, sizeof(pMic));
2055 sendbuf += sizeof(pMic);
2056 memcpy (sendbuf, buffer, len - sizeof(etherHead));
2058 *payloadLen = cpu_to_le16(len - sizeof(etherHead));
2060 dev->trans_start = jiffies;
2062 /* copy data into airo dma buffer */
2063 memcpy(sendbuf, buffer, len);
2066 memcpy_toio(ai->txfids[0].card_ram_off,
2067 &ai->txfids[0].tx_desc, sizeof(TxFid));
2069 OUT4500(ai, EVACK, 8);
2071 dev_kfree_skb_any(skb);
2075 static void get_tx_error(struct airo_info *ai, s32 fid)
2080 status = ((WifiCtlHdr *)ai->txfids[0].virtual_host_addr)->ctlhdr.status;
2082 if (bap_setup(ai, ai->fids[fid] & 0xffff, 4, BAP0) != SUCCESS)
2084 bap_read(ai, &status, 2, BAP0);
2086 if (le16_to_cpu(status) & 2) /* Too many retries */
2087 ai->stats.tx_aborted_errors++;
2088 if (le16_to_cpu(status) & 4) /* Transmit lifetime exceeded */
2089 ai->stats.tx_heartbeat_errors++;
2090 if (le16_to_cpu(status) & 8) /* Aid fail */
2092 if (le16_to_cpu(status) & 0x10) /* MAC disabled */
2093 ai->stats.tx_carrier_errors++;
2094 if (le16_to_cpu(status) & 0x20) /* Association lost */
2096 /* We produce a TXDROP event only for retry or lifetime
2097 * exceeded, because that's the only status that really mean
2098 * that this particular node went away.
2099 * Other errors means that *we* screwed up. - Jean II */
2100 if ((le16_to_cpu(status) & 2) ||
2101 (le16_to_cpu(status) & 4)) {
2102 union iwreq_data wrqu;
2105 /* Faster to skip over useless data than to do
2106 * another bap_setup(). We are at offset 0x6 and
2107 * need to go to 0x18 and read 6 bytes - Jean II */
2108 bap_read(ai, (u16 *) junk, 0x18, BAP0);
2110 /* Copy 802.11 dest address.
2111 * We use the 802.11 header because the frame may
2112 * not be 802.3 or may be mangled...
2113 * In Ad-Hoc mode, it will be the node address.
2114 * In managed mode, it will be most likely the AP addr
2115 * User space will figure out how to convert it to
2116 * whatever it needs (IP address or else).
2118 memcpy(wrqu.addr.sa_data, junk + 0x12, ETH_ALEN);
2119 wrqu.addr.sa_family = ARPHRD_ETHER;
2121 /* Send event to user space */
2122 wireless_send_event(ai->dev, IWEVTXDROP, &wrqu, NULL);
2126 static void airo_end_xmit(struct net_device *dev) {
2129 struct airo_info *priv = dev->priv;
2130 struct sk_buff *skb = priv->xmit.skb;
2131 int fid = priv->xmit.fid;
2132 u32 *fids = priv->fids;
2134 clear_bit(JOB_XMIT, &priv->jobs);
2135 clear_bit(FLAG_PENDING_XMIT, &priv->flags);
2136 status = transmit_802_3_packet (priv, fids[fid], skb->data);
2140 if ( status == SUCCESS ) {
2141 dev->trans_start = jiffies;
2142 for (; i < MAX_FIDS / 2 && (priv->fids[i] & 0xffff0000); i++);
2144 priv->fids[fid] &= 0xffff;
2145 priv->stats.tx_window_errors++;
2147 if (i < MAX_FIDS / 2)
2148 netif_wake_queue(dev);
2152 static int airo_start_xmit(struct sk_buff *skb, struct net_device *dev) {
2155 struct airo_info *priv = dev->priv;
2156 u32 *fids = priv->fids;
2158 if ( skb == NULL ) {
2159 airo_print_err(dev->name, "%s: skb == NULL!", __FUNCTION__);
2163 /* Find a vacant FID */
2164 for( i = 0; i < MAX_FIDS / 2 && (fids[i] & 0xffff0000); i++ );
2165 for( j = i + 1; j < MAX_FIDS / 2 && (fids[j] & 0xffff0000); j++ );
2167 if ( j >= MAX_FIDS / 2 ) {
2168 netif_stop_queue(dev);
2170 if (i == MAX_FIDS / 2) {
2171 priv->stats.tx_fifo_errors++;
2175 /* check min length*/
2176 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2177 /* Mark fid as used & save length for later */
2178 fids[i] |= (len << 16);
2179 priv->xmit.skb = skb;
2181 if (down_trylock(&priv->sem) != 0) {
2182 set_bit(FLAG_PENDING_XMIT, &priv->flags);
2183 netif_stop_queue(dev);
2184 set_bit(JOB_XMIT, &priv->jobs);
2185 wake_up_interruptible(&priv->thr_wait);
2191 static void airo_end_xmit11(struct net_device *dev) {
2194 struct airo_info *priv = dev->priv;
2195 struct sk_buff *skb = priv->xmit11.skb;
2196 int fid = priv->xmit11.fid;
2197 u32 *fids = priv->fids;
2199 clear_bit(JOB_XMIT11, &priv->jobs);
2200 clear_bit(FLAG_PENDING_XMIT11, &priv->flags);
2201 status = transmit_802_11_packet (priv, fids[fid], skb->data);
2205 if ( status == SUCCESS ) {
2206 dev->trans_start = jiffies;
2207 for (; i < MAX_FIDS && (priv->fids[i] & 0xffff0000); i++);
2209 priv->fids[fid] &= 0xffff;
2210 priv->stats.tx_window_errors++;
2213 netif_wake_queue(dev);
2217 static int airo_start_xmit11(struct sk_buff *skb, struct net_device *dev) {
2220 struct airo_info *priv = dev->priv;
2221 u32 *fids = priv->fids;
2223 if (test_bit(FLAG_MPI, &priv->flags)) {
2224 /* Not implemented yet for MPI350 */
2225 netif_stop_queue(dev);
2229 if ( skb == NULL ) {
2230 airo_print_err(dev->name, "%s: skb == NULL!", __FUNCTION__);
2234 /* Find a vacant FID */
2235 for( i = MAX_FIDS / 2; i < MAX_FIDS && (fids[i] & 0xffff0000); i++ );
2236 for( j = i + 1; j < MAX_FIDS && (fids[j] & 0xffff0000); j++ );
2238 if ( j >= MAX_FIDS ) {
2239 netif_stop_queue(dev);
2241 if (i == MAX_FIDS) {
2242 priv->stats.tx_fifo_errors++;
2246 /* check min length*/
2247 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2248 /* Mark fid as used & save length for later */
2249 fids[i] |= (len << 16);
2250 priv->xmit11.skb = skb;
2251 priv->xmit11.fid = i;
2252 if (down_trylock(&priv->sem) != 0) {
2253 set_bit(FLAG_PENDING_XMIT11, &priv->flags);
2254 netif_stop_queue(dev);
2255 set_bit(JOB_XMIT11, &priv->jobs);
2256 wake_up_interruptible(&priv->thr_wait);
2258 airo_end_xmit11(dev);
2262 static void airo_read_stats(struct airo_info *ai) {
2264 u32 *vals = stats_rid.vals;
2266 clear_bit(JOB_STATS, &ai->jobs);
2267 if (ai->power.event) {
2271 readStatsRid(ai, &stats_rid, RID_STATS, 0);
2274 ai->stats.rx_packets = vals[43] + vals[44] + vals[45];
2275 ai->stats.tx_packets = vals[39] + vals[40] + vals[41];
2276 ai->stats.rx_bytes = vals[92];
2277 ai->stats.tx_bytes = vals[91];
2278 ai->stats.rx_errors = vals[0] + vals[2] + vals[3] + vals[4];
2279 ai->stats.tx_errors = vals[42] + ai->stats.tx_fifo_errors;
2280 ai->stats.multicast = vals[43];
2281 ai->stats.collisions = vals[89];
2283 /* detailed rx_errors: */
2284 ai->stats.rx_length_errors = vals[3];
2285 ai->stats.rx_crc_errors = vals[4];
2286 ai->stats.rx_frame_errors = vals[2];
2287 ai->stats.rx_fifo_errors = vals[0];
2290 static struct net_device_stats *airo_get_stats(struct net_device *dev)
2292 struct airo_info *local = dev->priv;
2294 if (!test_bit(JOB_STATS, &local->jobs)) {
2295 /* Get stats out of the card if available */
2296 if (down_trylock(&local->sem) != 0) {
2297 set_bit(JOB_STATS, &local->jobs);
2298 wake_up_interruptible(&local->thr_wait);
2300 airo_read_stats(local);
2303 return &local->stats;
2306 static void airo_set_promisc(struct airo_info *ai) {
2310 memset(&cmd, 0, sizeof(cmd));
2311 cmd.cmd=CMD_SETMODE;
2312 clear_bit(JOB_PROMISC, &ai->jobs);
2313 cmd.parm0=(ai->flags&IFF_PROMISC) ? PROMISC : NOPROMISC;
2314 issuecommand(ai, &cmd, &rsp);
2318 static void airo_set_multicast_list(struct net_device *dev) {
2319 struct airo_info *ai = dev->priv;
2321 if ((dev->flags ^ ai->flags) & IFF_PROMISC) {
2322 change_bit(FLAG_PROMISC, &ai->flags);
2323 if (down_trylock(&ai->sem) != 0) {
2324 set_bit(JOB_PROMISC, &ai->jobs);
2325 wake_up_interruptible(&ai->thr_wait);
2327 airo_set_promisc(ai);
2330 if ((dev->flags&IFF_ALLMULTI)||dev->mc_count>0) {
2331 /* Turn on multicast. (Should be already setup...) */
2335 static int airo_set_mac_address(struct net_device *dev, void *p)
2337 struct airo_info *ai = dev->priv;
2338 struct sockaddr *addr = p;
2341 readConfigRid(ai, 1);
2342 memcpy (ai->config.macAddr, addr->sa_data, dev->addr_len);
2343 set_bit (FLAG_COMMIT, &ai->flags);
2345 writeConfigRid (ai, 1);
2346 enable_MAC(ai, &rsp, 1);
2347 memcpy (ai->dev->dev_addr, addr->sa_data, dev->addr_len);
2349 memcpy (ai->wifidev->dev_addr, addr->sa_data, dev->addr_len);
2353 static int airo_change_mtu(struct net_device *dev, int new_mtu)
2355 if ((new_mtu < 68) || (new_mtu > 2400))
2362 static int airo_close(struct net_device *dev) {
2363 struct airo_info *ai = dev->priv;
2365 netif_stop_queue(dev);
2367 if (ai->wifidev != dev) {
2368 #ifdef POWER_ON_DOWN
2369 /* Shut power to the card. The idea is that the user can save
2370 * power when he doesn't need the card with "ifconfig down".
2371 * That's the method that is most friendly towards the network
2372 * stack (i.e. the network stack won't try to broadcast
2373 * anything on the interface and routes are gone. Jean II */
2374 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2377 disable_interrupts( ai );
2382 static void del_airo_dev( struct net_device *dev );
2384 void stop_airo_card( struct net_device *dev, int freeres )
2386 struct airo_info *ai = dev->priv;
2388 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2390 disable_interrupts(ai);
2391 free_irq( dev->irq, dev );
2392 takedown_proc_entry( dev, ai );
2393 if (test_bit(FLAG_REGISTERED, &ai->flags)) {
2394 unregister_netdev( dev );
2396 unregister_netdev(ai->wifidev);
2397 free_netdev(ai->wifidev);
2400 clear_bit(FLAG_REGISTERED, &ai->flags);
2402 set_bit(JOB_DIE, &ai->jobs);
2403 kill_proc(ai->thr_pid, SIGTERM, 1);
2404 wait_for_completion(&ai->thr_exited);
2407 * Clean out tx queue
2409 if (test_bit(FLAG_MPI, &ai->flags) && !skb_queue_empty(&ai->txq)) {
2410 struct sk_buff *skb = NULL;
2411 for (;(skb = skb_dequeue(&ai->txq));)
2415 airo_networks_free (ai);
2422 /* PCMCIA frees this stuff, so only for PCI and ISA */
2423 release_region( dev->base_addr, 64 );
2424 if (test_bit(FLAG_MPI, &ai->flags)) {
2426 mpi_unmap_card(ai->pci);
2428 iounmap(ai->pcimem);
2430 iounmap(ai->pciaux);
2431 pci_free_consistent(ai->pci, PCI_SHARED_LEN,
2432 ai->shared, ai->shared_dma);
2435 crypto_free_tfm(ai->tfm);
2436 del_airo_dev( dev );
2440 EXPORT_SYMBOL(stop_airo_card);
2442 static int add_airo_dev( struct net_device *dev );
2444 static int wll_header_parse(struct sk_buff *skb, unsigned char *haddr)
2446 memcpy(haddr, skb->mac.raw + 10, ETH_ALEN);
2450 static void mpi_unmap_card(struct pci_dev *pci)
2452 unsigned long mem_start = pci_resource_start(pci, 1);
2453 unsigned long mem_len = pci_resource_len(pci, 1);
2454 unsigned long aux_start = pci_resource_start(pci, 2);
2455 unsigned long aux_len = AUXMEMSIZE;
2457 release_mem_region(aux_start, aux_len);
2458 release_mem_region(mem_start, mem_len);
2461 /*************************************************************
2462 * This routine assumes that descriptors have been setup .
2463 * Run at insmod time or after reset when the decriptors
2464 * have been initialized . Returns 0 if all is well nz
2465 * otherwise . Does not allocate memory but sets up card
2466 * using previously allocated descriptors.
2468 static int mpi_init_descriptors (struct airo_info *ai)
2475 /* Alloc card RX descriptors */
2476 netif_stop_queue(ai->dev);
2478 memset(&rsp,0,sizeof(rsp));
2479 memset(&cmd,0,sizeof(cmd));
2481 cmd.cmd = CMD_ALLOCATEAUX;
2483 cmd.parm1 = (ai->rxfids[0].card_ram_off - ai->pciaux);
2484 cmd.parm2 = MPI_MAX_FIDS;
2485 rc=issuecommand(ai, &cmd, &rsp);
2486 if (rc != SUCCESS) {
2487 airo_print_err(ai->dev->name, "Couldn't allocate RX FID");
2491 for (i=0; i<MPI_MAX_FIDS; i++) {
2492 memcpy_toio(ai->rxfids[i].card_ram_off,
2493 &ai->rxfids[i].rx_desc, sizeof(RxFid));
2496 /* Alloc card TX descriptors */
2498 memset(&rsp,0,sizeof(rsp));
2499 memset(&cmd,0,sizeof(cmd));
2501 cmd.cmd = CMD_ALLOCATEAUX;
2503 cmd.parm1 = (ai->txfids[0].card_ram_off - ai->pciaux);
2504 cmd.parm2 = MPI_MAX_FIDS;
2506 for (i=0; i<MPI_MAX_FIDS; i++) {
2507 ai->txfids[i].tx_desc.valid = 1;
2508 memcpy_toio(ai->txfids[i].card_ram_off,
2509 &ai->txfids[i].tx_desc, sizeof(TxFid));
2511 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2513 rc=issuecommand(ai, &cmd, &rsp);
2514 if (rc != SUCCESS) {
2515 airo_print_err(ai->dev->name, "Couldn't allocate TX FID");
2519 /* Alloc card Rid descriptor */
2520 memset(&rsp,0,sizeof(rsp));
2521 memset(&cmd,0,sizeof(cmd));
2523 cmd.cmd = CMD_ALLOCATEAUX;
2525 cmd.parm1 = (ai->config_desc.card_ram_off - ai->pciaux);
2526 cmd.parm2 = 1; /* Magic number... */
2527 rc=issuecommand(ai, &cmd, &rsp);
2528 if (rc != SUCCESS) {
2529 airo_print_err(ai->dev->name, "Couldn't allocate RID");
2533 memcpy_toio(ai->config_desc.card_ram_off,
2534 &ai->config_desc.rid_desc, sizeof(Rid));
2540 * We are setting up three things here:
2541 * 1) Map AUX memory for descriptors: Rid, TxFid, or RxFid.
2542 * 2) Map PCI memory for issueing commands.
2543 * 3) Allocate memory (shared) to send and receive ethernet frames.
2545 static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci,
2548 unsigned long mem_start, mem_len, aux_start, aux_len;
2551 dma_addr_t busaddroff;
2552 unsigned char *vpackoff;
2553 unsigned char __iomem *pciaddroff;
2555 mem_start = pci_resource_start(pci, 1);
2556 mem_len = pci_resource_len(pci, 1);
2557 aux_start = pci_resource_start(pci, 2);
2558 aux_len = AUXMEMSIZE;
2560 if (!request_mem_region(mem_start, mem_len, name)) {
2561 airo_print_err(ai->dev->name, "Couldn't get region %x[%x] for %s",
2562 (int)mem_start, (int)mem_len, name);
2565 if (!request_mem_region(aux_start, aux_len, name)) {
2566 airo_print_err(ai->dev->name, "Couldn't get region %x[%x] for %s",
2567 (int)aux_start, (int)aux_len, name);
2571 ai->pcimem = ioremap(mem_start, mem_len);
2573 airo_print_err(ai->dev->name, "Couldn't map region %x[%x] for %s",
2574 (int)mem_start, (int)mem_len, name);
2577 ai->pciaux = ioremap(aux_start, aux_len);
2579 airo_print_err(ai->dev->name, "Couldn't map region %x[%x] for %s",
2580 (int)aux_start, (int)aux_len, name);
2584 /* Reserve PKTSIZE for each fid and 2K for the Rids */
2585 ai->shared = pci_alloc_consistent(pci, PCI_SHARED_LEN, &ai->shared_dma);
2587 airo_print_err(ai->dev->name, "Couldn't alloc_consistent %d",
2593 * Setup descriptor RX, TX, CONFIG
2595 busaddroff = ai->shared_dma;
2596 pciaddroff = ai->pciaux + AUX_OFFSET;
2597 vpackoff = ai->shared;
2599 /* RX descriptor setup */
2600 for(i = 0; i < MPI_MAX_FIDS; i++) {
2601 ai->rxfids[i].pending = 0;
2602 ai->rxfids[i].card_ram_off = pciaddroff;
2603 ai->rxfids[i].virtual_host_addr = vpackoff;
2604 ai->rxfids[i].rx_desc.host_addr = busaddroff;
2605 ai->rxfids[i].rx_desc.valid = 1;
2606 ai->rxfids[i].rx_desc.len = PKTSIZE;
2607 ai->rxfids[i].rx_desc.rdy = 0;
2609 pciaddroff += sizeof(RxFid);
2610 busaddroff += PKTSIZE;
2611 vpackoff += PKTSIZE;
2614 /* TX descriptor setup */
2615 for(i = 0; i < MPI_MAX_FIDS; i++) {
2616 ai->txfids[i].card_ram_off = pciaddroff;
2617 ai->txfids[i].virtual_host_addr = vpackoff;
2618 ai->txfids[i].tx_desc.valid = 1;
2619 ai->txfids[i].tx_desc.host_addr = busaddroff;
2620 memcpy(ai->txfids[i].virtual_host_addr,
2621 &wifictlhdr8023, sizeof(wifictlhdr8023));
2623 pciaddroff += sizeof(TxFid);
2624 busaddroff += PKTSIZE;
2625 vpackoff += PKTSIZE;
2627 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2629 /* Rid descriptor setup */
2630 ai->config_desc.card_ram_off = pciaddroff;
2631 ai->config_desc.virtual_host_addr = vpackoff;
2632 ai->config_desc.rid_desc.host_addr = busaddroff;
2633 ai->ridbus = busaddroff;
2634 ai->config_desc.rid_desc.rid = 0;
2635 ai->config_desc.rid_desc.len = RIDSIZE;
2636 ai->config_desc.rid_desc.valid = 1;
2637 pciaddroff += sizeof(Rid);
2638 busaddroff += RIDSIZE;
2639 vpackoff += RIDSIZE;
2641 /* Tell card about descriptors */
2642 if (mpi_init_descriptors (ai) != SUCCESS)
2647 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2649 iounmap(ai->pciaux);
2651 iounmap(ai->pcimem);
2653 release_mem_region(aux_start, aux_len);
2655 release_mem_region(mem_start, mem_len);
2660 static void wifi_setup(struct net_device *dev)
2662 dev->hard_header = NULL;
2663 dev->rebuild_header = NULL;
2664 dev->hard_header_cache = NULL;
2665 dev->header_cache_update= NULL;
2667 dev->hard_header_parse = wll_header_parse;
2668 dev->hard_start_xmit = &airo_start_xmit11;
2669 dev->get_stats = &airo_get_stats;
2670 dev->set_mac_address = &airo_set_mac_address;
2671 dev->do_ioctl = &airo_ioctl;
2672 dev->wireless_handlers = &airo_handler_def;
2673 dev->change_mtu = &airo_change_mtu;
2674 dev->open = &airo_open;
2675 dev->stop = &airo_close;
2677 dev->type = ARPHRD_IEEE80211;
2678 dev->hard_header_len = ETH_HLEN;
2679 dev->mtu = AIRO_DEF_MTU;
2680 dev->addr_len = ETH_ALEN;
2681 dev->tx_queue_len = 100;
2683 memset(dev->broadcast,0xFF, ETH_ALEN);
2685 dev->flags = IFF_BROADCAST|IFF_MULTICAST;
2688 static struct net_device *init_wifidev(struct airo_info *ai,
2689 struct net_device *ethdev)
2692 struct net_device *dev = alloc_netdev(0, "wifi%d", wifi_setup);
2695 dev->priv = ethdev->priv;
2696 dev->irq = ethdev->irq;
2697 dev->base_addr = ethdev->base_addr;
2698 dev->wireless_data = ethdev->wireless_data;
2699 memcpy(dev->dev_addr, ethdev->dev_addr, dev->addr_len);
2700 err = register_netdev(dev);
2708 static int reset_card( struct net_device *dev , int lock) {
2709 struct airo_info *ai = dev->priv;
2711 if (lock && down_interruptible(&ai->sem))
2714 OUT4500(ai,COMMAND,CMD_SOFTRESET);
2723 #define AIRO_MAX_NETWORK_COUNT 64
2724 static int airo_networks_allocate(struct airo_info *ai)
2730 kzalloc(AIRO_MAX_NETWORK_COUNT * sizeof(BSSListElement),
2732 if (!ai->networks) {
2733 airo_print_warn(ai->dev->name, "Out of memory allocating beacons");
2740 static void airo_networks_free(struct airo_info *ai)
2744 kfree(ai->networks);
2745 ai->networks = NULL;
2748 static void airo_networks_initialize(struct airo_info *ai)
2752 INIT_LIST_HEAD(&ai->network_free_list);
2753 INIT_LIST_HEAD(&ai->network_list);
2754 for (i = 0; i < AIRO_MAX_NETWORK_COUNT; i++)
2755 list_add_tail(&ai->networks[i].list,
2756 &ai->network_free_list);
2759 static int airo_test_wpa_capable(struct airo_info *ai)
2762 CapabilityRid cap_rid;
2763 const char *name = ai->dev->name;
2765 status = readCapabilityRid(ai, &cap_rid, 1);
2766 if (status != SUCCESS) return 0;
2768 /* Only firmware versions 5.30.17 or better can do WPA */
2769 if ((cap_rid.softVer > 0x530)
2770 || ((cap_rid.softVer == 0x530) && (cap_rid.softSubVer >= 17))) {
2771 airo_print_info(name, "WPA is supported.");
2775 /* No WPA support */
2776 airo_print_info(name, "WPA unsupported (only firmware versions 5.30.17"
2777 " and greater support WPA. Detected %s)", cap_rid.prodVer);
2781 static struct net_device *_init_airo_card( unsigned short irq, int port,
2782 int is_pcmcia, struct pci_dev *pci,
2783 struct device *dmdev )
2785 struct net_device *dev;
2786 struct airo_info *ai;
2789 /* Create the network device object. */
2790 dev = alloc_etherdev(sizeof(*ai));
2792 airo_print_err("", "Couldn't alloc_etherdev");
2795 if (dev_alloc_name(dev, dev->name) < 0) {
2796 airo_print_err("", "Couldn't get name!");
2805 if (pci && (pci->device == 0x5000 || pci->device == 0xa504)) {
2806 airo_print_dbg(dev->name, "Found an MPI350 card");
2807 set_bit(FLAG_MPI, &ai->flags);
2809 spin_lock_init(&ai->aux_lock);
2810 sema_init(&ai->sem, 1);
2813 init_waitqueue_head (&ai->thr_wait);
2814 init_completion (&ai->thr_exited);
2815 ai->thr_pid = kernel_thread(airo_thread, dev, CLONE_FS | CLONE_FILES);
2816 if (ai->thr_pid < 0)
2819 rc = add_airo_dev( dev );
2823 if (airo_networks_allocate (ai))
2824 goto err_out_unlink;
2825 airo_networks_initialize (ai);
2827 /* The Airo-specific entries in the device structure. */
2828 if (test_bit(FLAG_MPI,&ai->flags)) {
2829 skb_queue_head_init (&ai->txq);
2830 dev->hard_start_xmit = &mpi_start_xmit;
2832 dev->hard_start_xmit = &airo_start_xmit;
2833 dev->get_stats = &airo_get_stats;
2834 dev->set_multicast_list = &airo_set_multicast_list;
2835 dev->set_mac_address = &airo_set_mac_address;
2836 dev->do_ioctl = &airo_ioctl;
2837 dev->wireless_handlers = &airo_handler_def;
2838 ai->wireless_data.spy_data = &ai->spy_data;
2839 dev->wireless_data = &ai->wireless_data;
2840 dev->change_mtu = &airo_change_mtu;
2841 dev->open = &airo_open;
2842 dev->stop = &airo_close;
2844 dev->base_addr = port;
2846 SET_NETDEV_DEV(dev, dmdev);
2848 reset_card (dev, 1);
2851 rc = request_irq( dev->irq, airo_interrupt, IRQF_SHARED, dev->name, dev );
2853 airo_print_err(dev->name, "register interrupt %d failed, rc %d",
2855 goto err_out_unlink;
2858 if (!request_region( dev->base_addr, 64, dev->name )) {
2860 airo_print_err(dev->name, "Couldn't request region");
2865 if (test_bit(FLAG_MPI,&ai->flags)) {
2866 if (mpi_map_card(ai, pci, dev->name)) {
2867 airo_print_err(dev->name, "Could not map memory");
2873 if ( setup_card( ai, dev->dev_addr, 1 ) != SUCCESS ) {
2874 airo_print_err(dev->name, "MAC could not be enabled" );
2878 } else if (!test_bit(FLAG_MPI,&ai->flags)) {
2879 ai->bap_read = fast_bap_read;
2880 set_bit(FLAG_FLASHING, &ai->flags);
2883 /* Test for WPA support */
2884 if (airo_test_wpa_capable(ai)) {
2885 set_bit(FLAG_WPA_CAPABLE, &ai->flags);
2886 ai->bssListFirst = RID_WPA_BSSLISTFIRST;
2887 ai->bssListNext = RID_WPA_BSSLISTNEXT;
2888 ai->bssListRidLen = sizeof(BSSListRid);
2890 ai->bssListFirst = RID_BSSLISTFIRST;
2891 ai->bssListNext = RID_BSSLISTNEXT;
2892 ai->bssListRidLen = sizeof(BSSListRid) - sizeof(BSSListRidExtra);
2895 rc = register_netdev(dev);
2897 airo_print_err(dev->name, "Couldn't register_netdev");
2900 ai->wifidev = init_wifidev(ai, dev);
2902 set_bit(FLAG_REGISTERED,&ai->flags);
2903 airo_print_info(dev->name, "MAC enabled %x:%x:%x:%x:%x:%x",
2904 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
2905 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5] );
2907 /* Allocate the transmit buffers */
2908 if (probe && !test_bit(FLAG_MPI,&ai->flags))
2909 for( i = 0; i < MAX_FIDS; i++ )
2910 ai->fids[i] = transmit_allocate(ai,AIRO_DEF_MTU,i>=MAX_FIDS/2);
2912 setup_proc_entry( dev, dev->priv ); /* XXX check for failure */
2913 netif_start_queue(dev);
2914 SET_MODULE_OWNER(dev);
2918 if (test_bit(FLAG_MPI,&ai->flags) && pci) {
2919 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2920 iounmap(ai->pciaux);
2921 iounmap(ai->pcimem);
2922 mpi_unmap_card(ai->pci);
2926 release_region( dev->base_addr, 64 );
2928 free_irq(dev->irq, dev);
2932 set_bit(JOB_DIE, &ai->jobs);
2933 kill_proc(ai->thr_pid, SIGTERM, 1);
2934 wait_for_completion(&ai->thr_exited);
2940 struct net_device *init_airo_card( unsigned short irq, int port, int is_pcmcia,
2941 struct device *dmdev)
2943 return _init_airo_card ( irq, port, is_pcmcia, NULL, dmdev);
2946 EXPORT_SYMBOL(init_airo_card);
2948 static int waitbusy (struct airo_info *ai) {
2950 while ((IN4500 (ai, COMMAND) & COMMAND_BUSY) & (delay < 10000)) {
2952 if ((++delay % 20) == 0)
2953 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
2955 return delay < 10000;
2958 int reset_airo_card( struct net_device *dev )
2961 struct airo_info *ai = dev->priv;
2963 if (reset_card (dev, 1))
2966 if ( setup_card(ai, dev->dev_addr, 1 ) != SUCCESS ) {
2967 airo_print_err(dev->name, "MAC could not be enabled");
2970 airo_print_info(dev->name, "MAC enabled %x:%x:%x:%x:%x:%x",
2971 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
2972 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
2973 /* Allocate the transmit buffers if needed */
2974 if (!test_bit(FLAG_MPI,&ai->flags))
2975 for( i = 0; i < MAX_FIDS; i++ )
2976 ai->fids[i] = transmit_allocate (ai,AIRO_DEF_MTU,i>=MAX_FIDS/2);
2978 enable_interrupts( ai );
2979 netif_wake_queue(dev);
2983 EXPORT_SYMBOL(reset_airo_card);
2985 static void airo_send_event(struct net_device *dev) {
2986 struct airo_info *ai = dev->priv;
2987 union iwreq_data wrqu;
2988 StatusRid status_rid;
2990 clear_bit(JOB_EVENT, &ai->jobs);
2991 PC4500_readrid(ai, RID_STATUS, &status_rid, sizeof(status_rid), 0);
2993 wrqu.data.length = 0;
2994 wrqu.data.flags = 0;
2995 memcpy(wrqu.ap_addr.sa_data, status_rid.bssid[0], ETH_ALEN);
2996 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
2998 /* Send event to user space */
2999 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
3002 static void airo_process_scan_results (struct airo_info *ai) {
3003 union iwreq_data wrqu;
3006 BSSListElement * loop_net;
3007 BSSListElement * tmp_net;
3009 /* Blow away current list of scan results */
3010 list_for_each_entry_safe (loop_net, tmp_net, &ai->network_list, list) {
3011 list_move_tail (&loop_net->list, &ai->network_free_list);
3012 /* Don't blow away ->list, just BSS data */
3013 memset (loop_net, 0, sizeof (loop_net->bss));
3016 /* Try to read the first entry of the scan result */
3017 rc = PC4500_readrid(ai, ai->bssListFirst, &bss, ai->bssListRidLen, 0);
3018 if((rc) || (bss.index == 0xffff)) {
3019 /* No scan results */
3023 /* Read and parse all entries */
3025 while((!rc) && (bss.index != 0xffff)) {
3026 /* Grab a network off the free list */
3027 if (!list_empty(&ai->network_free_list)) {
3028 tmp_net = list_entry(ai->network_free_list.next,
3029 BSSListElement, list);
3030 list_del(ai->network_free_list.next);
3033 if (tmp_net != NULL) {
3034 memcpy(tmp_net, &bss, sizeof(tmp_net->bss));
3035 list_add_tail(&tmp_net->list, &ai->network_list);
3039 /* Read next entry */
3040 rc = PC4500_readrid(ai, ai->bssListNext,
3041 &bss, ai->bssListRidLen, 0);
3045 ai->scan_timeout = 0;
3046 clear_bit(JOB_SCAN_RESULTS, &ai->jobs);
3049 /* Send an empty event to user space.
3050 * We don't send the received data on
3051 * the event because it would require
3052 * us to do complex transcoding, and
3053 * we want to minimise the work done in
3054 * the irq handler. Use a request to
3055 * extract the data - Jean II */
3056 wrqu.data.length = 0;
3057 wrqu.data.flags = 0;
3058 wireless_send_event(ai->dev, SIOCGIWSCAN, &wrqu, NULL);
3061 static int airo_thread(void *data) {
3062 struct net_device *dev = data;
3063 struct airo_info *ai = dev->priv;
3066 daemonize("%s", dev->name);
3067 allow_signal(SIGTERM);
3070 if (signal_pending(current))
3071 flush_signals(current);
3073 /* make swsusp happy with our thread */
3076 if (test_bit(JOB_DIE, &ai->jobs))
3080 locked = down_interruptible(&ai->sem);
3084 init_waitqueue_entry(&wait, current);
3085 add_wait_queue(&ai->thr_wait, &wait);
3087 set_current_state(TASK_INTERRUPTIBLE);
3090 if (ai->expires || ai->scan_timeout) {
3091 if (ai->scan_timeout &&
3092 time_after_eq(jiffies,ai->scan_timeout)){
3093 set_bit(JOB_SCAN_RESULTS, &ai->jobs);
3095 } else if (ai->expires &&
3096 time_after_eq(jiffies,ai->expires)){
3097 set_bit(JOB_AUTOWEP, &ai->jobs);
3100 if (!signal_pending(current)) {
3101 unsigned long wake_at;
3102 if (!ai->expires || !ai->scan_timeout) {
3103 wake_at = max(ai->expires,
3106 wake_at = min(ai->expires,
3109 schedule_timeout(wake_at - jiffies);
3112 } else if (!signal_pending(current)) {
3118 current->state = TASK_RUNNING;
3119 remove_wait_queue(&ai->thr_wait, &wait);
3126 if (test_bit(JOB_DIE, &ai->jobs)) {
3131 if (ai->power.event || test_bit(FLAG_FLASHING, &ai->flags)) {
3136 if (test_bit(JOB_XMIT, &ai->jobs))
3138 else if (test_bit(JOB_XMIT11, &ai->jobs))
3139 airo_end_xmit11(dev);
3140 else if (test_bit(JOB_STATS, &ai->jobs))
3141 airo_read_stats(ai);
3142 else if (test_bit(JOB_WSTATS, &ai->jobs))
3143 airo_read_wireless_stats(ai);
3144 else if (test_bit(JOB_PROMISC, &ai->jobs))
3145 airo_set_promisc(ai);
3146 else if (test_bit(JOB_MIC, &ai->jobs))
3148 else if (test_bit(JOB_EVENT, &ai->jobs))
3149 airo_send_event(dev);
3150 else if (test_bit(JOB_AUTOWEP, &ai->jobs))
3152 else if (test_bit(JOB_SCAN_RESULTS, &ai->jobs))
3153 airo_process_scan_results(ai);
3154 else /* Shouldn't get here, but we make sure to unlock */
3157 complete_and_exit (&ai->thr_exited, 0);
3160 static irqreturn_t airo_interrupt ( int irq, void* dev_id, struct pt_regs *regs) {
3161 struct net_device *dev = (struct net_device *)dev_id;
3164 struct airo_info *apriv = dev->priv;
3165 u16 savedInterrupts = 0;
3168 if (!netif_device_present(dev))
3172 status = IN4500( apriv, EVSTAT );
3173 if ( !(status & STATUS_INTS) || status == 0xffff ) break;
3177 if ( status & EV_AWAKE ) {
3178 OUT4500( apriv, EVACK, EV_AWAKE );
3179 OUT4500( apriv, EVACK, EV_AWAKE );
3182 if (!savedInterrupts) {
3183 savedInterrupts = IN4500( apriv, EVINTEN );
3184 OUT4500( apriv, EVINTEN, 0 );
3187 if ( status & EV_MIC ) {
3188 OUT4500( apriv, EVACK, EV_MIC );
3189 if (test_bit(FLAG_MIC_CAPABLE, &apriv->flags)) {
3190 set_bit(JOB_MIC, &apriv->jobs);
3191 wake_up_interruptible(&apriv->thr_wait);
3194 if ( status & EV_LINK ) {
3195 union iwreq_data wrqu;
3196 int scan_forceloss = 0;
3197 /* The link status has changed, if you want to put a
3198 monitor hook in, do it here. (Remember that
3199 interrupts are still disabled!)
3201 u16 newStatus = IN4500(apriv, LINKSTAT);
3202 OUT4500( apriv, EVACK, EV_LINK);
3203 /* Here is what newStatus means: */
3204 #define NOBEACON 0x8000 /* Loss of sync - missed beacons */
3205 #define MAXRETRIES 0x8001 /* Loss of sync - max retries */
3206 #define MAXARL 0x8002 /* Loss of sync - average retry level exceeded*/
3207 #define FORCELOSS 0x8003 /* Loss of sync - host request */
3208 #define TSFSYNC 0x8004 /* Loss of sync - TSF synchronization */
3209 #define DEAUTH 0x8100 /* Deauthentication (low byte is reason code) */
3210 #define DISASS 0x8200 /* Disassociation (low byte is reason code) */
3211 #define ASSFAIL 0x8400 /* Association failure (low byte is reason
3213 #define AUTHFAIL 0x0300 /* Authentication failure (low byte is reason
3215 #define ASSOCIATED 0x0400 /* Associated */
3216 #define REASSOCIATED 0x0600 /* Reassociated? Only on firmware >= 5.30.17 */
3217 #define RC_RESERVED 0 /* Reserved return code */
3218 #define RC_NOREASON 1 /* Unspecified reason */
3219 #define RC_AUTHINV 2 /* Previous authentication invalid */
3220 #define RC_DEAUTH 3 /* Deauthenticated because sending station is
3222 #define RC_NOACT 4 /* Disassociated due to inactivity */
3223 #define RC_MAXLOAD 5 /* Disassociated because AP is unable to handle
3224 all currently associated stations */
3225 #define RC_BADCLASS2 6 /* Class 2 frame received from
3226 non-Authenticated station */
3227 #define RC_BADCLASS3 7 /* Class 3 frame received from
3228 non-Associated station */
3229 #define RC_STATLEAVE 8 /* Disassociated because sending station is
3231 #define RC_NOAUTH 9 /* Station requesting (Re)Association is not
3232 Authenticated with the responding station */
3233 if (newStatus == FORCELOSS && apriv->scan_timeout > 0)
3235 if(newStatus == ASSOCIATED || newStatus == REASSOCIATED) {
3239 wake_up_process (apriv->task);
3240 set_bit(FLAG_UPDATE_UNI, &apriv->flags);
3241 set_bit(FLAG_UPDATE_MULTI, &apriv->flags);
3243 if (down_trylock(&apriv->sem) != 0) {
3244 set_bit(JOB_EVENT, &apriv->jobs);
3245 wake_up_interruptible(&apriv->thr_wait);
3247 airo_send_event(dev);
3248 } else if (!scan_forceloss) {
3249 if (auto_wep && !apriv->expires) {
3250 apriv->expires = RUN_AT(3*HZ);
3251 wake_up_interruptible(&apriv->thr_wait);
3254 /* Send event to user space */
3255 memset(wrqu.ap_addr.sa_data, '\0', ETH_ALEN);
3256 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
3257 wireless_send_event(dev, SIOCGIWAP, &wrqu,NULL);
3261 /* Check to see if there is something to receive */
3262 if ( status & EV_RX ) {
3263 struct sk_buff *skb = NULL;
3264 u16 fc, len, hdrlen = 0;
3278 if (test_bit(FLAG_MPI,&apriv->flags)) {
3279 if (test_bit(FLAG_802_11, &apriv->flags))
3280 mpi_receive_802_11(apriv);
3282 mpi_receive_802_3(apriv);
3283 OUT4500(apriv, EVACK, EV_RX);
3287 fid = IN4500( apriv, RXFID );
3289 /* Get the packet length */
3290 if (test_bit(FLAG_802_11, &apriv->flags)) {
3291 bap_setup (apriv, fid, 4, BAP0);
3292 bap_read (apriv, (u16*)&hdr, sizeof(hdr), BAP0);
3293 /* Bad CRC. Ignore packet */
3294 if (le16_to_cpu(hdr.status) & 2)
3296 if (apriv->wifidev == NULL)
3299 bap_setup (apriv, fid, 0x36, BAP0);
3300 bap_read (apriv, (u16*)&hdr.len, 2, BAP0);
3302 len = le16_to_cpu(hdr.len);
3304 if (len > AIRO_DEF_MTU) {
3305 airo_print_err(apriv->dev->name, "Bad size %d", len);
3311 if (test_bit(FLAG_802_11, &apriv->flags)) {
3312 bap_read (apriv, (u16*)&fc, sizeof(fc), BAP0);
3313 fc = le16_to_cpu(fc);
3316 if ((fc & 0xe0) == 0xc0)
3322 if ((fc&0x300)==0x300){
3330 hdrlen = ETH_ALEN * 2;
3332 skb = dev_alloc_skb( len + hdrlen + 2 + 2 );
3334 apriv->stats.rx_dropped++;
3337 skb_reserve(skb, 2); /* This way the IP header is aligned */
3338 buffer = (u16*)skb_put (skb, len + hdrlen);
3339 if (test_bit(FLAG_802_11, &apriv->flags)) {
3341 bap_read (apriv, buffer + 1, hdrlen - 2, BAP0);
3343 bap_read (apriv, tmpbuf, 6, BAP0);
3345 bap_read (apriv, &gap, sizeof(gap), BAP0);
3346 gap = le16_to_cpu(gap);
3349 bap_read (apriv, tmpbuf, gap, BAP0);
3351 airo_print_err(apriv->dev->name, "gaplen too "
3352 "big. Problems will follow...");
3355 bap_read (apriv, buffer + hdrlen/2, len, BAP0);
3358 bap_read (apriv, buffer, ETH_ALEN*2, BAP0);
3359 if (apriv->micstats.enabled) {
3360 bap_read (apriv,(u16*)&micbuf,sizeof(micbuf),BAP0);
3361 if (ntohs(micbuf.typelen) > 0x05DC)
3362 bap_setup (apriv, fid, 0x44, BAP0);
3364 if (len <= sizeof(micbuf))
3367 len -= sizeof(micbuf);
3368 skb_trim (skb, len + hdrlen);
3371 bap_read(apriv,buffer+ETH_ALEN,len,BAP0);
3372 if (decapsulate(apriv,&micbuf,(etherHead*)buffer,len)) {
3374 dev_kfree_skb_irq (skb);
3376 OUT4500( apriv, EVACK, EV_RX);
3381 if (apriv->spy_data.spy_number > 0) {
3383 struct iw_quality wstats;
3384 /* Prepare spy data : addr + qual */
3385 if (!test_bit(FLAG_802_11, &apriv->flags)) {
3386 sa = (char*)buffer + 6;
3387 bap_setup (apriv, fid, 8, BAP0);
3388 bap_read (apriv, (u16*)hdr.rssi, 2, BAP0);
3390 sa = (char*)buffer + 10;
3391 wstats.qual = hdr.rssi[0];
3393 wstats.level = 0x100 - apriv->rssi[hdr.rssi[1]].rssidBm;
3395 wstats.level = (hdr.rssi[1] + 321) / 2;
3396 wstats.noise = apriv->wstats.qual.noise;
3397 wstats.updated = IW_QUAL_LEVEL_UPDATED
3398 | IW_QUAL_QUAL_UPDATED
3400 /* Update spy records */
3401 wireless_spy_update(dev, sa, &wstats);
3403 #endif /* WIRELESS_SPY */
3404 OUT4500( apriv, EVACK, EV_RX);
3406 if (test_bit(FLAG_802_11, &apriv->flags)) {
3407 skb->mac.raw = skb->data;
3408 skb->pkt_type = PACKET_OTHERHOST;
3409 skb->dev = apriv->wifidev;
3410 skb->protocol = htons(ETH_P_802_2);
3413 skb->protocol = eth_type_trans(skb,dev);
3415 skb->dev->last_rx = jiffies;
3416 skb->ip_summed = CHECKSUM_NONE;
3422 /* Check to see if a packet has been transmitted */
3423 if ( status & ( EV_TX|EV_TXCPY|EV_TXEXC ) ) {
3428 if (test_bit(FLAG_MPI,&apriv->flags)) {
3429 unsigned long flags;
3431 if (status & EV_TXEXC)
3432 get_tx_error(apriv, -1);
3433 spin_lock_irqsave(&apriv->aux_lock, flags);
3434 if (!skb_queue_empty(&apriv->txq)) {
3435 spin_unlock_irqrestore(&apriv->aux_lock,flags);
3436 mpi_send_packet (dev);
3438 clear_bit(FLAG_PENDING_XMIT, &apriv->flags);
3439 spin_unlock_irqrestore(&apriv->aux_lock,flags);
3440 netif_wake_queue (dev);
3442 OUT4500( apriv, EVACK,
3443 status & (EV_TX|EV_TXCPY|EV_TXEXC));
3447 fid = IN4500(apriv, TXCOMPLFID);
3449 for( i = 0; i < MAX_FIDS; i++ ) {
3450 if ( ( apriv->fids[i] & 0xffff ) == fid ) {
3451 len = apriv->fids[i] >> 16;
3456 if (status & EV_TXEXC)
3457 get_tx_error(apriv, index);
3458 OUT4500( apriv, EVACK, status & (EV_TX | EV_TXEXC));
3459 /* Set up to be used again */
3460 apriv->fids[index] &= 0xffff;
3461 if (index < MAX_FIDS / 2) {
3462 if (!test_bit(FLAG_PENDING_XMIT, &apriv->flags))
3463 netif_wake_queue(dev);
3465 if (!test_bit(FLAG_PENDING_XMIT11, &apriv->flags))
3466 netif_wake_queue(apriv->wifidev);
3469 OUT4500( apriv, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3470 airo_print_err(apriv->dev->name, "Unallocated FID was "
3475 if ( status & ~STATUS_INTS & ~IGNORE_INTS )
3476 airo_print_warn(apriv->dev->name, "Got weird status %x",
3477 status & ~STATUS_INTS & ~IGNORE_INTS );
3480 if (savedInterrupts)
3481 OUT4500( apriv, EVINTEN, savedInterrupts );
3484 return IRQ_RETVAL(handled);
3488 * Routines to talk to the card
3492 * This was originally written for the 4500, hence the name
3493 * NOTE: If use with 8bit mode and SMP bad things will happen!
3494 * Why would some one do 8 bit IO in an SMP machine?!?
3496 static void OUT4500( struct airo_info *ai, u16 reg, u16 val ) {
3497 if (test_bit(FLAG_MPI,&ai->flags))
3500 outw( val, ai->dev->base_addr + reg );
3502 outb( val & 0xff, ai->dev->base_addr + reg );
3503 outb( val >> 8, ai->dev->base_addr + reg + 1 );
3507 static u16 IN4500( struct airo_info *ai, u16 reg ) {
3510 if (test_bit(FLAG_MPI,&ai->flags))
3513 rc = inw( ai->dev->base_addr + reg );
3515 rc = inb( ai->dev->base_addr + reg );
3516 rc += ((int)inb( ai->dev->base_addr + reg + 1 )) << 8;
3521 static int enable_MAC( struct airo_info *ai, Resp *rsp, int lock ) {
3525 /* FLAG_RADIO_OFF : Radio disabled via /proc or Wireless Extensions
3526 * FLAG_RADIO_DOWN : Radio disabled via "ifconfig ethX down"
3527 * Note : we could try to use !netif_running(dev) in enable_MAC()
3528 * instead of this flag, but I don't trust it *within* the
3529 * open/close functions, and testing both flags together is
3530 * "cheaper" - Jean II */
3531 if (ai->flags & FLAG_RADIO_MASK) return SUCCESS;
3533 if (lock && down_interruptible(&ai->sem))
3534 return -ERESTARTSYS;
3536 if (!test_bit(FLAG_ENABLED, &ai->flags)) {
3537 memset(&cmd, 0, sizeof(cmd));
3538 cmd.cmd = MAC_ENABLE;
3539 rc = issuecommand(ai, &cmd, rsp);
3541 set_bit(FLAG_ENABLED, &ai->flags);
3549 airo_print_err(ai->dev->name, "%s: Cannot enable MAC, err=%d",
3554 static void disable_MAC( struct airo_info *ai, int lock ) {
3558 if (lock && down_interruptible(&ai->sem))
3561 if (test_bit(FLAG_ENABLED, &ai->flags)) {
3562 memset(&cmd, 0, sizeof(cmd));
3563 cmd.cmd = MAC_DISABLE; // disable in case already enabled
3564 issuecommand(ai, &cmd, &rsp);
3565 clear_bit(FLAG_ENABLED, &ai->flags);
3571 static void enable_interrupts( struct airo_info *ai ) {
3572 /* Enable the interrupts */
3573 OUT4500( ai, EVINTEN, STATUS_INTS );
3576 static void disable_interrupts( struct airo_info *ai ) {
3577 OUT4500( ai, EVINTEN, 0 );
3580 static void mpi_receive_802_3(struct airo_info *ai)
3584 struct sk_buff *skb;
3589 memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3590 /* Make sure we got something */
3591 if (rxd.rdy && rxd.valid == 0) {
3593 if (len < 12 || len > 2048)
3596 skb = dev_alloc_skb(len);
3598 ai->stats.rx_dropped++;
3601 buffer = skb_put(skb,len);
3602 memcpy(buffer, ai->rxfids[0].virtual_host_addr, ETH_ALEN * 2);
3603 if (ai->micstats.enabled) {
3605 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2,
3607 if (ntohs(micbuf.typelen) <= 0x05DC) {
3608 if (len <= sizeof(micbuf) + ETH_ALEN * 2)
3611 off = sizeof(micbuf);
3612 skb_trim (skb, len - off);
3615 memcpy(buffer + ETH_ALEN * 2,
3616 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2 + off,
3617 len - ETH_ALEN * 2 - off);
3618 if (decapsulate (ai, &micbuf, (etherHead*)buffer, len - off - ETH_ALEN * 2)) {
3620 dev_kfree_skb_irq (skb);
3624 if (ai->spy_data.spy_number > 0) {
3626 struct iw_quality wstats;
3627 /* Prepare spy data : addr + qual */
3628 sa = buffer + ETH_ALEN;
3629 wstats.qual = 0; /* XXX Where do I get that info from ??? */
3632 /* Update spy records */
3633 wireless_spy_update(ai->dev, sa, &wstats);
3635 #endif /* WIRELESS_SPY */
3638 skb->ip_summed = CHECKSUM_NONE;
3639 skb->protocol = eth_type_trans(skb, ai->dev);
3640 skb->dev->last_rx = jiffies;
3644 if (rxd.valid == 0) {
3648 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3652 void mpi_receive_802_11 (struct airo_info *ai)
3655 struct sk_buff *skb = NULL;
3656 u16 fc, len, hdrlen = 0;
3668 char *ptr = ai->rxfids[0].virtual_host_addr+4;
3670 memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3671 memcpy ((char *)&hdr, ptr, sizeof(hdr));
3673 /* Bad CRC. Ignore packet */
3674 if (le16_to_cpu(hdr.status) & 2)
3676 if (ai->wifidev == NULL)
3678 len = le16_to_cpu(hdr.len);
3679 if (len > AIRO_DEF_MTU) {
3680 airo_print_err(ai->dev->name, "Bad size %d", len);
3686 memcpy ((char *)&fc, ptr, sizeof(fc));
3687 fc = le16_to_cpu(fc);
3690 if ((fc & 0xe0) == 0xc0)
3696 if ((fc&0x300)==0x300){
3704 skb = dev_alloc_skb( len + hdrlen + 2 );
3706 ai->stats.rx_dropped++;
3709 buffer = (u16*)skb_put (skb, len + hdrlen);
3710 memcpy ((char *)buffer, ptr, hdrlen);
3714 memcpy ((char *)&gap, ptr, sizeof(gap));
3716 gap = le16_to_cpu(gap);
3721 airo_print_err(ai->dev->name,
3722 "gaplen too big. Problems will follow...");
3724 memcpy ((char *)buffer + hdrlen, ptr, len);
3726 #ifdef IW_WIRELESS_SPY /* defined in iw_handler.h */
3727 if (ai->spy_data.spy_number > 0) {
3729 struct iw_quality wstats;
3730 /* Prepare spy data : addr + qual */
3731 sa = (char*)buffer + 10;
3732 wstats.qual = hdr.rssi[0];
3734 wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3736 wstats.level = (hdr.rssi[1] + 321) / 2;
3737 wstats.noise = ai->wstats.qual.noise;
3738 wstats.updated = IW_QUAL_QUAL_UPDATED
3739 | IW_QUAL_LEVEL_UPDATED
3741 /* Update spy records */
3742 wireless_spy_update(ai->dev, sa, &wstats);
3744 #endif /* IW_WIRELESS_SPY */
3745 skb->mac.raw = skb->data;
3746 skb->pkt_type = PACKET_OTHERHOST;
3747 skb->dev = ai->wifidev;
3748 skb->protocol = htons(ETH_P_802_2);
3749 skb->dev->last_rx = jiffies;
3750 skb->ip_summed = CHECKSUM_NONE;
3753 if (rxd.valid == 0) {
3757 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3761 static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
3772 memset( &mySsid, 0, sizeof( mySsid ) );
3776 /* The NOP is the first step in getting the card going */
3778 cmd.parm0 = cmd.parm1 = cmd.parm2 = 0;
3779 if (lock && down_interruptible(&ai->sem))
3781 if ( issuecommand( ai, &cmd, &rsp ) != SUCCESS ) {
3786 disable_MAC( ai, 0);
3788 // Let's figure out if we need to use the AUX port
3789 if (!test_bit(FLAG_MPI,&ai->flags)) {
3790 cmd.cmd = CMD_ENABLEAUX;
3791 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
3794 airo_print_err(ai->dev->name, "Error checking for AUX port");
3797 if (!aux_bap || rsp.status & 0xff00) {
3798 ai->bap_read = fast_bap_read;
3799 airo_print_dbg(ai->dev->name, "Doing fast bap_reads");
3801 ai->bap_read = aux_bap_read;
3802 airo_print_dbg(ai->dev->name, "Doing AUX bap_reads");
3807 if (ai->config.len == 0) {
3808 tdsRssiRid rssi_rid;
3809 CapabilityRid cap_rid;
3815 // general configuration (read/modify/write)
3816 status = readConfigRid(ai, lock);
3817 if ( status != SUCCESS ) return ERROR;
3819 status = readCapabilityRid(ai, &cap_rid, lock);
3820 if ( status != SUCCESS ) return ERROR;
3822 status = PC4500_readrid(ai,RID_RSSI,&rssi_rid,sizeof(rssi_rid),lock);
3823 if ( status == SUCCESS ) {
3824 if (ai->rssi || (ai->rssi = kmalloc(512, GFP_KERNEL)) != NULL)
3825 memcpy(ai->rssi, (u8*)&rssi_rid + 2, 512); /* Skip RID length member */
3830 if (cap_rid.softCap & 8)
3831 ai->config.rmode |= RXMODE_NORMALIZED_RSSI;
3833 airo_print_warn(ai->dev->name, "unknown received signal "
3836 ai->config.opmode = adhoc ? MODE_STA_IBSS : MODE_STA_ESS;
3837 ai->config.authType = AUTH_OPEN;
3838 ai->config.modulation = MOD_CCK;
3840 if ((cap_rid.len>=sizeof(cap_rid)) && (cap_rid.extSoftCap&1) &&
3841 (micsetup(ai) == SUCCESS)) {
3842 ai->config.opmode |= MODE_MIC;
3843 set_bit(FLAG_MIC_CAPABLE, &ai->flags);
3846 /* Save off the MAC */
3847 for( i = 0; i < ETH_ALEN; i++ ) {
3848 mac[i] = ai->config.macAddr[i];
3851 /* Check to see if there are any insmod configured
3855 memset(ai->config.rates,0,sizeof(ai->config.rates));
3856 for( i = 0; i < 8 && rates[i]; i++ ) {
3857 ai->config.rates[i] = rates[i];
3860 if ( basic_rate > 0 ) {
3862 for( i = 0; i < 8; i++ ) {
3863 if ( ai->config.rates[i] == basic_rate ||
3864 !ai->config.rates ) {
3865 ai->config.rates[i] = basic_rate | 0x80;
3870 set_bit (FLAG_COMMIT, &ai->flags);
3873 /* Setup the SSIDs if present */
3876 for( i = 0; i < 3 && ssids[i]; i++ ) {
3877 mySsid.ssids[i].len = strlen(ssids[i]);
3878 if ( mySsid.ssids[i].len > 32 )
3879 mySsid.ssids[i].len = 32;
3880 memcpy(mySsid.ssids[i].ssid, ssids[i],
3881 mySsid.ssids[i].len);
3883 mySsid.len = sizeof(mySsid);
3886 status = writeConfigRid(ai, lock);
3887 if ( status != SUCCESS ) return ERROR;
3889 /* Set up the SSID list */
3891 status = writeSsidRid(ai, &mySsid, lock);
3892 if ( status != SUCCESS ) return ERROR;
3895 status = enable_MAC(ai, &rsp, lock);
3896 if ( status != SUCCESS || (rsp.status & 0xFF00) != 0) {
3897 airo_print_err(ai->dev->name, "Bad MAC enable reason = %x, rid = %x,"
3898 " offset = %d", rsp.rsp0, rsp.rsp1, rsp.rsp2 );
3902 /* Grab the initial wep key, we gotta save it for auto_wep */
3903 rc = readWepKeyRid(ai, &wkr, 1, lock);
3904 if (rc == SUCCESS) do {
3905 lastindex = wkr.kindex;
3906 if (wkr.kindex == 0xffff) {
3907 ai->defindex = wkr.mac[0];
3909 rc = readWepKeyRid(ai, &wkr, 0, lock);
3910 } while(lastindex != wkr.kindex);
3913 ai->expires = RUN_AT(3*HZ);
3914 wake_up_interruptible(&ai->thr_wait);
3920 static u16 issuecommand(struct airo_info *ai, Cmd *pCmd, Resp *pRsp) {
3921 // Im really paranoid about letting it run forever!
3922 int max_tries = 600000;
3924 if (IN4500(ai, EVSTAT) & EV_CMD)
3925 OUT4500(ai, EVACK, EV_CMD);
3927 OUT4500(ai, PARAM0, pCmd->parm0);
3928 OUT4500(ai, PARAM1, pCmd->parm1);
3929 OUT4500(ai, PARAM2, pCmd->parm2);
3930 OUT4500(ai, COMMAND, pCmd->cmd);
3932 while (max_tries-- && (IN4500(ai, EVSTAT) & EV_CMD) == 0) {
3933 if ((IN4500(ai, COMMAND)) == pCmd->cmd)
3934 // PC4500 didn't notice command, try again
3935 OUT4500(ai, COMMAND, pCmd->cmd);
3936 if (!in_atomic() && (max_tries & 255) == 0)
3940 if ( max_tries == -1 ) {
3941 airo_print_err(ai->dev->name,
3942 "Max tries exceeded when issueing command");
3943 if (IN4500(ai, COMMAND) & COMMAND_BUSY)
3944 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3948 // command completed
3949 pRsp->status = IN4500(ai, STATUS);
3950 pRsp->rsp0 = IN4500(ai, RESP0);
3951 pRsp->rsp1 = IN4500(ai, RESP1);
3952 pRsp->rsp2 = IN4500(ai, RESP2);
3953 if ((pRsp->status & 0xff00)!=0 && pCmd->cmd != CMD_SOFTRESET)
3954 airo_print_err(ai->dev->name,
3955 "cmd:%x status:%x rsp0:%x rsp1:%x rsp2:%x",
3956 pCmd->cmd, pRsp->status, pRsp->rsp0, pRsp->rsp1,
3959 // clear stuck command busy if necessary
3960 if (IN4500(ai, COMMAND) & COMMAND_BUSY) {
3961 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3963 // acknowledge processing the status/response
3964 OUT4500(ai, EVACK, EV_CMD);
3969 /* Sets up the bap to start exchange data. whichbap should
3970 * be one of the BAP0 or BAP1 defines. Locks should be held before
3972 static int bap_setup(struct airo_info *ai, u16 rid, u16 offset, int whichbap )
3977 OUT4500(ai, SELECT0+whichbap, rid);
3978 OUT4500(ai, OFFSET0+whichbap, offset);
3980 int status = IN4500(ai, OFFSET0+whichbap);
3981 if (status & BAP_BUSY) {
3982 /* This isn't really a timeout, but its kinda
3987 } else if ( status & BAP_ERR ) {
3988 /* invalid rid or offset */
3989 airo_print_err(ai->dev->name, "BAP error %x %d",
3992 } else if (status & BAP_DONE) { // success
3995 if ( !(max_tries--) ) {
3996 airo_print_err(ai->dev->name,
3997 "airo: BAP setup error too many retries\n");
4000 // -- PC4500 missed it, try again
4001 OUT4500(ai, SELECT0+whichbap, rid);
4002 OUT4500(ai, OFFSET0+whichbap, offset);
4007 /* should only be called by aux_bap_read. This aux function and the
4008 following use concepts not documented in the developers guide. I
4009 got them from a patch given to my by Aironet */
4010 static u16 aux_setup(struct airo_info *ai, u16 page,
4011 u16 offset, u16 *len)
4015 OUT4500(ai, AUXPAGE, page);
4016 OUT4500(ai, AUXOFF, 0);
4017 next = IN4500(ai, AUXDATA);
4018 *len = IN4500(ai, AUXDATA)&0xff;
4019 if (offset != 4) OUT4500(ai, AUXOFF, offset);
4023 /* requires call to bap_setup() first */
4024 static int aux_bap_read(struct airo_info *ai, u16 *pu16Dst,
4025 int bytelen, int whichbap)
4033 unsigned long flags;
4035 spin_lock_irqsave(&ai->aux_lock, flags);
4036 page = IN4500(ai, SWS0+whichbap);
4037 offset = IN4500(ai, SWS2+whichbap);
4038 next = aux_setup(ai, page, offset, &len);
4039 words = (bytelen+1)>>1;
4041 for (i=0; i<words;) {
4043 count = (len>>1) < (words-i) ? (len>>1) : (words-i);
4045 insw( ai->dev->base_addr+DATA0+whichbap,
4048 insb( ai->dev->base_addr+DATA0+whichbap,
4049 pu16Dst+i, count << 1 );
4052 next = aux_setup(ai, next, 4, &len);
4055 spin_unlock_irqrestore(&ai->aux_lock, flags);
4060 /* requires call to bap_setup() first */
4061 static int fast_bap_read(struct airo_info *ai, u16 *pu16Dst,
4062 int bytelen, int whichbap)
4064 bytelen = (bytelen + 1) & (~1); // round up to even value
4066 insw( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen>>1 );
4068 insb( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen );
4072 /* requires call to bap_setup() first */
4073 static int bap_write(struct airo_info *ai, const u16 *pu16Src,
4074 int bytelen, int whichbap)
4076 bytelen = (bytelen + 1) & (~1); // round up to even value
4078 outsw( ai->dev->base_addr+DATA0+whichbap,
4079 pu16Src, bytelen>>1 );
4081 outsb( ai->dev->base_addr+DATA0+whichbap, pu16Src, bytelen );
4085 static int PC4500_accessrid(struct airo_info *ai, u16 rid, u16 accmd)
4087 Cmd cmd; /* for issuing commands */
4088 Resp rsp; /* response from commands */
4091 memset(&cmd, 0, sizeof(cmd));
4094 status = issuecommand(ai, &cmd, &rsp);
4095 if (status != 0) return status;
4096 if ( (rsp.status & 0x7F00) != 0) {
4097 return (accmd << 8) + (rsp.rsp0 & 0xFF);
4102 /* Note, that we are using BAP1 which is also used by transmit, so
4103 * we must get a lock. */
4104 static int PC4500_readrid(struct airo_info *ai, u16 rid, void *pBuf, int len, int lock)
4110 if (down_interruptible(&ai->sem))
4113 if (test_bit(FLAG_MPI,&ai->flags)) {
4117 memset(&cmd, 0, sizeof(cmd));
4118 memset(&rsp, 0, sizeof(rsp));
4119 ai->config_desc.rid_desc.valid = 1;
4120 ai->config_desc.rid_desc.len = RIDSIZE;
4121 ai->config_desc.rid_desc.rid = 0;
4122 ai->config_desc.rid_desc.host_addr = ai->ridbus;
4124 cmd.cmd = CMD_ACCESS;
4127 memcpy_toio(ai->config_desc.card_ram_off,
4128 &ai->config_desc.rid_desc, sizeof(Rid));
4130 rc = issuecommand(ai, &cmd, &rsp);
4132 if (rsp.status & 0x7f00)
4135 memcpy(pBuf, ai->config_desc.virtual_host_addr, len);
4138 if ((status = PC4500_accessrid(ai, rid, CMD_ACCESS))!=SUCCESS) {
4142 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4146 // read the rid length field
4147 bap_read(ai, pBuf, 2, BAP1);
4148 // length for remaining part of rid
4149 len = min(len, (int)le16_to_cpu(*(u16*)pBuf)) - 2;
4152 airo_print_err(ai->dev->name,
4153 "Rid %x has a length of %d which is too short",
4154 (int)rid, (int)len );
4158 // read remainder of the rid
4159 rc = bap_read(ai, ((u16*)pBuf)+1, len, BAP1);
4167 /* Note, that we are using BAP1 which is also used by transmit, so
4168 * make sure this isnt called when a transmit is happening */
4169 static int PC4500_writerid(struct airo_info *ai, u16 rid,
4170 const void *pBuf, int len, int lock)
4175 *(u16*)pBuf = cpu_to_le16((u16)len);
4178 if (down_interruptible(&ai->sem))
4181 if (test_bit(FLAG_MPI,&ai->flags)) {
4185 if (test_bit(FLAG_ENABLED, &ai->flags) && (RID_WEP_TEMP != rid))
4186 airo_print_err(ai->dev->name,
4187 "%s: MAC should be disabled (rid=%04x)",
4189 memset(&cmd, 0, sizeof(cmd));
4190 memset(&rsp, 0, sizeof(rsp));
4192 ai->config_desc.rid_desc.valid = 1;
4193 ai->config_desc.rid_desc.len = *((u16 *)pBuf);
4194 ai->config_desc.rid_desc.rid = 0;
4196 cmd.cmd = CMD_WRITERID;
4199 memcpy_toio(ai->config_desc.card_ram_off,
4200 &ai->config_desc.rid_desc, sizeof(Rid));
4202 if (len < 4 || len > 2047) {
4203 airo_print_err(ai->dev->name, "%s: len=%d", __FUNCTION__, len);
4206 memcpy((char *)ai->config_desc.virtual_host_addr,
4209 rc = issuecommand(ai, &cmd, &rsp);
4210 if ((rc & 0xff00) != 0) {
4211 airo_print_err(ai->dev->name, "%s: Write rid Error %d",
4213 airo_print_err(ai->dev->name, "%s: Cmd=%04x",
4214 __FUNCTION__, cmd.cmd);
4217 if ((rsp.status & 0x7f00))
4221 // --- first access so that we can write the rid data
4222 if ( (status = PC4500_accessrid(ai, rid, CMD_ACCESS)) != 0) {
4226 // --- now write the rid data
4227 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4231 bap_write(ai, pBuf, len, BAP1);
4232 // ---now commit the rid data
4233 rc = PC4500_accessrid(ai, rid, 0x100|CMD_ACCESS);
4241 /* Allocates a FID to be used for transmitting packets. We only use
4243 static u16 transmit_allocate(struct airo_info *ai, int lenPayload, int raw)
4245 unsigned int loop = 3000;
4251 cmd.cmd = CMD_ALLOCATETX;
4252 cmd.parm0 = lenPayload;
4253 if (down_interruptible(&ai->sem))
4255 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
4259 if ( (rsp.status & 0xFF00) != 0) {
4263 /* wait for the allocate event/indication
4264 * It makes me kind of nervous that this can just sit here and spin,
4265 * but in practice it only loops like four times. */
4266 while (((IN4500(ai, EVSTAT) & EV_ALLOC) == 0) && --loop);
4272 // get the allocated fid and acknowledge
4273 txFid = IN4500(ai, TXALLOCFID);
4274 OUT4500(ai, EVACK, EV_ALLOC);
4276 /* The CARD is pretty cool since it converts the ethernet packet
4277 * into 802.11. Also note that we don't release the FID since we
4278 * will be using the same one over and over again. */
4279 /* We only have to setup the control once since we are not
4280 * releasing the fid. */
4282 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_11
4283 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4285 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_3
4286 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4287 if (bap_setup(ai, txFid, 0x0008, BAP1) != SUCCESS)
4290 bap_write(ai, &txControl, sizeof(txControl), BAP1);
4298 /* In general BAP1 is dedicated to transmiting packets. However,
4299 since we need a BAP when accessing RIDs, we also use BAP1 for that.
4300 Make sure the BAP1 spinlock is held when this is called. */
4301 static int transmit_802_3_packet(struct airo_info *ai, int len, char *pPacket)
4312 if (len <= ETH_ALEN * 2) {
4313 airo_print_warn(ai->dev->name, "Short packet %d", len);
4316 len -= ETH_ALEN * 2;
4318 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
4319 (ntohs(((u16 *)pPacket)[6]) != 0x888E)) {
4320 if (encapsulate(ai,(etherHead *)pPacket,&pMic,len) != SUCCESS)
4322 miclen = sizeof(pMic);
4324 // packet is destination[6], source[6], payload[len-12]
4325 // write the payload length and dst/src/payload
4326 if (bap_setup(ai, txFid, 0x0036, BAP1) != SUCCESS) return ERROR;
4327 /* The hardware addresses aren't counted as part of the payload, so
4328 * we have to subtract the 12 bytes for the addresses off */
4329 payloadLen = cpu_to_le16(len + miclen);
4330 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4331 bap_write(ai, (const u16*)pPacket, sizeof(etherHead), BAP1);
4333 bap_write(ai, (const u16*)&pMic, miclen, BAP1);
4334 bap_write(ai, (const u16*)(pPacket + sizeof(etherHead)), len, BAP1);
4335 // issue the transmit command
4336 memset( &cmd, 0, sizeof( cmd ) );
4337 cmd.cmd = CMD_TRANSMIT;
4339 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4340 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4344 static int transmit_802_11_packet(struct airo_info *ai, int len, char *pPacket)
4359 fc = le16_to_cpu(*(const u16*)pPacket);
4362 if ((fc & 0xe0) == 0xc0)
4368 if ((fc&0x300)==0x300){
4377 airo_print_warn(ai->dev->name, "Short packet %d", len);
4381 /* packet is 802.11 header + payload
4382 * write the payload length and dst/src/payload */
4383 if (bap_setup(ai, txFid, 6, BAP1) != SUCCESS) return ERROR;
4384 /* The 802.11 header aren't counted as part of the payload, so
4385 * we have to subtract the header bytes off */
4386 payloadLen = cpu_to_le16(len-hdrlen);
4387 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4388 if (bap_setup(ai, txFid, 0x0014, BAP1) != SUCCESS) return ERROR;
4389 bap_write(ai, (const u16*)pPacket, hdrlen, BAP1);
4390 bap_write(ai, hdrlen == 30 ?
4391 (const u16*)&gap.gaplen : (const u16*)&gap, 38 - hdrlen, BAP1);
4393 bap_write(ai, (const u16*)(pPacket + hdrlen), len - hdrlen, BAP1);
4394 // issue the transmit command
4395 memset( &cmd, 0, sizeof( cmd ) );
4396 cmd.cmd = CMD_TRANSMIT;
4398 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4399 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4404 * This is the proc_fs routines. It is a bit messier than I would
4405 * like! Feel free to clean it up!
4408 static ssize_t proc_read( struct file *file,
4409 char __user *buffer,
4413 static ssize_t proc_write( struct file *file,
4414 const char __user *buffer,
4417 static int proc_close( struct inode *inode, struct file *file );
4419 static int proc_stats_open( struct inode *inode, struct file *file );
4420 static int proc_statsdelta_open( struct inode *inode, struct file *file );
4421 static int proc_status_open( struct inode *inode, struct file *file );
4422 static int proc_SSID_open( struct inode *inode, struct file *file );
4423 static int proc_APList_open( struct inode *inode, struct file *file );
4424 static int proc_BSSList_open( struct inode *inode, struct file *file );
4425 static int proc_config_open( struct inode *inode, struct file *file );
4426 static int proc_wepkey_open( struct inode *inode, struct file *file );
4428 static struct file_operations proc_statsdelta_ops = {
4430 .open = proc_statsdelta_open,
4431 .release = proc_close
4434 static struct file_operations proc_stats_ops = {
4436 .open = proc_stats_open,
4437 .release = proc_close
4440 static struct file_operations proc_status_ops = {
4442 .open = proc_status_open,
4443 .release = proc_close
4446 static struct file_operations proc_SSID_ops = {
4448 .write = proc_write,
4449 .open = proc_SSID_open,
4450 .release = proc_close
4453 static struct file_operations proc_BSSList_ops = {
4455 .write = proc_write,
4456 .open = proc_BSSList_open,
4457 .release = proc_close
4460 static struct file_operations proc_APList_ops = {
4462 .write = proc_write,
4463 .open = proc_APList_open,
4464 .release = proc_close
4467 static struct file_operations proc_config_ops = {
4469 .write = proc_write,
4470 .open = proc_config_open,
4471 .release = proc_close
4474 static struct file_operations proc_wepkey_ops = {
4476 .write = proc_write,
4477 .open = proc_wepkey_open,
4478 .release = proc_close
4481 static struct proc_dir_entry *airo_entry;
4490 void (*on_close) (struct inode *, struct file *);
4494 #define SETPROC_OPS(entry, ops) (entry)->proc_fops = &(ops)
4497 static int setup_proc_entry( struct net_device *dev,
4498 struct airo_info *apriv ) {
4499 struct proc_dir_entry *entry;
4500 /* First setup the device directory */
4501 strcpy(apriv->proc_name,dev->name);
4502 apriv->proc_entry = create_proc_entry(apriv->proc_name,
4505 apriv->proc_entry->uid = proc_uid;
4506 apriv->proc_entry->gid = proc_gid;
4507 apriv->proc_entry->owner = THIS_MODULE;
4509 /* Setup the StatsDelta */
4510 entry = create_proc_entry("StatsDelta",
4511 S_IFREG | (S_IRUGO&proc_perm),
4513 entry->uid = proc_uid;
4514 entry->gid = proc_gid;
4516 entry->owner = THIS_MODULE;
4517 SETPROC_OPS(entry, proc_statsdelta_ops);
4519 /* Setup the Stats */
4520 entry = create_proc_entry("Stats",
4521 S_IFREG | (S_IRUGO&proc_perm),
4523 entry->uid = proc_uid;
4524 entry->gid = proc_gid;
4526 entry->owner = THIS_MODULE;
4527 SETPROC_OPS(entry, proc_stats_ops);
4529 /* Setup the Status */
4530 entry = create_proc_entry("Status",
4531 S_IFREG | (S_IRUGO&proc_perm),
4533 entry->uid = proc_uid;
4534 entry->gid = proc_gid;
4536 entry->owner = THIS_MODULE;
4537 SETPROC_OPS(entry, proc_status_ops);
4539 /* Setup the Config */
4540 entry = create_proc_entry("Config",
4541 S_IFREG | proc_perm,
4543 entry->uid = proc_uid;
4544 entry->gid = proc_gid;
4546 entry->owner = THIS_MODULE;
4547 SETPROC_OPS(entry, proc_config_ops);
4549 /* Setup the SSID */
4550 entry = create_proc_entry("SSID",
4551 S_IFREG | proc_perm,
4553 entry->uid = proc_uid;
4554 entry->gid = proc_gid;
4556 entry->owner = THIS_MODULE;
4557 SETPROC_OPS(entry, proc_SSID_ops);
4559 /* Setup the APList */
4560 entry = create_proc_entry("APList",
4561 S_IFREG | proc_perm,
4563 entry->uid = proc_uid;
4564 entry->gid = proc_gid;
4566 entry->owner = THIS_MODULE;
4567 SETPROC_OPS(entry, proc_APList_ops);
4569 /* Setup the BSSList */
4570 entry = create_proc_entry("BSSList",
4571 S_IFREG | proc_perm,
4573 entry->uid = proc_uid;
4574 entry->gid = proc_gid;
4576 entry->owner = THIS_MODULE;
4577 SETPROC_OPS(entry, proc_BSSList_ops);
4579 /* Setup the WepKey */
4580 entry = create_proc_entry("WepKey",
4581 S_IFREG | proc_perm,
4583 entry->uid = proc_uid;
4584 entry->gid = proc_gid;
4586 entry->owner = THIS_MODULE;
4587 SETPROC_OPS(entry, proc_wepkey_ops);
4592 static int takedown_proc_entry( struct net_device *dev,
4593 struct airo_info *apriv ) {
4594 if ( !apriv->proc_entry->namelen ) return 0;
4595 remove_proc_entry("Stats",apriv->proc_entry);
4596 remove_proc_entry("StatsDelta",apriv->proc_entry);
4597 remove_proc_entry("Status",apriv->proc_entry);
4598 remove_proc_entry("Config",apriv->proc_entry);
4599 remove_proc_entry("SSID",apriv->proc_entry);
4600 remove_proc_entry("APList",apriv->proc_entry);
4601 remove_proc_entry("BSSList",apriv->proc_entry);
4602 remove_proc_entry("WepKey",apriv->proc_entry);
4603 remove_proc_entry(apriv->proc_name,airo_entry);
4608 * What we want from the proc_fs is to be able to efficiently read
4609 * and write the configuration. To do this, we want to read the
4610 * configuration when the file is opened and write it when the file is
4611 * closed. So basically we allocate a read buffer at open and fill it
4612 * with data, and allocate a write buffer and read it at close.
4616 * The read routine is generic, it relies on the preallocated rbuffer
4617 * to supply the data.
4619 static ssize_t proc_read( struct file *file,
4620 char __user *buffer,
4624 loff_t pos = *offset;
4625 struct proc_data *priv = (struct proc_data*)file->private_data;
4632 if (pos >= priv->readlen)
4634 if (len > priv->readlen - pos)
4635 len = priv->readlen - pos;
4636 if (copy_to_user(buffer, priv->rbuffer + pos, len))
4638 *offset = pos + len;
4643 * The write routine is generic, it fills in a preallocated rbuffer
4644 * to supply the data.
4646 static ssize_t proc_write( struct file *file,
4647 const char __user *buffer,
4651 loff_t pos = *offset;
4652 struct proc_data *priv = (struct proc_data*)file->private_data;
4659 if (pos >= priv->maxwritelen)
4661 if (len > priv->maxwritelen - pos)
4662 len = priv->maxwritelen - pos;
4663 if (copy_from_user(priv->wbuffer + pos, buffer, len))
4665 if ( pos + len > priv->writelen )
4666 priv->writelen = len + file->f_pos;
4667 *offset = pos + len;
4671 static int proc_status_open( struct inode *inode, struct file *file ) {
4672 struct proc_data *data;
4673 struct proc_dir_entry *dp = PDE(inode);
4674 struct net_device *dev = dp->data;
4675 struct airo_info *apriv = dev->priv;
4676 CapabilityRid cap_rid;
4677 StatusRid status_rid;
4680 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4682 data = (struct proc_data *)file->private_data;
4683 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4684 kfree (file->private_data);
4688 readStatusRid(apriv, &status_rid, 1);
4689 readCapabilityRid(apriv, &cap_rid, 1);
4691 i = sprintf(data->rbuffer, "Status: %s%s%s%s%s%s%s%s%s\n",
4692 status_rid.mode & 1 ? "CFG ": "",
4693 status_rid.mode & 2 ? "ACT ": "",
4694 status_rid.mode & 0x10 ? "SYN ": "",
4695 status_rid.mode & 0x20 ? "LNK ": "",
4696 status_rid.mode & 0x40 ? "LEAP ": "",
4697 status_rid.mode & 0x80 ? "PRIV ": "",
4698 status_rid.mode & 0x100 ? "KEY ": "",
4699 status_rid.mode & 0x200 ? "WEP ": "",
4700 status_rid.mode & 0x8000 ? "ERR ": "");
4701 sprintf( data->rbuffer+i, "Mode: %x\n"
4702 "Signal Strength: %d\n"
4703 "Signal Quality: %d\n"
4708 "Driver Version: %s\n"
4709 "Device: %s\nManufacturer: %s\nFirmware Version: %s\n"
4710 "Radio type: %x\nCountry: %x\nHardware Version: %x\n"
4711 "Software Version: %x\nSoftware Subversion: %x\n"
4712 "Boot block version: %x\n",
4713 (int)status_rid.mode,
4714 (int)status_rid.normalizedSignalStrength,
4715 (int)status_rid.signalQuality,
4716 (int)status_rid.SSIDlen,
4719 (int)status_rid.channel,
4720 (int)status_rid.currentXmitRate/2,
4728 (int)cap_rid.softVer,
4729 (int)cap_rid.softSubVer,
4730 (int)cap_rid.bootBlockVer );
4731 data->readlen = strlen( data->rbuffer );
4735 static int proc_stats_rid_open(struct inode*, struct file*, u16);
4736 static int proc_statsdelta_open( struct inode *inode,
4737 struct file *file ) {
4738 if (file->f_mode&FMODE_WRITE) {
4739 return proc_stats_rid_open(inode, file, RID_STATSDELTACLEAR);
4741 return proc_stats_rid_open(inode, file, RID_STATSDELTA);
4744 static int proc_stats_open( struct inode *inode, struct file *file ) {
4745 return proc_stats_rid_open(inode, file, RID_STATS);
4748 static int proc_stats_rid_open( struct inode *inode,
4751 struct proc_data *data;
4752 struct proc_dir_entry *dp = PDE(inode);
4753 struct net_device *dev = dp->data;
4754 struct airo_info *apriv = dev->priv;
4757 u32 *vals = stats.vals;
4759 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4761 data = (struct proc_data *)file->private_data;
4762 if ((data->rbuffer = kmalloc( 4096, GFP_KERNEL )) == NULL) {
4763 kfree (file->private_data);
4767 readStatsRid(apriv, &stats, rid, 1);
4770 for(i=0; statsLabels[i]!=(char *)-1 &&
4771 i*4<stats.len; i++){
4772 if (!statsLabels[i]) continue;
4773 if (j+strlen(statsLabels[i])+16>4096) {
4774 airo_print_warn(apriv->dev->name,
4775 "Potentially disasterous buffer overflow averted!");
4778 j+=sprintf(data->rbuffer+j, "%s: %u\n", statsLabels[i], vals[i]);
4780 if (i*4>=stats.len){
4781 airo_print_warn(apriv->dev->name, "Got a short rid");
4787 static int get_dec_u16( char *buffer, int *start, int limit ) {
4790 for( value = 0; buffer[*start] >= '0' &&
4791 buffer[*start] <= '9' &&
4792 *start < limit; (*start)++ ) {
4795 value += buffer[*start] - '0';
4797 if ( !valid ) return -1;
4801 static int airo_config_commit(struct net_device *dev,
4802 struct iw_request_info *info, void *zwrq,
4805 static void proc_config_on_close( struct inode *inode, struct file *file ) {
4806 struct proc_data *data = file->private_data;
4807 struct proc_dir_entry *dp = PDE(inode);
4808 struct net_device *dev = dp->data;
4809 struct airo_info *ai = dev->priv;
4812 if ( !data->writelen ) return;
4814 readConfigRid(ai, 1);
4815 set_bit (FLAG_COMMIT, &ai->flags);
4817 line = data->wbuffer;
4819 /*** Mode processing */
4820 if ( !strncmp( line, "Mode: ", 6 ) ) {
4822 if ((ai->config.rmode & 0xff) >= RXMODE_RFMON)
4823 set_bit (FLAG_RESET, &ai->flags);
4824 ai->config.rmode &= 0xfe00;
4825 clear_bit (FLAG_802_11, &ai->flags);
4826 ai->config.opmode &= 0xFF00;
4827 ai->config.scanMode = SCANMODE_ACTIVE;
4828 if ( line[0] == 'a' ) {
4829 ai->config.opmode |= 0;
4831 ai->config.opmode |= 1;
4832 if ( line[0] == 'r' ) {
4833 ai->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
4834 ai->config.scanMode = SCANMODE_PASSIVE;
4835 set_bit (FLAG_802_11, &ai->flags);
4836 } else if ( line[0] == 'y' ) {
4837 ai->config.rmode |= RXMODE_RFMON_ANYBSS | RXMODE_DISABLE_802_3_HEADER;
4838 ai->config.scanMode = SCANMODE_PASSIVE;
4839 set_bit (FLAG_802_11, &ai->flags);
4840 } else if ( line[0] == 'l' )
4841 ai->config.rmode |= RXMODE_LANMON;
4843 set_bit (FLAG_COMMIT, &ai->flags);
4846 /*** Radio status */
4847 else if (!strncmp(line,"Radio: ", 7)) {
4849 if (!strncmp(line,"off",3)) {
4850 set_bit (FLAG_RADIO_OFF, &ai->flags);
4852 clear_bit (FLAG_RADIO_OFF, &ai->flags);
4855 /*** NodeName processing */
4856 else if ( !strncmp( line, "NodeName: ", 10 ) ) {
4860 memset( ai->config.nodeName, 0, 16 );
4861 /* Do the name, assume a space between the mode and node name */
4862 for( j = 0; j < 16 && line[j] != '\n'; j++ ) {
4863 ai->config.nodeName[j] = line[j];
4865 set_bit (FLAG_COMMIT, &ai->flags);
4868 /*** PowerMode processing */
4869 else if ( !strncmp( line, "PowerMode: ", 11 ) ) {
4871 if ( !strncmp( line, "PSPCAM", 6 ) ) {
4872 ai->config.powerSaveMode = POWERSAVE_PSPCAM;
4873 set_bit (FLAG_COMMIT, &ai->flags);
4874 } else if ( !strncmp( line, "PSP", 3 ) ) {
4875 ai->config.powerSaveMode = POWERSAVE_PSP;
4876 set_bit (FLAG_COMMIT, &ai->flags);
4878 ai->config.powerSaveMode = POWERSAVE_CAM;
4879 set_bit (FLAG_COMMIT, &ai->flags);
4881 } else if ( !strncmp( line, "DataRates: ", 11 ) ) {
4882 int v, i = 0, k = 0; /* i is index into line,
4883 k is index to rates */
4886 while((v = get_dec_u16(line, &i, 3))!=-1) {
4887 ai->config.rates[k++] = (u8)v;
4891 set_bit (FLAG_COMMIT, &ai->flags);
4892 } else if ( !strncmp( line, "Channel: ", 9 ) ) {
4895 v = get_dec_u16(line, &i, i+3);
4897 ai->config.channelSet = (u16)v;
4898 set_bit (FLAG_COMMIT, &ai->flags);
4900 } else if ( !strncmp( line, "XmitPower: ", 11 ) ) {
4903 v = get_dec_u16(line, &i, i+3);
4905 ai->config.txPower = (u16)v;
4906 set_bit (FLAG_COMMIT, &ai->flags);
4908 } else if ( !strncmp( line, "WEP: ", 5 ) ) {
4912 ai->config.authType = (u16)AUTH_SHAREDKEY;
4915 ai->config.authType = (u16)AUTH_ENCRYPT;
4918 ai->config.authType = (u16)AUTH_OPEN;
4921 set_bit (FLAG_COMMIT, &ai->flags);
4922 } else if ( !strncmp( line, "LongRetryLimit: ", 16 ) ) {
4926 v = get_dec_u16(line, &i, 3);
4927 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4928 ai->config.longRetryLimit = (u16)v;
4929 set_bit (FLAG_COMMIT, &ai->flags);
4930 } else if ( !strncmp( line, "ShortRetryLimit: ", 17 ) ) {
4934 v = get_dec_u16(line, &i, 3);
4935 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4936 ai->config.shortRetryLimit = (u16)v;
4937 set_bit (FLAG_COMMIT, &ai->flags);
4938 } else if ( !strncmp( line, "RTSThreshold: ", 14 ) ) {
4942 v = get_dec_u16(line, &i, 4);
4943 v = (v<0) ? 0 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v);
4944 ai->config.rtsThres = (u16)v;
4945 set_bit (FLAG_COMMIT, &ai->flags);
4946 } else if ( !strncmp( line, "TXMSDULifetime: ", 16 ) ) {
4950 v = get_dec_u16(line, &i, 5);
4952 ai->config.txLifetime = (u16)v;
4953 set_bit (FLAG_COMMIT, &ai->flags);
4954 } else if ( !strncmp( line, "RXMSDULifetime: ", 16 ) ) {
4958 v = get_dec_u16(line, &i, 5);
4960 ai->config.rxLifetime = (u16)v;
4961 set_bit (FLAG_COMMIT, &ai->flags);
4962 } else if ( !strncmp( line, "TXDiversity: ", 13 ) ) {
4963 ai->config.txDiversity =
4964 (line[13]=='l') ? 1 :
4965 ((line[13]=='r')? 2: 3);
4966 set_bit (FLAG_COMMIT, &ai->flags);
4967 } else if ( !strncmp( line, "RXDiversity: ", 13 ) ) {
4968 ai->config.rxDiversity =
4969 (line[13]=='l') ? 1 :
4970 ((line[13]=='r')? 2: 3);
4971 set_bit (FLAG_COMMIT, &ai->flags);
4972 } else if ( !strncmp( line, "FragThreshold: ", 15 ) ) {
4976 v = get_dec_u16(line, &i, 4);
4977 v = (v<256) ? 256 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v);
4978 v = v & 0xfffe; /* Make sure its even */
4979 ai->config.fragThresh = (u16)v;
4980 set_bit (FLAG_COMMIT, &ai->flags);
4981 } else if (!strncmp(line, "Modulation: ", 12)) {
4984 case 'd': ai->config.modulation=MOD_DEFAULT; set_bit(FLAG_COMMIT, &ai->flags); break;
4985 case 'c': ai->config.modulation=MOD_CCK; set_bit(FLAG_COMMIT, &ai->flags); break;
4986 case 'm': ai->config.modulation=MOD_MOK; set_bit(FLAG_COMMIT, &ai->flags); break;
4987 default: airo_print_warn(ai->dev->name, "Unknown modulation");
4989 } else if (!strncmp(line, "Preamble: ", 10)) {
4992 case 'a': ai->config.preamble=PREAMBLE_AUTO; set_bit(FLAG_COMMIT, &ai->flags); break;
4993 case 'l': ai->config.preamble=PREAMBLE_LONG; set_bit(FLAG_COMMIT, &ai->flags); break;
4994 case 's': ai->config.preamble=PREAMBLE_SHORT; set_bit(FLAG_COMMIT, &ai->flags); break;
4995 default: airo_print_warn(ai->dev->name, "Unknown preamble");
4998 airo_print_warn(ai->dev->name, "Couldn't figure out %s", line);
5000 while( line[0] && line[0] != '\n' ) line++;
5001 if ( line[0] ) line++;
5003 airo_config_commit(dev, NULL, NULL, NULL);
5006 static char *get_rmode(u16 mode) {
5008 case RXMODE_RFMON: return "rfmon";
5009 case RXMODE_RFMON_ANYBSS: return "yna (any) bss rfmon";
5010 case RXMODE_LANMON: return "lanmon";
5015 static int proc_config_open( struct inode *inode, struct file *file ) {
5016 struct proc_data *data;
5017 struct proc_dir_entry *dp = PDE(inode);
5018 struct net_device *dev = dp->data;
5019 struct airo_info *ai = dev->priv;
5022 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5024 data = (struct proc_data *)file->private_data;
5025 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
5026 kfree (file->private_data);
5029 if ((data->wbuffer = kzalloc( 2048, GFP_KERNEL )) == NULL) {
5030 kfree (data->rbuffer);
5031 kfree (file->private_data);
5034 data->maxwritelen = 2048;
5035 data->on_close = proc_config_on_close;
5037 readConfigRid(ai, 1);
5039 i = sprintf( data->rbuffer,
5044 "DataRates: %d %d %d %d %d %d %d %d\n"
5047 (ai->config.opmode & 0xFF) == 0 ? "adhoc" :
5048 (ai->config.opmode & 0xFF) == 1 ? get_rmode(ai->config.rmode):
5049 (ai->config.opmode & 0xFF) == 2 ? "AP" :
5050 (ai->config.opmode & 0xFF) == 3 ? "AP RPTR" : "Error",
5051 test_bit(FLAG_RADIO_OFF, &ai->flags) ? "off" : "on",
5052 ai->config.nodeName,
5053 ai->config.powerSaveMode == 0 ? "CAM" :
5054 ai->config.powerSaveMode == 1 ? "PSP" :
5055 ai->config.powerSaveMode == 2 ? "PSPCAM" : "Error",
5056 (int)ai->config.rates[0],
5057 (int)ai->config.rates[1],
5058 (int)ai->config.rates[2],
5059 (int)ai->config.rates[3],
5060 (int)ai->config.rates[4],
5061 (int)ai->config.rates[5],
5062 (int)ai->config.rates[6],
5063 (int)ai->config.rates[7],
5064 (int)ai->config.channelSet,
5065 (int)ai->config.txPower
5067 sprintf( data->rbuffer + i,
5068 "LongRetryLimit: %d\n"
5069 "ShortRetryLimit: %d\n"
5070 "RTSThreshold: %d\n"
5071 "TXMSDULifetime: %d\n"
5072 "RXMSDULifetime: %d\n"
5075 "FragThreshold: %d\n"
5079 (int)ai->config.longRetryLimit,
5080 (int)ai->config.shortRetryLimit,
5081 (int)ai->config.rtsThres,
5082 (int)ai->config.txLifetime,
5083 (int)ai->config.rxLifetime,
5084 ai->config.txDiversity == 1 ? "left" :
5085 ai->config.txDiversity == 2 ? "right" : "both",
5086 ai->config.rxDiversity == 1 ? "left" :
5087 ai->config.rxDiversity == 2 ? "right" : "both",
5088 (int)ai->config.fragThresh,
5089 ai->config.authType == AUTH_ENCRYPT ? "encrypt" :
5090 ai->config.authType == AUTH_SHAREDKEY ? "shared" : "open",
5091 ai->config.modulation == 0 ? "default" :
5092 ai->config.modulation == MOD_CCK ? "cck" :
5093 ai->config.modulation == MOD_MOK ? "mok" : "error",
5094 ai->config.preamble == PREAMBLE_AUTO ? "auto" :
5095 ai->config.preamble == PREAMBLE_LONG ? "long" :
5096 ai->config.preamble == PREAMBLE_SHORT ? "short" : "error"
5098 data->readlen = strlen( data->rbuffer );
5102 static void proc_SSID_on_close( struct inode *inode, struct file *file ) {
5103 struct proc_data *data = (struct proc_data *)file->private_data;
5104 struct proc_dir_entry *dp = PDE(inode);
5105 struct net_device *dev = dp->data;
5106 struct airo_info *ai = dev->priv;
5112 if ( !data->writelen ) return;
5114 memset( &SSID_rid, 0, sizeof( SSID_rid ) );
5116 for( i = 0; i < 3; i++ ) {
5118 for( j = 0; j+offset < data->writelen && j < 32 &&
5119 data->wbuffer[offset+j] != '\n'; j++ ) {
5120 SSID_rid.ssids[i].ssid[j] = data->wbuffer[offset+j];
5122 if ( j == 0 ) break;
5123 SSID_rid.ssids[i].len = j;
5125 while( data->wbuffer[offset] != '\n' &&
5126 offset < data->writelen ) offset++;
5130 SSID_rid.len = sizeof(SSID_rid);
5132 writeSsidRid(ai, &SSID_rid, 1);
5133 enable_MAC(ai, &rsp, 1);
5136 static inline u8 hexVal(char c) {
5137 if (c>='0' && c<='9') return c -= '0';
5138 if (c>='a' && c<='f') return c -= 'a'-10;
5139 if (c>='A' && c<='F') return c -= 'A'-10;
5143 static void proc_APList_on_close( struct inode *inode, struct file *file ) {
5144 struct proc_data *data = (struct proc_data *)file->private_data;
5145 struct proc_dir_entry *dp = PDE(inode);
5146 struct net_device *dev = dp->data;
5147 struct airo_info *ai = dev->priv;
5148 APListRid APList_rid;
5152 if ( !data->writelen ) return;
5154 memset( &APList_rid, 0, sizeof(APList_rid) );
5155 APList_rid.len = sizeof(APList_rid);
5157 for( i = 0; i < 4 && data->writelen >= (i+1)*6*3; i++ ) {
5159 for( j = 0; j < 6*3 && data->wbuffer[j+i*6*3]; j++ ) {
5162 APList_rid.ap[i][j/3]=
5163 hexVal(data->wbuffer[j+i*6*3])<<4;
5166 APList_rid.ap[i][j/3]|=
5167 hexVal(data->wbuffer[j+i*6*3]);
5173 writeAPListRid(ai, &APList_rid, 1);
5174 enable_MAC(ai, &rsp, 1);
5177 /* This function wraps PC4500_writerid with a MAC disable */
5178 static int do_writerid( struct airo_info *ai, u16 rid, const void *rid_data,
5179 int len, int dummy ) {
5184 rc = PC4500_writerid(ai, rid, rid_data, len, 1);
5185 enable_MAC(ai, &rsp, 1);
5189 /* Returns the length of the key at the index. If index == 0xffff
5190 * the index of the transmit key is returned. If the key doesn't exist,
5191 * -1 will be returned.
5193 static int get_wep_key(struct airo_info *ai, u16 index) {
5198 rc = readWepKeyRid(ai, &wkr, 1, 1);
5199 if (rc == SUCCESS) do {
5200 lastindex = wkr.kindex;
5201 if (wkr.kindex == index) {
5202 if (index == 0xffff) {
5207 readWepKeyRid(ai, &wkr, 0, 1);
5208 } while(lastindex != wkr.kindex);
5212 static int set_wep_key(struct airo_info *ai, u16 index,
5213 const char *key, u16 keylen, int perm, int lock ) {
5214 static const unsigned char macaddr[ETH_ALEN] = { 0x01, 0, 0, 0, 0, 0 };
5218 memset(&wkr, 0, sizeof(wkr));
5220 // We are selecting which key to use
5221 wkr.len = sizeof(wkr);
5222 wkr.kindex = 0xffff;
5223 wkr.mac[0] = (char)index;
5224 if (perm) ai->defindex = (char)index;
5226 // We are actually setting the key
5227 wkr.len = sizeof(wkr);
5230 memcpy( wkr.key, key, keylen );
5231 memcpy( wkr.mac, macaddr, ETH_ALEN );
5234 if (perm) disable_MAC(ai, lock);
5235 writeWepKeyRid(ai, &wkr, perm, lock);
5236 if (perm) enable_MAC(ai, &rsp, lock);
5240 static void proc_wepkey_on_close( struct inode *inode, struct file *file ) {
5241 struct proc_data *data;
5242 struct proc_dir_entry *dp = PDE(inode);
5243 struct net_device *dev = dp->data;
5244 struct airo_info *ai = dev->priv;
5250 memset(key, 0, sizeof(key));
5252 data = (struct proc_data *)file->private_data;
5253 if ( !data->writelen ) return;
5255 if (data->wbuffer[0] >= '0' && data->wbuffer[0] <= '3' &&
5256 (data->wbuffer[1] == ' ' || data->wbuffer[1] == '\n')) {
5257 index = data->wbuffer[0] - '0';
5258 if (data->wbuffer[1] == '\n') {
5259 set_wep_key(ai, index, NULL, 0, 1, 1);
5264 airo_print_err(ai->dev->name, "WepKey passed invalid key index");
5268 for( i = 0; i < 16*3 && data->wbuffer[i+j]; i++ ) {
5271 key[i/3] = hexVal(data->wbuffer[i+j])<<4;
5274 key[i/3] |= hexVal(data->wbuffer[i+j]);
5278 set_wep_key(ai, index, key, i/3, 1, 1);
5281 static int proc_wepkey_open( struct inode *inode, struct file *file ) {
5282 struct proc_data *data;
5283 struct proc_dir_entry *dp = PDE(inode);
5284 struct net_device *dev = dp->data;
5285 struct airo_info *ai = dev->priv;
5292 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5294 memset(&wkr, 0, sizeof(wkr));
5295 data = (struct proc_data *)file->private_data;
5296 if ((data->rbuffer = kzalloc( 180, GFP_KERNEL )) == NULL) {
5297 kfree (file->private_data);
5301 data->maxwritelen = 80;
5302 if ((data->wbuffer = kzalloc( 80, GFP_KERNEL )) == NULL) {
5303 kfree (data->rbuffer);
5304 kfree (file->private_data);
5307 data->on_close = proc_wepkey_on_close;
5309 ptr = data->rbuffer;
5310 strcpy(ptr, "No wep keys\n");
5311 rc = readWepKeyRid(ai, &wkr, 1, 1);
5312 if (rc == SUCCESS) do {
5313 lastindex = wkr.kindex;
5314 if (wkr.kindex == 0xffff) {
5315 j += sprintf(ptr+j, "Tx key = %d\n",
5318 j += sprintf(ptr+j, "Key %d set with length = %d\n",
5319 (int)wkr.kindex, (int)wkr.klen);
5321 readWepKeyRid(ai, &wkr, 0, 1);
5322 } while((lastindex != wkr.kindex) && (j < 180-30));
5324 data->readlen = strlen( data->rbuffer );
5328 static int proc_SSID_open( struct inode *inode, struct file *file ) {
5329 struct proc_data *data;
5330 struct proc_dir_entry *dp = PDE(inode);
5331 struct net_device *dev = dp->data;
5332 struct airo_info *ai = dev->priv;
5337 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5339 data = (struct proc_data *)file->private_data;
5340 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5341 kfree (file->private_data);
5345 data->maxwritelen = 33*3;
5346 if ((data->wbuffer = kzalloc( 33*3, GFP_KERNEL )) == NULL) {
5347 kfree (data->rbuffer);
5348 kfree (file->private_data);
5351 data->on_close = proc_SSID_on_close;
5353 readSsidRid(ai, &SSID_rid);
5354 ptr = data->rbuffer;
5355 for( i = 0; i < 3; i++ ) {
5357 if ( !SSID_rid.ssids[i].len ) break;
5358 for( j = 0; j < 32 &&
5359 j < SSID_rid.ssids[i].len &&
5360 SSID_rid.ssids[i].ssid[j]; j++ ) {
5361 *ptr++ = SSID_rid.ssids[i].ssid[j];
5366 data->readlen = strlen( data->rbuffer );
5370 static int proc_APList_open( struct inode *inode, struct file *file ) {
5371 struct proc_data *data;
5372 struct proc_dir_entry *dp = PDE(inode);
5373 struct net_device *dev = dp->data;
5374 struct airo_info *ai = dev->priv;
5377 APListRid APList_rid;
5379 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5381 data = (struct proc_data *)file->private_data;
5382 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5383 kfree (file->private_data);
5387 data->maxwritelen = 4*6*3;
5388 if ((data->wbuffer = kzalloc( data->maxwritelen, GFP_KERNEL )) == NULL) {
5389 kfree (data->rbuffer);
5390 kfree (file->private_data);
5393 data->on_close = proc_APList_on_close;
5395 readAPListRid(ai, &APList_rid);
5396 ptr = data->rbuffer;
5397 for( i = 0; i < 4; i++ ) {
5398 // We end when we find a zero MAC
5399 if ( !*(int*)APList_rid.ap[i] &&
5400 !*(int*)&APList_rid.ap[i][2]) break;
5401 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x\n",
5402 (int)APList_rid.ap[i][0],
5403 (int)APList_rid.ap[i][1],
5404 (int)APList_rid.ap[i][2],
5405 (int)APList_rid.ap[i][3],
5406 (int)APList_rid.ap[i][4],
5407 (int)APList_rid.ap[i][5]);
5409 if (i==0) ptr += sprintf(ptr, "Not using specific APs\n");
5412 data->readlen = strlen( data->rbuffer );
5416 static int proc_BSSList_open( struct inode *inode, struct file *file ) {
5417 struct proc_data *data;
5418 struct proc_dir_entry *dp = PDE(inode);
5419 struct net_device *dev = dp->data;
5420 struct airo_info *ai = dev->priv;
5422 BSSListRid BSSList_rid;
5424 /* If doLoseSync is not 1, we won't do a Lose Sync */
5425 int doLoseSync = -1;
5427 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5429 data = (struct proc_data *)file->private_data;
5430 if ((data->rbuffer = kmalloc( 1024, GFP_KERNEL )) == NULL) {
5431 kfree (file->private_data);
5435 data->maxwritelen = 0;
5436 data->wbuffer = NULL;
5437 data->on_close = NULL;
5439 if (file->f_mode & FMODE_WRITE) {
5440 if (!(file->f_mode & FMODE_READ)) {
5444 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
5445 memset(&cmd, 0, sizeof(cmd));
5446 cmd.cmd=CMD_LISTBSS;
5447 if (down_interruptible(&ai->sem))
5448 return -ERESTARTSYS;
5449 issuecommand(ai, &cmd, &rsp);
5456 ptr = data->rbuffer;
5457 /* There is a race condition here if there are concurrent opens.
5458 Since it is a rare condition, we'll just live with it, otherwise
5459 we have to add a spin lock... */
5460 rc = readBSSListRid(ai, doLoseSync, &BSSList_rid);
5461 while(rc == 0 && BSSList_rid.index != 0xffff) {
5462 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x %*s rssi = %d",
5463 (int)BSSList_rid.bssid[0],
5464 (int)BSSList_rid.bssid[1],
5465 (int)BSSList_rid.bssid[2],
5466 (int)BSSList_rid.bssid[3],
5467 (int)BSSList_rid.bssid[4],
5468 (int)BSSList_rid.bssid[5],
5469 (int)BSSList_rid.ssidLen,
5471 (int)BSSList_rid.dBm);
5472 ptr += sprintf(ptr, " channel = %d %s %s %s %s\n",
5473 (int)BSSList_rid.dsChannel,
5474 BSSList_rid.cap & CAP_ESS ? "ESS" : "",
5475 BSSList_rid.cap & CAP_IBSS ? "adhoc" : "",
5476 BSSList_rid.cap & CAP_PRIVACY ? "wep" : "",
5477 BSSList_rid.cap & CAP_SHORTHDR ? "shorthdr" : "");
5478 rc = readBSSListRid(ai, 0, &BSSList_rid);
5481 data->readlen = strlen( data->rbuffer );
5485 static int proc_close( struct inode *inode, struct file *file )
5487 struct proc_data *data = file->private_data;
5489 if (data->on_close != NULL)
5490 data->on_close(inode, file);
5491 kfree(data->rbuffer);
5492 kfree(data->wbuffer);
5497 static struct net_device_list {
5498 struct net_device *dev;
5499 struct net_device_list *next;
5502 /* Since the card doesn't automatically switch to the right WEP mode,
5503 we will make it do it. If the card isn't associated, every secs we
5504 will switch WEP modes to see if that will help. If the card is
5505 associated we will check every minute to see if anything has
5507 static void timer_func( struct net_device *dev ) {
5508 struct airo_info *apriv = dev->priv;
5511 /* We don't have a link so try changing the authtype */
5512 readConfigRid(apriv, 0);
5513 disable_MAC(apriv, 0);
5514 switch(apriv->config.authType) {
5516 /* So drop to OPEN */
5517 apriv->config.authType = AUTH_OPEN;
5519 case AUTH_SHAREDKEY:
5520 if (apriv->keyindex < auto_wep) {
5521 set_wep_key(apriv, apriv->keyindex, NULL, 0, 0, 0);
5522 apriv->config.authType = AUTH_SHAREDKEY;
5525 /* Drop to ENCRYPT */
5526 apriv->keyindex = 0;
5527 set_wep_key(apriv, apriv->defindex, NULL, 0, 0, 0);
5528 apriv->config.authType = AUTH_ENCRYPT;
5531 default: /* We'll escalate to SHAREDKEY */
5532 apriv->config.authType = AUTH_SHAREDKEY;
5534 set_bit (FLAG_COMMIT, &apriv->flags);
5535 writeConfigRid(apriv, 0);
5536 enable_MAC(apriv, &rsp, 0);
5539 /* Schedule check to see if the change worked */
5540 clear_bit(JOB_AUTOWEP, &apriv->jobs);
5541 apriv->expires = RUN_AT(HZ*3);
5544 static int add_airo_dev( struct net_device *dev ) {
5545 struct net_device_list *node = kmalloc( sizeof( *node ), GFP_KERNEL );
5550 node->next = airo_devices;
5551 airo_devices = node;
5556 static void del_airo_dev( struct net_device *dev ) {
5557 struct net_device_list **p = &airo_devices;
5558 while( *p && ( (*p)->dev != dev ) )
5560 if ( *p && (*p)->dev == dev )
5565 static int __devinit airo_pci_probe(struct pci_dev *pdev,
5566 const struct pci_device_id *pent)
5568 struct net_device *dev;
5570 if (pci_enable_device(pdev))
5572 pci_set_master(pdev);
5574 if (pdev->device == 0x5000 || pdev->device == 0xa504)
5575 dev = _init_airo_card(pdev->irq, pdev->resource[0].start, 0, pdev, &pdev->dev);
5577 dev = _init_airo_card(pdev->irq, pdev->resource[2].start, 0, pdev, &pdev->dev);
5581 pci_set_drvdata(pdev, dev);
5585 static void __devexit airo_pci_remove(struct pci_dev *pdev)
5589 static int airo_pci_suspend(struct pci_dev *pdev, pm_message_t state)
5591 struct net_device *dev = pci_get_drvdata(pdev);
5592 struct airo_info *ai = dev->priv;
5596 if ((ai->APList == NULL) &&
5597 (ai->APList = kmalloc(sizeof(APListRid), GFP_KERNEL)) == NULL)
5599 if ((ai->SSID == NULL) &&
5600 (ai->SSID = kmalloc(sizeof(SsidRid), GFP_KERNEL)) == NULL)
5602 readAPListRid(ai, ai->APList);
5603 readSsidRid(ai, ai->SSID);
5604 memset(&cmd, 0, sizeof(cmd));
5605 /* the lock will be released at the end of the resume callback */
5606 if (down_interruptible(&ai->sem))
5609 netif_device_detach(dev);
5612 issuecommand(ai, &cmd, &rsp);
5614 pci_enable_wake(pdev, pci_choose_state(pdev, state), 1);
5615 pci_save_state(pdev);
5616 return pci_set_power_state(pdev, pci_choose_state(pdev, state));
5619 static int airo_pci_resume(struct pci_dev *pdev)
5621 struct net_device *dev = pci_get_drvdata(pdev);
5622 struct airo_info *ai = dev->priv;
5624 pci_power_t prev_state = pdev->current_state;
5626 pci_set_power_state(pdev, PCI_D0);
5627 pci_restore_state(pdev);
5628 pci_enable_wake(pdev, PCI_D0, 0);
5630 if (prev_state != PCI_D1) {
5632 mpi_init_descriptors(ai);
5633 setup_card(ai, dev->dev_addr, 0);
5634 clear_bit(FLAG_RADIO_OFF, &ai->flags);
5635 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
5637 OUT4500(ai, EVACK, EV_AWAKEN);
5638 OUT4500(ai, EVACK, EV_AWAKEN);
5642 set_bit (FLAG_COMMIT, &ai->flags);
5646 writeSsidRid(ai, ai->SSID, 0);
5651 writeAPListRid(ai, ai->APList, 0);
5655 writeConfigRid(ai, 0);
5656 enable_MAC(ai, &rsp, 0);
5657 ai->power = PMSG_ON;
5658 netif_device_attach(dev);
5659 netif_wake_queue(dev);
5660 enable_interrupts(ai);
5666 static int __init airo_init_module( void )
5668 int i, have_isa_dev = 0;
5670 airo_entry = create_proc_entry("aironet",
5671 S_IFDIR | airo_perm,
5673 airo_entry->uid = proc_uid;
5674 airo_entry->gid = proc_gid;
5676 for( i = 0; i < 4 && io[i] && irq[i]; i++ ) {
5677 airo_print_info("", "Trying to configure ISA adapter at irq=%d "
5678 "io=0x%x", irq[i], io[i] );
5679 if (init_airo_card( irq[i], io[i], 0, NULL ))
5684 airo_print_info("", "Probing for PCI adapters");
5685 pci_register_driver(&airo_driver);
5686 airo_print_info("", "Finished probing for PCI adapters");
5689 /* Always exit with success, as we are a library module
5690 * as well as a driver module
5695 static void __exit airo_cleanup_module( void )
5697 while( airo_devices ) {
5698 airo_print_info(airo_devices->dev->name, "Unregistering...\n");
5699 stop_airo_card( airo_devices->dev, 1 );
5702 pci_unregister_driver(&airo_driver);
5704 remove_proc_entry("aironet", proc_root_driver);
5708 * Initial Wireless Extension code for Aironet driver by :
5709 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 17 November 00
5710 * Conversion to new driver API by :
5711 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 26 March 02
5712 * Javier also did a good amount of work here, adding some new extensions
5713 * and fixing my code. Let's just say that without him this code just
5714 * would not work at all... - Jean II
5717 static u8 airo_rssi_to_dbm (tdsRssiEntry *rssi_rid, u8 rssi)
5722 return (0x100 - rssi_rid[rssi].rssidBm);
5725 static u8 airo_dbm_to_pct (tdsRssiEntry *rssi_rid, u8 dbm)
5732 for( i = 0; i < 256; i++ )
5733 if (rssi_rid[i].rssidBm == dbm)
5734 return rssi_rid[i].rssipct;
5740 static int airo_get_quality (StatusRid *status_rid, CapabilityRid *cap_rid)
5744 if ((status_rid->mode & 0x3f) == 0x3f && (cap_rid->hardCap & 8)) {
5745 if (memcmp(cap_rid->prodName, "350", 3))
5746 if (status_rid->signalQuality > 0x20)
5749 quality = 0x20 - status_rid->signalQuality;
5751 if (status_rid->signalQuality > 0xb0)
5753 else if (status_rid->signalQuality < 0x10)
5756 quality = 0xb0 - status_rid->signalQuality;
5761 #define airo_get_max_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x20 : 0xa0)
5762 #define airo_get_avg_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x10 : 0x50);
5764 /*------------------------------------------------------------------*/
5766 * Wireless Handler : get protocol name
5768 static int airo_get_name(struct net_device *dev,
5769 struct iw_request_info *info,
5773 strcpy(cwrq, "IEEE 802.11-DS");
5777 /*------------------------------------------------------------------*/
5779 * Wireless Handler : set frequency
5781 static int airo_set_freq(struct net_device *dev,
5782 struct iw_request_info *info,
5783 struct iw_freq *fwrq,
5786 struct airo_info *local = dev->priv;
5787 int rc = -EINPROGRESS; /* Call commit handler */
5789 /* If setting by frequency, convert to a channel */
5790 if((fwrq->e == 1) &&
5791 (fwrq->m >= (int) 2.412e8) &&
5792 (fwrq->m <= (int) 2.487e8)) {
5793 int f = fwrq->m / 100000;
5795 while((c < 14) && (f != frequency_list[c]))
5797 /* Hack to fall through... */
5801 /* Setting by channel number */
5802 if((fwrq->m > 1000) || (fwrq->e > 0))
5805 int channel = fwrq->m;
5806 /* We should do a better check than that,
5807 * based on the card capability !!! */
5808 if((channel < 1) || (channel > 14)) {
5809 airo_print_dbg(dev->name, "New channel value of %d is invalid!",
5813 readConfigRid(local, 1);
5814 /* Yes ! We can set it !!! */
5815 local->config.channelSet = (u16) channel;
5816 set_bit (FLAG_COMMIT, &local->flags);
5822 /*------------------------------------------------------------------*/
5824 * Wireless Handler : get frequency
5826 static int airo_get_freq(struct net_device *dev,
5827 struct iw_request_info *info,
5828 struct iw_freq *fwrq,
5831 struct airo_info *local = dev->priv;
5832 StatusRid status_rid; /* Card status info */
5835 readConfigRid(local, 1);
5836 if ((local->config.opmode & 0xFF) == MODE_STA_ESS)
5837 status_rid.channel = local->config.channelSet;
5839 readStatusRid(local, &status_rid, 1);
5841 ch = (int)status_rid.channel;
5842 if((ch > 0) && (ch < 15)) {
5843 fwrq->m = frequency_list[ch - 1] * 100000;
5853 /*------------------------------------------------------------------*/
5855 * Wireless Handler : set ESSID
5857 static int airo_set_essid(struct net_device *dev,
5858 struct iw_request_info *info,
5859 struct iw_point *dwrq,
5862 struct airo_info *local = dev->priv;
5864 SsidRid SSID_rid; /* SSIDs */
5866 /* Reload the list of current SSID */
5867 readSsidRid(local, &SSID_rid);
5869 /* Check if we asked for `any' */
5870 if(dwrq->flags == 0) {
5871 /* Just send an empty SSID list */
5872 memset(&SSID_rid, 0, sizeof(SSID_rid));
5874 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
5876 /* Check the size of the string */
5877 if(dwrq->length > IW_ESSID_MAX_SIZE+1) {
5880 /* Check if index is valid */
5881 if((index < 0) || (index >= 4)) {
5886 memset(SSID_rid.ssids[index].ssid, 0,
5887 sizeof(SSID_rid.ssids[index].ssid));
5888 memcpy(SSID_rid.ssids[index].ssid, extra, dwrq->length);
5889 SSID_rid.ssids[index].len = dwrq->length - 1;
5891 SSID_rid.len = sizeof(SSID_rid);
5892 /* Write it to the card */
5893 disable_MAC(local, 1);
5894 writeSsidRid(local, &SSID_rid, 1);
5895 enable_MAC(local, &rsp, 1);
5900 /*------------------------------------------------------------------*/
5902 * Wireless Handler : get ESSID
5904 static int airo_get_essid(struct net_device *dev,
5905 struct iw_request_info *info,
5906 struct iw_point *dwrq,
5909 struct airo_info *local = dev->priv;
5910 StatusRid status_rid; /* Card status info */
5912 readStatusRid(local, &status_rid, 1);
5914 /* Note : if dwrq->flags != 0, we should
5915 * get the relevant SSID from the SSID list... */
5917 /* Get the current SSID */
5918 memcpy(extra, status_rid.SSID, status_rid.SSIDlen);
5919 extra[status_rid.SSIDlen] = '\0';
5920 /* If none, we may want to get the one that was set */
5923 dwrq->length = status_rid.SSIDlen;
5924 dwrq->flags = 1; /* active */
5929 /*------------------------------------------------------------------*/
5931 * Wireless Handler : set AP address
5933 static int airo_set_wap(struct net_device *dev,
5934 struct iw_request_info *info,
5935 struct sockaddr *awrq,
5938 struct airo_info *local = dev->priv;
5941 APListRid APList_rid;
5942 static const u8 any[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
5943 static const u8 off[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
5945 if (awrq->sa_family != ARPHRD_ETHER)
5947 else if (!memcmp(any, awrq->sa_data, ETH_ALEN) ||
5948 !memcmp(off, awrq->sa_data, ETH_ALEN)) {
5949 memset(&cmd, 0, sizeof(cmd));
5950 cmd.cmd=CMD_LOSE_SYNC;
5951 if (down_interruptible(&local->sem))
5952 return -ERESTARTSYS;
5953 issuecommand(local, &cmd, &rsp);
5956 memset(&APList_rid, 0, sizeof(APList_rid));
5957 APList_rid.len = sizeof(APList_rid);
5958 memcpy(APList_rid.ap[0], awrq->sa_data, ETH_ALEN);
5959 disable_MAC(local, 1);
5960 writeAPListRid(local, &APList_rid, 1);
5961 enable_MAC(local, &rsp, 1);
5966 /*------------------------------------------------------------------*/
5968 * Wireless Handler : get AP address
5970 static int airo_get_wap(struct net_device *dev,
5971 struct iw_request_info *info,
5972 struct sockaddr *awrq,
5975 struct airo_info *local = dev->priv;
5976 StatusRid status_rid; /* Card status info */
5978 readStatusRid(local, &status_rid, 1);
5980 /* Tentative. This seems to work, wow, I'm lucky !!! */
5981 memcpy(awrq->sa_data, status_rid.bssid[0], ETH_ALEN);
5982 awrq->sa_family = ARPHRD_ETHER;
5987 /*------------------------------------------------------------------*/
5989 * Wireless Handler : set Nickname
5991 static int airo_set_nick(struct net_device *dev,
5992 struct iw_request_info *info,
5993 struct iw_point *dwrq,
5996 struct airo_info *local = dev->priv;
5998 /* Check the size of the string */
5999 if(dwrq->length > 16 + 1) {
6002 readConfigRid(local, 1);
6003 memset(local->config.nodeName, 0, sizeof(local->config.nodeName));
6004 memcpy(local->config.nodeName, extra, dwrq->length);
6005 set_bit (FLAG_COMMIT, &local->flags);
6007 return -EINPROGRESS; /* Call commit handler */
6010 /*------------------------------------------------------------------*/
6012 * Wireless Handler : get Nickname
6014 static int airo_get_nick(struct net_device *dev,
6015 struct iw_request_info *info,
6016 struct iw_point *dwrq,
6019 struct airo_info *local = dev->priv;
6021 readConfigRid(local, 1);
6022 strncpy(extra, local->config.nodeName, 16);
6024 dwrq->length = strlen(extra) + 1;
6029 /*------------------------------------------------------------------*/
6031 * Wireless Handler : set Bit-Rate
6033 static int airo_set_rate(struct net_device *dev,
6034 struct iw_request_info *info,
6035 struct iw_param *vwrq,
6038 struct airo_info *local = dev->priv;
6039 CapabilityRid cap_rid; /* Card capability info */
6043 /* First : get a valid bit rate value */
6044 readCapabilityRid(local, &cap_rid, 1);
6046 /* Which type of value ? */
6047 if((vwrq->value < 8) && (vwrq->value >= 0)) {
6048 /* Setting by rate index */
6049 /* Find value in the magic rate table */
6050 brate = cap_rid.supportedRates[vwrq->value];
6052 /* Setting by frequency value */
6053 u8 normvalue = (u8) (vwrq->value/500000);
6055 /* Check if rate is valid */
6056 for(i = 0 ; i < 8 ; i++) {
6057 if(normvalue == cap_rid.supportedRates[i]) {
6063 /* -1 designed the max rate (mostly auto mode) */
6064 if(vwrq->value == -1) {
6065 /* Get the highest available rate */
6066 for(i = 0 ; i < 8 ; i++) {
6067 if(cap_rid.supportedRates[i] == 0)
6071 brate = cap_rid.supportedRates[i - 1];
6073 /* Check that it is valid */
6078 readConfigRid(local, 1);
6079 /* Now, check if we want a fixed or auto value */
6080 if(vwrq->fixed == 0) {
6081 /* Fill all the rates up to this max rate */
6082 memset(local->config.rates, 0, 8);
6083 for(i = 0 ; i < 8 ; i++) {
6084 local->config.rates[i] = cap_rid.supportedRates[i];
6085 if(local->config.rates[i] == brate)
6090 /* One rate, fixed */
6091 memset(local->config.rates, 0, 8);
6092 local->config.rates[0] = brate;
6094 set_bit (FLAG_COMMIT, &local->flags);
6096 return -EINPROGRESS; /* Call commit handler */
6099 /*------------------------------------------------------------------*/
6101 * Wireless Handler : get Bit-Rate
6103 static int airo_get_rate(struct net_device *dev,
6104 struct iw_request_info *info,
6105 struct iw_param *vwrq,
6108 struct airo_info *local = dev->priv;
6109 StatusRid status_rid; /* Card status info */
6111 readStatusRid(local, &status_rid, 1);
6113 vwrq->value = status_rid.currentXmitRate * 500000;
6114 /* If more than one rate, set auto */
6115 readConfigRid(local, 1);
6116 vwrq->fixed = (local->config.rates[1] == 0);
6121 /*------------------------------------------------------------------*/
6123 * Wireless Handler : set RTS threshold
6125 static int airo_set_rts(struct net_device *dev,
6126 struct iw_request_info *info,
6127 struct iw_param *vwrq,
6130 struct airo_info *local = dev->priv;
6131 int rthr = vwrq->value;
6134 rthr = AIRO_DEF_MTU;
6135 if((rthr < 0) || (rthr > AIRO_DEF_MTU)) {
6138 readConfigRid(local, 1);
6139 local->config.rtsThres = rthr;
6140 set_bit (FLAG_COMMIT, &local->flags);
6142 return -EINPROGRESS; /* Call commit handler */
6145 /*------------------------------------------------------------------*/
6147 * Wireless Handler : get RTS threshold
6149 static int airo_get_rts(struct net_device *dev,
6150 struct iw_request_info *info,
6151 struct iw_param *vwrq,
6154 struct airo_info *local = dev->priv;
6156 readConfigRid(local, 1);
6157 vwrq->value = local->config.rtsThres;
6158 vwrq->disabled = (vwrq->value >= AIRO_DEF_MTU);
6164 /*------------------------------------------------------------------*/
6166 * Wireless Handler : set Fragmentation threshold
6168 static int airo_set_frag(struct net_device *dev,
6169 struct iw_request_info *info,
6170 struct iw_param *vwrq,
6173 struct airo_info *local = dev->priv;
6174 int fthr = vwrq->value;
6177 fthr = AIRO_DEF_MTU;
6178 if((fthr < 256) || (fthr > AIRO_DEF_MTU)) {
6181 fthr &= ~0x1; /* Get an even value - is it really needed ??? */
6182 readConfigRid(local, 1);
6183 local->config.fragThresh = (u16)fthr;
6184 set_bit (FLAG_COMMIT, &local->flags);
6186 return -EINPROGRESS; /* Call commit handler */
6189 /*------------------------------------------------------------------*/
6191 * Wireless Handler : get Fragmentation threshold
6193 static int airo_get_frag(struct net_device *dev,
6194 struct iw_request_info *info,
6195 struct iw_param *vwrq,
6198 struct airo_info *local = dev->priv;
6200 readConfigRid(local, 1);
6201 vwrq->value = local->config.fragThresh;
6202 vwrq->disabled = (vwrq->value >= AIRO_DEF_MTU);
6208 /*------------------------------------------------------------------*/
6210 * Wireless Handler : set Mode of Operation
6212 static int airo_set_mode(struct net_device *dev,
6213 struct iw_request_info *info,
6217 struct airo_info *local = dev->priv;
6220 readConfigRid(local, 1);
6221 if ((local->config.rmode & 0xff) >= RXMODE_RFMON)
6226 local->config.opmode &= 0xFF00;
6227 local->config.opmode |= MODE_STA_IBSS;
6228 local->config.rmode &= 0xfe00;
6229 local->config.scanMode = SCANMODE_ACTIVE;
6230 clear_bit (FLAG_802_11, &local->flags);
6233 local->config.opmode &= 0xFF00;
6234 local->config.opmode |= MODE_STA_ESS;
6235 local->config.rmode &= 0xfe00;
6236 local->config.scanMode = SCANMODE_ACTIVE;
6237 clear_bit (FLAG_802_11, &local->flags);
6239 case IW_MODE_MASTER:
6240 local->config.opmode &= 0xFF00;
6241 local->config.opmode |= MODE_AP;
6242 local->config.rmode &= 0xfe00;
6243 local->config.scanMode = SCANMODE_ACTIVE;
6244 clear_bit (FLAG_802_11, &local->flags);
6246 case IW_MODE_REPEAT:
6247 local->config.opmode &= 0xFF00;
6248 local->config.opmode |= MODE_AP_RPTR;
6249 local->config.rmode &= 0xfe00;
6250 local->config.scanMode = SCANMODE_ACTIVE;
6251 clear_bit (FLAG_802_11, &local->flags);
6253 case IW_MODE_MONITOR:
6254 local->config.opmode &= 0xFF00;
6255 local->config.opmode |= MODE_STA_ESS;
6256 local->config.rmode &= 0xfe00;
6257 local->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
6258 local->config.scanMode = SCANMODE_PASSIVE;
6259 set_bit (FLAG_802_11, &local->flags);
6265 set_bit (FLAG_RESET, &local->flags);
6266 set_bit (FLAG_COMMIT, &local->flags);
6268 return -EINPROGRESS; /* Call commit handler */
6271 /*------------------------------------------------------------------*/
6273 * Wireless Handler : get Mode of Operation
6275 static int airo_get_mode(struct net_device *dev,
6276 struct iw_request_info *info,
6280 struct airo_info *local = dev->priv;
6282 readConfigRid(local, 1);
6283 /* If not managed, assume it's ad-hoc */
6284 switch (local->config.opmode & 0xFF) {
6286 *uwrq = IW_MODE_INFRA;
6289 *uwrq = IW_MODE_MASTER;
6292 *uwrq = IW_MODE_REPEAT;
6295 *uwrq = IW_MODE_ADHOC;
6301 /*------------------------------------------------------------------*/
6303 * Wireless Handler : set Encryption Key
6305 static int airo_set_encode(struct net_device *dev,
6306 struct iw_request_info *info,
6307 struct iw_point *dwrq,
6310 struct airo_info *local = dev->priv;
6311 CapabilityRid cap_rid; /* Card capability info */
6312 int perm = ( dwrq->flags & IW_ENCODE_TEMP ? 0 : 1 );
6313 u16 currentAuthType = local->config.authType;
6315 /* Is WEP supported ? */
6316 readCapabilityRid(local, &cap_rid, 1);
6317 /* Older firmware doesn't support this...
6318 if(!(cap_rid.softCap & 2)) {
6321 readConfigRid(local, 1);
6323 /* Basic checking: do we have a key to set ?
6324 * Note : with the new API, it's impossible to get a NULL pointer.
6325 * Therefore, we need to check a key size == 0 instead.
6326 * New version of iwconfig properly set the IW_ENCODE_NOKEY flag
6327 * when no key is present (only change flags), but older versions
6328 * don't do it. - Jean II */
6329 if (dwrq->length > 0) {
6331 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6332 int current_index = get_wep_key(local, 0xffff);
6333 /* Check the size of the key */
6334 if (dwrq->length > MAX_KEY_SIZE) {
6337 /* Check the index (none -> use current) */
6338 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4:1)))
6339 index = current_index;
6340 /* Set the length */
6341 if (dwrq->length > MIN_KEY_SIZE)
6342 key.len = MAX_KEY_SIZE;
6344 if (dwrq->length > 0)
6345 key.len = MIN_KEY_SIZE;
6347 /* Disable the key */
6349 /* Check if the key is not marked as invalid */
6350 if(!(dwrq->flags & IW_ENCODE_NOKEY)) {
6352 memset(key.key, 0, MAX_KEY_SIZE);
6353 /* Copy the key in the driver */
6354 memcpy(key.key, extra, dwrq->length);
6355 /* Send the key to the card */
6356 set_wep_key(local, index, key.key, key.len, perm, 1);
6358 /* WE specify that if a valid key is set, encryption
6359 * should be enabled (user may turn it off later)
6360 * This is also how "iwconfig ethX key on" works */
6361 if((index == current_index) && (key.len > 0) &&
6362 (local->config.authType == AUTH_OPEN)) {
6363 local->config.authType = AUTH_ENCRYPT;
6366 /* Do we want to just set the transmit key index ? */
6367 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6368 if ((index >= 0) && (index < ((cap_rid.softCap & 0x80)?4:1))) {
6369 set_wep_key(local, index, NULL, 0, perm, 1);
6371 /* Don't complain if only change the mode */
6372 if(!dwrq->flags & IW_ENCODE_MODE) {
6376 /* Read the flags */
6377 if(dwrq->flags & IW_ENCODE_DISABLED)
6378 local->config.authType = AUTH_OPEN; // disable encryption
6379 if(dwrq->flags & IW_ENCODE_RESTRICTED)
6380 local->config.authType = AUTH_SHAREDKEY; // Only Both
6381 if(dwrq->flags & IW_ENCODE_OPEN)
6382 local->config.authType = AUTH_ENCRYPT; // Only Wep
6383 /* Commit the changes to flags if needed */
6384 if (local->config.authType != currentAuthType)
6385 set_bit (FLAG_COMMIT, &local->flags);
6386 return -EINPROGRESS; /* Call commit handler */
6389 /*------------------------------------------------------------------*/
6391 * Wireless Handler : get Encryption Key
6393 static int airo_get_encode(struct net_device *dev,
6394 struct iw_request_info *info,
6395 struct iw_point *dwrq,
6398 struct airo_info *local = dev->priv;
6399 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6400 CapabilityRid cap_rid; /* Card capability info */
6402 /* Is it supported ? */
6403 readCapabilityRid(local, &cap_rid, 1);
6404 if(!(cap_rid.softCap & 2)) {
6407 readConfigRid(local, 1);
6408 /* Check encryption mode */
6409 switch(local->config.authType) {
6411 dwrq->flags = IW_ENCODE_OPEN;
6413 case AUTH_SHAREDKEY:
6414 dwrq->flags = IW_ENCODE_RESTRICTED;
6418 dwrq->flags = IW_ENCODE_DISABLED;
6421 /* We can't return the key, so set the proper flag and return zero */
6422 dwrq->flags |= IW_ENCODE_NOKEY;
6423 memset(extra, 0, 16);
6425 /* Which key do we want ? -1 -> tx index */
6426 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4 : 1)))
6427 index = get_wep_key(local, 0xffff);
6428 dwrq->flags |= index + 1;
6429 /* Copy the key to the user buffer */
6430 dwrq->length = get_wep_key(local, index);
6431 if (dwrq->length > 16) {
6437 /*------------------------------------------------------------------*/
6439 * Wireless Handler : set extended Encryption parameters
6441 static int airo_set_encodeext(struct net_device *dev,
6442 struct iw_request_info *info,
6443 union iwreq_data *wrqu,
6446 struct airo_info *local = dev->priv;
6447 struct iw_point *encoding = &wrqu->encoding;
6448 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6449 CapabilityRid cap_rid; /* Card capability info */
6450 int perm = ( encoding->flags & IW_ENCODE_TEMP ? 0 : 1 );
6451 u16 currentAuthType = local->config.authType;
6452 int idx, key_len, alg = ext->alg, set_key = 1;
6455 /* Is WEP supported ? */
6456 readCapabilityRid(local, &cap_rid, 1);
6457 /* Older firmware doesn't support this...
6458 if(!(cap_rid.softCap & 2)) {
6461 readConfigRid(local, 1);
6463 /* Determine and validate the key index */
6464 idx = encoding->flags & IW_ENCODE_INDEX;
6466 if (idx < 1 || idx > ((cap_rid.softCap & 0x80) ? 4:1))
6470 idx = get_wep_key(local, 0xffff);
6472 if (encoding->flags & IW_ENCODE_DISABLED)
6473 alg = IW_ENCODE_ALG_NONE;
6475 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
6476 /* Only set transmit key index here, actual
6477 * key is set below if needed.
6479 set_wep_key(local, idx, NULL, 0, perm, 1);
6480 set_key = ext->key_len > 0 ? 1 : 0;
6484 /* Set the requested key first */
6485 memset(key.key, 0, MAX_KEY_SIZE);
6487 case IW_ENCODE_ALG_NONE:
6490 case IW_ENCODE_ALG_WEP:
6491 if (ext->key_len > MIN_KEY_SIZE) {
6492 key.len = MAX_KEY_SIZE;
6493 } else if (ext->key_len > 0) {
6494 key.len = MIN_KEY_SIZE;
6498 key_len = min (ext->key_len, key.len);
6499 memcpy(key.key, ext->key, key_len);
6504 /* Send the key to the card */
6505 set_wep_key(local, idx, key.key, key.len, perm, 1);
6508 /* Read the flags */
6509 if(encoding->flags & IW_ENCODE_DISABLED)
6510 local->config.authType = AUTH_OPEN; // disable encryption
6511 if(encoding->flags & IW_ENCODE_RESTRICTED)
6512 local->config.authType = AUTH_SHAREDKEY; // Only Both
6513 if(encoding->flags & IW_ENCODE_OPEN)
6514 local->config.authType = AUTH_ENCRYPT; // Only Wep
6515 /* Commit the changes to flags if needed */
6516 if (local->config.authType != currentAuthType)
6517 set_bit (FLAG_COMMIT, &local->flags);
6519 return -EINPROGRESS;
6523 /*------------------------------------------------------------------*/
6525 * Wireless Handler : get extended Encryption parameters
6527 static int airo_get_encodeext(struct net_device *dev,
6528 struct iw_request_info *info,
6529 union iwreq_data *wrqu,
6532 struct airo_info *local = dev->priv;
6533 struct iw_point *encoding = &wrqu->encoding;
6534 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6535 CapabilityRid cap_rid; /* Card capability info */
6536 int idx, max_key_len;
6538 /* Is it supported ? */
6539 readCapabilityRid(local, &cap_rid, 1);
6540 if(!(cap_rid.softCap & 2)) {
6543 readConfigRid(local, 1);
6545 max_key_len = encoding->length - sizeof(*ext);
6546 if (max_key_len < 0)
6549 idx = encoding->flags & IW_ENCODE_INDEX;
6551 if (idx < 1 || idx > ((cap_rid.softCap & 0x80) ? 4:1))
6555 idx = get_wep_key(local, 0xffff);
6557 encoding->flags = idx + 1;
6558 memset(ext, 0, sizeof(*ext));
6560 /* Check encryption mode */
6561 switch(local->config.authType) {
6563 encoding->flags = IW_ENCODE_ALG_WEP | IW_ENCODE_ENABLED;
6565 case AUTH_SHAREDKEY:
6566 encoding->flags = IW_ENCODE_ALG_WEP | IW_ENCODE_ENABLED;
6570 encoding->flags = IW_ENCODE_ALG_NONE | IW_ENCODE_DISABLED;
6573 /* We can't return the key, so set the proper flag and return zero */
6574 encoding->flags |= IW_ENCODE_NOKEY;
6575 memset(extra, 0, 16);
6577 /* Copy the key to the user buffer */
6578 ext->key_len = get_wep_key(local, idx);
6579 if (ext->key_len > 16) {
6587 /*------------------------------------------------------------------*/
6589 * Wireless Handler : set extended authentication parameters
6591 static int airo_set_auth(struct net_device *dev,
6592 struct iw_request_info *info,
6593 union iwreq_data *wrqu, char *extra)
6595 struct airo_info *local = dev->priv;
6596 struct iw_param *param = &wrqu->param;
6597 u16 currentAuthType = local->config.authType;
6599 switch (param->flags & IW_AUTH_INDEX) {
6600 case IW_AUTH_WPA_VERSION:
6601 case IW_AUTH_CIPHER_PAIRWISE:
6602 case IW_AUTH_CIPHER_GROUP:
6603 case IW_AUTH_KEY_MGMT:
6604 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6605 case IW_AUTH_PRIVACY_INVOKED:
6607 * airo does not use these parameters
6611 case IW_AUTH_DROP_UNENCRYPTED:
6613 /* Only change auth type if unencrypted */
6614 if (currentAuthType == AUTH_OPEN)
6615 local->config.authType = AUTH_ENCRYPT;
6617 local->config.authType = AUTH_OPEN;
6620 /* Commit the changes to flags if needed */
6621 if (local->config.authType != currentAuthType)
6622 set_bit (FLAG_COMMIT, &local->flags);
6625 case IW_AUTH_80211_AUTH_ALG: {
6626 /* FIXME: What about AUTH_OPEN? This API seems to
6627 * disallow setting our auth to AUTH_OPEN.
6629 if (param->value & IW_AUTH_ALG_SHARED_KEY) {
6630 local->config.authType = AUTH_SHAREDKEY;
6631 } else if (param->value & IW_AUTH_ALG_OPEN_SYSTEM) {
6632 local->config.authType = AUTH_ENCRYPT;
6637 /* Commit the changes to flags if needed */
6638 if (local->config.authType != currentAuthType)
6639 set_bit (FLAG_COMMIT, &local->flags);
6642 case IW_AUTH_WPA_ENABLED:
6643 /* Silently accept disable of WPA */
6644 if (param->value > 0)
6651 return -EINPROGRESS;
6655 /*------------------------------------------------------------------*/
6657 * Wireless Handler : get extended authentication parameters
6659 static int airo_get_auth(struct net_device *dev,
6660 struct iw_request_info *info,
6661 union iwreq_data *wrqu, char *extra)
6663 struct airo_info *local = dev->priv;
6664 struct iw_param *param = &wrqu->param;
6665 u16 currentAuthType = local->config.authType;
6667 switch (param->flags & IW_AUTH_INDEX) {
6668 case IW_AUTH_DROP_UNENCRYPTED:
6669 switch (currentAuthType) {
6670 case AUTH_SHAREDKEY:
6680 case IW_AUTH_80211_AUTH_ALG:
6681 switch (currentAuthType) {
6682 case AUTH_SHAREDKEY:
6683 param->value = IW_AUTH_ALG_SHARED_KEY;
6687 param->value = IW_AUTH_ALG_OPEN_SYSTEM;
6692 case IW_AUTH_WPA_ENABLED:
6703 /*------------------------------------------------------------------*/
6705 * Wireless Handler : set Tx-Power
6707 static int airo_set_txpow(struct net_device *dev,
6708 struct iw_request_info *info,
6709 struct iw_param *vwrq,
6712 struct airo_info *local = dev->priv;
6713 CapabilityRid cap_rid; /* Card capability info */
6717 readCapabilityRid(local, &cap_rid, 1);
6719 if (vwrq->disabled) {
6720 set_bit (FLAG_RADIO_OFF, &local->flags);
6721 set_bit (FLAG_COMMIT, &local->flags);
6722 return -EINPROGRESS; /* Call commit handler */
6724 if (vwrq->flags != IW_TXPOW_MWATT) {
6727 clear_bit (FLAG_RADIO_OFF, &local->flags);
6728 for (i = 0; cap_rid.txPowerLevels[i] && (i < 8); i++)
6729 if ((vwrq->value==cap_rid.txPowerLevels[i])) {
6730 readConfigRid(local, 1);
6731 local->config.txPower = vwrq->value;
6732 set_bit (FLAG_COMMIT, &local->flags);
6733 rc = -EINPROGRESS; /* Call commit handler */
6739 /*------------------------------------------------------------------*/
6741 * Wireless Handler : get Tx-Power
6743 static int airo_get_txpow(struct net_device *dev,
6744 struct iw_request_info *info,
6745 struct iw_param *vwrq,
6748 struct airo_info *local = dev->priv;
6750 readConfigRid(local, 1);
6751 vwrq->value = local->config.txPower;
6752 vwrq->fixed = 1; /* No power control */
6753 vwrq->disabled = test_bit(FLAG_RADIO_OFF, &local->flags);
6754 vwrq->flags = IW_TXPOW_MWATT;
6759 /*------------------------------------------------------------------*/
6761 * Wireless Handler : set Retry limits
6763 static int airo_set_retry(struct net_device *dev,
6764 struct iw_request_info *info,
6765 struct iw_param *vwrq,
6768 struct airo_info *local = dev->priv;
6771 if(vwrq->disabled) {
6774 readConfigRid(local, 1);
6775 if(vwrq->flags & IW_RETRY_LIMIT) {
6776 if(vwrq->flags & IW_RETRY_MAX)
6777 local->config.longRetryLimit = vwrq->value;
6778 else if (vwrq->flags & IW_RETRY_MIN)
6779 local->config.shortRetryLimit = vwrq->value;
6781 /* No modifier : set both */
6782 local->config.longRetryLimit = vwrq->value;
6783 local->config.shortRetryLimit = vwrq->value;
6785 set_bit (FLAG_COMMIT, &local->flags);
6786 rc = -EINPROGRESS; /* Call commit handler */
6788 if(vwrq->flags & IW_RETRY_LIFETIME) {
6789 local->config.txLifetime = vwrq->value / 1024;
6790 set_bit (FLAG_COMMIT, &local->flags);
6791 rc = -EINPROGRESS; /* Call commit handler */
6796 /*------------------------------------------------------------------*/
6798 * Wireless Handler : get Retry limits
6800 static int airo_get_retry(struct net_device *dev,
6801 struct iw_request_info *info,
6802 struct iw_param *vwrq,
6805 struct airo_info *local = dev->priv;
6807 vwrq->disabled = 0; /* Can't be disabled */
6809 readConfigRid(local, 1);
6810 /* Note : by default, display the min retry number */
6811 if((vwrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
6812 vwrq->flags = IW_RETRY_LIFETIME;
6813 vwrq->value = (int)local->config.txLifetime * 1024;
6814 } else if((vwrq->flags & IW_RETRY_MAX)) {
6815 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
6816 vwrq->value = (int)local->config.longRetryLimit;
6818 vwrq->flags = IW_RETRY_LIMIT;
6819 vwrq->value = (int)local->config.shortRetryLimit;
6820 if((int)local->config.shortRetryLimit != (int)local->config.longRetryLimit)
6821 vwrq->flags |= IW_RETRY_MIN;
6827 /*------------------------------------------------------------------*/
6829 * Wireless Handler : get range info
6831 static int airo_get_range(struct net_device *dev,
6832 struct iw_request_info *info,
6833 struct iw_point *dwrq,
6836 struct airo_info *local = dev->priv;
6837 struct iw_range *range = (struct iw_range *) extra;
6838 CapabilityRid cap_rid; /* Card capability info */
6842 readCapabilityRid(local, &cap_rid, 1);
6844 dwrq->length = sizeof(struct iw_range);
6845 memset(range, 0, sizeof(*range));
6846 range->min_nwid = 0x0000;
6847 range->max_nwid = 0x0000;
6848 range->num_channels = 14;
6849 /* Should be based on cap_rid.country to give only
6850 * what the current card support */
6852 for(i = 0; i < 14; i++) {
6853 range->freq[k].i = i + 1; /* List index */
6854 range->freq[k].m = frequency_list[i] * 100000;
6855 range->freq[k++].e = 1; /* Values in table in MHz -> * 10^5 * 10 */
6857 range->num_frequency = k;
6859 range->sensitivity = 65535;
6861 /* Hum... Should put the right values there */
6863 range->max_qual.qual = 100; /* % */
6865 range->max_qual.qual = airo_get_max_quality(&cap_rid);
6866 range->max_qual.level = 0x100 - 120; /* -120 dBm */
6867 range->max_qual.noise = 0x100 - 120; /* -120 dBm */
6869 /* Experimental measurements - boundary 11/5.5 Mb/s */
6870 /* Note : with or without the (local->rssi), results
6871 * are somewhat different. - Jean II */
6873 range->avg_qual.qual = 50; /* % */
6874 range->avg_qual.level = 0x100 - 70; /* -70 dBm */
6876 range->avg_qual.qual = airo_get_avg_quality(&cap_rid);
6877 range->avg_qual.level = 0x100 - 80; /* -80 dBm */
6879 range->avg_qual.noise = 0x100 - 85; /* -85 dBm */
6881 for(i = 0 ; i < 8 ; i++) {
6882 range->bitrate[i] = cap_rid.supportedRates[i] * 500000;
6883 if(range->bitrate[i] == 0)
6886 range->num_bitrates = i;
6888 /* Set an indication of the max TCP throughput
6889 * in bit/s that we can expect using this interface.
6890 * May be use for QoS stuff... Jean II */
6892 range->throughput = 5000 * 1000;
6894 range->throughput = 1500 * 1000;
6897 range->max_rts = AIRO_DEF_MTU;
6898 range->min_frag = 256;
6899 range->max_frag = AIRO_DEF_MTU;
6901 if(cap_rid.softCap & 2) {
6903 range->encoding_size[0] = 5;
6905 if (cap_rid.softCap & 0x100) {
6906 range->encoding_size[1] = 13;
6907 range->num_encoding_sizes = 2;
6909 range->num_encoding_sizes = 1;
6910 range->max_encoding_tokens = (cap_rid.softCap & 0x80) ? 4 : 1;
6912 range->num_encoding_sizes = 0;
6913 range->max_encoding_tokens = 0;
6916 range->max_pmp = 5000000; /* 5 secs */
6918 range->max_pmt = 65535 * 1024; /* ??? */
6919 range->pmp_flags = IW_POWER_PERIOD;
6920 range->pmt_flags = IW_POWER_TIMEOUT;
6921 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
6923 /* Transmit Power - values are in mW */
6924 for(i = 0 ; i < 8 ; i++) {
6925 range->txpower[i] = cap_rid.txPowerLevels[i];
6926 if(range->txpower[i] == 0)
6929 range->num_txpower = i;
6930 range->txpower_capa = IW_TXPOW_MWATT;
6931 range->we_version_source = 19;
6932 range->we_version_compiled = WIRELESS_EXT;
6933 range->retry_capa = IW_RETRY_LIMIT | IW_RETRY_LIFETIME;
6934 range->retry_flags = IW_RETRY_LIMIT;
6935 range->r_time_flags = IW_RETRY_LIFETIME;
6936 range->min_retry = 1;
6937 range->max_retry = 65535;
6938 range->min_r_time = 1024;
6939 range->max_r_time = 65535 * 1024;
6941 /* Event capability (kernel + driver) */
6942 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
6943 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
6944 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
6945 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
6946 range->event_capa[1] = IW_EVENT_CAPA_K_1;
6947 range->event_capa[4] = IW_EVENT_CAPA_MASK(IWEVTXDROP);
6951 /*------------------------------------------------------------------*/
6953 * Wireless Handler : set Power Management
6955 static int airo_set_power(struct net_device *dev,
6956 struct iw_request_info *info,
6957 struct iw_param *vwrq,
6960 struct airo_info *local = dev->priv;
6962 readConfigRid(local, 1);
6963 if (vwrq->disabled) {
6964 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6967 local->config.powerSaveMode = POWERSAVE_CAM;
6968 local->config.rmode &= 0xFF00;
6969 local->config.rmode |= RXMODE_BC_MC_ADDR;
6970 set_bit (FLAG_COMMIT, &local->flags);
6971 return -EINPROGRESS; /* Call commit handler */
6973 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
6974 local->config.fastListenDelay = (vwrq->value + 500) / 1024;
6975 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6976 set_bit (FLAG_COMMIT, &local->flags);
6977 } else if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
6978 local->config.fastListenInterval = local->config.listenInterval = (vwrq->value + 500) / 1024;
6979 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6980 set_bit (FLAG_COMMIT, &local->flags);
6982 switch (vwrq->flags & IW_POWER_MODE) {
6983 case IW_POWER_UNICAST_R:
6984 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6987 local->config.rmode &= 0xFF00;
6988 local->config.rmode |= RXMODE_ADDR;
6989 set_bit (FLAG_COMMIT, &local->flags);
6991 case IW_POWER_ALL_R:
6992 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6995 local->config.rmode &= 0xFF00;
6996 local->config.rmode |= RXMODE_BC_MC_ADDR;
6997 set_bit (FLAG_COMMIT, &local->flags);
7003 // Note : we may want to factor local->need_commit here
7004 // Note2 : may also want to factor RXMODE_RFMON test
7005 return -EINPROGRESS; /* Call commit handler */
7008 /*------------------------------------------------------------------*/
7010 * Wireless Handler : get Power Management
7012 static int airo_get_power(struct net_device *dev,
7013 struct iw_request_info *info,
7014 struct iw_param *vwrq,
7017 struct airo_info *local = dev->priv;
7020 readConfigRid(local, 1);
7021 mode = local->config.powerSaveMode;
7022 if ((vwrq->disabled = (mode == POWERSAVE_CAM)))
7024 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
7025 vwrq->value = (int)local->config.fastListenDelay * 1024;
7026 vwrq->flags = IW_POWER_TIMEOUT;
7028 vwrq->value = (int)local->config.fastListenInterval * 1024;
7029 vwrq->flags = IW_POWER_PERIOD;
7031 if ((local->config.rmode & 0xFF) == RXMODE_ADDR)
7032 vwrq->flags |= IW_POWER_UNICAST_R;
7034 vwrq->flags |= IW_POWER_ALL_R;
7039 /*------------------------------------------------------------------*/
7041 * Wireless Handler : set Sensitivity
7043 static int airo_set_sens(struct net_device *dev,
7044 struct iw_request_info *info,
7045 struct iw_param *vwrq,
7048 struct airo_info *local = dev->priv;
7050 readConfigRid(local, 1);
7051 local->config.rssiThreshold = vwrq->disabled ? RSSI_DEFAULT : vwrq->value;
7052 set_bit (FLAG_COMMIT, &local->flags);
7054 return -EINPROGRESS; /* Call commit handler */
7057 /*------------------------------------------------------------------*/
7059 * Wireless Handler : get Sensitivity
7061 static int airo_get_sens(struct net_device *dev,
7062 struct iw_request_info *info,
7063 struct iw_param *vwrq,
7066 struct airo_info *local = dev->priv;
7068 readConfigRid(local, 1);
7069 vwrq->value = local->config.rssiThreshold;
7070 vwrq->disabled = (vwrq->value == 0);
7076 /*------------------------------------------------------------------*/
7078 * Wireless Handler : get AP List
7079 * Note : this is deprecated in favor of IWSCAN
7081 static int airo_get_aplist(struct net_device *dev,
7082 struct iw_request_info *info,
7083 struct iw_point *dwrq,
7086 struct airo_info *local = dev->priv;
7087 struct sockaddr *address = (struct sockaddr *) extra;
7088 struct iw_quality qual[IW_MAX_AP];
7091 int loseSync = capable(CAP_NET_ADMIN) ? 1: -1;
7093 for (i = 0; i < IW_MAX_AP; i++) {
7094 if (readBSSListRid(local, loseSync, &BSSList))
7097 memcpy(address[i].sa_data, BSSList.bssid, ETH_ALEN);
7098 address[i].sa_family = ARPHRD_ETHER;
7100 qual[i].level = 0x100 - BSSList.dBm;
7101 qual[i].qual = airo_dbm_to_pct( local->rssi, BSSList.dBm );
7102 qual[i].updated = IW_QUAL_QUAL_UPDATED
7103 | IW_QUAL_LEVEL_UPDATED
7106 qual[i].level = (BSSList.dBm + 321) / 2;
7108 qual[i].updated = IW_QUAL_QUAL_INVALID
7109 | IW_QUAL_LEVEL_UPDATED
7112 qual[i].noise = local->wstats.qual.noise;
7113 if (BSSList.index == 0xffff)
7117 StatusRid status_rid; /* Card status info */
7118 readStatusRid(local, &status_rid, 1);
7120 i < min(IW_MAX_AP, 4) &&
7121 (status_rid.bssid[i][0]
7122 & status_rid.bssid[i][1]
7123 & status_rid.bssid[i][2]
7124 & status_rid.bssid[i][3]
7125 & status_rid.bssid[i][4]
7126 & status_rid.bssid[i][5])!=0xff &&
7127 (status_rid.bssid[i][0]
7128 | status_rid.bssid[i][1]
7129 | status_rid.bssid[i][2]
7130 | status_rid.bssid[i][3]
7131 | status_rid.bssid[i][4]
7132 | status_rid.bssid[i][5]);
7134 memcpy(address[i].sa_data,
7135 status_rid.bssid[i], ETH_ALEN);
7136 address[i].sa_family = ARPHRD_ETHER;
7139 dwrq->flags = 1; /* Should be define'd */
7140 memcpy(extra + sizeof(struct sockaddr)*i,
7141 &qual, sizeof(struct iw_quality)*i);
7148 /*------------------------------------------------------------------*/
7150 * Wireless Handler : Initiate Scan
7152 static int airo_set_scan(struct net_device *dev,
7153 struct iw_request_info *info,
7154 struct iw_param *vwrq,
7157 struct airo_info *ai = dev->priv;
7162 /* Note : you may have realised that, as this is a SET operation,
7163 * this is privileged and therefore a normal user can't
7165 * This is not an error, while the device perform scanning,
7166 * traffic doesn't flow, so it's a perfect DoS...
7168 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
7170 if (down_interruptible(&ai->sem))
7171 return -ERESTARTSYS;
7173 /* If there's already a scan in progress, don't
7174 * trigger another one. */
7175 if (ai->scan_timeout > 0)
7178 /* Initiate a scan command */
7179 ai->scan_timeout = RUN_AT(3*HZ);
7180 memset(&cmd, 0, sizeof(cmd));
7181 cmd.cmd=CMD_LISTBSS;
7182 issuecommand(ai, &cmd, &rsp);
7188 wake_up_interruptible(&ai->thr_wait);
7192 /*------------------------------------------------------------------*/
7194 * Translate scan data returned from the card to a card independent
7195 * format that the Wireless Tools will understand - Jean II
7197 static inline char *airo_translate_scan(struct net_device *dev,
7202 struct airo_info *ai = dev->priv;
7203 struct iw_event iwe; /* Temporary buffer */
7205 char * current_val; /* For rates */
7209 /* First entry *MUST* be the AP MAC address */
7210 iwe.cmd = SIOCGIWAP;
7211 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
7212 memcpy(iwe.u.ap_addr.sa_data, bss->bssid, ETH_ALEN);
7213 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_ADDR_LEN);
7215 /* Other entries will be displayed in the order we give them */
7218 iwe.u.data.length = bss->ssidLen;
7219 if(iwe.u.data.length > 32)
7220 iwe.u.data.length = 32;
7221 iwe.cmd = SIOCGIWESSID;
7222 iwe.u.data.flags = 1;
7223 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, bss->ssid);
7226 iwe.cmd = SIOCGIWMODE;
7227 capabilities = le16_to_cpu(bss->cap);
7228 if(capabilities & (CAP_ESS | CAP_IBSS)) {
7229 if(capabilities & CAP_ESS)
7230 iwe.u.mode = IW_MODE_MASTER;
7232 iwe.u.mode = IW_MODE_ADHOC;
7233 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_UINT_LEN);
7237 iwe.cmd = SIOCGIWFREQ;
7238 iwe.u.freq.m = le16_to_cpu(bss->dsChannel);
7239 /* iwe.u.freq.m containt the channel (starting 1), our
7240 * frequency_list array start at index 0...
7242 iwe.u.freq.m = frequency_list[iwe.u.freq.m - 1] * 100000;
7244 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_FREQ_LEN);
7246 /* Add quality statistics */
7249 iwe.u.qual.level = 0x100 - bss->dBm;
7250 iwe.u.qual.qual = airo_dbm_to_pct( ai->rssi, bss->dBm );
7251 iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED
7252 | IW_QUAL_LEVEL_UPDATED
7255 iwe.u.qual.level = (bss->dBm + 321) / 2;
7256 iwe.u.qual.qual = 0;
7257 iwe.u.qual.updated = IW_QUAL_QUAL_INVALID
7258 | IW_QUAL_LEVEL_UPDATED
7261 iwe.u.qual.noise = ai->wstats.qual.noise;
7262 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
7264 /* Add encryption capability */
7265 iwe.cmd = SIOCGIWENCODE;
7266 if(capabilities & CAP_PRIVACY)
7267 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
7269 iwe.u.data.flags = IW_ENCODE_DISABLED;
7270 iwe.u.data.length = 0;
7271 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, bss->ssid);
7273 /* Rate : stuffing multiple values in a single event require a bit
7274 * more of magic - Jean II */
7275 current_val = current_ev + IW_EV_LCP_LEN;
7277 iwe.cmd = SIOCGIWRATE;
7278 /* Those two flags are ignored... */
7279 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
7281 for(i = 0 ; i < 8 ; i++) {
7282 /* NULL terminated */
7283 if(bss->rates[i] == 0)
7285 /* Bit rate given in 500 kb/s units (+ 0x80) */
7286 iwe.u.bitrate.value = ((bss->rates[i] & 0x7f) * 500000);
7287 /* Add new value to event */
7288 current_val = iwe_stream_add_value(current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
7290 /* Check if we added any event */
7291 if((current_val - current_ev) > IW_EV_LCP_LEN)
7292 current_ev = current_val;
7294 /* Beacon interval */
7295 buf = kmalloc(30, GFP_KERNEL);
7297 iwe.cmd = IWEVCUSTOM;
7298 sprintf(buf, "bcn_int=%d", bss->beaconInterval);
7299 iwe.u.data.length = strlen(buf);
7300 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, buf);
7304 /* Put WPA/RSN Information Elements into the event stream */
7305 if (test_bit(FLAG_WPA_CAPABLE, &ai->flags)) {
7306 unsigned int num_null_ies = 0;
7307 u16 length = sizeof (bss->extra.iep);
7308 struct ieee80211_info_element *info_element =
7309 (struct ieee80211_info_element *) &bss->extra.iep;
7311 while ((length >= sizeof(*info_element)) && (num_null_ies < 2)) {
7312 if (sizeof(*info_element) + info_element->len > length) {
7313 /* Invalid element, don't continue parsing IE */
7317 switch (info_element->id) {
7318 case MFIE_TYPE_SSID:
7319 /* Two zero-length SSID elements
7320 * mean we're done parsing elements */
7321 if (!info_element->len)
7325 case MFIE_TYPE_GENERIC:
7326 if (info_element->len >= 4 &&
7327 info_element->data[0] == 0x00 &&
7328 info_element->data[1] == 0x50 &&
7329 info_element->data[2] == 0xf2 &&
7330 info_element->data[3] == 0x01) {
7331 iwe.cmd = IWEVGENIE;
7332 iwe.u.data.length = min(info_element->len + 2,
7334 current_ev = iwe_stream_add_point(current_ev, end_buf,
7335 &iwe, (char *) info_element);
7340 iwe.cmd = IWEVGENIE;
7341 iwe.u.data.length = min(info_element->len + 2,
7343 current_ev = iwe_stream_add_point(current_ev, end_buf,
7344 &iwe, (char *) info_element);
7351 length -= sizeof(*info_element) + info_element->len;
7353 (struct ieee80211_info_element *)&info_element->
7354 data[info_element->len];
7360 /*------------------------------------------------------------------*/
7362 * Wireless Handler : Read Scan Results
7364 static int airo_get_scan(struct net_device *dev,
7365 struct iw_request_info *info,
7366 struct iw_point *dwrq,
7369 struct airo_info *ai = dev->priv;
7370 BSSListElement *net;
7372 char *current_ev = extra;
7374 /* If a scan is in-progress, return -EAGAIN */
7375 if (ai->scan_timeout > 0)
7378 if (down_interruptible(&ai->sem))
7381 list_for_each_entry (net, &ai->network_list, list) {
7382 /* Translate to WE format this entry */
7383 current_ev = airo_translate_scan(dev, current_ev,
7384 extra + dwrq->length,
7387 /* Check if there is space for one more entry */
7388 if((extra + dwrq->length - current_ev) <= IW_EV_ADDR_LEN) {
7389 /* Ask user space to try again with a bigger buffer */
7395 /* Length of data */
7396 dwrq->length = (current_ev - extra);
7397 dwrq->flags = 0; /* todo */
7404 /*------------------------------------------------------------------*/
7406 * Commit handler : called after a bunch of SET operations
7408 static int airo_config_commit(struct net_device *dev,
7409 struct iw_request_info *info, /* NULL */
7410 void *zwrq, /* NULL */
7411 char *extra) /* NULL */
7413 struct airo_info *local = dev->priv;
7416 if (!test_bit (FLAG_COMMIT, &local->flags))
7419 /* Some of the "SET" function may have modified some of the
7420 * parameters. It's now time to commit them in the card */
7421 disable_MAC(local, 1);
7422 if (test_bit (FLAG_RESET, &local->flags)) {
7423 APListRid APList_rid;
7426 readAPListRid(local, &APList_rid);
7427 readSsidRid(local, &SSID_rid);
7428 if (test_bit(FLAG_MPI,&local->flags))
7429 setup_card(local, dev->dev_addr, 1 );
7431 reset_airo_card(dev);
7432 disable_MAC(local, 1);
7433 writeSsidRid(local, &SSID_rid, 1);
7434 writeAPListRid(local, &APList_rid, 1);
7436 if (down_interruptible(&local->sem))
7437 return -ERESTARTSYS;
7438 writeConfigRid(local, 0);
7439 enable_MAC(local, &rsp, 0);
7440 if (test_bit (FLAG_RESET, &local->flags))
7441 airo_set_promisc(local);
7448 /*------------------------------------------------------------------*/
7450 * Structures to export the Wireless Handlers
7453 static const struct iw_priv_args airo_private_args[] = {
7454 /*{ cmd, set_args, get_args, name } */
7455 { AIROIOCTL, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
7456 IW_PRIV_TYPE_BYTE | 2047, "airoioctl" },
7457 { AIROIDIFC, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
7458 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "airoidifc" },
7461 static const iw_handler airo_handler[] =
7463 (iw_handler) airo_config_commit, /* SIOCSIWCOMMIT */
7464 (iw_handler) airo_get_name, /* SIOCGIWNAME */
7465 (iw_handler) NULL, /* SIOCSIWNWID */
7466 (iw_handler) NULL, /* SIOCGIWNWID */
7467 (iw_handler) airo_set_freq, /* SIOCSIWFREQ */
7468 (iw_handler) airo_get_freq, /* SIOCGIWFREQ */
7469 (iw_handler) airo_set_mode, /* SIOCSIWMODE */
7470 (iw_handler) airo_get_mode, /* SIOCGIWMODE */
7471 (iw_handler) airo_set_sens, /* SIOCSIWSENS */
7472 (iw_handler) airo_get_sens, /* SIOCGIWSENS */
7473 (iw_handler) NULL, /* SIOCSIWRANGE */
7474 (iw_handler) airo_get_range, /* SIOCGIWRANGE */
7475 (iw_handler) NULL, /* SIOCSIWPRIV */
7476 (iw_handler) NULL, /* SIOCGIWPRIV */
7477 (iw_handler) NULL, /* SIOCSIWSTATS */
7478 (iw_handler) NULL, /* SIOCGIWSTATS */
7479 iw_handler_set_spy, /* SIOCSIWSPY */
7480 iw_handler_get_spy, /* SIOCGIWSPY */
7481 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
7482 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
7483 (iw_handler) airo_set_wap, /* SIOCSIWAP */
7484 (iw_handler) airo_get_wap, /* SIOCGIWAP */
7485 (iw_handler) NULL, /* -- hole -- */
7486 (iw_handler) airo_get_aplist, /* SIOCGIWAPLIST */
7487 (iw_handler) airo_set_scan, /* SIOCSIWSCAN */
7488 (iw_handler) airo_get_scan, /* SIOCGIWSCAN */
7489 (iw_handler) airo_set_essid, /* SIOCSIWESSID */
7490 (iw_handler) airo_get_essid, /* SIOCGIWESSID */
7491 (iw_handler) airo_set_nick, /* SIOCSIWNICKN */
7492 (iw_handler) airo_get_nick, /* SIOCGIWNICKN */
7493 (iw_handler) NULL, /* -- hole -- */
7494 (iw_handler) NULL, /* -- hole -- */
7495 (iw_handler) airo_set_rate, /* SIOCSIWRATE */
7496 (iw_handler) airo_get_rate, /* SIOCGIWRATE */
7497 (iw_handler) airo_set_rts, /* SIOCSIWRTS */
7498 (iw_handler) airo_get_rts, /* SIOCGIWRTS */
7499 (iw_handler) airo_set_frag, /* SIOCSIWFRAG */
7500 (iw_handler) airo_get_frag, /* SIOCGIWFRAG */
7501 (iw_handler) airo_set_txpow, /* SIOCSIWTXPOW */
7502 (iw_handler) airo_get_txpow, /* SIOCGIWTXPOW */
7503 (iw_handler) airo_set_retry, /* SIOCSIWRETRY */
7504 (iw_handler) airo_get_retry, /* SIOCGIWRETRY */
7505 (iw_handler) airo_set_encode, /* SIOCSIWENCODE */
7506 (iw_handler) airo_get_encode, /* SIOCGIWENCODE */
7507 (iw_handler) airo_set_power, /* SIOCSIWPOWER */
7508 (iw_handler) airo_get_power, /* SIOCGIWPOWER */
7509 (iw_handler) NULL, /* -- hole -- */
7510 (iw_handler) NULL, /* -- hole -- */
7511 (iw_handler) NULL, /* SIOCSIWGENIE */
7512 (iw_handler) NULL, /* SIOCGIWGENIE */
7513 (iw_handler) airo_set_auth, /* SIOCSIWAUTH */
7514 (iw_handler) airo_get_auth, /* SIOCGIWAUTH */
7515 (iw_handler) airo_set_encodeext, /* SIOCSIWENCODEEXT */
7516 (iw_handler) airo_get_encodeext, /* SIOCGIWENCODEEXT */
7517 (iw_handler) NULL, /* SIOCSIWPMKSA */
7520 /* Note : don't describe AIROIDIFC and AIROOLDIDIFC in here.
7521 * We want to force the use of the ioctl code, because those can't be
7522 * won't work the iw_handler code (because they simultaneously read
7523 * and write data and iw_handler can't do that).
7524 * Note that it's perfectly legal to read/write on a single ioctl command,
7525 * you just can't use iwpriv and need to force it via the ioctl handler.
7527 static const iw_handler airo_private_handler[] =
7529 NULL, /* SIOCIWFIRSTPRIV */
7532 static const struct iw_handler_def airo_handler_def =
7534 .num_standard = sizeof(airo_handler)/sizeof(iw_handler),
7535 .num_private = sizeof(airo_private_handler)/sizeof(iw_handler),
7536 .num_private_args = sizeof(airo_private_args)/sizeof(struct iw_priv_args),
7537 .standard = airo_handler,
7538 .private = airo_private_handler,
7539 .private_args = airo_private_args,
7540 .get_wireless_stats = airo_get_wireless_stats,
7544 * This defines the configuration part of the Wireless Extensions
7545 * Note : irq and spinlock protection will occur in the subroutines
7548 * o Check input value more carefully and fill correct values in range
7549 * o Test and shakeout the bugs (if any)
7553 * Javier Achirica did a great job of merging code from the unnamed CISCO
7554 * developer that added support for flashing the card.
7556 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
7559 struct airo_info *ai = (struct airo_info *)dev->priv;
7561 if (ai->power.event)
7571 int val = AIROMAGIC;
7573 if (copy_from_user(&com,rq->ifr_data,sizeof(com)))
7575 else if (copy_to_user(com.data,(char *)&val,sizeof(val)))
7584 /* Get the command struct and hand it off for evaluation by
7585 * the proper subfunction
7589 if (copy_from_user(&com,rq->ifr_data,sizeof(com))) {
7594 /* Separate R/W functions bracket legality here
7596 if ( com.command == AIRORSWVERSION ) {
7597 if (copy_to_user(com.data, swversion, sizeof(swversion)))
7602 else if ( com.command <= AIRORRID)
7603 rc = readrids(dev,&com);
7604 else if ( com.command >= AIROPCAP && com.command <= (AIROPLEAPUSR+2) )
7605 rc = writerids(dev,&com);
7606 else if ( com.command >= AIROFLSHRST && com.command <= AIRORESTART )
7607 rc = flashcard(dev,&com);
7609 rc = -EINVAL; /* Bad command in ioctl */
7612 #endif /* CISCO_EXT */
7614 // All other calls are currently unsupported
7622 * Get the Wireless stats out of the driver
7623 * Note : irq and spinlock protection will occur in the subroutines
7626 * o Check if work in Ad-Hoc mode (otherwise, use SPY, as in wvlan_cs)
7630 static void airo_read_wireless_stats(struct airo_info *local)
7632 StatusRid status_rid;
7634 CapabilityRid cap_rid;
7635 u32 *vals = stats_rid.vals;
7637 /* Get stats out of the card */
7638 clear_bit(JOB_WSTATS, &local->jobs);
7639 if (local->power.event) {
7643 readCapabilityRid(local, &cap_rid, 0);
7644 readStatusRid(local, &status_rid, 0);
7645 readStatsRid(local, &stats_rid, RID_STATS, 0);
7649 local->wstats.status = status_rid.mode;
7651 /* Signal quality and co */
7653 local->wstats.qual.level = airo_rssi_to_dbm( local->rssi, status_rid.sigQuality );
7654 /* normalizedSignalStrength appears to be a percentage */
7655 local->wstats.qual.qual = status_rid.normalizedSignalStrength;
7657 local->wstats.qual.level = (status_rid.normalizedSignalStrength + 321) / 2;
7658 local->wstats.qual.qual = airo_get_quality(&status_rid, &cap_rid);
7660 if (status_rid.len >= 124) {
7661 local->wstats.qual.noise = 0x100 - status_rid.noisedBm;
7662 local->wstats.qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
7664 local->wstats.qual.noise = 0;
7665 local->wstats.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_INVALID | IW_QUAL_DBM;
7668 /* Packets discarded in the wireless adapter due to wireless
7669 * specific problems */
7670 local->wstats.discard.nwid = vals[56] + vals[57] + vals[58];/* SSID Mismatch */
7671 local->wstats.discard.code = vals[6];/* RxWepErr */
7672 local->wstats.discard.fragment = vals[30];
7673 local->wstats.discard.retries = vals[10];
7674 local->wstats.discard.misc = vals[1] + vals[32];
7675 local->wstats.miss.beacon = vals[34];
7678 static struct iw_statistics *airo_get_wireless_stats(struct net_device *dev)
7680 struct airo_info *local = dev->priv;
7682 if (!test_bit(JOB_WSTATS, &local->jobs)) {
7683 /* Get stats out of the card if available */
7684 if (down_trylock(&local->sem) != 0) {
7685 set_bit(JOB_WSTATS, &local->jobs);
7686 wake_up_interruptible(&local->thr_wait);
7688 airo_read_wireless_stats(local);
7691 return &local->wstats;
7696 * This just translates from driver IOCTL codes to the command codes to
7697 * feed to the radio's host interface. Things can be added/deleted
7698 * as needed. This represents the READ side of control I/O to
7701 static int readrids(struct net_device *dev, aironet_ioctl *comp) {
7702 unsigned short ridcode;
7703 unsigned char *iobuf;
7705 struct airo_info *ai = dev->priv;
7708 if (test_bit(FLAG_FLASHING, &ai->flags))
7711 switch(comp->command)
7713 case AIROGCAP: ridcode = RID_CAPABILITIES; break;
7714 case AIROGCFG: ridcode = RID_CONFIG;
7715 if (test_bit(FLAG_COMMIT, &ai->flags)) {
7716 disable_MAC (ai, 1);
7717 writeConfigRid (ai, 1);
7718 enable_MAC (ai, &rsp, 1);
7721 case AIROGSLIST: ridcode = RID_SSID; break;
7722 case AIROGVLIST: ridcode = RID_APLIST; break;
7723 case AIROGDRVNAM: ridcode = RID_DRVNAME; break;
7724 case AIROGEHTENC: ridcode = RID_ETHERENCAP; break;
7725 case AIROGWEPKTMP: ridcode = RID_WEP_TEMP;
7726 /* Only super-user can read WEP keys */
7727 if (!capable(CAP_NET_ADMIN))
7730 case AIROGWEPKNV: ridcode = RID_WEP_PERM;
7731 /* Only super-user can read WEP keys */
7732 if (!capable(CAP_NET_ADMIN))
7735 case AIROGSTAT: ridcode = RID_STATUS; break;
7736 case AIROGSTATSD32: ridcode = RID_STATSDELTA; break;
7737 case AIROGSTATSC32: ridcode = RID_STATS; break;
7739 if (copy_to_user(comp->data, &ai->micstats,
7740 min((int)comp->len,(int)sizeof(ai->micstats))))
7743 case AIRORRID: ridcode = comp->ridnum; break;
7749 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7752 PC4500_readrid(ai,ridcode,iobuf,RIDSIZE, 1);
7753 /* get the count of bytes in the rid docs say 1st 2 bytes is it.
7754 * then return it to the user
7755 * 9/22/2000 Honor user given length
7759 if (copy_to_user(comp->data, iobuf, min(len, (int)RIDSIZE))) {
7768 * Danger Will Robinson write the rids here
7771 static int writerids(struct net_device *dev, aironet_ioctl *comp) {
7772 struct airo_info *ai = dev->priv;
7776 static int (* writer)(struct airo_info *, u16 rid, const void *, int, int);
7777 unsigned char *iobuf;
7779 /* Only super-user can write RIDs */
7780 if (!capable(CAP_NET_ADMIN))
7783 if (test_bit(FLAG_FLASHING, &ai->flags))
7787 writer = do_writerid;
7789 switch(comp->command)
7791 case AIROPSIDS: ridcode = RID_SSID; break;
7792 case AIROPCAP: ridcode = RID_CAPABILITIES; break;
7793 case AIROPAPLIST: ridcode = RID_APLIST; break;
7794 case AIROPCFG: ai->config.len = 0;
7795 clear_bit(FLAG_COMMIT, &ai->flags);
7796 ridcode = RID_CONFIG; break;
7797 case AIROPWEPKEYNV: ridcode = RID_WEP_PERM; break;
7798 case AIROPLEAPUSR: ridcode = RID_LEAPUSERNAME; break;
7799 case AIROPLEAPPWD: ridcode = RID_LEAPPASSWORD; break;
7800 case AIROPWEPKEY: ridcode = RID_WEP_TEMP; writer = PC4500_writerid;
7802 case AIROPLEAPUSR+1: ridcode = 0xFF2A; break;
7803 case AIROPLEAPUSR+2: ridcode = 0xFF2B; break;
7805 /* this is not really a rid but a command given to the card
7809 if (enable_MAC(ai, &rsp, 1) != 0)
7814 * Evidently this code in the airo driver does not get a symbol
7815 * as disable_MAC. it's probably so short the compiler does not gen one.
7821 /* This command merely clears the counts does not actually store any data
7822 * only reads rid. But as it changes the cards state, I put it in the
7823 * writerid routines.
7826 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7829 PC4500_readrid(ai,RID_STATSDELTACLEAR,iobuf,RIDSIZE, 1);
7831 enabled = ai->micstats.enabled;
7832 memset(&ai->micstats,0,sizeof(ai->micstats));
7833 ai->micstats.enabled = enabled;
7835 if (copy_to_user(comp->data, iobuf,
7836 min((int)comp->len, (int)RIDSIZE))) {
7844 return -EOPNOTSUPP; /* Blarg! */
7846 if(comp->len > RIDSIZE)
7849 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7852 if (copy_from_user(iobuf,comp->data,comp->len)) {
7857 if (comp->command == AIROPCFG) {
7858 ConfigRid *cfg = (ConfigRid *)iobuf;
7860 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags))
7861 cfg->opmode |= MODE_MIC;
7863 if ((cfg->opmode & 0xFF) == MODE_STA_IBSS)
7864 set_bit (FLAG_ADHOC, &ai->flags);
7866 clear_bit (FLAG_ADHOC, &ai->flags);
7869 if((*writer)(ai, ridcode, iobuf,comp->len,1)) {
7877 /*****************************************************************************
7878 * Ancillary flash / mod functions much black magic lurkes here *
7879 *****************************************************************************
7883 * Flash command switch table
7886 static int flashcard(struct net_device *dev, aironet_ioctl *comp) {
7889 /* Only super-user can modify flash */
7890 if (!capable(CAP_NET_ADMIN))
7893 switch(comp->command)
7896 return cmdreset((struct airo_info *)dev->priv);
7899 if (!((struct airo_info *)dev->priv)->flash &&
7900 (((struct airo_info *)dev->priv)->flash = kmalloc (FLASHSIZE, GFP_KERNEL)) == NULL)
7902 return setflashmode((struct airo_info *)dev->priv);
7904 case AIROFLSHGCHR: /* Get char from aux */
7905 if(comp->len != sizeof(int))
7907 if (copy_from_user(&z,comp->data,comp->len))
7909 return flashgchar((struct airo_info *)dev->priv,z,8000);
7911 case AIROFLSHPCHR: /* Send char to card. */
7912 if(comp->len != sizeof(int))
7914 if (copy_from_user(&z,comp->data,comp->len))
7916 return flashpchar((struct airo_info *)dev->priv,z,8000);
7918 case AIROFLPUTBUF: /* Send 32k to card */
7919 if (!((struct airo_info *)dev->priv)->flash)
7921 if(comp->len > FLASHSIZE)
7923 if(copy_from_user(((struct airo_info *)dev->priv)->flash,comp->data,comp->len))
7926 flashputbuf((struct airo_info *)dev->priv);
7930 if(flashrestart((struct airo_info *)dev->priv,dev))
7937 #define FLASH_COMMAND 0x7e7e
7941 * Disable MAC and do soft reset on
7945 static int cmdreset(struct airo_info *ai) {
7949 airo_print_info(ai->dev->name, "Waitbusy hang before RESET");
7953 OUT4500(ai,COMMAND,CMD_SOFTRESET);
7955 ssleep(1); /* WAS 600 12/7/00 */
7958 airo_print_info(ai->dev->name, "Waitbusy hang AFTER RESET");
7965 * Put the card in legendary flash
7969 static int setflashmode (struct airo_info *ai) {
7970 set_bit (FLAG_FLASHING, &ai->flags);
7972 OUT4500(ai, SWS0, FLASH_COMMAND);
7973 OUT4500(ai, SWS1, FLASH_COMMAND);
7975 OUT4500(ai, SWS0, FLASH_COMMAND);
7976 OUT4500(ai, COMMAND,0x10);
7978 OUT4500(ai, SWS2, FLASH_COMMAND);
7979 OUT4500(ai, SWS3, FLASH_COMMAND);
7980 OUT4500(ai, COMMAND,0);
7982 msleep(500); /* 500ms delay */
7985 clear_bit (FLAG_FLASHING, &ai->flags);
7986 airo_print_info(ai->dev->name, "Waitbusy hang after setflash mode");
7992 /* Put character to SWS0 wait for dwelltime
7996 static int flashpchar(struct airo_info *ai,int byte,int dwelltime) {
8007 /* Wait for busy bit d15 to go false indicating buffer empty */
8008 while ((IN4500 (ai, SWS0) & 0x8000) && waittime > 0) {
8013 /* timeout for busy clear wait */
8015 airo_print_info(ai->dev->name, "flash putchar busywait timeout!");
8019 /* Port is clear now write byte and wait for it to echo back */
8021 OUT4500(ai,SWS0,byte);
8024 echo = IN4500(ai,SWS1);
8025 } while (dwelltime >= 0 && echo != byte);
8029 return (echo == byte) ? 0 : -EIO;
8033 * Get a character from the card matching matchbyte
8036 static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime){
8038 unsigned char rbyte=0;
8041 rchar = IN4500(ai,SWS1);
8043 if(dwelltime && !(0x8000 & rchar)){
8048 rbyte = 0xff & rchar;
8050 if( (rbyte == matchbyte) && (0x8000 & rchar) ){
8054 if( rbyte == 0x81 || rbyte == 0x82 || rbyte == 0x83 || rbyte == 0x1a || 0xffff == rchar)
8058 }while(dwelltime > 0);
8063 * Transfer 32k of firmware data from user buffer to our buffer and
8067 static int flashputbuf(struct airo_info *ai){
8071 if (test_bit(FLAG_MPI,&ai->flags))
8072 memcpy_toio(ai->pciaux + 0x8000, ai->flash, FLASHSIZE);
8074 OUT4500(ai,AUXPAGE,0x100);
8075 OUT4500(ai,AUXOFF,0);
8077 for(nwords=0;nwords != FLASHSIZE / 2;nwords++){
8078 OUT4500(ai,AUXDATA,ai->flash[nwords] & 0xffff);
8081 OUT4500(ai,SWS0,0x8000);
8089 static int flashrestart(struct airo_info *ai,struct net_device *dev){
8092 ssleep(1); /* Added 12/7/00 */
8093 clear_bit (FLAG_FLASHING, &ai->flags);
8094 if (test_bit(FLAG_MPI, &ai->flags)) {
8095 status = mpi_init_descriptors(ai);
8096 if (status != SUCCESS)
8099 status = setup_card(ai, dev->dev_addr, 1);
8101 if (!test_bit(FLAG_MPI,&ai->flags))
8102 for( i = 0; i < MAX_FIDS; i++ ) {
8103 ai->fids[i] = transmit_allocate
8104 ( ai, AIRO_DEF_MTU, i >= MAX_FIDS / 2 );
8107 ssleep(1); /* Added 12/7/00 */
8110 #endif /* CISCO_EXT */
8113 This program is free software; you can redistribute it and/or
8114 modify it under the terms of the GNU General Public License
8115 as published by the Free Software Foundation; either version 2
8116 of the License, or (at your option) any later version.
8118 This program is distributed in the hope that it will be useful,
8119 but WITHOUT ANY WARRANTY; without even the implied warranty of
8120 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
8121 GNU General Public License for more details.
8125 Redistribution and use in source and binary forms, with or without
8126 modification, are permitted provided that the following conditions
8129 1. Redistributions of source code must retain the above copyright
8130 notice, this list of conditions and the following disclaimer.
8131 2. Redistributions in binary form must reproduce the above copyright
8132 notice, this list of conditions and the following disclaimer in the
8133 documentation and/or other materials provided with the distribution.
8134 3. The name of the author may not be used to endorse or promote
8135 products derived from this software without specific prior written
8138 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
8139 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
8140 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
8141 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
8142 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
8143 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
8144 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
8145 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
8146 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
8147 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
8148 POSSIBILITY OF SUCH DAMAGE.
8151 module_init(airo_init_module);
8152 module_exit(airo_cleanup_module);
projects / linux-2.6 / blob