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, "cmd= %x\n", pCmd->cmd);
3955 airo_print_err(ai->dev->name, "status= %x\n", pRsp->status);
3956 airo_print_err(ai->dev->name, "Rsp0= %x\n", pRsp->rsp0);
3957 airo_print_err(ai->dev->name, "Rsp1= %x\n", pRsp->rsp1);
3958 airo_print_err(ai->dev->name, "Rsp2= %x\n", pRsp->rsp2);
3961 // clear stuck command busy if necessary
3962 if (IN4500(ai, COMMAND) & COMMAND_BUSY) {
3963 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3965 // acknowledge processing the status/response
3966 OUT4500(ai, EVACK, EV_CMD);
3971 /* Sets up the bap to start exchange data. whichbap should
3972 * be one of the BAP0 or BAP1 defines. Locks should be held before
3974 static int bap_setup(struct airo_info *ai, u16 rid, u16 offset, int whichbap )
3979 OUT4500(ai, SELECT0+whichbap, rid);
3980 OUT4500(ai, OFFSET0+whichbap, offset);
3982 int status = IN4500(ai, OFFSET0+whichbap);
3983 if (status & BAP_BUSY) {
3984 /* This isn't really a timeout, but its kinda
3989 } else if ( status & BAP_ERR ) {
3990 /* invalid rid or offset */
3991 airo_print_err(ai->dev->name, "BAP error %x %d",
3994 } else if (status & BAP_DONE) { // success
3997 if ( !(max_tries--) ) {
3998 airo_print_err(ai->dev->name,
3999 "airo: BAP setup error too many retries\n");
4002 // -- PC4500 missed it, try again
4003 OUT4500(ai, SELECT0+whichbap, rid);
4004 OUT4500(ai, OFFSET0+whichbap, offset);
4009 /* should only be called by aux_bap_read. This aux function and the
4010 following use concepts not documented in the developers guide. I
4011 got them from a patch given to my by Aironet */
4012 static u16 aux_setup(struct airo_info *ai, u16 page,
4013 u16 offset, u16 *len)
4017 OUT4500(ai, AUXPAGE, page);
4018 OUT4500(ai, AUXOFF, 0);
4019 next = IN4500(ai, AUXDATA);
4020 *len = IN4500(ai, AUXDATA)&0xff;
4021 if (offset != 4) OUT4500(ai, AUXOFF, offset);
4025 /* requires call to bap_setup() first */
4026 static int aux_bap_read(struct airo_info *ai, u16 *pu16Dst,
4027 int bytelen, int whichbap)
4035 unsigned long flags;
4037 spin_lock_irqsave(&ai->aux_lock, flags);
4038 page = IN4500(ai, SWS0+whichbap);
4039 offset = IN4500(ai, SWS2+whichbap);
4040 next = aux_setup(ai, page, offset, &len);
4041 words = (bytelen+1)>>1;
4043 for (i=0; i<words;) {
4045 count = (len>>1) < (words-i) ? (len>>1) : (words-i);
4047 insw( ai->dev->base_addr+DATA0+whichbap,
4050 insb( ai->dev->base_addr+DATA0+whichbap,
4051 pu16Dst+i, count << 1 );
4054 next = aux_setup(ai, next, 4, &len);
4057 spin_unlock_irqrestore(&ai->aux_lock, flags);
4062 /* requires call to bap_setup() first */
4063 static int fast_bap_read(struct airo_info *ai, u16 *pu16Dst,
4064 int bytelen, int whichbap)
4066 bytelen = (bytelen + 1) & (~1); // round up to even value
4068 insw( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen>>1 );
4070 insb( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen );
4074 /* requires call to bap_setup() first */
4075 static int bap_write(struct airo_info *ai, const u16 *pu16Src,
4076 int bytelen, int whichbap)
4078 bytelen = (bytelen + 1) & (~1); // round up to even value
4080 outsw( ai->dev->base_addr+DATA0+whichbap,
4081 pu16Src, bytelen>>1 );
4083 outsb( ai->dev->base_addr+DATA0+whichbap, pu16Src, bytelen );
4087 static int PC4500_accessrid(struct airo_info *ai, u16 rid, u16 accmd)
4089 Cmd cmd; /* for issuing commands */
4090 Resp rsp; /* response from commands */
4093 memset(&cmd, 0, sizeof(cmd));
4096 status = issuecommand(ai, &cmd, &rsp);
4097 if (status != 0) return status;
4098 if ( (rsp.status & 0x7F00) != 0) {
4099 return (accmd << 8) + (rsp.rsp0 & 0xFF);
4104 /* Note, that we are using BAP1 which is also used by transmit, so
4105 * we must get a lock. */
4106 static int PC4500_readrid(struct airo_info *ai, u16 rid, void *pBuf, int len, int lock)
4112 if (down_interruptible(&ai->sem))
4115 if (test_bit(FLAG_MPI,&ai->flags)) {
4119 memset(&cmd, 0, sizeof(cmd));
4120 memset(&rsp, 0, sizeof(rsp));
4121 ai->config_desc.rid_desc.valid = 1;
4122 ai->config_desc.rid_desc.len = RIDSIZE;
4123 ai->config_desc.rid_desc.rid = 0;
4124 ai->config_desc.rid_desc.host_addr = ai->ridbus;
4126 cmd.cmd = CMD_ACCESS;
4129 memcpy_toio(ai->config_desc.card_ram_off,
4130 &ai->config_desc.rid_desc, sizeof(Rid));
4132 rc = issuecommand(ai, &cmd, &rsp);
4134 if (rsp.status & 0x7f00)
4137 memcpy(pBuf, ai->config_desc.virtual_host_addr, len);
4140 if ((status = PC4500_accessrid(ai, rid, CMD_ACCESS))!=SUCCESS) {
4144 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4148 // read the rid length field
4149 bap_read(ai, pBuf, 2, BAP1);
4150 // length for remaining part of rid
4151 len = min(len, (int)le16_to_cpu(*(u16*)pBuf)) - 2;
4154 airo_print_err(ai->dev->name,
4155 "Rid %x has a length of %d which is too short",
4156 (int)rid, (int)len );
4160 // read remainder of the rid
4161 rc = bap_read(ai, ((u16*)pBuf)+1, len, BAP1);
4169 /* Note, that we are using BAP1 which is also used by transmit, so
4170 * make sure this isnt called when a transmit is happening */
4171 static int PC4500_writerid(struct airo_info *ai, u16 rid,
4172 const void *pBuf, int len, int lock)
4177 *(u16*)pBuf = cpu_to_le16((u16)len);
4180 if (down_interruptible(&ai->sem))
4183 if (test_bit(FLAG_MPI,&ai->flags)) {
4187 if (test_bit(FLAG_ENABLED, &ai->flags) && (RID_WEP_TEMP != rid))
4188 airo_print_err(ai->dev->name,
4189 "%s: MAC should be disabled (rid=%04x)",
4191 memset(&cmd, 0, sizeof(cmd));
4192 memset(&rsp, 0, sizeof(rsp));
4194 ai->config_desc.rid_desc.valid = 1;
4195 ai->config_desc.rid_desc.len = *((u16 *)pBuf);
4196 ai->config_desc.rid_desc.rid = 0;
4198 cmd.cmd = CMD_WRITERID;
4201 memcpy_toio(ai->config_desc.card_ram_off,
4202 &ai->config_desc.rid_desc, sizeof(Rid));
4204 if (len < 4 || len > 2047) {
4205 airo_print_err(ai->dev->name, "%s: len=%d", __FUNCTION__, len);
4208 memcpy((char *)ai->config_desc.virtual_host_addr,
4211 rc = issuecommand(ai, &cmd, &rsp);
4212 if ((rc & 0xff00) != 0) {
4213 airo_print_err(ai->dev->name, "%s: Write rid Error %d",
4215 airo_print_err(ai->dev->name, "%s: Cmd=%04x",
4216 __FUNCTION__, cmd.cmd);
4219 if ((rsp.status & 0x7f00))
4223 // --- first access so that we can write the rid data
4224 if ( (status = PC4500_accessrid(ai, rid, CMD_ACCESS)) != 0) {
4228 // --- now write the rid data
4229 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4233 bap_write(ai, pBuf, len, BAP1);
4234 // ---now commit the rid data
4235 rc = PC4500_accessrid(ai, rid, 0x100|CMD_ACCESS);
4243 /* Allocates a FID to be used for transmitting packets. We only use
4245 static u16 transmit_allocate(struct airo_info *ai, int lenPayload, int raw)
4247 unsigned int loop = 3000;
4253 cmd.cmd = CMD_ALLOCATETX;
4254 cmd.parm0 = lenPayload;
4255 if (down_interruptible(&ai->sem))
4257 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
4261 if ( (rsp.status & 0xFF00) != 0) {
4265 /* wait for the allocate event/indication
4266 * It makes me kind of nervous that this can just sit here and spin,
4267 * but in practice it only loops like four times. */
4268 while (((IN4500(ai, EVSTAT) & EV_ALLOC) == 0) && --loop);
4274 // get the allocated fid and acknowledge
4275 txFid = IN4500(ai, TXALLOCFID);
4276 OUT4500(ai, EVACK, EV_ALLOC);
4278 /* The CARD is pretty cool since it converts the ethernet packet
4279 * into 802.11. Also note that we don't release the FID since we
4280 * will be using the same one over and over again. */
4281 /* We only have to setup the control once since we are not
4282 * releasing the fid. */
4284 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_11
4285 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4287 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_3
4288 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4289 if (bap_setup(ai, txFid, 0x0008, BAP1) != SUCCESS)
4292 bap_write(ai, &txControl, sizeof(txControl), BAP1);
4300 /* In general BAP1 is dedicated to transmiting packets. However,
4301 since we need a BAP when accessing RIDs, we also use BAP1 for that.
4302 Make sure the BAP1 spinlock is held when this is called. */
4303 static int transmit_802_3_packet(struct airo_info *ai, int len, char *pPacket)
4314 if (len <= ETH_ALEN * 2) {
4315 airo_print_warn(ai->dev->name, "Short packet %d", len);
4318 len -= ETH_ALEN * 2;
4320 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
4321 (ntohs(((u16 *)pPacket)[6]) != 0x888E)) {
4322 if (encapsulate(ai,(etherHead *)pPacket,&pMic,len) != SUCCESS)
4324 miclen = sizeof(pMic);
4326 // packet is destination[6], source[6], payload[len-12]
4327 // write the payload length and dst/src/payload
4328 if (bap_setup(ai, txFid, 0x0036, BAP1) != SUCCESS) return ERROR;
4329 /* The hardware addresses aren't counted as part of the payload, so
4330 * we have to subtract the 12 bytes for the addresses off */
4331 payloadLen = cpu_to_le16(len + miclen);
4332 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4333 bap_write(ai, (const u16*)pPacket, sizeof(etherHead), BAP1);
4335 bap_write(ai, (const u16*)&pMic, miclen, BAP1);
4336 bap_write(ai, (const u16*)(pPacket + sizeof(etherHead)), len, BAP1);
4337 // issue the transmit command
4338 memset( &cmd, 0, sizeof( cmd ) );
4339 cmd.cmd = CMD_TRANSMIT;
4341 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4342 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4346 static int transmit_802_11_packet(struct airo_info *ai, int len, char *pPacket)
4361 fc = le16_to_cpu(*(const u16*)pPacket);
4364 if ((fc & 0xe0) == 0xc0)
4370 if ((fc&0x300)==0x300){
4379 airo_print_warn(ai->dev->name, "Short packet %d", len);
4383 /* packet is 802.11 header + payload
4384 * write the payload length and dst/src/payload */
4385 if (bap_setup(ai, txFid, 6, BAP1) != SUCCESS) return ERROR;
4386 /* The 802.11 header aren't counted as part of the payload, so
4387 * we have to subtract the header bytes off */
4388 payloadLen = cpu_to_le16(len-hdrlen);
4389 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4390 if (bap_setup(ai, txFid, 0x0014, BAP1) != SUCCESS) return ERROR;
4391 bap_write(ai, (const u16*)pPacket, hdrlen, BAP1);
4392 bap_write(ai, hdrlen == 30 ?
4393 (const u16*)&gap.gaplen : (const u16*)&gap, 38 - hdrlen, BAP1);
4395 bap_write(ai, (const u16*)(pPacket + hdrlen), len - hdrlen, BAP1);
4396 // issue the transmit command
4397 memset( &cmd, 0, sizeof( cmd ) );
4398 cmd.cmd = CMD_TRANSMIT;
4400 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4401 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4406 * This is the proc_fs routines. It is a bit messier than I would
4407 * like! Feel free to clean it up!
4410 static ssize_t proc_read( struct file *file,
4411 char __user *buffer,
4415 static ssize_t proc_write( struct file *file,
4416 const char __user *buffer,
4419 static int proc_close( struct inode *inode, struct file *file );
4421 static int proc_stats_open( struct inode *inode, struct file *file );
4422 static int proc_statsdelta_open( struct inode *inode, struct file *file );
4423 static int proc_status_open( struct inode *inode, struct file *file );
4424 static int proc_SSID_open( struct inode *inode, struct file *file );
4425 static int proc_APList_open( struct inode *inode, struct file *file );
4426 static int proc_BSSList_open( struct inode *inode, struct file *file );
4427 static int proc_config_open( struct inode *inode, struct file *file );
4428 static int proc_wepkey_open( struct inode *inode, struct file *file );
4430 static struct file_operations proc_statsdelta_ops = {
4432 .open = proc_statsdelta_open,
4433 .release = proc_close
4436 static struct file_operations proc_stats_ops = {
4438 .open = proc_stats_open,
4439 .release = proc_close
4442 static struct file_operations proc_status_ops = {
4444 .open = proc_status_open,
4445 .release = proc_close
4448 static struct file_operations proc_SSID_ops = {
4450 .write = proc_write,
4451 .open = proc_SSID_open,
4452 .release = proc_close
4455 static struct file_operations proc_BSSList_ops = {
4457 .write = proc_write,
4458 .open = proc_BSSList_open,
4459 .release = proc_close
4462 static struct file_operations proc_APList_ops = {
4464 .write = proc_write,
4465 .open = proc_APList_open,
4466 .release = proc_close
4469 static struct file_operations proc_config_ops = {
4471 .write = proc_write,
4472 .open = proc_config_open,
4473 .release = proc_close
4476 static struct file_operations proc_wepkey_ops = {
4478 .write = proc_write,
4479 .open = proc_wepkey_open,
4480 .release = proc_close
4483 static struct proc_dir_entry *airo_entry;
4492 void (*on_close) (struct inode *, struct file *);
4496 #define SETPROC_OPS(entry, ops) (entry)->proc_fops = &(ops)
4499 static int setup_proc_entry( struct net_device *dev,
4500 struct airo_info *apriv ) {
4501 struct proc_dir_entry *entry;
4502 /* First setup the device directory */
4503 strcpy(apriv->proc_name,dev->name);
4504 apriv->proc_entry = create_proc_entry(apriv->proc_name,
4507 apriv->proc_entry->uid = proc_uid;
4508 apriv->proc_entry->gid = proc_gid;
4509 apriv->proc_entry->owner = THIS_MODULE;
4511 /* Setup the StatsDelta */
4512 entry = create_proc_entry("StatsDelta",
4513 S_IFREG | (S_IRUGO&proc_perm),
4515 entry->uid = proc_uid;
4516 entry->gid = proc_gid;
4518 entry->owner = THIS_MODULE;
4519 SETPROC_OPS(entry, proc_statsdelta_ops);
4521 /* Setup the Stats */
4522 entry = create_proc_entry("Stats",
4523 S_IFREG | (S_IRUGO&proc_perm),
4525 entry->uid = proc_uid;
4526 entry->gid = proc_gid;
4528 entry->owner = THIS_MODULE;
4529 SETPROC_OPS(entry, proc_stats_ops);
4531 /* Setup the Status */
4532 entry = create_proc_entry("Status",
4533 S_IFREG | (S_IRUGO&proc_perm),
4535 entry->uid = proc_uid;
4536 entry->gid = proc_gid;
4538 entry->owner = THIS_MODULE;
4539 SETPROC_OPS(entry, proc_status_ops);
4541 /* Setup the Config */
4542 entry = create_proc_entry("Config",
4543 S_IFREG | proc_perm,
4545 entry->uid = proc_uid;
4546 entry->gid = proc_gid;
4548 entry->owner = THIS_MODULE;
4549 SETPROC_OPS(entry, proc_config_ops);
4551 /* Setup the SSID */
4552 entry = create_proc_entry("SSID",
4553 S_IFREG | proc_perm,
4555 entry->uid = proc_uid;
4556 entry->gid = proc_gid;
4558 entry->owner = THIS_MODULE;
4559 SETPROC_OPS(entry, proc_SSID_ops);
4561 /* Setup the APList */
4562 entry = create_proc_entry("APList",
4563 S_IFREG | proc_perm,
4565 entry->uid = proc_uid;
4566 entry->gid = proc_gid;
4568 entry->owner = THIS_MODULE;
4569 SETPROC_OPS(entry, proc_APList_ops);
4571 /* Setup the BSSList */
4572 entry = create_proc_entry("BSSList",
4573 S_IFREG | proc_perm,
4575 entry->uid = proc_uid;
4576 entry->gid = proc_gid;
4578 entry->owner = THIS_MODULE;
4579 SETPROC_OPS(entry, proc_BSSList_ops);
4581 /* Setup the WepKey */
4582 entry = create_proc_entry("WepKey",
4583 S_IFREG | proc_perm,
4585 entry->uid = proc_uid;
4586 entry->gid = proc_gid;
4588 entry->owner = THIS_MODULE;
4589 SETPROC_OPS(entry, proc_wepkey_ops);
4594 static int takedown_proc_entry( struct net_device *dev,
4595 struct airo_info *apriv ) {
4596 if ( !apriv->proc_entry->namelen ) return 0;
4597 remove_proc_entry("Stats",apriv->proc_entry);
4598 remove_proc_entry("StatsDelta",apriv->proc_entry);
4599 remove_proc_entry("Status",apriv->proc_entry);
4600 remove_proc_entry("Config",apriv->proc_entry);
4601 remove_proc_entry("SSID",apriv->proc_entry);
4602 remove_proc_entry("APList",apriv->proc_entry);
4603 remove_proc_entry("BSSList",apriv->proc_entry);
4604 remove_proc_entry("WepKey",apriv->proc_entry);
4605 remove_proc_entry(apriv->proc_name,airo_entry);
4610 * What we want from the proc_fs is to be able to efficiently read
4611 * and write the configuration. To do this, we want to read the
4612 * configuration when the file is opened and write it when the file is
4613 * closed. So basically we allocate a read buffer at open and fill it
4614 * with data, and allocate a write buffer and read it at close.
4618 * The read routine is generic, it relies on the preallocated rbuffer
4619 * to supply the data.
4621 static ssize_t proc_read( struct file *file,
4622 char __user *buffer,
4626 loff_t pos = *offset;
4627 struct proc_data *priv = (struct proc_data*)file->private_data;
4634 if (pos >= priv->readlen)
4636 if (len > priv->readlen - pos)
4637 len = priv->readlen - pos;
4638 if (copy_to_user(buffer, priv->rbuffer + pos, len))
4640 *offset = pos + len;
4645 * The write routine is generic, it fills in a preallocated rbuffer
4646 * to supply the data.
4648 static ssize_t proc_write( struct file *file,
4649 const char __user *buffer,
4653 loff_t pos = *offset;
4654 struct proc_data *priv = (struct proc_data*)file->private_data;
4661 if (pos >= priv->maxwritelen)
4663 if (len > priv->maxwritelen - pos)
4664 len = priv->maxwritelen - pos;
4665 if (copy_from_user(priv->wbuffer + pos, buffer, len))
4667 if ( pos + len > priv->writelen )
4668 priv->writelen = len + file->f_pos;
4669 *offset = pos + len;
4673 static int proc_status_open( struct inode *inode, struct file *file ) {
4674 struct proc_data *data;
4675 struct proc_dir_entry *dp = PDE(inode);
4676 struct net_device *dev = dp->data;
4677 struct airo_info *apriv = dev->priv;
4678 CapabilityRid cap_rid;
4679 StatusRid status_rid;
4682 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4684 data = (struct proc_data *)file->private_data;
4685 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4686 kfree (file->private_data);
4690 readStatusRid(apriv, &status_rid, 1);
4691 readCapabilityRid(apriv, &cap_rid, 1);
4693 i = sprintf(data->rbuffer, "Status: %s%s%s%s%s%s%s%s%s\n",
4694 status_rid.mode & 1 ? "CFG ": "",
4695 status_rid.mode & 2 ? "ACT ": "",
4696 status_rid.mode & 0x10 ? "SYN ": "",
4697 status_rid.mode & 0x20 ? "LNK ": "",
4698 status_rid.mode & 0x40 ? "LEAP ": "",
4699 status_rid.mode & 0x80 ? "PRIV ": "",
4700 status_rid.mode & 0x100 ? "KEY ": "",
4701 status_rid.mode & 0x200 ? "WEP ": "",
4702 status_rid.mode & 0x8000 ? "ERR ": "");
4703 sprintf( data->rbuffer+i, "Mode: %x\n"
4704 "Signal Strength: %d\n"
4705 "Signal Quality: %d\n"
4710 "Driver Version: %s\n"
4711 "Device: %s\nManufacturer: %s\nFirmware Version: %s\n"
4712 "Radio type: %x\nCountry: %x\nHardware Version: %x\n"
4713 "Software Version: %x\nSoftware Subversion: %x\n"
4714 "Boot block version: %x\n",
4715 (int)status_rid.mode,
4716 (int)status_rid.normalizedSignalStrength,
4717 (int)status_rid.signalQuality,
4718 (int)status_rid.SSIDlen,
4721 (int)status_rid.channel,
4722 (int)status_rid.currentXmitRate/2,
4730 (int)cap_rid.softVer,
4731 (int)cap_rid.softSubVer,
4732 (int)cap_rid.bootBlockVer );
4733 data->readlen = strlen( data->rbuffer );
4737 static int proc_stats_rid_open(struct inode*, struct file*, u16);
4738 static int proc_statsdelta_open( struct inode *inode,
4739 struct file *file ) {
4740 if (file->f_mode&FMODE_WRITE) {
4741 return proc_stats_rid_open(inode, file, RID_STATSDELTACLEAR);
4743 return proc_stats_rid_open(inode, file, RID_STATSDELTA);
4746 static int proc_stats_open( struct inode *inode, struct file *file ) {
4747 return proc_stats_rid_open(inode, file, RID_STATS);
4750 static int proc_stats_rid_open( struct inode *inode,
4753 struct proc_data *data;
4754 struct proc_dir_entry *dp = PDE(inode);
4755 struct net_device *dev = dp->data;
4756 struct airo_info *apriv = dev->priv;
4759 u32 *vals = stats.vals;
4761 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4763 data = (struct proc_data *)file->private_data;
4764 if ((data->rbuffer = kmalloc( 4096, GFP_KERNEL )) == NULL) {
4765 kfree (file->private_data);
4769 readStatsRid(apriv, &stats, rid, 1);
4772 for(i=0; statsLabels[i]!=(char *)-1 &&
4773 i*4<stats.len; i++){
4774 if (!statsLabels[i]) continue;
4775 if (j+strlen(statsLabels[i])+16>4096) {
4776 airo_print_warn(apriv->dev->name,
4777 "Potentially disasterous buffer overflow averted!");
4780 j+=sprintf(data->rbuffer+j, "%s: %u\n", statsLabels[i], vals[i]);
4782 if (i*4>=stats.len){
4783 airo_print_warn(apriv->dev->name, "Got a short rid");
4789 static int get_dec_u16( char *buffer, int *start, int limit ) {
4792 for( value = 0; buffer[*start] >= '0' &&
4793 buffer[*start] <= '9' &&
4794 *start < limit; (*start)++ ) {
4797 value += buffer[*start] - '0';
4799 if ( !valid ) return -1;
4803 static int airo_config_commit(struct net_device *dev,
4804 struct iw_request_info *info, void *zwrq,
4807 static void proc_config_on_close( struct inode *inode, struct file *file ) {
4808 struct proc_data *data = file->private_data;
4809 struct proc_dir_entry *dp = PDE(inode);
4810 struct net_device *dev = dp->data;
4811 struct airo_info *ai = dev->priv;
4814 if ( !data->writelen ) return;
4816 readConfigRid(ai, 1);
4817 set_bit (FLAG_COMMIT, &ai->flags);
4819 line = data->wbuffer;
4821 /*** Mode processing */
4822 if ( !strncmp( line, "Mode: ", 6 ) ) {
4824 if ((ai->config.rmode & 0xff) >= RXMODE_RFMON)
4825 set_bit (FLAG_RESET, &ai->flags);
4826 ai->config.rmode &= 0xfe00;
4827 clear_bit (FLAG_802_11, &ai->flags);
4828 ai->config.opmode &= 0xFF00;
4829 ai->config.scanMode = SCANMODE_ACTIVE;
4830 if ( line[0] == 'a' ) {
4831 ai->config.opmode |= 0;
4833 ai->config.opmode |= 1;
4834 if ( line[0] == 'r' ) {
4835 ai->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
4836 ai->config.scanMode = SCANMODE_PASSIVE;
4837 set_bit (FLAG_802_11, &ai->flags);
4838 } else if ( line[0] == 'y' ) {
4839 ai->config.rmode |= RXMODE_RFMON_ANYBSS | RXMODE_DISABLE_802_3_HEADER;
4840 ai->config.scanMode = SCANMODE_PASSIVE;
4841 set_bit (FLAG_802_11, &ai->flags);
4842 } else if ( line[0] == 'l' )
4843 ai->config.rmode |= RXMODE_LANMON;
4845 set_bit (FLAG_COMMIT, &ai->flags);
4848 /*** Radio status */
4849 else if (!strncmp(line,"Radio: ", 7)) {
4851 if (!strncmp(line,"off",3)) {
4852 set_bit (FLAG_RADIO_OFF, &ai->flags);
4854 clear_bit (FLAG_RADIO_OFF, &ai->flags);
4857 /*** NodeName processing */
4858 else if ( !strncmp( line, "NodeName: ", 10 ) ) {
4862 memset( ai->config.nodeName, 0, 16 );
4863 /* Do the name, assume a space between the mode and node name */
4864 for( j = 0; j < 16 && line[j] != '\n'; j++ ) {
4865 ai->config.nodeName[j] = line[j];
4867 set_bit (FLAG_COMMIT, &ai->flags);
4870 /*** PowerMode processing */
4871 else if ( !strncmp( line, "PowerMode: ", 11 ) ) {
4873 if ( !strncmp( line, "PSPCAM", 6 ) ) {
4874 ai->config.powerSaveMode = POWERSAVE_PSPCAM;
4875 set_bit (FLAG_COMMIT, &ai->flags);
4876 } else if ( !strncmp( line, "PSP", 3 ) ) {
4877 ai->config.powerSaveMode = POWERSAVE_PSP;
4878 set_bit (FLAG_COMMIT, &ai->flags);
4880 ai->config.powerSaveMode = POWERSAVE_CAM;
4881 set_bit (FLAG_COMMIT, &ai->flags);
4883 } else if ( !strncmp( line, "DataRates: ", 11 ) ) {
4884 int v, i = 0, k = 0; /* i is index into line,
4885 k is index to rates */
4888 while((v = get_dec_u16(line, &i, 3))!=-1) {
4889 ai->config.rates[k++] = (u8)v;
4893 set_bit (FLAG_COMMIT, &ai->flags);
4894 } else if ( !strncmp( line, "Channel: ", 9 ) ) {
4897 v = get_dec_u16(line, &i, i+3);
4899 ai->config.channelSet = (u16)v;
4900 set_bit (FLAG_COMMIT, &ai->flags);
4902 } else if ( !strncmp( line, "XmitPower: ", 11 ) ) {
4905 v = get_dec_u16(line, &i, i+3);
4907 ai->config.txPower = (u16)v;
4908 set_bit (FLAG_COMMIT, &ai->flags);
4910 } else if ( !strncmp( line, "WEP: ", 5 ) ) {
4914 ai->config.authType = (u16)AUTH_SHAREDKEY;
4917 ai->config.authType = (u16)AUTH_ENCRYPT;
4920 ai->config.authType = (u16)AUTH_OPEN;
4923 set_bit (FLAG_COMMIT, &ai->flags);
4924 } else if ( !strncmp( line, "LongRetryLimit: ", 16 ) ) {
4928 v = get_dec_u16(line, &i, 3);
4929 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4930 ai->config.longRetryLimit = (u16)v;
4931 set_bit (FLAG_COMMIT, &ai->flags);
4932 } else if ( !strncmp( line, "ShortRetryLimit: ", 17 ) ) {
4936 v = get_dec_u16(line, &i, 3);
4937 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4938 ai->config.shortRetryLimit = (u16)v;
4939 set_bit (FLAG_COMMIT, &ai->flags);
4940 } else if ( !strncmp( line, "RTSThreshold: ", 14 ) ) {
4944 v = get_dec_u16(line, &i, 4);
4945 v = (v<0) ? 0 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v);
4946 ai->config.rtsThres = (u16)v;
4947 set_bit (FLAG_COMMIT, &ai->flags);
4948 } else if ( !strncmp( line, "TXMSDULifetime: ", 16 ) ) {
4952 v = get_dec_u16(line, &i, 5);
4954 ai->config.txLifetime = (u16)v;
4955 set_bit (FLAG_COMMIT, &ai->flags);
4956 } else if ( !strncmp( line, "RXMSDULifetime: ", 16 ) ) {
4960 v = get_dec_u16(line, &i, 5);
4962 ai->config.rxLifetime = (u16)v;
4963 set_bit (FLAG_COMMIT, &ai->flags);
4964 } else if ( !strncmp( line, "TXDiversity: ", 13 ) ) {
4965 ai->config.txDiversity =
4966 (line[13]=='l') ? 1 :
4967 ((line[13]=='r')? 2: 3);
4968 set_bit (FLAG_COMMIT, &ai->flags);
4969 } else if ( !strncmp( line, "RXDiversity: ", 13 ) ) {
4970 ai->config.rxDiversity =
4971 (line[13]=='l') ? 1 :
4972 ((line[13]=='r')? 2: 3);
4973 set_bit (FLAG_COMMIT, &ai->flags);
4974 } else if ( !strncmp( line, "FragThreshold: ", 15 ) ) {
4978 v = get_dec_u16(line, &i, 4);
4979 v = (v<256) ? 256 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v);
4980 v = v & 0xfffe; /* Make sure its even */
4981 ai->config.fragThresh = (u16)v;
4982 set_bit (FLAG_COMMIT, &ai->flags);
4983 } else if (!strncmp(line, "Modulation: ", 12)) {
4986 case 'd': ai->config.modulation=MOD_DEFAULT; set_bit(FLAG_COMMIT, &ai->flags); break;
4987 case 'c': ai->config.modulation=MOD_CCK; set_bit(FLAG_COMMIT, &ai->flags); break;
4988 case 'm': ai->config.modulation=MOD_MOK; set_bit(FLAG_COMMIT, &ai->flags); break;
4989 default: airo_print_warn(ai->dev->name, "Unknown modulation");
4991 } else if (!strncmp(line, "Preamble: ", 10)) {
4994 case 'a': ai->config.preamble=PREAMBLE_AUTO; set_bit(FLAG_COMMIT, &ai->flags); break;
4995 case 'l': ai->config.preamble=PREAMBLE_LONG; set_bit(FLAG_COMMIT, &ai->flags); break;
4996 case 's': ai->config.preamble=PREAMBLE_SHORT; set_bit(FLAG_COMMIT, &ai->flags); break;
4997 default: airo_print_warn(ai->dev->name, "Unknown preamble");
5000 airo_print_warn(ai->dev->name, "Couldn't figure out %s", line);
5002 while( line[0] && line[0] != '\n' ) line++;
5003 if ( line[0] ) line++;
5005 airo_config_commit(dev, NULL, NULL, NULL);
5008 static char *get_rmode(u16 mode) {
5010 case RXMODE_RFMON: return "rfmon";
5011 case RXMODE_RFMON_ANYBSS: return "yna (any) bss rfmon";
5012 case RXMODE_LANMON: return "lanmon";
5017 static int proc_config_open( struct inode *inode, struct file *file ) {
5018 struct proc_data *data;
5019 struct proc_dir_entry *dp = PDE(inode);
5020 struct net_device *dev = dp->data;
5021 struct airo_info *ai = dev->priv;
5024 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5026 data = (struct proc_data *)file->private_data;
5027 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
5028 kfree (file->private_data);
5031 if ((data->wbuffer = kzalloc( 2048, GFP_KERNEL )) == NULL) {
5032 kfree (data->rbuffer);
5033 kfree (file->private_data);
5036 data->maxwritelen = 2048;
5037 data->on_close = proc_config_on_close;
5039 readConfigRid(ai, 1);
5041 i = sprintf( data->rbuffer,
5046 "DataRates: %d %d %d %d %d %d %d %d\n"
5049 (ai->config.opmode & 0xFF) == 0 ? "adhoc" :
5050 (ai->config.opmode & 0xFF) == 1 ? get_rmode(ai->config.rmode):
5051 (ai->config.opmode & 0xFF) == 2 ? "AP" :
5052 (ai->config.opmode & 0xFF) == 3 ? "AP RPTR" : "Error",
5053 test_bit(FLAG_RADIO_OFF, &ai->flags) ? "off" : "on",
5054 ai->config.nodeName,
5055 ai->config.powerSaveMode == 0 ? "CAM" :
5056 ai->config.powerSaveMode == 1 ? "PSP" :
5057 ai->config.powerSaveMode == 2 ? "PSPCAM" : "Error",
5058 (int)ai->config.rates[0],
5059 (int)ai->config.rates[1],
5060 (int)ai->config.rates[2],
5061 (int)ai->config.rates[3],
5062 (int)ai->config.rates[4],
5063 (int)ai->config.rates[5],
5064 (int)ai->config.rates[6],
5065 (int)ai->config.rates[7],
5066 (int)ai->config.channelSet,
5067 (int)ai->config.txPower
5069 sprintf( data->rbuffer + i,
5070 "LongRetryLimit: %d\n"
5071 "ShortRetryLimit: %d\n"
5072 "RTSThreshold: %d\n"
5073 "TXMSDULifetime: %d\n"
5074 "RXMSDULifetime: %d\n"
5077 "FragThreshold: %d\n"
5081 (int)ai->config.longRetryLimit,
5082 (int)ai->config.shortRetryLimit,
5083 (int)ai->config.rtsThres,
5084 (int)ai->config.txLifetime,
5085 (int)ai->config.rxLifetime,
5086 ai->config.txDiversity == 1 ? "left" :
5087 ai->config.txDiversity == 2 ? "right" : "both",
5088 ai->config.rxDiversity == 1 ? "left" :
5089 ai->config.rxDiversity == 2 ? "right" : "both",
5090 (int)ai->config.fragThresh,
5091 ai->config.authType == AUTH_ENCRYPT ? "encrypt" :
5092 ai->config.authType == AUTH_SHAREDKEY ? "shared" : "open",
5093 ai->config.modulation == 0 ? "default" :
5094 ai->config.modulation == MOD_CCK ? "cck" :
5095 ai->config.modulation == MOD_MOK ? "mok" : "error",
5096 ai->config.preamble == PREAMBLE_AUTO ? "auto" :
5097 ai->config.preamble == PREAMBLE_LONG ? "long" :
5098 ai->config.preamble == PREAMBLE_SHORT ? "short" : "error"
5100 data->readlen = strlen( data->rbuffer );
5104 static void proc_SSID_on_close( struct inode *inode, struct file *file ) {
5105 struct proc_data *data = (struct proc_data *)file->private_data;
5106 struct proc_dir_entry *dp = PDE(inode);
5107 struct net_device *dev = dp->data;
5108 struct airo_info *ai = dev->priv;
5114 if ( !data->writelen ) return;
5116 memset( &SSID_rid, 0, sizeof( SSID_rid ) );
5118 for( i = 0; i < 3; i++ ) {
5120 for( j = 0; j+offset < data->writelen && j < 32 &&
5121 data->wbuffer[offset+j] != '\n'; j++ ) {
5122 SSID_rid.ssids[i].ssid[j] = data->wbuffer[offset+j];
5124 if ( j == 0 ) break;
5125 SSID_rid.ssids[i].len = j;
5127 while( data->wbuffer[offset] != '\n' &&
5128 offset < data->writelen ) offset++;
5132 SSID_rid.len = sizeof(SSID_rid);
5134 writeSsidRid(ai, &SSID_rid, 1);
5135 enable_MAC(ai, &rsp, 1);
5138 static inline u8 hexVal(char c) {
5139 if (c>='0' && c<='9') return c -= '0';
5140 if (c>='a' && c<='f') return c -= 'a'-10;
5141 if (c>='A' && c<='F') return c -= 'A'-10;
5145 static void proc_APList_on_close( struct inode *inode, struct file *file ) {
5146 struct proc_data *data = (struct proc_data *)file->private_data;
5147 struct proc_dir_entry *dp = PDE(inode);
5148 struct net_device *dev = dp->data;
5149 struct airo_info *ai = dev->priv;
5150 APListRid APList_rid;
5154 if ( !data->writelen ) return;
5156 memset( &APList_rid, 0, sizeof(APList_rid) );
5157 APList_rid.len = sizeof(APList_rid);
5159 for( i = 0; i < 4 && data->writelen >= (i+1)*6*3; i++ ) {
5161 for( j = 0; j < 6*3 && data->wbuffer[j+i*6*3]; j++ ) {
5164 APList_rid.ap[i][j/3]=
5165 hexVal(data->wbuffer[j+i*6*3])<<4;
5168 APList_rid.ap[i][j/3]|=
5169 hexVal(data->wbuffer[j+i*6*3]);
5175 writeAPListRid(ai, &APList_rid, 1);
5176 enable_MAC(ai, &rsp, 1);
5179 /* This function wraps PC4500_writerid with a MAC disable */
5180 static int do_writerid( struct airo_info *ai, u16 rid, const void *rid_data,
5181 int len, int dummy ) {
5186 rc = PC4500_writerid(ai, rid, rid_data, len, 1);
5187 enable_MAC(ai, &rsp, 1);
5191 /* Returns the length of the key at the index. If index == 0xffff
5192 * the index of the transmit key is returned. If the key doesn't exist,
5193 * -1 will be returned.
5195 static int get_wep_key(struct airo_info *ai, u16 index) {
5200 rc = readWepKeyRid(ai, &wkr, 1, 1);
5201 if (rc == SUCCESS) do {
5202 lastindex = wkr.kindex;
5203 if (wkr.kindex == index) {
5204 if (index == 0xffff) {
5209 readWepKeyRid(ai, &wkr, 0, 1);
5210 } while(lastindex != wkr.kindex);
5214 static int set_wep_key(struct airo_info *ai, u16 index,
5215 const char *key, u16 keylen, int perm, int lock ) {
5216 static const unsigned char macaddr[ETH_ALEN] = { 0x01, 0, 0, 0, 0, 0 };
5220 memset(&wkr, 0, sizeof(wkr));
5222 // We are selecting which key to use
5223 wkr.len = sizeof(wkr);
5224 wkr.kindex = 0xffff;
5225 wkr.mac[0] = (char)index;
5226 if (perm) ai->defindex = (char)index;
5228 // We are actually setting the key
5229 wkr.len = sizeof(wkr);
5232 memcpy( wkr.key, key, keylen );
5233 memcpy( wkr.mac, macaddr, ETH_ALEN );
5236 if (perm) disable_MAC(ai, lock);
5237 writeWepKeyRid(ai, &wkr, perm, lock);
5238 if (perm) enable_MAC(ai, &rsp, lock);
5242 static void proc_wepkey_on_close( struct inode *inode, struct file *file ) {
5243 struct proc_data *data;
5244 struct proc_dir_entry *dp = PDE(inode);
5245 struct net_device *dev = dp->data;
5246 struct airo_info *ai = dev->priv;
5252 memset(key, 0, sizeof(key));
5254 data = (struct proc_data *)file->private_data;
5255 if ( !data->writelen ) return;
5257 if (data->wbuffer[0] >= '0' && data->wbuffer[0] <= '3' &&
5258 (data->wbuffer[1] == ' ' || data->wbuffer[1] == '\n')) {
5259 index = data->wbuffer[0] - '0';
5260 if (data->wbuffer[1] == '\n') {
5261 set_wep_key(ai, index, NULL, 0, 1, 1);
5266 airo_print_err(ai->dev->name, "WepKey passed invalid key index");
5270 for( i = 0; i < 16*3 && data->wbuffer[i+j]; i++ ) {
5273 key[i/3] = hexVal(data->wbuffer[i+j])<<4;
5276 key[i/3] |= hexVal(data->wbuffer[i+j]);
5280 set_wep_key(ai, index, key, i/3, 1, 1);
5283 static int proc_wepkey_open( struct inode *inode, struct file *file ) {
5284 struct proc_data *data;
5285 struct proc_dir_entry *dp = PDE(inode);
5286 struct net_device *dev = dp->data;
5287 struct airo_info *ai = dev->priv;
5294 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5296 memset(&wkr, 0, sizeof(wkr));
5297 data = (struct proc_data *)file->private_data;
5298 if ((data->rbuffer = kzalloc( 180, GFP_KERNEL )) == NULL) {
5299 kfree (file->private_data);
5303 data->maxwritelen = 80;
5304 if ((data->wbuffer = kzalloc( 80, GFP_KERNEL )) == NULL) {
5305 kfree (data->rbuffer);
5306 kfree (file->private_data);
5309 data->on_close = proc_wepkey_on_close;
5311 ptr = data->rbuffer;
5312 strcpy(ptr, "No wep keys\n");
5313 rc = readWepKeyRid(ai, &wkr, 1, 1);
5314 if (rc == SUCCESS) do {
5315 lastindex = wkr.kindex;
5316 if (wkr.kindex == 0xffff) {
5317 j += sprintf(ptr+j, "Tx key = %d\n",
5320 j += sprintf(ptr+j, "Key %d set with length = %d\n",
5321 (int)wkr.kindex, (int)wkr.klen);
5323 readWepKeyRid(ai, &wkr, 0, 1);
5324 } while((lastindex != wkr.kindex) && (j < 180-30));
5326 data->readlen = strlen( data->rbuffer );
5330 static int proc_SSID_open( struct inode *inode, struct file *file ) {
5331 struct proc_data *data;
5332 struct proc_dir_entry *dp = PDE(inode);
5333 struct net_device *dev = dp->data;
5334 struct airo_info *ai = dev->priv;
5339 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5341 data = (struct proc_data *)file->private_data;
5342 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5343 kfree (file->private_data);
5347 data->maxwritelen = 33*3;
5348 if ((data->wbuffer = kzalloc( 33*3, GFP_KERNEL )) == NULL) {
5349 kfree (data->rbuffer);
5350 kfree (file->private_data);
5353 data->on_close = proc_SSID_on_close;
5355 readSsidRid(ai, &SSID_rid);
5356 ptr = data->rbuffer;
5357 for( i = 0; i < 3; i++ ) {
5359 if ( !SSID_rid.ssids[i].len ) break;
5360 for( j = 0; j < 32 &&
5361 j < SSID_rid.ssids[i].len &&
5362 SSID_rid.ssids[i].ssid[j]; j++ ) {
5363 *ptr++ = SSID_rid.ssids[i].ssid[j];
5368 data->readlen = strlen( data->rbuffer );
5372 static int proc_APList_open( struct inode *inode, struct file *file ) {
5373 struct proc_data *data;
5374 struct proc_dir_entry *dp = PDE(inode);
5375 struct net_device *dev = dp->data;
5376 struct airo_info *ai = dev->priv;
5379 APListRid APList_rid;
5381 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5383 data = (struct proc_data *)file->private_data;
5384 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5385 kfree (file->private_data);
5389 data->maxwritelen = 4*6*3;
5390 if ((data->wbuffer = kzalloc( data->maxwritelen, GFP_KERNEL )) == NULL) {
5391 kfree (data->rbuffer);
5392 kfree (file->private_data);
5395 data->on_close = proc_APList_on_close;
5397 readAPListRid(ai, &APList_rid);
5398 ptr = data->rbuffer;
5399 for( i = 0; i < 4; i++ ) {
5400 // We end when we find a zero MAC
5401 if ( !*(int*)APList_rid.ap[i] &&
5402 !*(int*)&APList_rid.ap[i][2]) break;
5403 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x\n",
5404 (int)APList_rid.ap[i][0],
5405 (int)APList_rid.ap[i][1],
5406 (int)APList_rid.ap[i][2],
5407 (int)APList_rid.ap[i][3],
5408 (int)APList_rid.ap[i][4],
5409 (int)APList_rid.ap[i][5]);
5411 if (i==0) ptr += sprintf(ptr, "Not using specific APs\n");
5414 data->readlen = strlen( data->rbuffer );
5418 static int proc_BSSList_open( struct inode *inode, struct file *file ) {
5419 struct proc_data *data;
5420 struct proc_dir_entry *dp = PDE(inode);
5421 struct net_device *dev = dp->data;
5422 struct airo_info *ai = dev->priv;
5424 BSSListRid BSSList_rid;
5426 /* If doLoseSync is not 1, we won't do a Lose Sync */
5427 int doLoseSync = -1;
5429 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5431 data = (struct proc_data *)file->private_data;
5432 if ((data->rbuffer = kmalloc( 1024, GFP_KERNEL )) == NULL) {
5433 kfree (file->private_data);
5437 data->maxwritelen = 0;
5438 data->wbuffer = NULL;
5439 data->on_close = NULL;
5441 if (file->f_mode & FMODE_WRITE) {
5442 if (!(file->f_mode & FMODE_READ)) {
5446 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
5447 memset(&cmd, 0, sizeof(cmd));
5448 cmd.cmd=CMD_LISTBSS;
5449 if (down_interruptible(&ai->sem))
5450 return -ERESTARTSYS;
5451 issuecommand(ai, &cmd, &rsp);
5458 ptr = data->rbuffer;
5459 /* There is a race condition here if there are concurrent opens.
5460 Since it is a rare condition, we'll just live with it, otherwise
5461 we have to add a spin lock... */
5462 rc = readBSSListRid(ai, doLoseSync, &BSSList_rid);
5463 while(rc == 0 && BSSList_rid.index != 0xffff) {
5464 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x %*s rssi = %d",
5465 (int)BSSList_rid.bssid[0],
5466 (int)BSSList_rid.bssid[1],
5467 (int)BSSList_rid.bssid[2],
5468 (int)BSSList_rid.bssid[3],
5469 (int)BSSList_rid.bssid[4],
5470 (int)BSSList_rid.bssid[5],
5471 (int)BSSList_rid.ssidLen,
5473 (int)BSSList_rid.dBm);
5474 ptr += sprintf(ptr, " channel = %d %s %s %s %s\n",
5475 (int)BSSList_rid.dsChannel,
5476 BSSList_rid.cap & CAP_ESS ? "ESS" : "",
5477 BSSList_rid.cap & CAP_IBSS ? "adhoc" : "",
5478 BSSList_rid.cap & CAP_PRIVACY ? "wep" : "",
5479 BSSList_rid.cap & CAP_SHORTHDR ? "shorthdr" : "");
5480 rc = readBSSListRid(ai, 0, &BSSList_rid);
5483 data->readlen = strlen( data->rbuffer );
5487 static int proc_close( struct inode *inode, struct file *file )
5489 struct proc_data *data = file->private_data;
5491 if (data->on_close != NULL)
5492 data->on_close(inode, file);
5493 kfree(data->rbuffer);
5494 kfree(data->wbuffer);
5499 static struct net_device_list {
5500 struct net_device *dev;
5501 struct net_device_list *next;
5504 /* Since the card doesn't automatically switch to the right WEP mode,
5505 we will make it do it. If the card isn't associated, every secs we
5506 will switch WEP modes to see if that will help. If the card is
5507 associated we will check every minute to see if anything has
5509 static void timer_func( struct net_device *dev ) {
5510 struct airo_info *apriv = dev->priv;
5513 /* We don't have a link so try changing the authtype */
5514 readConfigRid(apriv, 0);
5515 disable_MAC(apriv, 0);
5516 switch(apriv->config.authType) {
5518 /* So drop to OPEN */
5519 apriv->config.authType = AUTH_OPEN;
5521 case AUTH_SHAREDKEY:
5522 if (apriv->keyindex < auto_wep) {
5523 set_wep_key(apriv, apriv->keyindex, NULL, 0, 0, 0);
5524 apriv->config.authType = AUTH_SHAREDKEY;
5527 /* Drop to ENCRYPT */
5528 apriv->keyindex = 0;
5529 set_wep_key(apriv, apriv->defindex, NULL, 0, 0, 0);
5530 apriv->config.authType = AUTH_ENCRYPT;
5533 default: /* We'll escalate to SHAREDKEY */
5534 apriv->config.authType = AUTH_SHAREDKEY;
5536 set_bit (FLAG_COMMIT, &apriv->flags);
5537 writeConfigRid(apriv, 0);
5538 enable_MAC(apriv, &rsp, 0);
5541 /* Schedule check to see if the change worked */
5542 clear_bit(JOB_AUTOWEP, &apriv->jobs);
5543 apriv->expires = RUN_AT(HZ*3);
5546 static int add_airo_dev( struct net_device *dev ) {
5547 struct net_device_list *node = kmalloc( sizeof( *node ), GFP_KERNEL );
5552 node->next = airo_devices;
5553 airo_devices = node;
5558 static void del_airo_dev( struct net_device *dev ) {
5559 struct net_device_list **p = &airo_devices;
5560 while( *p && ( (*p)->dev != dev ) )
5562 if ( *p && (*p)->dev == dev )
5567 static int __devinit airo_pci_probe(struct pci_dev *pdev,
5568 const struct pci_device_id *pent)
5570 struct net_device *dev;
5572 if (pci_enable_device(pdev))
5574 pci_set_master(pdev);
5576 if (pdev->device == 0x5000 || pdev->device == 0xa504)
5577 dev = _init_airo_card(pdev->irq, pdev->resource[0].start, 0, pdev, &pdev->dev);
5579 dev = _init_airo_card(pdev->irq, pdev->resource[2].start, 0, pdev, &pdev->dev);
5583 pci_set_drvdata(pdev, dev);
5587 static void __devexit airo_pci_remove(struct pci_dev *pdev)
5591 static int airo_pci_suspend(struct pci_dev *pdev, pm_message_t state)
5593 struct net_device *dev = pci_get_drvdata(pdev);
5594 struct airo_info *ai = dev->priv;
5598 if ((ai->APList == NULL) &&
5599 (ai->APList = kmalloc(sizeof(APListRid), GFP_KERNEL)) == NULL)
5601 if ((ai->SSID == NULL) &&
5602 (ai->SSID = kmalloc(sizeof(SsidRid), GFP_KERNEL)) == NULL)
5604 readAPListRid(ai, ai->APList);
5605 readSsidRid(ai, ai->SSID);
5606 memset(&cmd, 0, sizeof(cmd));
5607 /* the lock will be released at the end of the resume callback */
5608 if (down_interruptible(&ai->sem))
5611 netif_device_detach(dev);
5614 issuecommand(ai, &cmd, &rsp);
5616 pci_enable_wake(pdev, pci_choose_state(pdev, state), 1);
5617 pci_save_state(pdev);
5618 return pci_set_power_state(pdev, pci_choose_state(pdev, state));
5621 static int airo_pci_resume(struct pci_dev *pdev)
5623 struct net_device *dev = pci_get_drvdata(pdev);
5624 struct airo_info *ai = dev->priv;
5626 pci_power_t prev_state = pdev->current_state;
5628 pci_set_power_state(pdev, PCI_D0);
5629 pci_restore_state(pdev);
5630 pci_enable_wake(pdev, PCI_D0, 0);
5632 if (prev_state != PCI_D1) {
5634 mpi_init_descriptors(ai);
5635 setup_card(ai, dev->dev_addr, 0);
5636 clear_bit(FLAG_RADIO_OFF, &ai->flags);
5637 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
5639 OUT4500(ai, EVACK, EV_AWAKEN);
5640 OUT4500(ai, EVACK, EV_AWAKEN);
5644 set_bit (FLAG_COMMIT, &ai->flags);
5648 writeSsidRid(ai, ai->SSID, 0);
5653 writeAPListRid(ai, ai->APList, 0);
5657 writeConfigRid(ai, 0);
5658 enable_MAC(ai, &rsp, 0);
5659 ai->power = PMSG_ON;
5660 netif_device_attach(dev);
5661 netif_wake_queue(dev);
5662 enable_interrupts(ai);
5668 static int __init airo_init_module( void )
5670 int i, have_isa_dev = 0;
5672 airo_entry = create_proc_entry("aironet",
5673 S_IFDIR | airo_perm,
5675 airo_entry->uid = proc_uid;
5676 airo_entry->gid = proc_gid;
5678 for( i = 0; i < 4 && io[i] && irq[i]; i++ ) {
5679 airo_print_info("", "Trying to configure ISA adapter at irq=%d "
5680 "io=0x%x", irq[i], io[i] );
5681 if (init_airo_card( irq[i], io[i], 0, NULL ))
5686 airo_print_info("", "Probing for PCI adapters");
5687 pci_register_driver(&airo_driver);
5688 airo_print_info("", "Finished probing for PCI adapters");
5691 /* Always exit with success, as we are a library module
5692 * as well as a driver module
5697 static void __exit airo_cleanup_module( void )
5699 while( airo_devices ) {
5700 airo_print_info(airo_devices->dev->name, "Unregistering...\n");
5701 stop_airo_card( airo_devices->dev, 1 );
5704 pci_unregister_driver(&airo_driver);
5706 remove_proc_entry("aironet", proc_root_driver);
5710 * Initial Wireless Extension code for Aironet driver by :
5711 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 17 November 00
5712 * Conversion to new driver API by :
5713 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 26 March 02
5714 * Javier also did a good amount of work here, adding some new extensions
5715 * and fixing my code. Let's just say that without him this code just
5716 * would not work at all... - Jean II
5719 static u8 airo_rssi_to_dbm (tdsRssiEntry *rssi_rid, u8 rssi)
5724 return (0x100 - rssi_rid[rssi].rssidBm);
5727 static u8 airo_dbm_to_pct (tdsRssiEntry *rssi_rid, u8 dbm)
5734 for( i = 0; i < 256; i++ )
5735 if (rssi_rid[i].rssidBm == dbm)
5736 return rssi_rid[i].rssipct;
5742 static int airo_get_quality (StatusRid *status_rid, CapabilityRid *cap_rid)
5746 if ((status_rid->mode & 0x3f) == 0x3f && (cap_rid->hardCap & 8)) {
5747 if (memcmp(cap_rid->prodName, "350", 3))
5748 if (status_rid->signalQuality > 0x20)
5751 quality = 0x20 - status_rid->signalQuality;
5753 if (status_rid->signalQuality > 0xb0)
5755 else if (status_rid->signalQuality < 0x10)
5758 quality = 0xb0 - status_rid->signalQuality;
5763 #define airo_get_max_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x20 : 0xa0)
5764 #define airo_get_avg_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x10 : 0x50);
5766 /*------------------------------------------------------------------*/
5768 * Wireless Handler : get protocol name
5770 static int airo_get_name(struct net_device *dev,
5771 struct iw_request_info *info,
5775 strcpy(cwrq, "IEEE 802.11-DS");
5779 /*------------------------------------------------------------------*/
5781 * Wireless Handler : set frequency
5783 static int airo_set_freq(struct net_device *dev,
5784 struct iw_request_info *info,
5785 struct iw_freq *fwrq,
5788 struct airo_info *local = dev->priv;
5789 int rc = -EINPROGRESS; /* Call commit handler */
5791 /* If setting by frequency, convert to a channel */
5792 if((fwrq->e == 1) &&
5793 (fwrq->m >= (int) 2.412e8) &&
5794 (fwrq->m <= (int) 2.487e8)) {
5795 int f = fwrq->m / 100000;
5797 while((c < 14) && (f != frequency_list[c]))
5799 /* Hack to fall through... */
5803 /* Setting by channel number */
5804 if((fwrq->m > 1000) || (fwrq->e > 0))
5807 int channel = fwrq->m;
5808 /* We should do a better check than that,
5809 * based on the card capability !!! */
5810 if((channel < 1) || (channel > 14)) {
5811 airo_print_dbg(dev->name, "New channel value of %d is invalid!",
5815 readConfigRid(local, 1);
5816 /* Yes ! We can set it !!! */
5817 local->config.channelSet = (u16) channel;
5818 set_bit (FLAG_COMMIT, &local->flags);
5824 /*------------------------------------------------------------------*/
5826 * Wireless Handler : get frequency
5828 static int airo_get_freq(struct net_device *dev,
5829 struct iw_request_info *info,
5830 struct iw_freq *fwrq,
5833 struct airo_info *local = dev->priv;
5834 StatusRid status_rid; /* Card status info */
5837 readConfigRid(local, 1);
5838 if ((local->config.opmode & 0xFF) == MODE_STA_ESS)
5839 status_rid.channel = local->config.channelSet;
5841 readStatusRid(local, &status_rid, 1);
5843 ch = (int)status_rid.channel;
5844 if((ch > 0) && (ch < 15)) {
5845 fwrq->m = frequency_list[ch - 1] * 100000;
5855 /*------------------------------------------------------------------*/
5857 * Wireless Handler : set ESSID
5859 static int airo_set_essid(struct net_device *dev,
5860 struct iw_request_info *info,
5861 struct iw_point *dwrq,
5864 struct airo_info *local = dev->priv;
5866 SsidRid SSID_rid; /* SSIDs */
5868 /* Reload the list of current SSID */
5869 readSsidRid(local, &SSID_rid);
5871 /* Check if we asked for `any' */
5872 if(dwrq->flags == 0) {
5873 /* Just send an empty SSID list */
5874 memset(&SSID_rid, 0, sizeof(SSID_rid));
5876 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
5878 /* Check the size of the string */
5879 if(dwrq->length > IW_ESSID_MAX_SIZE+1) {
5882 /* Check if index is valid */
5883 if((index < 0) || (index >= 4)) {
5888 memset(SSID_rid.ssids[index].ssid, 0,
5889 sizeof(SSID_rid.ssids[index].ssid));
5890 memcpy(SSID_rid.ssids[index].ssid, extra, dwrq->length);
5891 SSID_rid.ssids[index].len = dwrq->length - 1;
5893 SSID_rid.len = sizeof(SSID_rid);
5894 /* Write it to the card */
5895 disable_MAC(local, 1);
5896 writeSsidRid(local, &SSID_rid, 1);
5897 enable_MAC(local, &rsp, 1);
5902 /*------------------------------------------------------------------*/
5904 * Wireless Handler : get ESSID
5906 static int airo_get_essid(struct net_device *dev,
5907 struct iw_request_info *info,
5908 struct iw_point *dwrq,
5911 struct airo_info *local = dev->priv;
5912 StatusRid status_rid; /* Card status info */
5914 readStatusRid(local, &status_rid, 1);
5916 /* Note : if dwrq->flags != 0, we should
5917 * get the relevant SSID from the SSID list... */
5919 /* Get the current SSID */
5920 memcpy(extra, status_rid.SSID, status_rid.SSIDlen);
5921 extra[status_rid.SSIDlen] = '\0';
5922 /* If none, we may want to get the one that was set */
5925 dwrq->length = status_rid.SSIDlen;
5926 dwrq->flags = 1; /* active */
5931 /*------------------------------------------------------------------*/
5933 * Wireless Handler : set AP address
5935 static int airo_set_wap(struct net_device *dev,
5936 struct iw_request_info *info,
5937 struct sockaddr *awrq,
5940 struct airo_info *local = dev->priv;
5943 APListRid APList_rid;
5944 static const u8 any[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
5945 static const u8 off[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
5947 if (awrq->sa_family != ARPHRD_ETHER)
5949 else if (!memcmp(any, awrq->sa_data, ETH_ALEN) ||
5950 !memcmp(off, awrq->sa_data, ETH_ALEN)) {
5951 memset(&cmd, 0, sizeof(cmd));
5952 cmd.cmd=CMD_LOSE_SYNC;
5953 if (down_interruptible(&local->sem))
5954 return -ERESTARTSYS;
5955 issuecommand(local, &cmd, &rsp);
5958 memset(&APList_rid, 0, sizeof(APList_rid));
5959 APList_rid.len = sizeof(APList_rid);
5960 memcpy(APList_rid.ap[0], awrq->sa_data, ETH_ALEN);
5961 disable_MAC(local, 1);
5962 writeAPListRid(local, &APList_rid, 1);
5963 enable_MAC(local, &rsp, 1);
5968 /*------------------------------------------------------------------*/
5970 * Wireless Handler : get AP address
5972 static int airo_get_wap(struct net_device *dev,
5973 struct iw_request_info *info,
5974 struct sockaddr *awrq,
5977 struct airo_info *local = dev->priv;
5978 StatusRid status_rid; /* Card status info */
5980 readStatusRid(local, &status_rid, 1);
5982 /* Tentative. This seems to work, wow, I'm lucky !!! */
5983 memcpy(awrq->sa_data, status_rid.bssid[0], ETH_ALEN);
5984 awrq->sa_family = ARPHRD_ETHER;
5989 /*------------------------------------------------------------------*/
5991 * Wireless Handler : set Nickname
5993 static int airo_set_nick(struct net_device *dev,
5994 struct iw_request_info *info,
5995 struct iw_point *dwrq,
5998 struct airo_info *local = dev->priv;
6000 /* Check the size of the string */
6001 if(dwrq->length > 16 + 1) {
6004 readConfigRid(local, 1);
6005 memset(local->config.nodeName, 0, sizeof(local->config.nodeName));
6006 memcpy(local->config.nodeName, extra, dwrq->length);
6007 set_bit (FLAG_COMMIT, &local->flags);
6009 return -EINPROGRESS; /* Call commit handler */
6012 /*------------------------------------------------------------------*/
6014 * Wireless Handler : get Nickname
6016 static int airo_get_nick(struct net_device *dev,
6017 struct iw_request_info *info,
6018 struct iw_point *dwrq,
6021 struct airo_info *local = dev->priv;
6023 readConfigRid(local, 1);
6024 strncpy(extra, local->config.nodeName, 16);
6026 dwrq->length = strlen(extra) + 1;
6031 /*------------------------------------------------------------------*/
6033 * Wireless Handler : set Bit-Rate
6035 static int airo_set_rate(struct net_device *dev,
6036 struct iw_request_info *info,
6037 struct iw_param *vwrq,
6040 struct airo_info *local = dev->priv;
6041 CapabilityRid cap_rid; /* Card capability info */
6045 /* First : get a valid bit rate value */
6046 readCapabilityRid(local, &cap_rid, 1);
6048 /* Which type of value ? */
6049 if((vwrq->value < 8) && (vwrq->value >= 0)) {
6050 /* Setting by rate index */
6051 /* Find value in the magic rate table */
6052 brate = cap_rid.supportedRates[vwrq->value];
6054 /* Setting by frequency value */
6055 u8 normvalue = (u8) (vwrq->value/500000);
6057 /* Check if rate is valid */
6058 for(i = 0 ; i < 8 ; i++) {
6059 if(normvalue == cap_rid.supportedRates[i]) {
6065 /* -1 designed the max rate (mostly auto mode) */
6066 if(vwrq->value == -1) {
6067 /* Get the highest available rate */
6068 for(i = 0 ; i < 8 ; i++) {
6069 if(cap_rid.supportedRates[i] == 0)
6073 brate = cap_rid.supportedRates[i - 1];
6075 /* Check that it is valid */
6080 readConfigRid(local, 1);
6081 /* Now, check if we want a fixed or auto value */
6082 if(vwrq->fixed == 0) {
6083 /* Fill all the rates up to this max rate */
6084 memset(local->config.rates, 0, 8);
6085 for(i = 0 ; i < 8 ; i++) {
6086 local->config.rates[i] = cap_rid.supportedRates[i];
6087 if(local->config.rates[i] == brate)
6092 /* One rate, fixed */
6093 memset(local->config.rates, 0, 8);
6094 local->config.rates[0] = brate;
6096 set_bit (FLAG_COMMIT, &local->flags);
6098 return -EINPROGRESS; /* Call commit handler */
6101 /*------------------------------------------------------------------*/
6103 * Wireless Handler : get Bit-Rate
6105 static int airo_get_rate(struct net_device *dev,
6106 struct iw_request_info *info,
6107 struct iw_param *vwrq,
6110 struct airo_info *local = dev->priv;
6111 StatusRid status_rid; /* Card status info */
6113 readStatusRid(local, &status_rid, 1);
6115 vwrq->value = status_rid.currentXmitRate * 500000;
6116 /* If more than one rate, set auto */
6117 readConfigRid(local, 1);
6118 vwrq->fixed = (local->config.rates[1] == 0);
6123 /*------------------------------------------------------------------*/
6125 * Wireless Handler : set RTS threshold
6127 static int airo_set_rts(struct net_device *dev,
6128 struct iw_request_info *info,
6129 struct iw_param *vwrq,
6132 struct airo_info *local = dev->priv;
6133 int rthr = vwrq->value;
6136 rthr = AIRO_DEF_MTU;
6137 if((rthr < 0) || (rthr > AIRO_DEF_MTU)) {
6140 readConfigRid(local, 1);
6141 local->config.rtsThres = rthr;
6142 set_bit (FLAG_COMMIT, &local->flags);
6144 return -EINPROGRESS; /* Call commit handler */
6147 /*------------------------------------------------------------------*/
6149 * Wireless Handler : get RTS threshold
6151 static int airo_get_rts(struct net_device *dev,
6152 struct iw_request_info *info,
6153 struct iw_param *vwrq,
6156 struct airo_info *local = dev->priv;
6158 readConfigRid(local, 1);
6159 vwrq->value = local->config.rtsThres;
6160 vwrq->disabled = (vwrq->value >= AIRO_DEF_MTU);
6166 /*------------------------------------------------------------------*/
6168 * Wireless Handler : set Fragmentation threshold
6170 static int airo_set_frag(struct net_device *dev,
6171 struct iw_request_info *info,
6172 struct iw_param *vwrq,
6175 struct airo_info *local = dev->priv;
6176 int fthr = vwrq->value;
6179 fthr = AIRO_DEF_MTU;
6180 if((fthr < 256) || (fthr > AIRO_DEF_MTU)) {
6183 fthr &= ~0x1; /* Get an even value - is it really needed ??? */
6184 readConfigRid(local, 1);
6185 local->config.fragThresh = (u16)fthr;
6186 set_bit (FLAG_COMMIT, &local->flags);
6188 return -EINPROGRESS; /* Call commit handler */
6191 /*------------------------------------------------------------------*/
6193 * Wireless Handler : get Fragmentation threshold
6195 static int airo_get_frag(struct net_device *dev,
6196 struct iw_request_info *info,
6197 struct iw_param *vwrq,
6200 struct airo_info *local = dev->priv;
6202 readConfigRid(local, 1);
6203 vwrq->value = local->config.fragThresh;
6204 vwrq->disabled = (vwrq->value >= AIRO_DEF_MTU);
6210 /*------------------------------------------------------------------*/
6212 * Wireless Handler : set Mode of Operation
6214 static int airo_set_mode(struct net_device *dev,
6215 struct iw_request_info *info,
6219 struct airo_info *local = dev->priv;
6222 readConfigRid(local, 1);
6223 if ((local->config.rmode & 0xff) >= RXMODE_RFMON)
6228 local->config.opmode &= 0xFF00;
6229 local->config.opmode |= MODE_STA_IBSS;
6230 local->config.rmode &= 0xfe00;
6231 local->config.scanMode = SCANMODE_ACTIVE;
6232 clear_bit (FLAG_802_11, &local->flags);
6235 local->config.opmode &= 0xFF00;
6236 local->config.opmode |= MODE_STA_ESS;
6237 local->config.rmode &= 0xfe00;
6238 local->config.scanMode = SCANMODE_ACTIVE;
6239 clear_bit (FLAG_802_11, &local->flags);
6241 case IW_MODE_MASTER:
6242 local->config.opmode &= 0xFF00;
6243 local->config.opmode |= MODE_AP;
6244 local->config.rmode &= 0xfe00;
6245 local->config.scanMode = SCANMODE_ACTIVE;
6246 clear_bit (FLAG_802_11, &local->flags);
6248 case IW_MODE_REPEAT:
6249 local->config.opmode &= 0xFF00;
6250 local->config.opmode |= MODE_AP_RPTR;
6251 local->config.rmode &= 0xfe00;
6252 local->config.scanMode = SCANMODE_ACTIVE;
6253 clear_bit (FLAG_802_11, &local->flags);
6255 case IW_MODE_MONITOR:
6256 local->config.opmode &= 0xFF00;
6257 local->config.opmode |= MODE_STA_ESS;
6258 local->config.rmode &= 0xfe00;
6259 local->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
6260 local->config.scanMode = SCANMODE_PASSIVE;
6261 set_bit (FLAG_802_11, &local->flags);
6267 set_bit (FLAG_RESET, &local->flags);
6268 set_bit (FLAG_COMMIT, &local->flags);
6270 return -EINPROGRESS; /* Call commit handler */
6273 /*------------------------------------------------------------------*/
6275 * Wireless Handler : get Mode of Operation
6277 static int airo_get_mode(struct net_device *dev,
6278 struct iw_request_info *info,
6282 struct airo_info *local = dev->priv;
6284 readConfigRid(local, 1);
6285 /* If not managed, assume it's ad-hoc */
6286 switch (local->config.opmode & 0xFF) {
6288 *uwrq = IW_MODE_INFRA;
6291 *uwrq = IW_MODE_MASTER;
6294 *uwrq = IW_MODE_REPEAT;
6297 *uwrq = IW_MODE_ADHOC;
6303 /*------------------------------------------------------------------*/
6305 * Wireless Handler : set Encryption Key
6307 static int airo_set_encode(struct net_device *dev,
6308 struct iw_request_info *info,
6309 struct iw_point *dwrq,
6312 struct airo_info *local = dev->priv;
6313 CapabilityRid cap_rid; /* Card capability info */
6314 int perm = ( dwrq->flags & IW_ENCODE_TEMP ? 0 : 1 );
6315 u16 currentAuthType = local->config.authType;
6317 /* Is WEP supported ? */
6318 readCapabilityRid(local, &cap_rid, 1);
6319 /* Older firmware doesn't support this...
6320 if(!(cap_rid.softCap & 2)) {
6323 readConfigRid(local, 1);
6325 /* Basic checking: do we have a key to set ?
6326 * Note : with the new API, it's impossible to get a NULL pointer.
6327 * Therefore, we need to check a key size == 0 instead.
6328 * New version of iwconfig properly set the IW_ENCODE_NOKEY flag
6329 * when no key is present (only change flags), but older versions
6330 * don't do it. - Jean II */
6331 if (dwrq->length > 0) {
6333 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6334 int current_index = get_wep_key(local, 0xffff);
6335 /* Check the size of the key */
6336 if (dwrq->length > MAX_KEY_SIZE) {
6339 /* Check the index (none -> use current) */
6340 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4:1)))
6341 index = current_index;
6342 /* Set the length */
6343 if (dwrq->length > MIN_KEY_SIZE)
6344 key.len = MAX_KEY_SIZE;
6346 if (dwrq->length > 0)
6347 key.len = MIN_KEY_SIZE;
6349 /* Disable the key */
6351 /* Check if the key is not marked as invalid */
6352 if(!(dwrq->flags & IW_ENCODE_NOKEY)) {
6354 memset(key.key, 0, MAX_KEY_SIZE);
6355 /* Copy the key in the driver */
6356 memcpy(key.key, extra, dwrq->length);
6357 /* Send the key to the card */
6358 set_wep_key(local, index, key.key, key.len, perm, 1);
6360 /* WE specify that if a valid key is set, encryption
6361 * should be enabled (user may turn it off later)
6362 * This is also how "iwconfig ethX key on" works */
6363 if((index == current_index) && (key.len > 0) &&
6364 (local->config.authType == AUTH_OPEN)) {
6365 local->config.authType = AUTH_ENCRYPT;
6368 /* Do we want to just set the transmit key index ? */
6369 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6370 if ((index >= 0) && (index < ((cap_rid.softCap & 0x80)?4:1))) {
6371 set_wep_key(local, index, NULL, 0, perm, 1);
6373 /* Don't complain if only change the mode */
6374 if(!dwrq->flags & IW_ENCODE_MODE) {
6378 /* Read the flags */
6379 if(dwrq->flags & IW_ENCODE_DISABLED)
6380 local->config.authType = AUTH_OPEN; // disable encryption
6381 if(dwrq->flags & IW_ENCODE_RESTRICTED)
6382 local->config.authType = AUTH_SHAREDKEY; // Only Both
6383 if(dwrq->flags & IW_ENCODE_OPEN)
6384 local->config.authType = AUTH_ENCRYPT; // Only Wep
6385 /* Commit the changes to flags if needed */
6386 if (local->config.authType != currentAuthType)
6387 set_bit (FLAG_COMMIT, &local->flags);
6388 return -EINPROGRESS; /* Call commit handler */
6391 /*------------------------------------------------------------------*/
6393 * Wireless Handler : get Encryption Key
6395 static int airo_get_encode(struct net_device *dev,
6396 struct iw_request_info *info,
6397 struct iw_point *dwrq,
6400 struct airo_info *local = dev->priv;
6401 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6402 CapabilityRid cap_rid; /* Card capability info */
6404 /* Is it supported ? */
6405 readCapabilityRid(local, &cap_rid, 1);
6406 if(!(cap_rid.softCap & 2)) {
6409 readConfigRid(local, 1);
6410 /* Check encryption mode */
6411 switch(local->config.authType) {
6413 dwrq->flags = IW_ENCODE_OPEN;
6415 case AUTH_SHAREDKEY:
6416 dwrq->flags = IW_ENCODE_RESTRICTED;
6420 dwrq->flags = IW_ENCODE_DISABLED;
6423 /* We can't return the key, so set the proper flag and return zero */
6424 dwrq->flags |= IW_ENCODE_NOKEY;
6425 memset(extra, 0, 16);
6427 /* Which key do we want ? -1 -> tx index */
6428 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4 : 1)))
6429 index = get_wep_key(local, 0xffff);
6430 dwrq->flags |= index + 1;
6431 /* Copy the key to the user buffer */
6432 dwrq->length = get_wep_key(local, index);
6433 if (dwrq->length > 16) {
6439 /*------------------------------------------------------------------*/
6441 * Wireless Handler : set extended Encryption parameters
6443 static int airo_set_encodeext(struct net_device *dev,
6444 struct iw_request_info *info,
6445 union iwreq_data *wrqu,
6448 struct airo_info *local = dev->priv;
6449 struct iw_point *encoding = &wrqu->encoding;
6450 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6451 CapabilityRid cap_rid; /* Card capability info */
6452 int perm = ( encoding->flags & IW_ENCODE_TEMP ? 0 : 1 );
6453 u16 currentAuthType = local->config.authType;
6454 int idx, key_len, alg = ext->alg, set_key = 1;
6457 /* Is WEP supported ? */
6458 readCapabilityRid(local, &cap_rid, 1);
6459 /* Older firmware doesn't support this...
6460 if(!(cap_rid.softCap & 2)) {
6463 readConfigRid(local, 1);
6465 /* Determine and validate the key index */
6466 idx = encoding->flags & IW_ENCODE_INDEX;
6468 if (idx < 1 || idx > ((cap_rid.softCap & 0x80) ? 4:1))
6472 idx = get_wep_key(local, 0xffff);
6474 if (encoding->flags & IW_ENCODE_DISABLED)
6475 alg = IW_ENCODE_ALG_NONE;
6477 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
6478 /* Only set transmit key index here, actual
6479 * key is set below if needed.
6481 set_wep_key(local, idx, NULL, 0, perm, 1);
6482 set_key = ext->key_len > 0 ? 1 : 0;
6486 /* Set the requested key first */
6487 memset(key.key, 0, MAX_KEY_SIZE);
6489 case IW_ENCODE_ALG_NONE:
6492 case IW_ENCODE_ALG_WEP:
6493 if (ext->key_len > MIN_KEY_SIZE) {
6494 key.len = MAX_KEY_SIZE;
6495 } else if (ext->key_len > 0) {
6496 key.len = MIN_KEY_SIZE;
6500 key_len = min (ext->key_len, key.len);
6501 memcpy(key.key, ext->key, key_len);
6506 /* Send the key to the card */
6507 set_wep_key(local, idx, key.key, key.len, perm, 1);
6510 /* Read the flags */
6511 if(encoding->flags & IW_ENCODE_DISABLED)
6512 local->config.authType = AUTH_OPEN; // disable encryption
6513 if(encoding->flags & IW_ENCODE_RESTRICTED)
6514 local->config.authType = AUTH_SHAREDKEY; // Only Both
6515 if(encoding->flags & IW_ENCODE_OPEN)
6516 local->config.authType = AUTH_ENCRYPT; // Only Wep
6517 /* Commit the changes to flags if needed */
6518 if (local->config.authType != currentAuthType)
6519 set_bit (FLAG_COMMIT, &local->flags);
6521 return -EINPROGRESS;
6525 /*------------------------------------------------------------------*/
6527 * Wireless Handler : get extended Encryption parameters
6529 static int airo_get_encodeext(struct net_device *dev,
6530 struct iw_request_info *info,
6531 union iwreq_data *wrqu,
6534 struct airo_info *local = dev->priv;
6535 struct iw_point *encoding = &wrqu->encoding;
6536 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6537 CapabilityRid cap_rid; /* Card capability info */
6538 int idx, max_key_len;
6540 /* Is it supported ? */
6541 readCapabilityRid(local, &cap_rid, 1);
6542 if(!(cap_rid.softCap & 2)) {
6545 readConfigRid(local, 1);
6547 max_key_len = encoding->length - sizeof(*ext);
6548 if (max_key_len < 0)
6551 idx = encoding->flags & IW_ENCODE_INDEX;
6553 if (idx < 1 || idx > ((cap_rid.softCap & 0x80) ? 4:1))
6557 idx = get_wep_key(local, 0xffff);
6559 encoding->flags = idx + 1;
6560 memset(ext, 0, sizeof(*ext));
6562 /* Check encryption mode */
6563 switch(local->config.authType) {
6565 encoding->flags = IW_ENCODE_ALG_WEP | IW_ENCODE_ENABLED;
6567 case AUTH_SHAREDKEY:
6568 encoding->flags = IW_ENCODE_ALG_WEP | IW_ENCODE_ENABLED;
6572 encoding->flags = IW_ENCODE_ALG_NONE | IW_ENCODE_DISABLED;
6575 /* We can't return the key, so set the proper flag and return zero */
6576 encoding->flags |= IW_ENCODE_NOKEY;
6577 memset(extra, 0, 16);
6579 /* Copy the key to the user buffer */
6580 ext->key_len = get_wep_key(local, idx);
6581 if (ext->key_len > 16) {
6589 /*------------------------------------------------------------------*/
6591 * Wireless Handler : set extended authentication parameters
6593 static int airo_set_auth(struct net_device *dev,
6594 struct iw_request_info *info,
6595 union iwreq_data *wrqu, char *extra)
6597 struct airo_info *local = dev->priv;
6598 struct iw_param *param = &wrqu->param;
6599 u16 currentAuthType = local->config.authType;
6601 switch (param->flags & IW_AUTH_INDEX) {
6602 case IW_AUTH_WPA_VERSION:
6603 case IW_AUTH_CIPHER_PAIRWISE:
6604 case IW_AUTH_CIPHER_GROUP:
6605 case IW_AUTH_KEY_MGMT:
6606 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6607 case IW_AUTH_PRIVACY_INVOKED:
6609 * airo does not use these parameters
6613 case IW_AUTH_DROP_UNENCRYPTED:
6615 /* Only change auth type if unencrypted */
6616 if (currentAuthType == AUTH_OPEN)
6617 local->config.authType = AUTH_ENCRYPT;
6619 local->config.authType = AUTH_OPEN;
6622 /* Commit the changes to flags if needed */
6623 if (local->config.authType != currentAuthType)
6624 set_bit (FLAG_COMMIT, &local->flags);
6627 case IW_AUTH_80211_AUTH_ALG: {
6628 /* FIXME: What about AUTH_OPEN? This API seems to
6629 * disallow setting our auth to AUTH_OPEN.
6631 if (param->value & IW_AUTH_ALG_SHARED_KEY) {
6632 local->config.authType = AUTH_SHAREDKEY;
6633 } else if (param->value & IW_AUTH_ALG_OPEN_SYSTEM) {
6634 local->config.authType = AUTH_ENCRYPT;
6639 /* Commit the changes to flags if needed */
6640 if (local->config.authType != currentAuthType)
6641 set_bit (FLAG_COMMIT, &local->flags);
6644 case IW_AUTH_WPA_ENABLED:
6645 /* Silently accept disable of WPA */
6646 if (param->value > 0)
6653 return -EINPROGRESS;
6657 /*------------------------------------------------------------------*/
6659 * Wireless Handler : get extended authentication parameters
6661 static int airo_get_auth(struct net_device *dev,
6662 struct iw_request_info *info,
6663 union iwreq_data *wrqu, char *extra)
6665 struct airo_info *local = dev->priv;
6666 struct iw_param *param = &wrqu->param;
6667 u16 currentAuthType = local->config.authType;
6669 switch (param->flags & IW_AUTH_INDEX) {
6670 case IW_AUTH_DROP_UNENCRYPTED:
6671 switch (currentAuthType) {
6672 case AUTH_SHAREDKEY:
6682 case IW_AUTH_80211_AUTH_ALG:
6683 switch (currentAuthType) {
6684 case AUTH_SHAREDKEY:
6685 param->value = IW_AUTH_ALG_SHARED_KEY;
6689 param->value = IW_AUTH_ALG_OPEN_SYSTEM;
6694 case IW_AUTH_WPA_ENABLED:
6705 /*------------------------------------------------------------------*/
6707 * Wireless Handler : set Tx-Power
6709 static int airo_set_txpow(struct net_device *dev,
6710 struct iw_request_info *info,
6711 struct iw_param *vwrq,
6714 struct airo_info *local = dev->priv;
6715 CapabilityRid cap_rid; /* Card capability info */
6719 readCapabilityRid(local, &cap_rid, 1);
6721 if (vwrq->disabled) {
6722 set_bit (FLAG_RADIO_OFF, &local->flags);
6723 set_bit (FLAG_COMMIT, &local->flags);
6724 return -EINPROGRESS; /* Call commit handler */
6726 if (vwrq->flags != IW_TXPOW_MWATT) {
6729 clear_bit (FLAG_RADIO_OFF, &local->flags);
6730 for (i = 0; cap_rid.txPowerLevels[i] && (i < 8); i++)
6731 if ((vwrq->value==cap_rid.txPowerLevels[i])) {
6732 readConfigRid(local, 1);
6733 local->config.txPower = vwrq->value;
6734 set_bit (FLAG_COMMIT, &local->flags);
6735 rc = -EINPROGRESS; /* Call commit handler */
6741 /*------------------------------------------------------------------*/
6743 * Wireless Handler : get Tx-Power
6745 static int airo_get_txpow(struct net_device *dev,
6746 struct iw_request_info *info,
6747 struct iw_param *vwrq,
6750 struct airo_info *local = dev->priv;
6752 readConfigRid(local, 1);
6753 vwrq->value = local->config.txPower;
6754 vwrq->fixed = 1; /* No power control */
6755 vwrq->disabled = test_bit(FLAG_RADIO_OFF, &local->flags);
6756 vwrq->flags = IW_TXPOW_MWATT;
6761 /*------------------------------------------------------------------*/
6763 * Wireless Handler : set Retry limits
6765 static int airo_set_retry(struct net_device *dev,
6766 struct iw_request_info *info,
6767 struct iw_param *vwrq,
6770 struct airo_info *local = dev->priv;
6773 if(vwrq->disabled) {
6776 readConfigRid(local, 1);
6777 if(vwrq->flags & IW_RETRY_LIMIT) {
6778 if(vwrq->flags & IW_RETRY_MAX)
6779 local->config.longRetryLimit = vwrq->value;
6780 else if (vwrq->flags & IW_RETRY_MIN)
6781 local->config.shortRetryLimit = vwrq->value;
6783 /* No modifier : set both */
6784 local->config.longRetryLimit = vwrq->value;
6785 local->config.shortRetryLimit = vwrq->value;
6787 set_bit (FLAG_COMMIT, &local->flags);
6788 rc = -EINPROGRESS; /* Call commit handler */
6790 if(vwrq->flags & IW_RETRY_LIFETIME) {
6791 local->config.txLifetime = vwrq->value / 1024;
6792 set_bit (FLAG_COMMIT, &local->flags);
6793 rc = -EINPROGRESS; /* Call commit handler */
6798 /*------------------------------------------------------------------*/
6800 * Wireless Handler : get Retry limits
6802 static int airo_get_retry(struct net_device *dev,
6803 struct iw_request_info *info,
6804 struct iw_param *vwrq,
6807 struct airo_info *local = dev->priv;
6809 vwrq->disabled = 0; /* Can't be disabled */
6811 readConfigRid(local, 1);
6812 /* Note : by default, display the min retry number */
6813 if((vwrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
6814 vwrq->flags = IW_RETRY_LIFETIME;
6815 vwrq->value = (int)local->config.txLifetime * 1024;
6816 } else if((vwrq->flags & IW_RETRY_MAX)) {
6817 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
6818 vwrq->value = (int)local->config.longRetryLimit;
6820 vwrq->flags = IW_RETRY_LIMIT;
6821 vwrq->value = (int)local->config.shortRetryLimit;
6822 if((int)local->config.shortRetryLimit != (int)local->config.longRetryLimit)
6823 vwrq->flags |= IW_RETRY_MIN;
6829 /*------------------------------------------------------------------*/
6831 * Wireless Handler : get range info
6833 static int airo_get_range(struct net_device *dev,
6834 struct iw_request_info *info,
6835 struct iw_point *dwrq,
6838 struct airo_info *local = dev->priv;
6839 struct iw_range *range = (struct iw_range *) extra;
6840 CapabilityRid cap_rid; /* Card capability info */
6844 readCapabilityRid(local, &cap_rid, 1);
6846 dwrq->length = sizeof(struct iw_range);
6847 memset(range, 0, sizeof(*range));
6848 range->min_nwid = 0x0000;
6849 range->max_nwid = 0x0000;
6850 range->num_channels = 14;
6851 /* Should be based on cap_rid.country to give only
6852 * what the current card support */
6854 for(i = 0; i < 14; i++) {
6855 range->freq[k].i = i + 1; /* List index */
6856 range->freq[k].m = frequency_list[i] * 100000;
6857 range->freq[k++].e = 1; /* Values in table in MHz -> * 10^5 * 10 */
6859 range->num_frequency = k;
6861 range->sensitivity = 65535;
6863 /* Hum... Should put the right values there */
6865 range->max_qual.qual = 100; /* % */
6867 range->max_qual.qual = airo_get_max_quality(&cap_rid);
6868 range->max_qual.level = 0x100 - 120; /* -120 dBm */
6869 range->max_qual.noise = 0x100 - 120; /* -120 dBm */
6871 /* Experimental measurements - boundary 11/5.5 Mb/s */
6872 /* Note : with or without the (local->rssi), results
6873 * are somewhat different. - Jean II */
6875 range->avg_qual.qual = 50; /* % */
6876 range->avg_qual.level = 0x100 - 70; /* -70 dBm */
6878 range->avg_qual.qual = airo_get_avg_quality(&cap_rid);
6879 range->avg_qual.level = 0x100 - 80; /* -80 dBm */
6881 range->avg_qual.noise = 0x100 - 85; /* -85 dBm */
6883 for(i = 0 ; i < 8 ; i++) {
6884 range->bitrate[i] = cap_rid.supportedRates[i] * 500000;
6885 if(range->bitrate[i] == 0)
6888 range->num_bitrates = i;
6890 /* Set an indication of the max TCP throughput
6891 * in bit/s that we can expect using this interface.
6892 * May be use for QoS stuff... Jean II */
6894 range->throughput = 5000 * 1000;
6896 range->throughput = 1500 * 1000;
6899 range->max_rts = AIRO_DEF_MTU;
6900 range->min_frag = 256;
6901 range->max_frag = AIRO_DEF_MTU;
6903 if(cap_rid.softCap & 2) {
6905 range->encoding_size[0] = 5;
6907 if (cap_rid.softCap & 0x100) {
6908 range->encoding_size[1] = 13;
6909 range->num_encoding_sizes = 2;
6911 range->num_encoding_sizes = 1;
6912 range->max_encoding_tokens = (cap_rid.softCap & 0x80) ? 4 : 1;
6914 range->num_encoding_sizes = 0;
6915 range->max_encoding_tokens = 0;
6918 range->max_pmp = 5000000; /* 5 secs */
6920 range->max_pmt = 65535 * 1024; /* ??? */
6921 range->pmp_flags = IW_POWER_PERIOD;
6922 range->pmt_flags = IW_POWER_TIMEOUT;
6923 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
6925 /* Transmit Power - values are in mW */
6926 for(i = 0 ; i < 8 ; i++) {
6927 range->txpower[i] = cap_rid.txPowerLevels[i];
6928 if(range->txpower[i] == 0)
6931 range->num_txpower = i;
6932 range->txpower_capa = IW_TXPOW_MWATT;
6933 range->we_version_source = 19;
6934 range->we_version_compiled = WIRELESS_EXT;
6935 range->retry_capa = IW_RETRY_LIMIT | IW_RETRY_LIFETIME;
6936 range->retry_flags = IW_RETRY_LIMIT;
6937 range->r_time_flags = IW_RETRY_LIFETIME;
6938 range->min_retry = 1;
6939 range->max_retry = 65535;
6940 range->min_r_time = 1024;
6941 range->max_r_time = 65535 * 1024;
6943 /* Event capability (kernel + driver) */
6944 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
6945 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
6946 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
6947 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
6948 range->event_capa[1] = IW_EVENT_CAPA_K_1;
6949 range->event_capa[4] = IW_EVENT_CAPA_MASK(IWEVTXDROP);
6953 /*------------------------------------------------------------------*/
6955 * Wireless Handler : set Power Management
6957 static int airo_set_power(struct net_device *dev,
6958 struct iw_request_info *info,
6959 struct iw_param *vwrq,
6962 struct airo_info *local = dev->priv;
6964 readConfigRid(local, 1);
6965 if (vwrq->disabled) {
6966 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6969 local->config.powerSaveMode = POWERSAVE_CAM;
6970 local->config.rmode &= 0xFF00;
6971 local->config.rmode |= RXMODE_BC_MC_ADDR;
6972 set_bit (FLAG_COMMIT, &local->flags);
6973 return -EINPROGRESS; /* Call commit handler */
6975 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
6976 local->config.fastListenDelay = (vwrq->value + 500) / 1024;
6977 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6978 set_bit (FLAG_COMMIT, &local->flags);
6979 } else if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
6980 local->config.fastListenInterval = local->config.listenInterval = (vwrq->value + 500) / 1024;
6981 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6982 set_bit (FLAG_COMMIT, &local->flags);
6984 switch (vwrq->flags & IW_POWER_MODE) {
6985 case IW_POWER_UNICAST_R:
6986 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6989 local->config.rmode &= 0xFF00;
6990 local->config.rmode |= RXMODE_ADDR;
6991 set_bit (FLAG_COMMIT, &local->flags);
6993 case IW_POWER_ALL_R:
6994 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6997 local->config.rmode &= 0xFF00;
6998 local->config.rmode |= RXMODE_BC_MC_ADDR;
6999 set_bit (FLAG_COMMIT, &local->flags);
7005 // Note : we may want to factor local->need_commit here
7006 // Note2 : may also want to factor RXMODE_RFMON test
7007 return -EINPROGRESS; /* Call commit handler */
7010 /*------------------------------------------------------------------*/
7012 * Wireless Handler : get Power Management
7014 static int airo_get_power(struct net_device *dev,
7015 struct iw_request_info *info,
7016 struct iw_param *vwrq,
7019 struct airo_info *local = dev->priv;
7022 readConfigRid(local, 1);
7023 mode = local->config.powerSaveMode;
7024 if ((vwrq->disabled = (mode == POWERSAVE_CAM)))
7026 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
7027 vwrq->value = (int)local->config.fastListenDelay * 1024;
7028 vwrq->flags = IW_POWER_TIMEOUT;
7030 vwrq->value = (int)local->config.fastListenInterval * 1024;
7031 vwrq->flags = IW_POWER_PERIOD;
7033 if ((local->config.rmode & 0xFF) == RXMODE_ADDR)
7034 vwrq->flags |= IW_POWER_UNICAST_R;
7036 vwrq->flags |= IW_POWER_ALL_R;
7041 /*------------------------------------------------------------------*/
7043 * Wireless Handler : set Sensitivity
7045 static int airo_set_sens(struct net_device *dev,
7046 struct iw_request_info *info,
7047 struct iw_param *vwrq,
7050 struct airo_info *local = dev->priv;
7052 readConfigRid(local, 1);
7053 local->config.rssiThreshold = vwrq->disabled ? RSSI_DEFAULT : vwrq->value;
7054 set_bit (FLAG_COMMIT, &local->flags);
7056 return -EINPROGRESS; /* Call commit handler */
7059 /*------------------------------------------------------------------*/
7061 * Wireless Handler : get Sensitivity
7063 static int airo_get_sens(struct net_device *dev,
7064 struct iw_request_info *info,
7065 struct iw_param *vwrq,
7068 struct airo_info *local = dev->priv;
7070 readConfigRid(local, 1);
7071 vwrq->value = local->config.rssiThreshold;
7072 vwrq->disabled = (vwrq->value == 0);
7078 /*------------------------------------------------------------------*/
7080 * Wireless Handler : get AP List
7081 * Note : this is deprecated in favor of IWSCAN
7083 static int airo_get_aplist(struct net_device *dev,
7084 struct iw_request_info *info,
7085 struct iw_point *dwrq,
7088 struct airo_info *local = dev->priv;
7089 struct sockaddr *address = (struct sockaddr *) extra;
7090 struct iw_quality qual[IW_MAX_AP];
7093 int loseSync = capable(CAP_NET_ADMIN) ? 1: -1;
7095 for (i = 0; i < IW_MAX_AP; i++) {
7096 if (readBSSListRid(local, loseSync, &BSSList))
7099 memcpy(address[i].sa_data, BSSList.bssid, ETH_ALEN);
7100 address[i].sa_family = ARPHRD_ETHER;
7102 qual[i].level = 0x100 - BSSList.dBm;
7103 qual[i].qual = airo_dbm_to_pct( local->rssi, BSSList.dBm );
7104 qual[i].updated = IW_QUAL_QUAL_UPDATED
7105 | IW_QUAL_LEVEL_UPDATED
7108 qual[i].level = (BSSList.dBm + 321) / 2;
7110 qual[i].updated = IW_QUAL_QUAL_INVALID
7111 | IW_QUAL_LEVEL_UPDATED
7114 qual[i].noise = local->wstats.qual.noise;
7115 if (BSSList.index == 0xffff)
7119 StatusRid status_rid; /* Card status info */
7120 readStatusRid(local, &status_rid, 1);
7122 i < min(IW_MAX_AP, 4) &&
7123 (status_rid.bssid[i][0]
7124 & status_rid.bssid[i][1]
7125 & status_rid.bssid[i][2]
7126 & status_rid.bssid[i][3]
7127 & status_rid.bssid[i][4]
7128 & status_rid.bssid[i][5])!=0xff &&
7129 (status_rid.bssid[i][0]
7130 | status_rid.bssid[i][1]
7131 | status_rid.bssid[i][2]
7132 | status_rid.bssid[i][3]
7133 | status_rid.bssid[i][4]
7134 | status_rid.bssid[i][5]);
7136 memcpy(address[i].sa_data,
7137 status_rid.bssid[i], ETH_ALEN);
7138 address[i].sa_family = ARPHRD_ETHER;
7141 dwrq->flags = 1; /* Should be define'd */
7142 memcpy(extra + sizeof(struct sockaddr)*i,
7143 &qual, sizeof(struct iw_quality)*i);
7150 /*------------------------------------------------------------------*/
7152 * Wireless Handler : Initiate Scan
7154 static int airo_set_scan(struct net_device *dev,
7155 struct iw_request_info *info,
7156 struct iw_param *vwrq,
7159 struct airo_info *ai = dev->priv;
7164 /* Note : you may have realised that, as this is a SET operation,
7165 * this is privileged and therefore a normal user can't
7167 * This is not an error, while the device perform scanning,
7168 * traffic doesn't flow, so it's a perfect DoS...
7170 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
7172 if (down_interruptible(&ai->sem))
7173 return -ERESTARTSYS;
7175 /* If there's already a scan in progress, don't
7176 * trigger another one. */
7177 if (ai->scan_timeout > 0)
7180 /* Initiate a scan command */
7181 ai->scan_timeout = RUN_AT(3*HZ);
7182 memset(&cmd, 0, sizeof(cmd));
7183 cmd.cmd=CMD_LISTBSS;
7184 issuecommand(ai, &cmd, &rsp);
7190 wake_up_interruptible(&ai->thr_wait);
7194 /*------------------------------------------------------------------*/
7196 * Translate scan data returned from the card to a card independent
7197 * format that the Wireless Tools will understand - Jean II
7199 static inline char *airo_translate_scan(struct net_device *dev,
7204 struct airo_info *ai = dev->priv;
7205 struct iw_event iwe; /* Temporary buffer */
7207 char * current_val; /* For rates */
7211 /* First entry *MUST* be the AP MAC address */
7212 iwe.cmd = SIOCGIWAP;
7213 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
7214 memcpy(iwe.u.ap_addr.sa_data, bss->bssid, ETH_ALEN);
7215 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_ADDR_LEN);
7217 /* Other entries will be displayed in the order we give them */
7220 iwe.u.data.length = bss->ssidLen;
7221 if(iwe.u.data.length > 32)
7222 iwe.u.data.length = 32;
7223 iwe.cmd = SIOCGIWESSID;
7224 iwe.u.data.flags = 1;
7225 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, bss->ssid);
7228 iwe.cmd = SIOCGIWMODE;
7229 capabilities = le16_to_cpu(bss->cap);
7230 if(capabilities & (CAP_ESS | CAP_IBSS)) {
7231 if(capabilities & CAP_ESS)
7232 iwe.u.mode = IW_MODE_MASTER;
7234 iwe.u.mode = IW_MODE_ADHOC;
7235 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_UINT_LEN);
7239 iwe.cmd = SIOCGIWFREQ;
7240 iwe.u.freq.m = le16_to_cpu(bss->dsChannel);
7241 /* iwe.u.freq.m containt the channel (starting 1), our
7242 * frequency_list array start at index 0...
7244 iwe.u.freq.m = frequency_list[iwe.u.freq.m - 1] * 100000;
7246 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_FREQ_LEN);
7248 /* Add quality statistics */
7251 iwe.u.qual.level = 0x100 - bss->dBm;
7252 iwe.u.qual.qual = airo_dbm_to_pct( ai->rssi, bss->dBm );
7253 iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED
7254 | IW_QUAL_LEVEL_UPDATED
7257 iwe.u.qual.level = (bss->dBm + 321) / 2;
7258 iwe.u.qual.qual = 0;
7259 iwe.u.qual.updated = IW_QUAL_QUAL_INVALID
7260 | IW_QUAL_LEVEL_UPDATED
7263 iwe.u.qual.noise = ai->wstats.qual.noise;
7264 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
7266 /* Add encryption capability */
7267 iwe.cmd = SIOCGIWENCODE;
7268 if(capabilities & CAP_PRIVACY)
7269 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
7271 iwe.u.data.flags = IW_ENCODE_DISABLED;
7272 iwe.u.data.length = 0;
7273 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, bss->ssid);
7275 /* Rate : stuffing multiple values in a single event require a bit
7276 * more of magic - Jean II */
7277 current_val = current_ev + IW_EV_LCP_LEN;
7279 iwe.cmd = SIOCGIWRATE;
7280 /* Those two flags are ignored... */
7281 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
7283 for(i = 0 ; i < 8 ; i++) {
7284 /* NULL terminated */
7285 if(bss->rates[i] == 0)
7287 /* Bit rate given in 500 kb/s units (+ 0x80) */
7288 iwe.u.bitrate.value = ((bss->rates[i] & 0x7f) * 500000);
7289 /* Add new value to event */
7290 current_val = iwe_stream_add_value(current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
7292 /* Check if we added any event */
7293 if((current_val - current_ev) > IW_EV_LCP_LEN)
7294 current_ev = current_val;
7296 /* Beacon interval */
7297 buf = kmalloc(30, GFP_KERNEL);
7299 iwe.cmd = IWEVCUSTOM;
7300 sprintf(buf, "bcn_int=%d", bss->beaconInterval);
7301 iwe.u.data.length = strlen(buf);
7302 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, buf);
7306 /* Put WPA/RSN Information Elements into the event stream */
7307 if (test_bit(FLAG_WPA_CAPABLE, &ai->flags)) {
7308 unsigned int num_null_ies = 0;
7309 u16 length = sizeof (bss->extra.iep);
7310 struct ieee80211_info_element *info_element =
7311 (struct ieee80211_info_element *) &bss->extra.iep;
7313 while ((length >= sizeof(*info_element)) && (num_null_ies < 2)) {
7314 if (sizeof(*info_element) + info_element->len > length) {
7315 /* Invalid element, don't continue parsing IE */
7319 switch (info_element->id) {
7320 case MFIE_TYPE_SSID:
7321 /* Two zero-length SSID elements
7322 * mean we're done parsing elements */
7323 if (!info_element->len)
7327 case MFIE_TYPE_GENERIC:
7328 if (info_element->len >= 4 &&
7329 info_element->data[0] == 0x00 &&
7330 info_element->data[1] == 0x50 &&
7331 info_element->data[2] == 0xf2 &&
7332 info_element->data[3] == 0x01) {
7333 iwe.cmd = IWEVGENIE;
7334 iwe.u.data.length = min(info_element->len + 2,
7336 current_ev = iwe_stream_add_point(current_ev, end_buf,
7337 &iwe, (char *) info_element);
7342 iwe.cmd = IWEVGENIE;
7343 iwe.u.data.length = min(info_element->len + 2,
7345 current_ev = iwe_stream_add_point(current_ev, end_buf,
7346 &iwe, (char *) info_element);
7353 length -= sizeof(*info_element) + info_element->len;
7355 (struct ieee80211_info_element *)&info_element->
7356 data[info_element->len];
7362 /*------------------------------------------------------------------*/
7364 * Wireless Handler : Read Scan Results
7366 static int airo_get_scan(struct net_device *dev,
7367 struct iw_request_info *info,
7368 struct iw_point *dwrq,
7371 struct airo_info *ai = dev->priv;
7372 BSSListElement *net;
7374 char *current_ev = extra;
7376 /* If a scan is in-progress, return -EAGAIN */
7377 if (ai->scan_timeout > 0)
7380 if (down_interruptible(&ai->sem))
7383 list_for_each_entry (net, &ai->network_list, list) {
7384 /* Translate to WE format this entry */
7385 current_ev = airo_translate_scan(dev, current_ev,
7386 extra + dwrq->length,
7389 /* Check if there is space for one more entry */
7390 if((extra + dwrq->length - current_ev) <= IW_EV_ADDR_LEN) {
7391 /* Ask user space to try again with a bigger buffer */
7397 /* Length of data */
7398 dwrq->length = (current_ev - extra);
7399 dwrq->flags = 0; /* todo */
7406 /*------------------------------------------------------------------*/
7408 * Commit handler : called after a bunch of SET operations
7410 static int airo_config_commit(struct net_device *dev,
7411 struct iw_request_info *info, /* NULL */
7412 void *zwrq, /* NULL */
7413 char *extra) /* NULL */
7415 struct airo_info *local = dev->priv;
7418 if (!test_bit (FLAG_COMMIT, &local->flags))
7421 /* Some of the "SET" function may have modified some of the
7422 * parameters. It's now time to commit them in the card */
7423 disable_MAC(local, 1);
7424 if (test_bit (FLAG_RESET, &local->flags)) {
7425 APListRid APList_rid;
7428 readAPListRid(local, &APList_rid);
7429 readSsidRid(local, &SSID_rid);
7430 if (test_bit(FLAG_MPI,&local->flags))
7431 setup_card(local, dev->dev_addr, 1 );
7433 reset_airo_card(dev);
7434 disable_MAC(local, 1);
7435 writeSsidRid(local, &SSID_rid, 1);
7436 writeAPListRid(local, &APList_rid, 1);
7438 if (down_interruptible(&local->sem))
7439 return -ERESTARTSYS;
7440 writeConfigRid(local, 0);
7441 enable_MAC(local, &rsp, 0);
7442 if (test_bit (FLAG_RESET, &local->flags))
7443 airo_set_promisc(local);
7450 /*------------------------------------------------------------------*/
7452 * Structures to export the Wireless Handlers
7455 static const struct iw_priv_args airo_private_args[] = {
7456 /*{ cmd, set_args, get_args, name } */
7457 { AIROIOCTL, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
7458 IW_PRIV_TYPE_BYTE | 2047, "airoioctl" },
7459 { AIROIDIFC, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
7460 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "airoidifc" },
7463 static const iw_handler airo_handler[] =
7465 (iw_handler) airo_config_commit, /* SIOCSIWCOMMIT */
7466 (iw_handler) airo_get_name, /* SIOCGIWNAME */
7467 (iw_handler) NULL, /* SIOCSIWNWID */
7468 (iw_handler) NULL, /* SIOCGIWNWID */
7469 (iw_handler) airo_set_freq, /* SIOCSIWFREQ */
7470 (iw_handler) airo_get_freq, /* SIOCGIWFREQ */
7471 (iw_handler) airo_set_mode, /* SIOCSIWMODE */
7472 (iw_handler) airo_get_mode, /* SIOCGIWMODE */
7473 (iw_handler) airo_set_sens, /* SIOCSIWSENS */
7474 (iw_handler) airo_get_sens, /* SIOCGIWSENS */
7475 (iw_handler) NULL, /* SIOCSIWRANGE */
7476 (iw_handler) airo_get_range, /* SIOCGIWRANGE */
7477 (iw_handler) NULL, /* SIOCSIWPRIV */
7478 (iw_handler) NULL, /* SIOCGIWPRIV */
7479 (iw_handler) NULL, /* SIOCSIWSTATS */
7480 (iw_handler) NULL, /* SIOCGIWSTATS */
7481 iw_handler_set_spy, /* SIOCSIWSPY */
7482 iw_handler_get_spy, /* SIOCGIWSPY */
7483 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
7484 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
7485 (iw_handler) airo_set_wap, /* SIOCSIWAP */
7486 (iw_handler) airo_get_wap, /* SIOCGIWAP */
7487 (iw_handler) NULL, /* -- hole -- */
7488 (iw_handler) airo_get_aplist, /* SIOCGIWAPLIST */
7489 (iw_handler) airo_set_scan, /* SIOCSIWSCAN */
7490 (iw_handler) airo_get_scan, /* SIOCGIWSCAN */
7491 (iw_handler) airo_set_essid, /* SIOCSIWESSID */
7492 (iw_handler) airo_get_essid, /* SIOCGIWESSID */
7493 (iw_handler) airo_set_nick, /* SIOCSIWNICKN */
7494 (iw_handler) airo_get_nick, /* SIOCGIWNICKN */
7495 (iw_handler) NULL, /* -- hole -- */
7496 (iw_handler) NULL, /* -- hole -- */
7497 (iw_handler) airo_set_rate, /* SIOCSIWRATE */
7498 (iw_handler) airo_get_rate, /* SIOCGIWRATE */
7499 (iw_handler) airo_set_rts, /* SIOCSIWRTS */
7500 (iw_handler) airo_get_rts, /* SIOCGIWRTS */
7501 (iw_handler) airo_set_frag, /* SIOCSIWFRAG */
7502 (iw_handler) airo_get_frag, /* SIOCGIWFRAG */
7503 (iw_handler) airo_set_txpow, /* SIOCSIWTXPOW */
7504 (iw_handler) airo_get_txpow, /* SIOCGIWTXPOW */
7505 (iw_handler) airo_set_retry, /* SIOCSIWRETRY */
7506 (iw_handler) airo_get_retry, /* SIOCGIWRETRY */
7507 (iw_handler) airo_set_encode, /* SIOCSIWENCODE */
7508 (iw_handler) airo_get_encode, /* SIOCGIWENCODE */
7509 (iw_handler) airo_set_power, /* SIOCSIWPOWER */
7510 (iw_handler) airo_get_power, /* SIOCGIWPOWER */
7511 (iw_handler) NULL, /* -- hole -- */
7512 (iw_handler) NULL, /* -- hole -- */
7513 (iw_handler) NULL, /* SIOCSIWGENIE */
7514 (iw_handler) NULL, /* SIOCGIWGENIE */
7515 (iw_handler) airo_set_auth, /* SIOCSIWAUTH */
7516 (iw_handler) airo_get_auth, /* SIOCGIWAUTH */
7517 (iw_handler) airo_set_encodeext, /* SIOCSIWENCODEEXT */
7518 (iw_handler) airo_get_encodeext, /* SIOCGIWENCODEEXT */
7519 (iw_handler) NULL, /* SIOCSIWPMKSA */
7522 /* Note : don't describe AIROIDIFC and AIROOLDIDIFC in here.
7523 * We want to force the use of the ioctl code, because those can't be
7524 * won't work the iw_handler code (because they simultaneously read
7525 * and write data and iw_handler can't do that).
7526 * Note that it's perfectly legal to read/write on a single ioctl command,
7527 * you just can't use iwpriv and need to force it via the ioctl handler.
7529 static const iw_handler airo_private_handler[] =
7531 NULL, /* SIOCIWFIRSTPRIV */
7534 static const struct iw_handler_def airo_handler_def =
7536 .num_standard = sizeof(airo_handler)/sizeof(iw_handler),
7537 .num_private = sizeof(airo_private_handler)/sizeof(iw_handler),
7538 .num_private_args = sizeof(airo_private_args)/sizeof(struct iw_priv_args),
7539 .standard = airo_handler,
7540 .private = airo_private_handler,
7541 .private_args = airo_private_args,
7542 .get_wireless_stats = airo_get_wireless_stats,
7546 * This defines the configuration part of the Wireless Extensions
7547 * Note : irq and spinlock protection will occur in the subroutines
7550 * o Check input value more carefully and fill correct values in range
7551 * o Test and shakeout the bugs (if any)
7555 * Javier Achirica did a great job of merging code from the unnamed CISCO
7556 * developer that added support for flashing the card.
7558 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
7561 struct airo_info *ai = (struct airo_info *)dev->priv;
7563 if (ai->power.event)
7573 int val = AIROMAGIC;
7575 if (copy_from_user(&com,rq->ifr_data,sizeof(com)))
7577 else if (copy_to_user(com.data,(char *)&val,sizeof(val)))
7586 /* Get the command struct and hand it off for evaluation by
7587 * the proper subfunction
7591 if (copy_from_user(&com,rq->ifr_data,sizeof(com))) {
7596 /* Separate R/W functions bracket legality here
7598 if ( com.command == AIRORSWVERSION ) {
7599 if (copy_to_user(com.data, swversion, sizeof(swversion)))
7604 else if ( com.command <= AIRORRID)
7605 rc = readrids(dev,&com);
7606 else if ( com.command >= AIROPCAP && com.command <= (AIROPLEAPUSR+2) )
7607 rc = writerids(dev,&com);
7608 else if ( com.command >= AIROFLSHRST && com.command <= AIRORESTART )
7609 rc = flashcard(dev,&com);
7611 rc = -EINVAL; /* Bad command in ioctl */
7614 #endif /* CISCO_EXT */
7616 // All other calls are currently unsupported
7624 * Get the Wireless stats out of the driver
7625 * Note : irq and spinlock protection will occur in the subroutines
7628 * o Check if work in Ad-Hoc mode (otherwise, use SPY, as in wvlan_cs)
7632 static void airo_read_wireless_stats(struct airo_info *local)
7634 StatusRid status_rid;
7636 CapabilityRid cap_rid;
7637 u32 *vals = stats_rid.vals;
7639 /* Get stats out of the card */
7640 clear_bit(JOB_WSTATS, &local->jobs);
7641 if (local->power.event) {
7645 readCapabilityRid(local, &cap_rid, 0);
7646 readStatusRid(local, &status_rid, 0);
7647 readStatsRid(local, &stats_rid, RID_STATS, 0);
7651 local->wstats.status = status_rid.mode;
7653 /* Signal quality and co */
7655 local->wstats.qual.level = airo_rssi_to_dbm( local->rssi, status_rid.sigQuality );
7656 /* normalizedSignalStrength appears to be a percentage */
7657 local->wstats.qual.qual = status_rid.normalizedSignalStrength;
7659 local->wstats.qual.level = (status_rid.normalizedSignalStrength + 321) / 2;
7660 local->wstats.qual.qual = airo_get_quality(&status_rid, &cap_rid);
7662 if (status_rid.len >= 124) {
7663 local->wstats.qual.noise = 0x100 - status_rid.noisedBm;
7664 local->wstats.qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
7666 local->wstats.qual.noise = 0;
7667 local->wstats.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_INVALID | IW_QUAL_DBM;
7670 /* Packets discarded in the wireless adapter due to wireless
7671 * specific problems */
7672 local->wstats.discard.nwid = vals[56] + vals[57] + vals[58];/* SSID Mismatch */
7673 local->wstats.discard.code = vals[6];/* RxWepErr */
7674 local->wstats.discard.fragment = vals[30];
7675 local->wstats.discard.retries = vals[10];
7676 local->wstats.discard.misc = vals[1] + vals[32];
7677 local->wstats.miss.beacon = vals[34];
7680 static struct iw_statistics *airo_get_wireless_stats(struct net_device *dev)
7682 struct airo_info *local = dev->priv;
7684 if (!test_bit(JOB_WSTATS, &local->jobs)) {
7685 /* Get stats out of the card if available */
7686 if (down_trylock(&local->sem) != 0) {
7687 set_bit(JOB_WSTATS, &local->jobs);
7688 wake_up_interruptible(&local->thr_wait);
7690 airo_read_wireless_stats(local);
7693 return &local->wstats;
7698 * This just translates from driver IOCTL codes to the command codes to
7699 * feed to the radio's host interface. Things can be added/deleted
7700 * as needed. This represents the READ side of control I/O to
7703 static int readrids(struct net_device *dev, aironet_ioctl *comp) {
7704 unsigned short ridcode;
7705 unsigned char *iobuf;
7707 struct airo_info *ai = dev->priv;
7710 if (test_bit(FLAG_FLASHING, &ai->flags))
7713 switch(comp->command)
7715 case AIROGCAP: ridcode = RID_CAPABILITIES; break;
7716 case AIROGCFG: ridcode = RID_CONFIG;
7717 if (test_bit(FLAG_COMMIT, &ai->flags)) {
7718 disable_MAC (ai, 1);
7719 writeConfigRid (ai, 1);
7720 enable_MAC (ai, &rsp, 1);
7723 case AIROGSLIST: ridcode = RID_SSID; break;
7724 case AIROGVLIST: ridcode = RID_APLIST; break;
7725 case AIROGDRVNAM: ridcode = RID_DRVNAME; break;
7726 case AIROGEHTENC: ridcode = RID_ETHERENCAP; break;
7727 case AIROGWEPKTMP: ridcode = RID_WEP_TEMP;
7728 /* Only super-user can read WEP keys */
7729 if (!capable(CAP_NET_ADMIN))
7732 case AIROGWEPKNV: ridcode = RID_WEP_PERM;
7733 /* Only super-user can read WEP keys */
7734 if (!capable(CAP_NET_ADMIN))
7737 case AIROGSTAT: ridcode = RID_STATUS; break;
7738 case AIROGSTATSD32: ridcode = RID_STATSDELTA; break;
7739 case AIROGSTATSC32: ridcode = RID_STATS; break;
7741 if (copy_to_user(comp->data, &ai->micstats,
7742 min((int)comp->len,(int)sizeof(ai->micstats))))
7745 case AIRORRID: ridcode = comp->ridnum; break;
7751 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7754 PC4500_readrid(ai,ridcode,iobuf,RIDSIZE, 1);
7755 /* get the count of bytes in the rid docs say 1st 2 bytes is it.
7756 * then return it to the user
7757 * 9/22/2000 Honor user given length
7761 if (copy_to_user(comp->data, iobuf, min(len, (int)RIDSIZE))) {
7770 * Danger Will Robinson write the rids here
7773 static int writerids(struct net_device *dev, aironet_ioctl *comp) {
7774 struct airo_info *ai = dev->priv;
7778 static int (* writer)(struct airo_info *, u16 rid, const void *, int, int);
7779 unsigned char *iobuf;
7781 /* Only super-user can write RIDs */
7782 if (!capable(CAP_NET_ADMIN))
7785 if (test_bit(FLAG_FLASHING, &ai->flags))
7789 writer = do_writerid;
7791 switch(comp->command)
7793 case AIROPSIDS: ridcode = RID_SSID; break;
7794 case AIROPCAP: ridcode = RID_CAPABILITIES; break;
7795 case AIROPAPLIST: ridcode = RID_APLIST; break;
7796 case AIROPCFG: ai->config.len = 0;
7797 clear_bit(FLAG_COMMIT, &ai->flags);
7798 ridcode = RID_CONFIG; break;
7799 case AIROPWEPKEYNV: ridcode = RID_WEP_PERM; break;
7800 case AIROPLEAPUSR: ridcode = RID_LEAPUSERNAME; break;
7801 case AIROPLEAPPWD: ridcode = RID_LEAPPASSWORD; break;
7802 case AIROPWEPKEY: ridcode = RID_WEP_TEMP; writer = PC4500_writerid;
7804 case AIROPLEAPUSR+1: ridcode = 0xFF2A; break;
7805 case AIROPLEAPUSR+2: ridcode = 0xFF2B; break;
7807 /* this is not really a rid but a command given to the card
7811 if (enable_MAC(ai, &rsp, 1) != 0)
7816 * Evidently this code in the airo driver does not get a symbol
7817 * as disable_MAC. it's probably so short the compiler does not gen one.
7823 /* This command merely clears the counts does not actually store any data
7824 * only reads rid. But as it changes the cards state, I put it in the
7825 * writerid routines.
7828 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7831 PC4500_readrid(ai,RID_STATSDELTACLEAR,iobuf,RIDSIZE, 1);
7833 enabled = ai->micstats.enabled;
7834 memset(&ai->micstats,0,sizeof(ai->micstats));
7835 ai->micstats.enabled = enabled;
7837 if (copy_to_user(comp->data, iobuf,
7838 min((int)comp->len, (int)RIDSIZE))) {
7846 return -EOPNOTSUPP; /* Blarg! */
7848 if(comp->len > RIDSIZE)
7851 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7854 if (copy_from_user(iobuf,comp->data,comp->len)) {
7859 if (comp->command == AIROPCFG) {
7860 ConfigRid *cfg = (ConfigRid *)iobuf;
7862 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags))
7863 cfg->opmode |= MODE_MIC;
7865 if ((cfg->opmode & 0xFF) == MODE_STA_IBSS)
7866 set_bit (FLAG_ADHOC, &ai->flags);
7868 clear_bit (FLAG_ADHOC, &ai->flags);
7871 if((*writer)(ai, ridcode, iobuf,comp->len,1)) {
7879 /*****************************************************************************
7880 * Ancillary flash / mod functions much black magic lurkes here *
7881 *****************************************************************************
7885 * Flash command switch table
7888 static int flashcard(struct net_device *dev, aironet_ioctl *comp) {
7891 /* Only super-user can modify flash */
7892 if (!capable(CAP_NET_ADMIN))
7895 switch(comp->command)
7898 return cmdreset((struct airo_info *)dev->priv);
7901 if (!((struct airo_info *)dev->priv)->flash &&
7902 (((struct airo_info *)dev->priv)->flash = kmalloc (FLASHSIZE, GFP_KERNEL)) == NULL)
7904 return setflashmode((struct airo_info *)dev->priv);
7906 case AIROFLSHGCHR: /* Get char from aux */
7907 if(comp->len != sizeof(int))
7909 if (copy_from_user(&z,comp->data,comp->len))
7911 return flashgchar((struct airo_info *)dev->priv,z,8000);
7913 case AIROFLSHPCHR: /* Send char to card. */
7914 if(comp->len != sizeof(int))
7916 if (copy_from_user(&z,comp->data,comp->len))
7918 return flashpchar((struct airo_info *)dev->priv,z,8000);
7920 case AIROFLPUTBUF: /* Send 32k to card */
7921 if (!((struct airo_info *)dev->priv)->flash)
7923 if(comp->len > FLASHSIZE)
7925 if(copy_from_user(((struct airo_info *)dev->priv)->flash,comp->data,comp->len))
7928 flashputbuf((struct airo_info *)dev->priv);
7932 if(flashrestart((struct airo_info *)dev->priv,dev))
7939 #define FLASH_COMMAND 0x7e7e
7943 * Disable MAC and do soft reset on
7947 static int cmdreset(struct airo_info *ai) {
7951 airo_print_info(ai->dev->name, "Waitbusy hang before RESET");
7955 OUT4500(ai,COMMAND,CMD_SOFTRESET);
7957 ssleep(1); /* WAS 600 12/7/00 */
7960 airo_print_info(ai->dev->name, "Waitbusy hang AFTER RESET");
7967 * Put the card in legendary flash
7971 static int setflashmode (struct airo_info *ai) {
7972 set_bit (FLAG_FLASHING, &ai->flags);
7974 OUT4500(ai, SWS0, FLASH_COMMAND);
7975 OUT4500(ai, SWS1, FLASH_COMMAND);
7977 OUT4500(ai, SWS0, FLASH_COMMAND);
7978 OUT4500(ai, COMMAND,0x10);
7980 OUT4500(ai, SWS2, FLASH_COMMAND);
7981 OUT4500(ai, SWS3, FLASH_COMMAND);
7982 OUT4500(ai, COMMAND,0);
7984 msleep(500); /* 500ms delay */
7987 clear_bit (FLAG_FLASHING, &ai->flags);
7988 airo_print_info(ai->dev->name, "Waitbusy hang after setflash mode");
7994 /* Put character to SWS0 wait for dwelltime
7998 static int flashpchar(struct airo_info *ai,int byte,int dwelltime) {
8009 /* Wait for busy bit d15 to go false indicating buffer empty */
8010 while ((IN4500 (ai, SWS0) & 0x8000) && waittime > 0) {
8015 /* timeout for busy clear wait */
8017 airo_print_info(ai->dev->name, "flash putchar busywait timeout!");
8021 /* Port is clear now write byte and wait for it to echo back */
8023 OUT4500(ai,SWS0,byte);
8026 echo = IN4500(ai,SWS1);
8027 } while (dwelltime >= 0 && echo != byte);
8031 return (echo == byte) ? 0 : -EIO;
8035 * Get a character from the card matching matchbyte
8038 static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime){
8040 unsigned char rbyte=0;
8043 rchar = IN4500(ai,SWS1);
8045 if(dwelltime && !(0x8000 & rchar)){
8050 rbyte = 0xff & rchar;
8052 if( (rbyte == matchbyte) && (0x8000 & rchar) ){
8056 if( rbyte == 0x81 || rbyte == 0x82 || rbyte == 0x83 || rbyte == 0x1a || 0xffff == rchar)
8060 }while(dwelltime > 0);
8065 * Transfer 32k of firmware data from user buffer to our buffer and
8069 static int flashputbuf(struct airo_info *ai){
8073 if (test_bit(FLAG_MPI,&ai->flags))
8074 memcpy_toio(ai->pciaux + 0x8000, ai->flash, FLASHSIZE);
8076 OUT4500(ai,AUXPAGE,0x100);
8077 OUT4500(ai,AUXOFF,0);
8079 for(nwords=0;nwords != FLASHSIZE / 2;nwords++){
8080 OUT4500(ai,AUXDATA,ai->flash[nwords] & 0xffff);
8083 OUT4500(ai,SWS0,0x8000);
8091 static int flashrestart(struct airo_info *ai,struct net_device *dev){
8094 ssleep(1); /* Added 12/7/00 */
8095 clear_bit (FLAG_FLASHING, &ai->flags);
8096 if (test_bit(FLAG_MPI, &ai->flags)) {
8097 status = mpi_init_descriptors(ai);
8098 if (status != SUCCESS)
8101 status = setup_card(ai, dev->dev_addr, 1);
8103 if (!test_bit(FLAG_MPI,&ai->flags))
8104 for( i = 0; i < MAX_FIDS; i++ ) {
8105 ai->fids[i] = transmit_allocate
8106 ( ai, AIRO_DEF_MTU, i >= MAX_FIDS / 2 );
8109 ssleep(1); /* Added 12/7/00 */
8112 #endif /* CISCO_EXT */
8115 This program is free software; you can redistribute it and/or
8116 modify it under the terms of the GNU General Public License
8117 as published by the Free Software Foundation; either version 2
8118 of the License, or (at your option) any later version.
8120 This program is distributed in the hope that it will be useful,
8121 but WITHOUT ANY WARRANTY; without even the implied warranty of
8122 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
8123 GNU General Public License for more details.
8127 Redistribution and use in source and binary forms, with or without
8128 modification, are permitted provided that the following conditions
8131 1. Redistributions of source code must retain the above copyright
8132 notice, this list of conditions and the following disclaimer.
8133 2. Redistributions in binary form must reproduce the above copyright
8134 notice, this list of conditions and the following disclaimer in the
8135 documentation and/or other materials provided with the distribution.
8136 3. The name of the author may not be used to endorse or promote
8137 products derived from this software without specific prior written
8140 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
8141 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
8142 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
8143 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
8144 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
8145 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
8146 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
8147 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
8148 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
8149 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
8150 POSSIBILITY OF SUCH DAMAGE.
8153 module_init(airo_init_module);
8154 module_exit(airo_cleanup_module);
git://git.onelab.eu / linux-2.6.git / blob