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/config.h>
23 #include <linux/init.h>
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/proc_fs.h>
28 #include <linux/smp_lock.h>
30 #include <linux/sched.h>
31 #include <linux/ptrace.h>
32 #include <linux/slab.h>
33 #include <linux/string.h>
34 #include <linux/timer.h>
35 #include <linux/interrupt.h>
37 #include <linux/bitops.h>
39 #include <asm/system.h>
41 #include <linux/netdevice.h>
42 #include <linux/etherdevice.h>
43 #include <linux/skbuff.h>
44 #include <linux/if_arp.h>
45 #include <linux/ioport.h>
46 #include <linux/pci.h>
47 #include <asm/uaccess.h>
50 static struct pci_device_id card_ids[] = {
51 { 0x14b9, 1, PCI_ANY_ID, PCI_ANY_ID, },
52 { 0x14b9, 0x4500, PCI_ANY_ID, PCI_ANY_ID },
53 { 0x14b9, 0x4800, PCI_ANY_ID, PCI_ANY_ID, },
54 { 0x14b9, 0x0340, PCI_ANY_ID, PCI_ANY_ID, },
55 { 0x14b9, 0x0350, PCI_ANY_ID, PCI_ANY_ID, },
56 { 0x14b9, 0x5000, PCI_ANY_ID, PCI_ANY_ID, },
57 { 0x14b9, 0xa504, PCI_ANY_ID, PCI_ANY_ID, },
60 MODULE_DEVICE_TABLE(pci, card_ids);
62 static int airo_pci_probe(struct pci_dev *, const struct pci_device_id *);
63 static void airo_pci_remove(struct pci_dev *);
64 static int airo_pci_suspend(struct pci_dev *pdev, u32 state);
65 static int airo_pci_resume(struct pci_dev *pdev);
67 static struct pci_driver airo_driver = {
70 .probe = airo_pci_probe,
71 .remove = __devexit_p(airo_pci_remove),
72 .suspend = airo_pci_suspend,
73 .resume = airo_pci_resume,
75 #endif /* CONFIG_PCI */
77 /* Include Wireless Extension definition and check version - Jean II */
78 #include <linux/wireless.h>
79 #define WIRELESS_SPY // enable iwspy support
80 #include <net/iw_handler.h> // New driver API
82 #define CISCO_EXT // enable Cisco extensions
84 #include <linux/delay.h>
87 /* Support Cisco MIC feature */
90 #if defined(MICSUPPORT) && !defined(CONFIG_CRYPTO)
91 #warning MIC support requires Crypto API
95 /* Hack to do some power saving */
98 /* As you can see this list is HUGH!
99 I really don't know what a lot of these counts are about, but they
100 are all here for completeness. If the IGNLABEL macro is put in
101 infront of the label, that statistic will not be included in the list
102 of statistics in the /proc filesystem */
104 #define IGNLABEL(comment) NULL
105 static char *statsLabels[] = {
107 IGNLABEL("RxPlcpCrcErr"),
108 IGNLABEL("RxPlcpFormatErr"),
109 IGNLABEL("RxPlcpLengthErr"),
140 "LostSync-MissedBeacons",
141 "LostSync-ArlExceeded",
143 "LostSync-Disassoced",
144 "LostSync-TsfTiming",
153 IGNLABEL("HmacTxMc"),
154 IGNLABEL("HmacTxBc"),
155 IGNLABEL("HmacTxUc"),
156 IGNLABEL("HmacTxFail"),
157 IGNLABEL("HmacRxMc"),
158 IGNLABEL("HmacRxBc"),
159 IGNLABEL("HmacRxUc"),
160 IGNLABEL("HmacRxDiscard"),
161 IGNLABEL("HmacRxAccepted"),
169 IGNLABEL("ReasonOutsideTable"),
170 IGNLABEL("ReasonStatus1"),
171 IGNLABEL("ReasonStatus2"),
172 IGNLABEL("ReasonStatus3"),
173 IGNLABEL("ReasonStatus4"),
174 IGNLABEL("ReasonStatus5"),
175 IGNLABEL("ReasonStatus6"),
176 IGNLABEL("ReasonStatus7"),
177 IGNLABEL("ReasonStatus8"),
178 IGNLABEL("ReasonStatus9"),
179 IGNLABEL("ReasonStatus10"),
180 IGNLABEL("ReasonStatus11"),
181 IGNLABEL("ReasonStatus12"),
182 IGNLABEL("ReasonStatus13"),
183 IGNLABEL("ReasonStatus14"),
184 IGNLABEL("ReasonStatus15"),
185 IGNLABEL("ReasonStatus16"),
186 IGNLABEL("ReasonStatus17"),
187 IGNLABEL("ReasonStatus18"),
188 IGNLABEL("ReasonStatus19"),
208 #define RUN_AT(x) (jiffies+(x))
212 /* These variables are for insmod, since it seems that the rates
213 can only be set in setup_card. Rates should be a comma separated
214 (no spaces) list of rates (up to 8). */
217 static int basic_rate;
218 static char *ssids[3];
224 int maxencrypt /* = 0 */; /* The highest rate that the card can encrypt at.
225 0 means no limit. For old cards this was 4 */
227 static int auto_wep /* = 0 */; /* If set, it tries to figure out the wep mode */
228 static int aux_bap /* = 0 */; /* Checks to see if the aux ports are needed to read
229 the bap, needed on some older cards and buses. */
232 static int probe = 1;
234 static int proc_uid /* = 0 */;
236 static int proc_gid /* = 0 */;
238 static int airo_perm = 0555;
240 static int proc_perm = 0644;
242 MODULE_AUTHOR("Benjamin Reed");
243 MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet \
244 cards. Direct support for ISA/PCI/MPI cards and support \
245 for PCMCIA when used with airo_cs.");
246 MODULE_LICENSE("Dual BSD/GPL");
247 MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340/350");
248 module_param_array(io, int, NULL, 0);
249 module_param_array(irq, int, NULL, 0);
250 module_param(basic_rate, int, 0);
251 module_param_array(rates, int, NULL, 0);
252 module_param_array(ssids, charp, NULL, 0);
253 module_param(auto_wep, int, 0);
254 MODULE_PARM_DESC(auto_wep, "If non-zero, the driver will keep looping through \
255 the authentication options until an association is made. The value of \
256 auto_wep is number of the wep keys to check. A value of 2 will try using \
257 the key at index 0 and index 1.");
258 module_param(aux_bap, int, 0);
259 MODULE_PARM_DESC(aux_bap, "If non-zero, the driver will switch into a mode \
260 than seems to work better for older cards with some older buses. Before \
261 switching it checks that the switch is needed.");
262 module_param(maxencrypt, int, 0);
263 MODULE_PARM_DESC(maxencrypt, "The maximum speed that the card can do \
264 encryption. Units are in 512kbs. Zero (default) means there is no limit. \
265 Older cards used to be limited to 2mbs (4).");
266 module_param(adhoc, int, 0);
267 MODULE_PARM_DESC(adhoc, "If non-zero, the card will start in adhoc mode.");
268 module_param(probe, int, 0);
269 MODULE_PARM_DESC(probe, "If zero, the driver won't start the card.");
271 module_param(proc_uid, int, 0);
272 MODULE_PARM_DESC(proc_uid, "The uid that the /proc files will belong to.");
273 module_param(proc_gid, int, 0);
274 MODULE_PARM_DESC(proc_gid, "The gid that the /proc files will belong to.");
275 module_param(airo_perm, int, 0);
276 MODULE_PARM_DESC(airo_perm, "The permission bits of /proc/[driver/]aironet.");
277 module_param(proc_perm, int, 0);
278 MODULE_PARM_DESC(proc_perm, "The permission bits of the files in /proc");
280 /* This is a kind of sloppy hack to get this information to OUT4500 and
281 IN4500. I would be extremely interested in the situation where this
282 doesn't work though!!! */
283 static int do8bitIO = 0;
292 #define MAC_ENABLE 0x0001
293 #define MAC_DISABLE 0x0002
294 #define CMD_LOSE_SYNC 0x0003 /* Not sure what this does... */
295 #define CMD_SOFTRESET 0x0004
296 #define HOSTSLEEP 0x0005
297 #define CMD_MAGIC_PKT 0x0006
298 #define CMD_SETWAKEMASK 0x0007
299 #define CMD_READCFG 0x0008
300 #define CMD_SETMODE 0x0009
301 #define CMD_ALLOCATETX 0x000a
302 #define CMD_TRANSMIT 0x000b
303 #define CMD_DEALLOCATETX 0x000c
305 #define CMD_WORKAROUND 0x0011
306 #define CMD_ALLOCATEAUX 0x0020
307 #define CMD_ACCESS 0x0021
308 #define CMD_PCIBAP 0x0022
309 #define CMD_PCIAUX 0x0023
310 #define CMD_ALLOCBUF 0x0028
311 #define CMD_GETTLV 0x0029
312 #define CMD_PUTTLV 0x002a
313 #define CMD_DELTLV 0x002b
314 #define CMD_FINDNEXTTLV 0x002c
315 #define CMD_PSPNODES 0x0030
316 #define CMD_SETCW 0x0031
317 #define CMD_SETPCF 0x0032
318 #define CMD_SETPHYREG 0x003e
319 #define CMD_TXTEST 0x003f
320 #define MAC_ENABLETX 0x0101
321 #define CMD_LISTBSS 0x0103
322 #define CMD_SAVECFG 0x0108
323 #define CMD_ENABLEAUX 0x0111
324 #define CMD_WRITERID 0x0121
325 #define CMD_USEPSPNODES 0x0130
326 #define MAC_ENABLERX 0x0201
329 #define ERROR_QUALIF 0x00
330 #define ERROR_ILLCMD 0x01
331 #define ERROR_ILLFMT 0x02
332 #define ERROR_INVFID 0x03
333 #define ERROR_INVRID 0x04
334 #define ERROR_LARGE 0x05
335 #define ERROR_NDISABL 0x06
336 #define ERROR_ALLOCBSY 0x07
337 #define ERROR_NORD 0x0B
338 #define ERROR_NOWR 0x0C
339 #define ERROR_INVFIDTX 0x0D
340 #define ERROR_TESTACT 0x0E
341 #define ERROR_TAGNFND 0x12
342 #define ERROR_DECODE 0x20
343 #define ERROR_DESCUNAV 0x21
344 #define ERROR_BADLEN 0x22
345 #define ERROR_MODE 0x80
346 #define ERROR_HOP 0x81
347 #define ERROR_BINTER 0x82
348 #define ERROR_RXMODE 0x83
349 #define ERROR_MACADDR 0x84
350 #define ERROR_RATES 0x85
351 #define ERROR_ORDER 0x86
352 #define ERROR_SCAN 0x87
353 #define ERROR_AUTH 0x88
354 #define ERROR_PSMODE 0x89
355 #define ERROR_RTYPE 0x8A
356 #define ERROR_DIVER 0x8B
357 #define ERROR_SSID 0x8C
358 #define ERROR_APLIST 0x8D
359 #define ERROR_AUTOWAKE 0x8E
360 #define ERROR_LEAP 0x8F
371 #define LINKSTAT 0x10
375 #define TXALLOCFID 0x22
376 #define TXCOMPLFID 0x24
391 /* Offset into aux memory for descriptors */
392 #define AUX_OFFSET 0x800
393 /* Size of allocated packets */
396 /* Size of the transmit queue */
400 #define BAP0 0 // Used for receiving packets
401 #define BAP1 2 // Used for xmiting packets and working with RIDS
404 #define COMMAND_BUSY 0x8000
406 #define BAP_BUSY 0x8000
407 #define BAP_ERR 0x4000
408 #define BAP_DONE 0x2000
410 #define PROMISC 0xffff
411 #define NOPROMISC 0x0000
414 #define EV_CLEARCOMMANDBUSY 0x4000
417 #define EV_TXEXC 0x04
418 #define EV_ALLOC 0x08
420 #define EV_AWAKE 0x100
421 #define EV_TXCPY 0x400
422 #define EV_UNKNOWN 0x800
423 #define EV_MIC 0x1000 /* Message Integrity Check Interrupt */
424 #define EV_AWAKEN 0x2000
425 #define STATUS_INTS (EV_AWAKE|EV_LINK|EV_TXEXC|EV_TX|EV_TXCPY|EV_RX|EV_MIC)
427 #ifdef CHECK_UNKNOWN_INTS
428 #define IGNORE_INTS ( EV_CMD | EV_UNKNOWN)
430 #define IGNORE_INTS (~STATUS_INTS)
437 #define RID_CAPABILITIES 0xFF00
438 #define RID_APINFO 0xFF01
439 #define RID_RADIOINFO 0xFF02
440 #define RID_UNKNOWN3 0xFF03
441 #define RID_RSSI 0xFF04
442 #define RID_CONFIG 0xFF10
443 #define RID_SSID 0xFF11
444 #define RID_APLIST 0xFF12
445 #define RID_DRVNAME 0xFF13
446 #define RID_ETHERENCAP 0xFF14
447 #define RID_WEP_TEMP 0xFF15
448 #define RID_WEP_PERM 0xFF16
449 #define RID_MODULATION 0xFF17
450 #define RID_OPTIONS 0xFF18
451 #define RID_ACTUALCONFIG 0xFF20 /*readonly*/
452 #define RID_FACTORYCONFIG 0xFF21
453 #define RID_UNKNOWN22 0xFF22
454 #define RID_LEAPUSERNAME 0xFF23
455 #define RID_LEAPPASSWORD 0xFF24
456 #define RID_STATUS 0xFF50
457 #define RID_BEACON_HST 0xFF51
458 #define RID_BUSY_HST 0xFF52
459 #define RID_RETRIES_HST 0xFF53
460 #define RID_UNKNOWN54 0xFF54
461 #define RID_UNKNOWN55 0xFF55
462 #define RID_UNKNOWN56 0xFF56
463 #define RID_MIC 0xFF57
464 #define RID_STATS16 0xFF60
465 #define RID_STATS16DELTA 0xFF61
466 #define RID_STATS16DELTACLEAR 0xFF62
467 #define RID_STATS 0xFF68
468 #define RID_STATSDELTA 0xFF69
469 #define RID_STATSDELTACLEAR 0xFF6A
470 #define RID_ECHOTEST_RID 0xFF70
471 #define RID_ECHOTEST_RESULTS 0xFF71
472 #define RID_BSSLISTFIRST 0xFF72
473 #define RID_BSSLISTNEXT 0xFF73
490 * Rids and endian-ness: The Rids will always be in cpu endian, since
491 * this all the patches from the big-endian guys end up doing that.
492 * so all rid access should use the read/writeXXXRid routines.
495 /* This is redundant for x86 archs, but it seems necessary for ARM */
498 /* This structure came from an email sent to me from an engineer at
499 aironet for inclusion into this driver */
508 /* These structures are from the Aironet's PC4500 Developers Manual */
522 #define MOD_DEFAULT 0
528 u16 len; /* sizeof(ConfigRid) */
529 u16 opmode; /* operating mode */
530 #define MODE_STA_IBSS 0
531 #define MODE_STA_ESS 1
533 #define MODE_AP_RPTR 3
534 #define MODE_ETHERNET_HOST (0<<8) /* rx payloads converted */
535 #define MODE_LLC_HOST (1<<8) /* rx payloads left as is */
536 #define MODE_AIRONET_EXTEND (1<<9) /* enable Aironet extenstions */
537 #define MODE_AP_INTERFACE (1<<10) /* enable ap interface extensions */
538 #define MODE_ANTENNA_ALIGN (1<<11) /* enable antenna alignment */
539 #define MODE_ETHER_LLC (1<<12) /* enable ethernet LLC */
540 #define MODE_LEAF_NODE (1<<13) /* enable leaf node bridge */
541 #define MODE_CF_POLLABLE (1<<14) /* enable CF pollable */
542 #define MODE_MIC (1<<15) /* enable MIC */
543 u16 rmode; /* receive mode */
544 #define RXMODE_BC_MC_ADDR 0
545 #define RXMODE_BC_ADDR 1 /* ignore multicasts */
546 #define RXMODE_ADDR 2 /* ignore multicast and broadcast */
547 #define RXMODE_RFMON 3 /* wireless monitor mode */
548 #define RXMODE_RFMON_ANYBSS 4
549 #define RXMODE_LANMON 5 /* lan style monitor -- data packets only */
550 #define RXMODE_DISABLE_802_3_HEADER (1<<8) /* disables 802.3 header on rx */
551 #define RXMODE_NORMALIZED_RSSI (1<<9) /* return normalized RSSI */
554 u8 macAddr[ETH_ALEN];
558 u16 txLifetime; /* in kusec */
559 u16 rxLifetime; /* in kusec */
562 u16 u16deviceType; /* for overriding device type */
566 /*---------- Scanning/Associating ----------*/
568 #define SCANMODE_ACTIVE 0
569 #define SCANMODE_PASSIVE 1
570 #define SCANMODE_AIROSCAN 2
571 u16 probeDelay; /* in kusec */
572 u16 probeEnergyTimeout; /* in kusec */
573 u16 probeResponseTimeout;
574 u16 beaconListenTimeout;
578 #define AUTH_OPEN 0x1
579 #define AUTH_ENCRYPT 0x101
580 #define AUTH_SHAREDKEY 0x102
581 #define AUTH_ALLOW_UNENCRYPTED 0x200
582 u16 associationTimeout;
583 u16 specifiedApTimeout;
584 u16 offlineScanInterval;
585 u16 offlineScanDuration;
587 u16 maxBeaconLostTime;
589 #define DISABLE_REFRESH 0xFFFF
591 /*---------- Power save operation ----------*/
593 #define POWERSAVE_CAM 0
594 #define POWERSAVE_PSP 1
595 #define POWERSAVE_PSPCAM 2
598 u16 fastListenInterval;
602 /*---------- Ap/Ibss config items ----------*/
611 /*---------- Radio configuration ----------*/
613 #define RADIOTYPE_DEFAULT 0
614 #define RADIOTYPE_802_11 1
615 #define RADIOTYPE_LEGACY 2
619 #define TXPOWER_DEFAULT 0
621 #define RSSI_DEFAULT 0
623 #define PREAMBLE_AUTO 0
624 #define PREAMBLE_LONG 1
625 #define PREAMBLE_SHORT 2
629 /*---------- Aironet Extensions ----------*/
635 /*---------- Aironet Extensions ----------*/
637 #define MAGIC_ACTION_STSCHG 1
638 #define MAGIC_ACTION_RESUME 2
639 #define MAGIC_IGNORE_MCAST (1<<8)
640 #define MAGIC_IGNORE_BCAST (1<<9)
641 #define MAGIC_SWITCH_TO_PSP (0<<10)
642 #define MAGIC_STAY_IN_CAM (1<<10)
656 u8 bssid[4][ETH_ALEN];
670 u16 normalizedSignalStrength;
673 u8 noisePercent; /* Noise percent in last second */
674 u8 noisedBm; /* Noise dBm in last second */
675 u8 noiseAvePercent; /* Noise percent in last minute */
676 u8 noiseAvedBm; /* Noise dBm in last minute */
677 u8 noiseMaxPercent; /* Highest noise percent in last minute */
678 u8 noiseMaxdBm; /* Highest noise dbm in last minute */
682 #define STAT_NOPACKETS 0
683 #define STAT_NOCARRIERSET 10
684 #define STAT_GOTCARRIERSET 11
685 #define STAT_WRONGSSID 20
686 #define STAT_BADCHANNEL 25
687 #define STAT_BADBITRATES 30
688 #define STAT_BADPRIVACY 35
689 #define STAT_APFOUND 40
690 #define STAT_APREJECTED 50
691 #define STAT_AUTHENTICATING 60
692 #define STAT_DEAUTHENTICATED 61
693 #define STAT_AUTHTIMEOUT 62
694 #define STAT_ASSOCIATING 70
695 #define STAT_DEASSOCIATED 71
696 #define STAT_ASSOCTIMEOUT 72
697 #define STAT_NOTAIROAP 73
698 #define STAT_ASSOCIATED 80
699 #define STAT_LEAPING 90
700 #define STAT_LEAPFAILED 91
701 #define STAT_LEAPTIMEDOUT 92
702 #define STAT_LEAPCOMPLETE 93
725 char factoryAddr[ETH_ALEN];
726 char aironetAddr[ETH_ALEN];
729 char callid[ETH_ALEN];
730 char supportedRates[8];
733 u16 txPowerLevels[8];
748 u16 index; /* First is 0 and 0xffff means end of list */
749 #define RADIO_FH 1 /* Frequency hopping radio type */
750 #define RADIO_DS 2 /* Direct sequence radio type */
751 #define RADIO_TMA 4 /* Proprietary radio used in old cards (2500) */
753 u8 bssid[ETH_ALEN]; /* Mac address of the BSS */
758 #define CAP_ESS (1<<0)
759 #define CAP_IBSS (1<<1)
760 #define CAP_PRIVACY (1<<4)
761 #define CAP_SHORTHDR (1<<5)
764 u8 rates[8]; /* Same as rates for config rid */
765 struct { /* For frequency hopping only */
819 #define TXCTL_TXOK (1<<1) /* report if tx is ok */
820 #define TXCTL_TXEX (1<<2) /* report if tx fails */
821 #define TXCTL_802_3 (0<<3) /* 802.3 packet */
822 #define TXCTL_802_11 (1<<3) /* 802.11 mac packet */
823 #define TXCTL_ETHERNET (0<<4) /* payload has ethertype */
824 #define TXCTL_LLC (1<<4) /* payload is llc */
825 #define TXCTL_RELEASE (0<<5) /* release after completion */
826 #define TXCTL_NORELEASE (1<<5) /* on completion returns to host */
828 #define BUSY_FID 0x10000
831 #define AIROMAGIC 0xa55a
832 /* Warning : SIOCDEVPRIVATE may disapear during 2.5.X - Jean II */
833 #ifdef SIOCIWFIRSTPRIV
834 #ifdef SIOCDEVPRIVATE
835 #define AIROOLDIOCTL SIOCDEVPRIVATE
836 #define AIROOLDIDIFC AIROOLDIOCTL + 1
837 #endif /* SIOCDEVPRIVATE */
838 #else /* SIOCIWFIRSTPRIV */
839 #define SIOCIWFIRSTPRIV SIOCDEVPRIVATE
840 #endif /* SIOCIWFIRSTPRIV */
841 /* This may be wrong. When using the new SIOCIWFIRSTPRIV range, we probably
842 * should use only "GET" ioctls (last bit set to 1). "SET" ioctls are root
843 * only and don't return the modified struct ifreq to the application which
844 * is usually a problem. - Jean II */
845 #define AIROIOCTL SIOCIWFIRSTPRIV
846 #define AIROIDIFC AIROIOCTL + 1
848 /* Ioctl constants to be used in airo_ioctl.command */
850 #define AIROGCAP 0 // Capability rid
851 #define AIROGCFG 1 // USED A LOT
852 #define AIROGSLIST 2 // System ID list
853 #define AIROGVLIST 3 // List of specified AP's
854 #define AIROGDRVNAM 4 // NOTUSED
855 #define AIROGEHTENC 5 // NOTUSED
856 #define AIROGWEPKTMP 6
857 #define AIROGWEPKNV 7
859 #define AIROGSTATSC32 9
860 #define AIROGSTATSD32 10
861 #define AIROGMICRID 11
862 #define AIROGMICSTATS 12
863 #define AIROGFLAGS 13
866 #define AIRORSWVERSION 17
868 /* Leave gap of 40 commands after AIROGSTATSD32 for future */
870 #define AIROPCAP AIROGSTATSD32 + 40
871 #define AIROPVLIST AIROPCAP + 1
872 #define AIROPSLIST AIROPVLIST + 1
873 #define AIROPCFG AIROPSLIST + 1
874 #define AIROPSIDS AIROPCFG + 1
875 #define AIROPAPLIST AIROPSIDS + 1
876 #define AIROPMACON AIROPAPLIST + 1 /* Enable mac */
877 #define AIROPMACOFF AIROPMACON + 1 /* Disable mac */
878 #define AIROPSTCLR AIROPMACOFF + 1
879 #define AIROPWEPKEY AIROPSTCLR + 1
880 #define AIROPWEPKEYNV AIROPWEPKEY + 1
881 #define AIROPLEAPPWD AIROPWEPKEYNV + 1
882 #define AIROPLEAPUSR AIROPLEAPPWD + 1
886 #define AIROFLSHRST AIROPWEPKEYNV + 40
887 #define AIROFLSHGCHR AIROFLSHRST + 1
888 #define AIROFLSHSTFL AIROFLSHGCHR + 1
889 #define AIROFLSHPCHR AIROFLSHSTFL + 1
890 #define AIROFLPUTBUF AIROFLSHPCHR + 1
891 #define AIRORESTART AIROFLPUTBUF + 1
893 #define FLASHSIZE 32768
894 #define AUXMEMSIZE (256 * 1024)
896 typedef struct aironet_ioctl {
897 unsigned short command; // What to do
898 unsigned short len; // Len of data
899 unsigned short ridnum; // rid number
900 unsigned char __user *data; // d-data
903 static char *swversion = "2.1";
904 #endif /* CISCO_EXT */
906 #define NUM_MODULES 2
907 #define MIC_MSGLEN_MAX 2400
908 #define EMMH32_MSGLEN_MAX MIC_MSGLEN_MAX
912 u8 enabled; // MIC enabled or not
913 u32 rxSuccess; // successful packets received
914 u32 rxIncorrectMIC; // pkts dropped due to incorrect MIC comparison
915 u32 rxNotMICed; // pkts dropped due to not being MIC'd
916 u32 rxMICPlummed; // pkts dropped due to not having a MIC plummed
917 u32 rxWrongSequence; // pkts dropped due to sequence number violation
922 u32 coeff[((EMMH32_MSGLEN_MAX)+3)>>2];
923 u64 accum; // accumulated mic, reduced to u32 in final()
924 int position; // current position (byte offset) in message
928 } part; // saves partial message word across update() calls
932 emmh32_context seed; // Context - the seed
933 u32 rx; // Received sequence number
934 u32 tx; // Tx sequence number
935 u32 window; // Start of window
936 u8 valid; // Flag to say if context is valid or not
941 miccntx mCtx; // Multicast context
942 miccntx uCtx; // Unicast context
946 unsigned int rid: 16;
947 unsigned int len: 15;
948 unsigned int valid: 1;
949 dma_addr_t host_addr;
953 unsigned int offset: 15;
955 unsigned int len: 15;
956 unsigned int valid: 1;
957 dma_addr_t host_addr;
961 unsigned int ctl: 15;
963 unsigned int len: 15;
964 unsigned int valid: 1;
965 dma_addr_t host_addr;
969 * Host receive descriptor
972 unsigned char __iomem *card_ram_off; /* offset into card memory of the
974 RxFid rx_desc; /* card receive descriptor */
975 char *virtual_host_addr; /* virtual address of host receive
981 * Host transmit descriptor
984 unsigned char __iomem *card_ram_off; /* offset into card memory of the
986 TxFid tx_desc; /* card transmit descriptor */
987 char *virtual_host_addr; /* virtual address of host receive
993 * Host RID descriptor
996 unsigned char __iomem *card_ram_off; /* offset into card memory of the
998 Rid rid_desc; /* card RID descriptor */
999 char *virtual_host_addr; /* virtual address of host receive
1008 #define HOST_SET (1 << 0)
1009 #define HOST_INT_TX (1 << 1) /* Interrupt on successful TX */
1010 #define HOST_INT_TXERR (1 << 2) /* Interrupt on unseccessful TX */
1011 #define HOST_LCC_PAYLOAD (1 << 4) /* LLC payload, 0 = Ethertype */
1012 #define HOST_DONT_RLSE (1 << 5) /* Don't release buffer when done */
1013 #define HOST_DONT_RETRY (1 << 6) /* Don't retry trasmit */
1014 #define HOST_CLR_AID (1 << 7) /* clear AID failure */
1015 #define HOST_RTS (1 << 9) /* Force RTS use */
1016 #define HOST_SHORT (1 << 10) /* Do short preamble */
1043 WifiCtlHdr wifictlhdr8023 = {
1045 .ctl = HOST_DONT_RLSE,
1050 // Frequency list (map channels to frequencies)
1051 static const long frequency_list[] = { 2412, 2417, 2422, 2427, 2432, 2437, 2442,
1052 2447, 2452, 2457, 2462, 2467, 2472, 2484 };
1054 // A few details needed for WEP (Wireless Equivalent Privacy)
1055 #define MAX_KEY_SIZE 13 // 128 (?) bits
1056 #define MIN_KEY_SIZE 5 // 40 bits RC4 - WEP
1057 typedef struct wep_key_t {
1059 u8 key[16]; /* 40-bit and 104-bit keys */
1062 /* Backward compatibility */
1063 #ifndef IW_ENCODE_NOKEY
1064 #define IW_ENCODE_NOKEY 0x0800 /* Key is write only, so not present */
1065 #define IW_ENCODE_MODE (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
1066 #endif /* IW_ENCODE_NOKEY */
1068 /* List of Wireless Handlers (new API) */
1069 static const struct iw_handler_def airo_handler_def;
1070 #endif /* WIRELESS_EXT */
1072 static const char version[] = "airo.c 0.6 (Ben Reed & Javier Achirica)";
1076 static int get_dec_u16( char *buffer, int *start, int limit );
1077 static void OUT4500( struct airo_info *, u16 register, u16 value );
1078 static unsigned short IN4500( struct airo_info *, u16 register );
1079 static u16 setup_card(struct airo_info*, u8 *mac, int lock);
1080 static int enable_MAC( struct airo_info *ai, Resp *rsp, int lock );
1081 static void disable_MAC(struct airo_info *ai, int lock);
1082 static void enable_interrupts(struct airo_info*);
1083 static void disable_interrupts(struct airo_info*);
1084 static u16 issuecommand(struct airo_info*, Cmd *pCmd, Resp *pRsp);
1085 static int bap_setup(struct airo_info*, u16 rid, u16 offset, int whichbap);
1086 static int aux_bap_read(struct airo_info*, u16 *pu16Dst, int bytelen,
1088 static int fast_bap_read(struct airo_info*, u16 *pu16Dst, int bytelen,
1090 static int bap_write(struct airo_info*, const u16 *pu16Src, int bytelen,
1092 static int PC4500_accessrid(struct airo_info*, u16 rid, u16 accmd);
1093 static int PC4500_readrid(struct airo_info*, u16 rid, void *pBuf, int len, int lock);
1094 static int PC4500_writerid(struct airo_info*, u16 rid, const void
1095 *pBuf, int len, int lock);
1096 static int do_writerid( struct airo_info*, u16 rid, const void *rid_data,
1097 int len, int dummy );
1098 static u16 transmit_allocate(struct airo_info*, int lenPayload, int raw);
1099 static int transmit_802_3_packet(struct airo_info*, int len, char *pPacket);
1100 static int transmit_802_11_packet(struct airo_info*, int len, char *pPacket);
1102 static int mpi_send_packet (struct net_device *dev);
1103 static void mpi_unmap_card(struct pci_dev *pci);
1104 static void mpi_receive_802_3(struct airo_info *ai);
1105 static void mpi_receive_802_11(struct airo_info *ai);
1106 static int waitbusy (struct airo_info *ai);
1108 static irqreturn_t airo_interrupt( int irq, void* dev_id, struct pt_regs
1110 static int airo_thread(void *data);
1111 static void timer_func( struct net_device *dev );
1112 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
1114 struct iw_statistics *airo_get_wireless_stats (struct net_device *dev);
1115 static void airo_read_wireless_stats (struct airo_info *local);
1116 #endif /* WIRELESS_EXT */
1118 static int readrids(struct net_device *dev, aironet_ioctl *comp);
1119 static int writerids(struct net_device *dev, aironet_ioctl *comp);
1120 int flashcard(struct net_device *dev, aironet_ioctl *comp);
1121 #endif /* CISCO_EXT */
1123 static void micinit(struct airo_info *ai);
1124 static int micsetup(struct airo_info *ai);
1125 static int encapsulate(struct airo_info *ai, etherHead *pPacket, MICBuffer *buffer, int len);
1126 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *pPacket, u16 payLen);
1128 #include <linux/crypto.h>
1132 struct net_device_stats stats;
1133 struct net_device *dev;
1134 /* Note, we can have MAX_FIDS outstanding. FIDs are 16-bits, so we
1135 use the high bit to mark whether it is in use. */
1137 #define MPI_MAX_FIDS 1
1140 char keyindex; // Used with auto wep
1141 char defindex; // Used with auto wep
1142 struct proc_dir_entry *proc_entry;
1143 spinlock_t aux_lock;
1144 unsigned long flags;
1145 #define FLAG_PROMISC 8 /* IFF_PROMISC 0x100 - include/linux/if.h */
1146 #define FLAG_RADIO_OFF 0 /* User disabling of MAC */
1147 #define FLAG_RADIO_DOWN 1 /* ifup/ifdown disabling of MAC */
1148 #define FLAG_RADIO_MASK 0x03
1149 #define FLAG_ENABLED 2
1150 #define FLAG_ADHOC 3 /* Needed by MIC */
1151 #define FLAG_MIC_CAPABLE 4
1152 #define FLAG_UPDATE_MULTI 5
1153 #define FLAG_UPDATE_UNI 6
1154 #define FLAG_802_11 7
1155 #define FLAG_PENDING_XMIT 9
1156 #define FLAG_PENDING_XMIT11 10
1158 #define FLAG_REGISTERED 12
1159 #define FLAG_COMMIT 13
1160 #define FLAG_RESET 14
1161 #define FLAG_FLASHING 15
1162 #define JOB_MASK 0x1ff0000
1165 #define JOB_XMIT11 18
1166 #define JOB_STATS 19
1167 #define JOB_PROMISC 20
1169 #define JOB_EVENT 22
1170 #define JOB_AUTOWEP 23
1171 #define JOB_WSTATS 24
1172 int (*bap_read)(struct airo_info*, u16 *pu16Dst, int bytelen,
1174 unsigned short *flash;
1176 struct task_struct *task;
1177 struct semaphore sem;
1179 wait_queue_head_t thr_wait;
1180 struct completion thr_exited;
1181 unsigned long expires;
1183 struct sk_buff *skb;
1186 struct net_device *wifidev;
1188 struct iw_statistics wstats; // wireless stats
1189 unsigned long scan_timestamp; /* Time started to scan */
1190 struct iw_spy_data spy_data;
1191 struct iw_public_data wireless_data;
1192 #endif /* WIRELESS_EXT */
1195 struct crypto_tfm *tfm;
1197 mic_statistics micstats;
1199 HostRxDesc rxfids[MPI_MAX_FIDS]; // rx/tx/config MPI350 descriptors
1200 HostTxDesc txfids[MPI_MAX_FIDS];
1201 HostRidDesc config_desc;
1202 unsigned long ridbus; // phys addr of config_desc
1203 struct sk_buff_head txq;// tx queue used by mpi350 code
1204 struct pci_dev *pci;
1205 unsigned char __iomem *pcimem;
1206 unsigned char __iomem *pciaux;
1207 unsigned char *shared;
1208 dma_addr_t shared_dma;
1212 #define PCI_SHARED_LEN 2*MPI_MAX_FIDS*PKTSIZE+RIDSIZE
1213 char proc_name[IFNAMSIZ];
1216 static inline int bap_read(struct airo_info *ai, u16 *pu16Dst, int bytelen,
1218 return ai->bap_read(ai, pu16Dst, bytelen, whichbap);
1221 static int setup_proc_entry( struct net_device *dev,
1222 struct airo_info *apriv );
1223 static int takedown_proc_entry( struct net_device *dev,
1224 struct airo_info *apriv );
1227 /***********************************************************************
1229 ***********************************************************************
1232 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq);
1233 static void MoveWindow(miccntx *context, u32 micSeq);
1234 void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct crypto_tfm *);
1235 void emmh32_init(emmh32_context *context);
1236 void emmh32_update(emmh32_context *context, u8 *pOctets, int len);
1237 void emmh32_final(emmh32_context *context, u8 digest[4]);
1239 /* micinit - Initialize mic seed */
1241 static void micinit(struct airo_info *ai)
1245 clear_bit(JOB_MIC, &ai->flags);
1246 PC4500_readrid(ai, RID_MIC, &mic_rid, sizeof(mic_rid), 0);
1249 ai->micstats.enabled = (mic_rid.state & 0x00FF) ? 1 : 0;
1251 if (ai->micstats.enabled) {
1252 /* Key must be valid and different */
1253 if (mic_rid.multicastValid && (!ai->mod[0].mCtx.valid ||
1254 (memcmp (ai->mod[0].mCtx.key, mic_rid.multicast,
1255 sizeof(ai->mod[0].mCtx.key)) != 0))) {
1256 /* Age current mic Context */
1257 memcpy(&ai->mod[1].mCtx,&ai->mod[0].mCtx,sizeof(miccntx));
1258 /* Initialize new context */
1259 memcpy(&ai->mod[0].mCtx.key,mic_rid.multicast,sizeof(mic_rid.multicast));
1260 ai->mod[0].mCtx.window = 33; //Window always points to the middle
1261 ai->mod[0].mCtx.rx = 0; //Rx Sequence numbers
1262 ai->mod[0].mCtx.tx = 0; //Tx sequence numbers
1263 ai->mod[0].mCtx.valid = 1; //Key is now valid
1265 /* Give key to mic seed */
1266 emmh32_setseed(&ai->mod[0].mCtx.seed,mic_rid.multicast,sizeof(mic_rid.multicast), ai->tfm);
1269 /* Key must be valid and different */
1270 if (mic_rid.unicastValid && (!ai->mod[0].uCtx.valid ||
1271 (memcmp(ai->mod[0].uCtx.key, mic_rid.unicast,
1272 sizeof(ai->mod[0].uCtx.key)) != 0))) {
1273 /* Age current mic Context */
1274 memcpy(&ai->mod[1].uCtx,&ai->mod[0].uCtx,sizeof(miccntx));
1275 /* Initialize new context */
1276 memcpy(&ai->mod[0].uCtx.key,mic_rid.unicast,sizeof(mic_rid.unicast));
1278 ai->mod[0].uCtx.window = 33; //Window always points to the middle
1279 ai->mod[0].uCtx.rx = 0; //Rx Sequence numbers
1280 ai->mod[0].uCtx.tx = 0; //Tx sequence numbers
1281 ai->mod[0].uCtx.valid = 1; //Key is now valid
1283 //Give key to mic seed
1284 emmh32_setseed(&ai->mod[0].uCtx.seed, mic_rid.unicast, sizeof(mic_rid.unicast), ai->tfm);
1287 /* So next time we have a valid key and mic is enabled, we will update
1288 * the sequence number if the key is the same as before.
1290 ai->mod[0].uCtx.valid = 0;
1291 ai->mod[0].mCtx.valid = 0;
1295 /* micsetup - Get ready for business */
1297 static int micsetup(struct airo_info *ai) {
1300 if (ai->tfm == NULL)
1301 ai->tfm = crypto_alloc_tfm("aes", 0);
1303 if (ai->tfm == NULL) {
1304 printk(KERN_ERR "airo: failed to load transform for AES\n");
1308 for (i=0; i < NUM_MODULES; i++) {
1309 memset(&ai->mod[i].mCtx,0,sizeof(miccntx));
1310 memset(&ai->mod[i].uCtx,0,sizeof(miccntx));
1315 char micsnap[]= {0xAA,0xAA,0x03,0x00,0x40,0x96,0x00,0x02};
1317 /*===========================================================================
1318 * Description: Mic a packet
1320 * Inputs: etherHead * pointer to an 802.3 frame
1322 * Returns: BOOLEAN if successful, otherwise false.
1323 * PacketTxLen will be updated with the mic'd packets size.
1325 * Caveats: It is assumed that the frame buffer will already
1326 * be big enough to hold the largets mic message possible.
1327 * (No memory allocation is done here).
1329 * Author: sbraneky (10/15/01)
1330 * Merciless hacks by rwilcher (1/14/02)
1333 static int encapsulate(struct airo_info *ai ,etherHead *frame, MICBuffer *mic, int payLen)
1337 // Determine correct context
1338 // If not adhoc, always use unicast key
1340 if (test_bit(FLAG_ADHOC, &ai->flags) && (frame->da[0] & 0x1))
1341 context = &ai->mod[0].mCtx;
1343 context = &ai->mod[0].uCtx;
1345 if (!context->valid)
1348 mic->typelen = htons(payLen + 16); //Length of Mic'd packet
1350 memcpy(&mic->u.snap, micsnap, sizeof(micsnap)); // Add Snap
1353 mic->seq = htonl(context->tx);
1356 emmh32_init(&context->seed); // Mic the packet
1357 emmh32_update(&context->seed,frame->da,ETH_ALEN * 2); // DA,SA
1358 emmh32_update(&context->seed,(u8*)&mic->typelen,10); // Type/Length and Snap
1359 emmh32_update(&context->seed,(u8*)&mic->seq,sizeof(mic->seq)); //SEQ
1360 emmh32_update(&context->seed,frame->da + ETH_ALEN * 2,payLen); //payload
1361 emmh32_final(&context->seed, (u8*)&mic->mic);
1363 /* New Type/length ?????????? */
1364 mic->typelen = 0; //Let NIC know it could be an oversized packet
1376 /*===========================================================================
1377 * Description: Decapsulates a MIC'd packet and returns the 802.3 packet
1378 * (removes the MIC stuff) if packet is a valid packet.
1380 * Inputs: etherHead pointer to the 802.3 packet
1382 * Returns: BOOLEAN - TRUE if packet should be dropped otherwise FALSE
1384 * Author: sbraneky (10/15/01)
1385 * Merciless hacks by rwilcher (1/14/02)
1386 *---------------------------------------------------------------------------
1389 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *eth, u16 payLen)
1395 mic_error micError = NONE;
1397 // Check if the packet is a Mic'd packet
1399 if (!ai->micstats.enabled) {
1400 //No Mic set or Mic OFF but we received a MIC'd packet.
1401 if (memcmp ((u8*)eth + 14, micsnap, sizeof(micsnap)) == 0) {
1402 ai->micstats.rxMICPlummed++;
1408 if (ntohs(mic->typelen) == 0x888E)
1411 if (memcmp (mic->u.snap, micsnap, sizeof(micsnap)) != 0) {
1412 // Mic enabled but packet isn't Mic'd
1413 ai->micstats.rxMICPlummed++;
1417 micSEQ = ntohl(mic->seq); //store SEQ as CPU order
1419 //At this point we a have a mic'd packet and mic is enabled
1420 //Now do the mic error checking.
1422 //Receive seq must be odd
1423 if ( (micSEQ & 1) == 0 ) {
1424 ai->micstats.rxWrongSequence++;
1428 for (i = 0; i < NUM_MODULES; i++) {
1429 int mcast = eth->da[0] & 1;
1430 //Determine proper context
1431 context = mcast ? &ai->mod[i].mCtx : &ai->mod[i].uCtx;
1433 //Make sure context is valid
1434 if (!context->valid) {
1436 micError = NOMICPLUMMED;
1442 mic->typelen = htons(payLen + sizeof(MICBuffer) - 2);
1444 emmh32_init(&context->seed);
1445 emmh32_update(&context->seed, eth->da, ETH_ALEN*2);
1446 emmh32_update(&context->seed, (u8 *)&mic->typelen, sizeof(mic->typelen)+sizeof(mic->u.snap));
1447 emmh32_update(&context->seed, (u8 *)&mic->seq,sizeof(mic->seq));
1448 emmh32_update(&context->seed, eth->da + ETH_ALEN*2,payLen);
1450 emmh32_final(&context->seed, digest);
1452 if (memcmp(digest, &mic->mic, 4)) { //Make sure the mics match
1455 micError = INCORRECTMIC;
1459 //Check Sequence number if mics pass
1460 if (RxSeqValid(ai, context, mcast, micSEQ) == SUCCESS) {
1461 ai->micstats.rxSuccess++;
1465 micError = SEQUENCE;
1468 // Update statistics
1470 case NOMICPLUMMED: ai->micstats.rxMICPlummed++; break;
1471 case SEQUENCE: ai->micstats.rxWrongSequence++; break;
1472 case INCORRECTMIC: ai->micstats.rxIncorrectMIC++; break;
1479 /*===========================================================================
1480 * Description: Checks the Rx Seq number to make sure it is valid
1481 * and hasn't already been received
1483 * Inputs: miccntx - mic context to check seq against
1484 * micSeq - the Mic seq number
1486 * Returns: TRUE if valid otherwise FALSE.
1488 * Author: sbraneky (10/15/01)
1489 * Merciless hacks by rwilcher (1/14/02)
1490 *---------------------------------------------------------------------------
1493 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq)
1497 //Allow for the ap being rebooted - if it is then use the next
1498 //sequence number of the current sequence number - might go backwards
1501 if (test_bit(FLAG_UPDATE_MULTI, &ai->flags)) {
1502 clear_bit (FLAG_UPDATE_MULTI, &ai->flags);
1503 context->window = (micSeq > 33) ? micSeq : 33;
1504 context->rx = 0; // Reset rx
1506 } else if (test_bit(FLAG_UPDATE_UNI, &ai->flags)) {
1507 clear_bit (FLAG_UPDATE_UNI, &ai->flags);
1508 context->window = (micSeq > 33) ? micSeq : 33; // Move window
1509 context->rx = 0; // Reset rx
1512 //Make sequence number relative to START of window
1513 seq = micSeq - (context->window - 33);
1515 //Too old of a SEQ number to check.
1520 //Window is infinite forward
1521 MoveWindow(context,micSeq);
1525 // We are in the window. Now check the context rx bit to see if it was already sent
1526 seq >>= 1; //divide by 2 because we only have odd numbers
1527 index = 1 << seq; //Get an index number
1529 if (!(context->rx & index)) {
1530 //micSEQ falls inside the window.
1531 //Add seqence number to the list of received numbers.
1532 context->rx |= index;
1534 MoveWindow(context,micSeq);
1541 static void MoveWindow(miccntx *context, u32 micSeq)
1545 //Move window if seq greater than the middle of the window
1546 if (micSeq > context->window) {
1547 shift = (micSeq - context->window) >> 1;
1551 context->rx >>= shift;
1555 context->window = micSeq; //Move window
1559 /*==============================================*/
1560 /*========== EMMH ROUTINES ====================*/
1561 /*==============================================*/
1563 /* mic accumulate */
1564 #define MIC_ACCUM(val) \
1565 context->accum += (u64)(val) * context->coeff[coeff_position++];
1567 static unsigned char aes_counter[16];
1569 /* expand the key to fill the MMH coefficient array */
1570 void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct crypto_tfm *tfm)
1572 /* take the keying material, expand if necessary, truncate at 16-bytes */
1573 /* run through AES counter mode to generate context->coeff[] */
1577 u8 *cipher, plain[16];
1578 struct scatterlist sg[1];
1580 crypto_cipher_setkey(tfm, pkey, 16);
1582 for (i = 0; i < (sizeof(context->coeff)/sizeof(context->coeff[0])); ) {
1583 aes_counter[15] = (u8)(counter >> 0);
1584 aes_counter[14] = (u8)(counter >> 8);
1585 aes_counter[13] = (u8)(counter >> 16);
1586 aes_counter[12] = (u8)(counter >> 24);
1588 memcpy (plain, aes_counter, 16);
1589 sg[0].page = virt_to_page(plain);
1590 sg[0].offset = ((long) plain & ~PAGE_MASK);
1592 crypto_cipher_encrypt(tfm, sg, sg, 16);
1593 cipher = kmap(sg[0].page) + sg[0].offset;
1594 for (j=0; (j<16) && (i< (sizeof(context->coeff)/sizeof(context->coeff[0]))); ) {
1595 context->coeff[i++] = ntohl(*(u32 *)&cipher[j]);
1601 /* prepare for calculation of a new mic */
1602 void emmh32_init(emmh32_context *context)
1604 /* prepare for new mic calculation */
1606 context->position = 0;
1609 /* add some bytes to the mic calculation */
1610 void emmh32_update(emmh32_context *context, u8 *pOctets, int len)
1612 int coeff_position, byte_position;
1614 if (len == 0) return;
1616 coeff_position = context->position >> 2;
1618 /* deal with partial 32-bit word left over from last update */
1619 byte_position = context->position & 3;
1620 if (byte_position) {
1621 /* have a partial word in part to deal with */
1623 if (len == 0) return;
1624 context->part.d8[byte_position++] = *pOctets++;
1625 context->position++;
1627 } while (byte_position < 4);
1628 MIC_ACCUM(htonl(context->part.d32));
1631 /* deal with full 32-bit words */
1633 MIC_ACCUM(htonl(*(u32 *)pOctets));
1634 context->position += 4;
1639 /* deal with partial 32-bit word that will be left over from this update */
1642 context->part.d8[byte_position++] = *pOctets++;
1643 context->position++;
1648 /* mask used to zero empty bytes for final partial word */
1649 static u32 mask32[4] = { 0x00000000L, 0xFF000000L, 0xFFFF0000L, 0xFFFFFF00L };
1651 /* calculate the mic */
1652 void emmh32_final(emmh32_context *context, u8 digest[4])
1654 int coeff_position, byte_position;
1660 coeff_position = context->position >> 2;
1662 /* deal with partial 32-bit word left over from last update */
1663 byte_position = context->position & 3;
1664 if (byte_position) {
1665 /* have a partial word in part to deal with */
1666 val = htonl(context->part.d32);
1667 MIC_ACCUM(val & mask32[byte_position]); /* zero empty bytes */
1670 /* reduce the accumulated u64 to a 32-bit MIC */
1671 sum = context->accum;
1672 stmp = (sum & 0xffffffffLL) - ((sum >> 32) * 15);
1673 utmp = (stmp & 0xffffffffLL) - ((stmp >> 32) * 15);
1674 sum = utmp & 0xffffffffLL;
1675 if (utmp > 0x10000000fLL)
1679 digest[0] = (val>>24) & 0xFF;
1680 digest[1] = (val>>16) & 0xFF;
1681 digest[2] = (val>>8) & 0xFF;
1682 digest[3] = val & 0xFF;
1686 static int readBSSListRid(struct airo_info *ai, int first,
1693 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
1694 memset(&cmd, 0, sizeof(cmd));
1695 cmd.cmd=CMD_LISTBSS;
1696 if (down_interruptible(&ai->sem))
1697 return -ERESTARTSYS;
1698 issuecommand(ai, &cmd, &rsp);
1700 /* Let the command take effect */
1701 set_current_state (TASK_INTERRUPTIBLE);
1703 schedule_timeout (3*HZ);
1706 rc = PC4500_readrid(ai, first ? RID_BSSLISTFIRST : RID_BSSLISTNEXT,
1707 list, sizeof(*list), 1);
1709 list->len = le16_to_cpu(list->len);
1710 list->index = le16_to_cpu(list->index);
1711 list->radioType = le16_to_cpu(list->radioType);
1712 list->cap = le16_to_cpu(list->cap);
1713 list->beaconInterval = le16_to_cpu(list->beaconInterval);
1714 list->fh.dwell = le16_to_cpu(list->fh.dwell);
1715 list->dsChannel = le16_to_cpu(list->dsChannel);
1716 list->atimWindow = le16_to_cpu(list->atimWindow);
1720 static int readWepKeyRid(struct airo_info*ai, WepKeyRid *wkr, int temp, int lock) {
1721 int rc = PC4500_readrid(ai, temp ? RID_WEP_TEMP : RID_WEP_PERM,
1722 wkr, sizeof(*wkr), lock);
1724 wkr->len = le16_to_cpu(wkr->len);
1725 wkr->kindex = le16_to_cpu(wkr->kindex);
1726 wkr->klen = le16_to_cpu(wkr->klen);
1729 /* In the writeXXXRid routines we copy the rids so that we don't screwup
1730 * the originals when we endian them... */
1731 static int writeWepKeyRid(struct airo_info*ai, WepKeyRid *pwkr, int perm, int lock) {
1733 WepKeyRid wkr = *pwkr;
1735 wkr.len = cpu_to_le16(wkr.len);
1736 wkr.kindex = cpu_to_le16(wkr.kindex);
1737 wkr.klen = cpu_to_le16(wkr.klen);
1738 rc = PC4500_writerid(ai, RID_WEP_TEMP, &wkr, sizeof(wkr), lock);
1739 if (rc!=SUCCESS) printk(KERN_ERR "airo: WEP_TEMP set %x\n", rc);
1741 rc = PC4500_writerid(ai, RID_WEP_PERM, &wkr, sizeof(wkr), lock);
1743 printk(KERN_ERR "airo: WEP_PERM set %x\n", rc);
1749 static int readSsidRid(struct airo_info*ai, SsidRid *ssidr) {
1751 int rc = PC4500_readrid(ai, RID_SSID, ssidr, sizeof(*ssidr), 1);
1753 ssidr->len = le16_to_cpu(ssidr->len);
1754 for(i = 0; i < 3; i++) {
1755 ssidr->ssids[i].len = le16_to_cpu(ssidr->ssids[i].len);
1759 static int writeSsidRid(struct airo_info*ai, SsidRid *pssidr, int lock) {
1762 SsidRid ssidr = *pssidr;
1764 ssidr.len = cpu_to_le16(ssidr.len);
1765 for(i = 0; i < 3; i++) {
1766 ssidr.ssids[i].len = cpu_to_le16(ssidr.ssids[i].len);
1768 rc = PC4500_writerid(ai, RID_SSID, &ssidr, sizeof(ssidr), lock);
1771 static int readConfigRid(struct airo_info*ai, int lock) {
1779 rc = PC4500_readrid(ai, RID_ACTUALCONFIG, &cfg, sizeof(cfg), lock);
1783 for(s = &cfg.len; s <= &cfg.rtsThres; s++) *s = le16_to_cpu(*s);
1785 for(s = &cfg.shortRetryLimit; s <= &cfg.radioType; s++)
1786 *s = le16_to_cpu(*s);
1788 for(s = &cfg.txPower; s <= &cfg.radioSpecific; s++)
1789 *s = le16_to_cpu(*s);
1791 for(s = &cfg.arlThreshold; s <= &cfg._reserved4[0]; s++)
1792 *s = cpu_to_le16(*s);
1794 for(s = &cfg.autoWake; s <= &cfg.autoWake; s++)
1795 *s = cpu_to_le16(*s);
1800 static inline void checkThrottle(struct airo_info *ai) {
1802 /* Old hardware had a limit on encryption speed */
1803 if (ai->config.authType != AUTH_OPEN && maxencrypt) {
1804 for(i=0; i<8; i++) {
1805 if (ai->config.rates[i] > maxencrypt) {
1806 ai->config.rates[i] = 0;
1811 static int writeConfigRid(struct airo_info*ai, int lock) {
1815 if (!test_bit (FLAG_COMMIT, &ai->flags))
1818 clear_bit (FLAG_COMMIT, &ai->flags);
1819 clear_bit (FLAG_RESET, &ai->flags);
1823 if ((cfgr.opmode & 0xFF) == MODE_STA_IBSS)
1824 set_bit(FLAG_ADHOC, &ai->flags);
1826 clear_bit(FLAG_ADHOC, &ai->flags);
1828 for(s = &cfgr.len; s <= &cfgr.rtsThres; s++) *s = cpu_to_le16(*s);
1830 for(s = &cfgr.shortRetryLimit; s <= &cfgr.radioType; s++)
1831 *s = cpu_to_le16(*s);
1833 for(s = &cfgr.txPower; s <= &cfgr.radioSpecific; s++)
1834 *s = cpu_to_le16(*s);
1836 for(s = &cfgr.arlThreshold; s <= &cfgr._reserved4[0]; s++)
1837 *s = cpu_to_le16(*s);
1839 for(s = &cfgr.autoWake; s <= &cfgr.autoWake; s++)
1840 *s = cpu_to_le16(*s);
1842 return PC4500_writerid( ai, RID_CONFIG, &cfgr, sizeof(cfgr), lock);
1844 static int readStatusRid(struct airo_info*ai, StatusRid *statr, int lock) {
1845 int rc = PC4500_readrid(ai, RID_STATUS, statr, sizeof(*statr), lock);
1848 statr->len = le16_to_cpu(statr->len);
1849 for(s = &statr->mode; s <= &statr->SSIDlen; s++) *s = le16_to_cpu(*s);
1851 for(s = &statr->beaconPeriod; s <= &statr->shortPreamble; s++)
1852 *s = le16_to_cpu(*s);
1853 statr->load = le16_to_cpu(statr->load);
1854 statr->assocStatus = le16_to_cpu(statr->assocStatus);
1857 static int readAPListRid(struct airo_info*ai, APListRid *aplr) {
1858 int rc = PC4500_readrid(ai, RID_APLIST, aplr, sizeof(*aplr), 1);
1859 aplr->len = le16_to_cpu(aplr->len);
1862 static int writeAPListRid(struct airo_info*ai, APListRid *aplr, int lock) {
1864 aplr->len = cpu_to_le16(aplr->len);
1865 rc = PC4500_writerid(ai, RID_APLIST, aplr, sizeof(*aplr), lock);
1868 static int readCapabilityRid(struct airo_info*ai, CapabilityRid *capr, int lock) {
1869 int rc = PC4500_readrid(ai, RID_CAPABILITIES, capr, sizeof(*capr), lock);
1872 capr->len = le16_to_cpu(capr->len);
1873 capr->prodNum = le16_to_cpu(capr->prodNum);
1874 capr->radioType = le16_to_cpu(capr->radioType);
1875 capr->country = le16_to_cpu(capr->country);
1876 for(s = &capr->txPowerLevels[0]; s <= &capr->requiredHard; s++)
1877 *s = le16_to_cpu(*s);
1880 static int readStatsRid(struct airo_info*ai, StatsRid *sr, int rid, int lock) {
1881 int rc = PC4500_readrid(ai, rid, sr, sizeof(*sr), lock);
1884 sr->len = le16_to_cpu(sr->len);
1885 for(i = &sr->vals[0]; i <= &sr->vals[99]; i++) *i = le32_to_cpu(*i);
1889 static int airo_open(struct net_device *dev) {
1890 struct airo_info *info = dev->priv;
1893 if (test_bit(FLAG_FLASHING, &info->flags))
1896 /* Make sure the card is configured.
1897 * Wireless Extensions may postpone config changes until the card
1898 * is open (to pipeline changes and speed-up card setup). If
1899 * those changes are not yet commited, do it now - Jean II */
1900 if (test_bit (FLAG_COMMIT, &info->flags)) {
1901 disable_MAC(info, 1);
1902 writeConfigRid(info, 1);
1905 if (info->wifidev != dev) {
1906 /* Power on the MAC controller (which may have been disabled) */
1907 clear_bit(FLAG_RADIO_DOWN, &info->flags);
1908 enable_interrupts(info);
1910 enable_MAC(info, &rsp, 1);
1912 netif_start_queue(dev);
1916 static int mpi_start_xmit(struct sk_buff *skb, struct net_device *dev) {
1917 int npacks, pending;
1918 unsigned long flags;
1919 struct airo_info *ai = dev->priv;
1922 printk(KERN_ERR "airo: %s: skb==NULL\n",__FUNCTION__);
1925 npacks = skb_queue_len (&ai->txq);
1927 if (npacks >= MAXTXQ - 1) {
1928 netif_stop_queue (dev);
1929 if (npacks > MAXTXQ) {
1930 ai->stats.tx_fifo_errors++;
1933 skb_queue_tail (&ai->txq, skb);
1937 spin_lock_irqsave(&ai->aux_lock, flags);
1938 skb_queue_tail (&ai->txq, skb);
1939 pending = test_bit(FLAG_PENDING_XMIT, &ai->flags);
1940 spin_unlock_irqrestore(&ai->aux_lock,flags);
1941 netif_wake_queue (dev);
1944 set_bit(FLAG_PENDING_XMIT, &ai->flags);
1945 mpi_send_packet (dev);
1953 * Attempt to transmit a packet. Can be called from interrupt
1954 * or transmit . return number of packets we tried to send
1957 static int mpi_send_packet (struct net_device *dev)
1959 struct sk_buff *skb;
1960 unsigned char *buffer;
1961 s16 len, *payloadLen;
1962 struct airo_info *ai = dev->priv;
1965 /* get a packet to send */
1967 if ((skb = skb_dequeue(&ai->txq)) == 0) {
1969 "airo: %s: Dequeue'd zero in send_packet()\n",
1974 /* check min length*/
1975 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1978 ai->txfids[0].tx_desc.offset = 0;
1979 ai->txfids[0].tx_desc.valid = 1;
1980 ai->txfids[0].tx_desc.eoc = 1;
1981 ai->txfids[0].tx_desc.len =len+sizeof(WifiHdr);
1984 * Magic, the cards firmware needs a length count (2 bytes) in the host buffer
1985 * right after TXFID_HDR.The TXFID_HDR contains the status short so payloadlen
1986 * is immediatly after it. ------------------------------------------------
1987 * |TXFIDHDR+STATUS|PAYLOADLEN|802.3HDR|PACKETDATA|
1988 * ------------------------------------------------
1991 memcpy((char *)ai->txfids[0].virtual_host_addr,
1992 (char *)&wifictlhdr8023, sizeof(wifictlhdr8023));
1994 payloadLen = (s16 *)(ai->txfids[0].virtual_host_addr +
1995 sizeof(wifictlhdr8023));
1996 sendbuf = ai->txfids[0].virtual_host_addr +
1997 sizeof(wifictlhdr8023) + 2 ;
2000 * Firmware automaticly puts 802 header on so
2001 * we don't need to account for it in the length
2004 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
2005 (ntohs(((u16 *)buffer)[6]) != 0x888E)) {
2008 if (encapsulate(ai, (etherHead *)buffer, &pMic, len - sizeof(etherHead)) != SUCCESS)
2011 *payloadLen = cpu_to_le16(len-sizeof(etherHead)+sizeof(pMic));
2012 ai->txfids[0].tx_desc.len += sizeof(pMic);
2013 /* copy data into airo dma buffer */
2014 memcpy (sendbuf, buffer, sizeof(etherHead));
2015 buffer += sizeof(etherHead);
2016 sendbuf += sizeof(etherHead);
2017 memcpy (sendbuf, &pMic, sizeof(pMic));
2018 sendbuf += sizeof(pMic);
2019 memcpy (sendbuf, buffer, len - sizeof(etherHead));
2023 *payloadLen = cpu_to_le16(len - sizeof(etherHead));
2025 dev->trans_start = jiffies;
2027 /* copy data into airo dma buffer */
2028 memcpy(sendbuf, buffer, len);
2031 memcpy_toio(ai->txfids[0].card_ram_off,
2032 &ai->txfids[0].tx_desc, sizeof(TxFid));
2034 OUT4500(ai, EVACK, 8);
2036 dev_kfree_skb_any(skb);
2040 static void get_tx_error(struct airo_info *ai, u32 fid)
2045 status = ((WifiCtlHdr *)ai->txfids[0].virtual_host_addr)->ctlhdr.status;
2047 if (bap_setup(ai, ai->fids[fid] & 0xffff, 4, BAP0) != SUCCESS)
2049 bap_read(ai, &status, 2, BAP0);
2051 if (le16_to_cpu(status) & 2) /* Too many retries */
2052 ai->stats.tx_aborted_errors++;
2053 if (le16_to_cpu(status) & 4) /* Transmit lifetime exceeded */
2054 ai->stats.tx_heartbeat_errors++;
2055 if (le16_to_cpu(status) & 8) /* Aid fail */
2057 if (le16_to_cpu(status) & 0x10) /* MAC disabled */
2058 ai->stats.tx_carrier_errors++;
2059 if (le16_to_cpu(status) & 0x20) /* Association lost */
2061 /* We produce a TXDROP event only for retry or lifetime
2062 * exceeded, because that's the only status that really mean
2063 * that this particular node went away.
2064 * Other errors means that *we* screwed up. - Jean II */
2065 if ((le16_to_cpu(status) & 2) ||
2066 (le16_to_cpu(status) & 4)) {
2067 union iwreq_data wrqu;
2070 /* Faster to skip over useless data than to do
2071 * another bap_setup(). We are at offset 0x6 and
2072 * need to go to 0x18 and read 6 bytes - Jean II */
2073 bap_read(ai, (u16 *) junk, 0x18, BAP0);
2075 /* Copy 802.11 dest address.
2076 * We use the 802.11 header because the frame may
2077 * not be 802.3 or may be mangled...
2078 * In Ad-Hoc mode, it will be the node address.
2079 * In managed mode, it will be most likely the AP addr
2080 * User space will figure out how to convert it to
2081 * whatever it needs (IP address or else).
2083 memcpy(wrqu.addr.sa_data, junk + 0x12, ETH_ALEN);
2084 wrqu.addr.sa_family = ARPHRD_ETHER;
2086 /* Send event to user space */
2087 wireless_send_event(ai->dev, IWEVTXDROP, &wrqu, NULL);
2091 static void airo_end_xmit(struct net_device *dev) {
2094 struct airo_info *priv = dev->priv;
2095 struct sk_buff *skb = priv->xmit.skb;
2096 int fid = priv->xmit.fid;
2097 u32 *fids = priv->fids;
2099 clear_bit(JOB_XMIT, &priv->flags);
2100 clear_bit(FLAG_PENDING_XMIT, &priv->flags);
2101 status = transmit_802_3_packet (priv, fids[fid], skb->data);
2105 if ( status == SUCCESS ) {
2106 dev->trans_start = jiffies;
2107 for (; i < MAX_FIDS / 2 && (priv->fids[i] & 0xffff0000); i++);
2109 priv->fids[fid] &= 0xffff;
2110 priv->stats.tx_window_errors++;
2112 if (i < MAX_FIDS / 2)
2113 netif_wake_queue(dev);
2117 static int airo_start_xmit(struct sk_buff *skb, struct net_device *dev) {
2120 struct airo_info *priv = dev->priv;
2121 u32 *fids = priv->fids;
2123 if ( skb == NULL ) {
2124 printk( KERN_ERR "airo: skb == NULL!!!\n" );
2128 /* Find a vacant FID */
2129 for( i = 0; i < MAX_FIDS / 2 && (fids[i] & 0xffff0000); i++ );
2130 for( j = i + 1; j < MAX_FIDS / 2 && (fids[j] & 0xffff0000); j++ );
2132 if ( j >= MAX_FIDS / 2 ) {
2133 netif_stop_queue(dev);
2135 if (i == MAX_FIDS / 2) {
2136 priv->stats.tx_fifo_errors++;
2140 /* check min length*/
2141 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2142 /* Mark fid as used & save length for later */
2143 fids[i] |= (len << 16);
2144 priv->xmit.skb = skb;
2146 if (down_trylock(&priv->sem) != 0) {
2147 set_bit(FLAG_PENDING_XMIT, &priv->flags);
2148 netif_stop_queue(dev);
2149 set_bit(JOB_XMIT, &priv->flags);
2150 wake_up_interruptible(&priv->thr_wait);
2156 static void airo_end_xmit11(struct net_device *dev) {
2159 struct airo_info *priv = dev->priv;
2160 struct sk_buff *skb = priv->xmit11.skb;
2161 int fid = priv->xmit11.fid;
2162 u32 *fids = priv->fids;
2164 clear_bit(JOB_XMIT11, &priv->flags);
2165 clear_bit(FLAG_PENDING_XMIT11, &priv->flags);
2166 status = transmit_802_11_packet (priv, fids[fid], skb->data);
2170 if ( status == SUCCESS ) {
2171 dev->trans_start = jiffies;
2172 for (; i < MAX_FIDS && (priv->fids[i] & 0xffff0000); i++);
2174 priv->fids[fid] &= 0xffff;
2175 priv->stats.tx_window_errors++;
2178 netif_wake_queue(dev);
2182 static int airo_start_xmit11(struct sk_buff *skb, struct net_device *dev) {
2185 struct airo_info *priv = dev->priv;
2186 u32 *fids = priv->fids;
2188 if (test_bit(FLAG_MPI, &priv->flags)) {
2189 /* Not implemented yet for MPI350 */
2190 netif_stop_queue(dev);
2194 if ( skb == NULL ) {
2195 printk( KERN_ERR "airo: skb == NULL!!!\n" );
2199 /* Find a vacant FID */
2200 for( i = MAX_FIDS / 2; i < MAX_FIDS && (fids[i] & 0xffff0000); i++ );
2201 for( j = i + 1; j < MAX_FIDS && (fids[j] & 0xffff0000); j++ );
2203 if ( j >= MAX_FIDS ) {
2204 netif_stop_queue(dev);
2206 if (i == MAX_FIDS) {
2207 priv->stats.tx_fifo_errors++;
2211 /* check min length*/
2212 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2213 /* Mark fid as used & save length for later */
2214 fids[i] |= (len << 16);
2215 priv->xmit11.skb = skb;
2216 priv->xmit11.fid = i;
2217 if (down_trylock(&priv->sem) != 0) {
2218 set_bit(FLAG_PENDING_XMIT11, &priv->flags);
2219 netif_stop_queue(dev);
2220 set_bit(JOB_XMIT11, &priv->flags);
2221 wake_up_interruptible(&priv->thr_wait);
2223 airo_end_xmit11(dev);
2227 static void airo_read_stats(struct airo_info *ai) {
2229 u32 *vals = stats_rid.vals;
2231 clear_bit(JOB_STATS, &ai->flags);
2236 readStatsRid(ai, &stats_rid, RID_STATS, 0);
2239 ai->stats.rx_packets = vals[43] + vals[44] + vals[45];
2240 ai->stats.tx_packets = vals[39] + vals[40] + vals[41];
2241 ai->stats.rx_bytes = vals[92];
2242 ai->stats.tx_bytes = vals[91];
2243 ai->stats.rx_errors = vals[0] + vals[2] + vals[3] + vals[4];
2244 ai->stats.tx_errors = vals[42] + ai->stats.tx_fifo_errors;
2245 ai->stats.multicast = vals[43];
2246 ai->stats.collisions = vals[89];
2248 /* detailed rx_errors: */
2249 ai->stats.rx_length_errors = vals[3];
2250 ai->stats.rx_crc_errors = vals[4];
2251 ai->stats.rx_frame_errors = vals[2];
2252 ai->stats.rx_fifo_errors = vals[0];
2255 struct net_device_stats *airo_get_stats(struct net_device *dev)
2257 struct airo_info *local = dev->priv;
2259 if (!test_bit(JOB_STATS, &local->flags)) {
2260 /* Get stats out of the card if available */
2261 if (down_trylock(&local->sem) != 0) {
2262 set_bit(JOB_STATS, &local->flags);
2263 wake_up_interruptible(&local->thr_wait);
2265 airo_read_stats(local);
2268 return &local->stats;
2271 static void airo_set_promisc(struct airo_info *ai) {
2275 memset(&cmd, 0, sizeof(cmd));
2276 cmd.cmd=CMD_SETMODE;
2277 clear_bit(JOB_PROMISC, &ai->flags);
2278 cmd.parm0=(ai->flags&IFF_PROMISC) ? PROMISC : NOPROMISC;
2279 issuecommand(ai, &cmd, &rsp);
2283 static void airo_set_multicast_list(struct net_device *dev) {
2284 struct airo_info *ai = dev->priv;
2286 if ((dev->flags ^ ai->flags) & IFF_PROMISC) {
2287 change_bit(FLAG_PROMISC, &ai->flags);
2288 if (down_trylock(&ai->sem) != 0) {
2289 set_bit(JOB_PROMISC, &ai->flags);
2290 wake_up_interruptible(&ai->thr_wait);
2292 airo_set_promisc(ai);
2295 if ((dev->flags&IFF_ALLMULTI)||dev->mc_count>0) {
2296 /* Turn on multicast. (Should be already setup...) */
2300 static int airo_set_mac_address(struct net_device *dev, void *p)
2302 struct airo_info *ai = dev->priv;
2303 struct sockaddr *addr = p;
2306 readConfigRid(ai, 1);
2307 memcpy (ai->config.macAddr, addr->sa_data, dev->addr_len);
2308 set_bit (FLAG_COMMIT, &ai->flags);
2310 writeConfigRid (ai, 1);
2311 enable_MAC(ai, &rsp, 1);
2312 memcpy (ai->dev->dev_addr, addr->sa_data, dev->addr_len);
2314 memcpy (ai->wifidev->dev_addr, addr->sa_data, dev->addr_len);
2318 static int airo_change_mtu(struct net_device *dev, int new_mtu)
2320 if ((new_mtu < 68) || (new_mtu > 2400))
2327 static int airo_close(struct net_device *dev) {
2328 struct airo_info *ai = dev->priv;
2330 netif_stop_queue(dev);
2332 if (ai->wifidev != dev) {
2333 #ifdef POWER_ON_DOWN
2334 /* Shut power to the card. The idea is that the user can save
2335 * power when he doesn't need the card with "ifconfig down".
2336 * That's the method that is most friendly towards the network
2337 * stack (i.e. the network stack won't try to broadcast
2338 * anything on the interface and routes are gone. Jean II */
2339 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2342 disable_interrupts( ai );
2347 static void del_airo_dev( struct net_device *dev );
2349 void stop_airo_card( struct net_device *dev, int freeres )
2351 struct airo_info *ai = dev->priv;
2353 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2355 disable_interrupts(ai);
2356 free_irq( dev->irq, dev );
2357 takedown_proc_entry( dev, ai );
2358 if (test_bit(FLAG_REGISTERED, &ai->flags)) {
2359 unregister_netdev( dev );
2361 unregister_netdev(ai->wifidev);
2362 free_netdev(ai->wifidev);
2365 clear_bit(FLAG_REGISTERED, &ai->flags);
2367 set_bit(JOB_DIE, &ai->flags);
2368 kill_proc(ai->thr_pid, SIGTERM, 1);
2369 wait_for_completion(&ai->thr_exited);
2372 * Clean out tx queue
2374 if (test_bit(FLAG_MPI, &ai->flags) && skb_queue_len (&ai->txq) > 0) {
2375 struct sk_buff *skb = NULL;
2376 for (;(skb = skb_dequeue(&ai->txq));)
2389 /* PCMCIA frees this stuff, so only for PCI and ISA */
2390 release_region( dev->base_addr, 64 );
2391 if (test_bit(FLAG_MPI, &ai->flags)) {
2393 mpi_unmap_card(ai->pci);
2395 iounmap(ai->pcimem);
2397 iounmap(ai->pciaux);
2398 pci_free_consistent(ai->pci, PCI_SHARED_LEN,
2399 ai->shared, ai->shared_dma);
2404 crypto_free_tfm(ai->tfm);
2406 del_airo_dev( dev );
2410 EXPORT_SYMBOL(stop_airo_card);
2412 static int add_airo_dev( struct net_device *dev );
2414 int wll_header_parse(struct sk_buff *skb, unsigned char *haddr)
2416 memcpy(haddr, skb->mac.raw + 10, ETH_ALEN);
2420 static void mpi_unmap_card(struct pci_dev *pci)
2422 unsigned long mem_start = pci_resource_start(pci, 1);
2423 unsigned long mem_len = pci_resource_len(pci, 1);
2424 unsigned long aux_start = pci_resource_start(pci, 2);
2425 unsigned long aux_len = AUXMEMSIZE;
2427 release_mem_region(aux_start, aux_len);
2428 release_mem_region(mem_start, mem_len);
2431 /*************************************************************
2432 * This routine assumes that descriptors have been setup .
2433 * Run at insmod time or after reset when the decriptors
2434 * have been initialized . Returns 0 if all is well nz
2435 * otherwise . Does not allocate memory but sets up card
2436 * using previously allocated descriptors.
2438 static int mpi_init_descriptors (struct airo_info *ai)
2445 /* Alloc card RX descriptors */
2446 netif_stop_queue(ai->dev);
2448 memset(&rsp,0,sizeof(rsp));
2449 memset(&cmd,0,sizeof(cmd));
2451 cmd.cmd = CMD_ALLOCATEAUX;
2453 cmd.parm1 = (ai->rxfids[0].card_ram_off - ai->pciaux);
2454 cmd.parm2 = MPI_MAX_FIDS;
2455 rc=issuecommand(ai, &cmd, &rsp);
2456 if (rc != SUCCESS) {
2457 printk(KERN_ERR "airo: Couldn't allocate RX FID\n");
2461 for (i=0; i<MPI_MAX_FIDS; i++) {
2462 memcpy_toio(ai->rxfids[i].card_ram_off,
2463 &ai->rxfids[i].rx_desc, sizeof(RxFid));
2466 /* Alloc card TX descriptors */
2468 memset(&rsp,0,sizeof(rsp));
2469 memset(&cmd,0,sizeof(cmd));
2471 cmd.cmd = CMD_ALLOCATEAUX;
2473 cmd.parm1 = (ai->txfids[0].card_ram_off - ai->pciaux);
2474 cmd.parm2 = MPI_MAX_FIDS;
2476 for (i=0; i<MPI_MAX_FIDS; i++) {
2477 ai->txfids[i].tx_desc.valid = 1;
2478 memcpy_toio(ai->txfids[i].card_ram_off,
2479 &ai->txfids[i].tx_desc, sizeof(TxFid));
2481 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2483 rc=issuecommand(ai, &cmd, &rsp);
2484 if (rc != SUCCESS) {
2485 printk(KERN_ERR "airo: Couldn't allocate TX FID\n");
2489 /* Alloc card Rid descriptor */
2490 memset(&rsp,0,sizeof(rsp));
2491 memset(&cmd,0,sizeof(cmd));
2493 cmd.cmd = CMD_ALLOCATEAUX;
2495 cmd.parm1 = (ai->config_desc.card_ram_off - ai->pciaux);
2496 cmd.parm2 = 1; /* Magic number... */
2497 rc=issuecommand(ai, &cmd, &rsp);
2498 if (rc != SUCCESS) {
2499 printk(KERN_ERR "airo: Couldn't allocate RID\n");
2503 memcpy_toio(ai->config_desc.card_ram_off,
2504 &ai->config_desc.rid_desc, sizeof(Rid));
2510 * We are setting up three things here:
2511 * 1) Map AUX memory for descriptors: Rid, TxFid, or RxFid.
2512 * 2) Map PCI memory for issueing commands.
2513 * 3) Allocate memory (shared) to send and receive ethernet frames.
2515 static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci,
2518 unsigned long mem_start, mem_len, aux_start, aux_len;
2521 unsigned char *busaddroff,*vpackoff;
2522 unsigned char __iomem *pciaddroff;
2524 mem_start = pci_resource_start(pci, 1);
2525 mem_len = pci_resource_len(pci, 1);
2526 aux_start = pci_resource_start(pci, 2);
2527 aux_len = AUXMEMSIZE;
2529 if (!request_mem_region(mem_start, mem_len, name)) {
2530 printk(KERN_ERR "airo: Couldn't get region %x[%x] for %s\n",
2531 (int)mem_start, (int)mem_len, name);
2534 if (!request_mem_region(aux_start, aux_len, name)) {
2535 printk(KERN_ERR "airo: Couldn't get region %x[%x] for %s\n",
2536 (int)aux_start, (int)aux_len, name);
2540 ai->pcimem = ioremap(mem_start, mem_len);
2542 printk(KERN_ERR "airo: Couldn't map region %x[%x] for %s\n",
2543 (int)mem_start, (int)mem_len, name);
2546 ai->pciaux = ioremap(aux_start, aux_len);
2548 printk(KERN_ERR "airo: Couldn't map region %x[%x] for %s\n",
2549 (int)aux_start, (int)aux_len, name);
2553 /* Reserve PKTSIZE for each fid and 2K for the Rids */
2554 ai->shared = pci_alloc_consistent(pci, PCI_SHARED_LEN, &ai->shared_dma);
2556 printk(KERN_ERR "airo: Couldn't alloc_consistent %d\n",
2562 * Setup descriptor RX, TX, CONFIG
2564 busaddroff = (unsigned char *)ai->shared_dma;
2565 pciaddroff = ai->pciaux + AUX_OFFSET;
2566 vpackoff = ai->shared;
2568 /* RX descriptor setup */
2569 for(i = 0; i < MPI_MAX_FIDS; i++) {
2570 ai->rxfids[i].pending = 0;
2571 ai->rxfids[i].card_ram_off = pciaddroff;
2572 ai->rxfids[i].virtual_host_addr = vpackoff;
2573 ai->rxfids[i].rx_desc.host_addr = (dma_addr_t) busaddroff;
2574 ai->rxfids[i].rx_desc.valid = 1;
2575 ai->rxfids[i].rx_desc.len = PKTSIZE;
2576 ai->rxfids[i].rx_desc.rdy = 0;
2578 pciaddroff += sizeof(RxFid);
2579 busaddroff += PKTSIZE;
2580 vpackoff += PKTSIZE;
2583 /* TX descriptor setup */
2584 for(i = 0; i < MPI_MAX_FIDS; i++) {
2585 ai->txfids[i].card_ram_off = pciaddroff;
2586 ai->txfids[i].virtual_host_addr = vpackoff;
2587 ai->txfids[i].tx_desc.valid = 1;
2588 ai->txfids[i].tx_desc.host_addr = (dma_addr_t) busaddroff;
2589 memcpy(ai->txfids[i].virtual_host_addr,
2590 &wifictlhdr8023, sizeof(wifictlhdr8023));
2592 pciaddroff += sizeof(TxFid);
2593 busaddroff += PKTSIZE;
2594 vpackoff += PKTSIZE;
2596 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2598 /* Rid descriptor setup */
2599 ai->config_desc.card_ram_off = pciaddroff;
2600 ai->config_desc.virtual_host_addr = vpackoff;
2601 ai->config_desc.rid_desc.host_addr = (dma_addr_t) busaddroff;
2602 ai->ridbus = (dma_addr_t)busaddroff;
2603 ai->config_desc.rid_desc.rid = 0;
2604 ai->config_desc.rid_desc.len = RIDSIZE;
2605 ai->config_desc.rid_desc.valid = 1;
2606 pciaddroff += sizeof(Rid);
2607 busaddroff += RIDSIZE;
2608 vpackoff += RIDSIZE;
2610 /* Tell card about descriptors */
2611 if (mpi_init_descriptors (ai) != SUCCESS)
2616 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2618 iounmap(ai->pciaux);
2620 iounmap(ai->pcimem);
2622 release_mem_region(aux_start, aux_len);
2624 release_mem_region(mem_start, mem_len);
2629 static void wifi_setup(struct net_device *dev)
2631 dev->hard_header = NULL;
2632 dev->rebuild_header = NULL;
2633 dev->hard_header_cache = NULL;
2634 dev->header_cache_update= NULL;
2636 dev->hard_header_parse = wll_header_parse;
2637 dev->hard_start_xmit = &airo_start_xmit11;
2638 dev->get_stats = &airo_get_stats;
2639 dev->set_mac_address = &airo_set_mac_address;
2640 dev->do_ioctl = &airo_ioctl;
2642 dev->wireless_handlers = &airo_handler_def;
2643 #endif /* WIRELESS_EXT */
2644 dev->change_mtu = &airo_change_mtu;
2645 dev->open = &airo_open;
2646 dev->stop = &airo_close;
2648 dev->type = ARPHRD_IEEE80211;
2649 dev->hard_header_len = ETH_HLEN;
2651 dev->addr_len = ETH_ALEN;
2652 dev->tx_queue_len = 100;
2654 memset(dev->broadcast,0xFF, ETH_ALEN);
2656 dev->flags = IFF_BROADCAST|IFF_MULTICAST;
2659 static struct net_device *init_wifidev(struct airo_info *ai,
2660 struct net_device *ethdev)
2663 struct net_device *dev = alloc_netdev(0, "wifi%d", wifi_setup);
2666 dev->priv = ethdev->priv;
2667 dev->irq = ethdev->irq;
2668 dev->base_addr = ethdev->base_addr;
2670 dev->wireless_data = ethdev->wireless_data;
2671 #endif /* WIRELESS_EXT */
2672 memcpy(dev->dev_addr, ethdev->dev_addr, dev->addr_len);
2673 err = register_netdev(dev);
2681 int reset_card( struct net_device *dev , int lock) {
2682 struct airo_info *ai = dev->priv;
2684 if (lock && down_interruptible(&ai->sem))
2687 OUT4500(ai,COMMAND,CMD_SOFTRESET);
2688 set_current_state (TASK_UNINTERRUPTIBLE);
2689 schedule_timeout (HZ/5);
2691 set_current_state (TASK_UNINTERRUPTIBLE);
2692 schedule_timeout (HZ/5);
2698 struct net_device *_init_airo_card( unsigned short irq, int port,
2699 int is_pcmcia, struct pci_dev *pci,
2700 struct device *dmdev )
2702 struct net_device *dev;
2703 struct airo_info *ai;
2706 /* Create the network device object. */
2707 dev = alloc_etherdev(sizeof(*ai));
2709 printk(KERN_ERR "airo: Couldn't alloc_etherdev\n");
2712 if (dev_alloc_name(dev, dev->name) < 0) {
2713 printk(KERN_ERR "airo: Couldn't get name!\n");
2720 if (pci && (pci->device == 0x5000 || pci->device == 0xa504)) {
2721 printk(KERN_DEBUG "airo: Found an MPI350 card\n");
2722 set_bit(FLAG_MPI, &ai->flags);
2725 spin_lock_init(&ai->aux_lock);
2726 sema_init(&ai->sem, 1);
2729 init_waitqueue_head (&ai->thr_wait);
2730 init_completion (&ai->thr_exited);
2731 ai->thr_pid = kernel_thread(airo_thread, dev, CLONE_FS | CLONE_FILES);
2732 if (ai->thr_pid < 0)
2737 rc = add_airo_dev( dev );
2741 /* The Airo-specific entries in the device structure. */
2742 if (test_bit(FLAG_MPI,&ai->flags)) {
2743 skb_queue_head_init (&ai->txq);
2744 dev->hard_start_xmit = &mpi_start_xmit;
2746 dev->hard_start_xmit = &airo_start_xmit;
2747 dev->get_stats = &airo_get_stats;
2748 dev->set_multicast_list = &airo_set_multicast_list;
2749 dev->set_mac_address = &airo_set_mac_address;
2750 dev->do_ioctl = &airo_ioctl;
2752 dev->wireless_handlers = &airo_handler_def;
2753 ai->wireless_data.spy_data = &ai->spy_data;
2754 dev->wireless_data = &ai->wireless_data;
2755 #endif /* WIRELESS_EXT */
2756 dev->change_mtu = &airo_change_mtu;
2757 dev->open = &airo_open;
2758 dev->stop = &airo_close;
2760 dev->base_addr = port;
2762 SET_NETDEV_DEV(dev, dmdev);
2765 if (test_bit(FLAG_MPI,&ai->flags))
2766 reset_card (dev, 1);
2768 rc = request_irq( dev->irq, airo_interrupt, SA_SHIRQ, dev->name, dev );
2770 printk(KERN_ERR "airo: register interrupt %d failed, rc %d\n", irq, rc );
2771 goto err_out_unlink;
2774 if (!request_region( dev->base_addr, 64, dev->name )) {
2776 printk(KERN_ERR "airo: Couldn't request region\n");
2781 if (test_bit(FLAG_MPI,&ai->flags)) {
2782 if (mpi_map_card(ai, pci, dev->name)) {
2783 printk(KERN_ERR "airo: Could not map memory\n");
2789 if ( setup_card( ai, dev->dev_addr, 1 ) != SUCCESS ) {
2790 printk( KERN_ERR "airo: MAC could not be enabled\n" );
2794 } else if (!test_bit(FLAG_MPI,&ai->flags)) {
2795 ai->bap_read = fast_bap_read;
2796 set_bit(FLAG_FLASHING, &ai->flags);
2799 rc = register_netdev(dev);
2801 printk(KERN_ERR "airo: Couldn't register_netdev\n");
2804 ai->wifidev = init_wifidev(ai, dev);
2806 set_bit(FLAG_REGISTERED,&ai->flags);
2807 printk( KERN_INFO "airo: MAC enabled %s %x:%x:%x:%x:%x:%x\n",
2809 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
2810 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5] );
2812 /* Allocate the transmit buffers */
2813 if (probe && !test_bit(FLAG_MPI,&ai->flags))
2814 for( i = 0; i < MAX_FIDS; i++ )
2815 ai->fids[i] = transmit_allocate(ai,2312,i>=MAX_FIDS/2);
2817 setup_proc_entry( dev, dev->priv ); /* XXX check for failure */
2818 netif_start_queue(dev);
2819 SET_MODULE_OWNER(dev);
2823 if (test_bit(FLAG_MPI,&ai->flags) && pci) {
2824 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2825 iounmap(ai->pciaux);
2826 iounmap(ai->pcimem);
2827 mpi_unmap_card(ai->pci);
2831 release_region( dev->base_addr, 64 );
2833 free_irq(dev->irq, dev);
2837 set_bit(JOB_DIE, &ai->flags);
2838 kill_proc(ai->thr_pid, SIGTERM, 1);
2839 wait_for_completion(&ai->thr_exited);
2845 struct net_device *init_airo_card( unsigned short irq, int port, int is_pcmcia,
2846 struct device *dmdev)
2848 return _init_airo_card ( irq, port, is_pcmcia, NULL, dmdev);
2851 EXPORT_SYMBOL(init_airo_card);
2853 static int waitbusy (struct airo_info *ai) {
2855 while ((IN4500 (ai, COMMAND) & COMMAND_BUSY) & (delay < 10000)) {
2857 if ((++delay % 20) == 0)
2858 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
2860 return delay < 10000;
2863 int reset_airo_card( struct net_device *dev )
2866 struct airo_info *ai = dev->priv;
2868 if (reset_card (dev, 1))
2871 if ( setup_card(ai, dev->dev_addr, 1 ) != SUCCESS ) {
2872 printk( KERN_ERR "airo: MAC could not be enabled\n" );
2875 printk( KERN_INFO "airo: MAC enabled %s %x:%x:%x:%x:%x:%x\n", dev->name,
2876 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
2877 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
2878 /* Allocate the transmit buffers if needed */
2879 if (!test_bit(FLAG_MPI,&ai->flags))
2880 for( i = 0; i < MAX_FIDS; i++ )
2881 ai->fids[i] = transmit_allocate (ai,2312,i>=MAX_FIDS/2);
2883 enable_interrupts( ai );
2884 netif_wake_queue(dev);
2888 EXPORT_SYMBOL(reset_airo_card);
2890 static void airo_send_event(struct net_device *dev) {
2891 struct airo_info *ai = dev->priv;
2892 union iwreq_data wrqu;
2893 StatusRid status_rid;
2895 clear_bit(JOB_EVENT, &ai->flags);
2896 PC4500_readrid(ai, RID_STATUS, &status_rid, sizeof(status_rid), 0);
2898 wrqu.data.length = 0;
2899 wrqu.data.flags = 0;
2900 memcpy(wrqu.ap_addr.sa_data, status_rid.bssid[0], ETH_ALEN);
2901 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
2903 /* Send event to user space */
2904 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
2907 static int airo_thread(void *data) {
2908 struct net_device *dev = data;
2909 struct airo_info *ai = dev->priv;
2912 daemonize("%s", dev->name);
2913 allow_signal(SIGTERM);
2916 if (signal_pending(current))
2917 flush_signals(current);
2919 /* make swsusp happy with our thread */
2920 try_to_freeze(PF_FREEZE);
2922 if (test_bit(JOB_DIE, &ai->flags))
2925 if (ai->flags & JOB_MASK) {
2926 locked = down_interruptible(&ai->sem);
2930 init_waitqueue_entry(&wait, current);
2931 add_wait_queue(&ai->thr_wait, &wait);
2933 set_current_state(TASK_INTERRUPTIBLE);
2934 if (ai->flags & JOB_MASK)
2937 if (time_after_eq(jiffies,ai->expires)){
2938 set_bit(JOB_AUTOWEP,&ai->flags);
2941 if (!signal_pending(current)) {
2942 schedule_timeout(ai->expires - jiffies);
2945 } else if (!signal_pending(current)) {
2951 current->state = TASK_RUNNING;
2952 remove_wait_queue(&ai->thr_wait, &wait);
2959 if (test_bit(JOB_DIE, &ai->flags)) {
2964 if (ai->power || test_bit(FLAG_FLASHING, &ai->flags)) {
2969 if (test_bit(JOB_XMIT, &ai->flags))
2971 else if (test_bit(JOB_XMIT11, &ai->flags))
2972 airo_end_xmit11(dev);
2973 else if (test_bit(JOB_STATS, &ai->flags))
2974 airo_read_stats(ai);
2975 else if (test_bit(JOB_WSTATS, &ai->flags))
2976 airo_read_wireless_stats(ai);
2977 else if (test_bit(JOB_PROMISC, &ai->flags))
2978 airo_set_promisc(ai);
2980 else if (test_bit(JOB_MIC, &ai->flags))
2983 else if (test_bit(JOB_EVENT, &ai->flags))
2984 airo_send_event(dev);
2985 else if (test_bit(JOB_AUTOWEP, &ai->flags))
2988 complete_and_exit (&ai->thr_exited, 0);
2991 static irqreturn_t airo_interrupt ( int irq, void* dev_id, struct pt_regs *regs) {
2992 struct net_device *dev = (struct net_device *)dev_id;
2995 struct airo_info *apriv = dev->priv;
2996 u16 savedInterrupts = 0;
2999 if (!netif_device_present(dev))
3003 status = IN4500( apriv, EVSTAT );
3004 if ( !(status & STATUS_INTS) || status == 0xffff ) break;
3008 if ( status & EV_AWAKE ) {
3009 OUT4500( apriv, EVACK, EV_AWAKE );
3010 OUT4500( apriv, EVACK, EV_AWAKE );
3013 if (!savedInterrupts) {
3014 savedInterrupts = IN4500( apriv, EVINTEN );
3015 OUT4500( apriv, EVINTEN, 0 );
3018 if ( status & EV_MIC ) {
3019 OUT4500( apriv, EVACK, EV_MIC );
3021 if (test_bit(FLAG_MIC_CAPABLE, &apriv->flags)) {
3022 set_bit(JOB_MIC, &apriv->flags);
3023 wake_up_interruptible(&apriv->thr_wait);
3027 if ( status & EV_LINK ) {
3028 union iwreq_data wrqu;
3029 /* The link status has changed, if you want to put a
3030 monitor hook in, do it here. (Remember that
3031 interrupts are still disabled!)
3033 u16 newStatus = IN4500(apriv, LINKSTAT);
3034 OUT4500( apriv, EVACK, EV_LINK);
3035 /* Here is what newStatus means: */
3036 #define NOBEACON 0x8000 /* Loss of sync - missed beacons */
3037 #define MAXRETRIES 0x8001 /* Loss of sync - max retries */
3038 #define MAXARL 0x8002 /* Loss of sync - average retry level exceeded*/
3039 #define FORCELOSS 0x8003 /* Loss of sync - host request */
3040 #define TSFSYNC 0x8004 /* Loss of sync - TSF synchronization */
3041 #define DEAUTH 0x8100 /* Deauthentication (low byte is reason code) */
3042 #define DISASS 0x8200 /* Disassociation (low byte is reason code) */
3043 #define ASSFAIL 0x8400 /* Association failure (low byte is reason
3045 #define AUTHFAIL 0x0300 /* Authentication failure (low byte is reason
3047 #define ASSOCIATED 0x0400 /* Assocatied */
3048 #define RC_RESERVED 0 /* Reserved return code */
3049 #define RC_NOREASON 1 /* Unspecified reason */
3050 #define RC_AUTHINV 2 /* Previous authentication invalid */
3051 #define RC_DEAUTH 3 /* Deauthenticated because sending station is
3053 #define RC_NOACT 4 /* Disassociated due to inactivity */
3054 #define RC_MAXLOAD 5 /* Disassociated because AP is unable to handle
3055 all currently associated stations */
3056 #define RC_BADCLASS2 6 /* Class 2 frame received from
3057 non-Authenticated station */
3058 #define RC_BADCLASS3 7 /* Class 3 frame received from
3059 non-Associated station */
3060 #define RC_STATLEAVE 8 /* Disassociated because sending station is
3062 #define RC_NOAUTH 9 /* Station requesting (Re)Association is not
3063 Authenticated with the responding station */
3064 if (newStatus != ASSOCIATED) {
3065 if (auto_wep && !apriv->expires) {
3066 apriv->expires = RUN_AT(3*HZ);
3067 wake_up_interruptible(&apriv->thr_wait);
3070 struct task_struct *task = apriv->task;
3074 wake_up_process (task);
3075 set_bit(FLAG_UPDATE_UNI, &apriv->flags);
3076 set_bit(FLAG_UPDATE_MULTI, &apriv->flags);
3078 /* Question : is ASSOCIATED the only status
3079 * that is valid ? We want to catch handover
3080 * and reassociations as valid status
3082 if(newStatus == ASSOCIATED) {
3083 if (apriv->scan_timestamp) {
3084 /* Send an empty event to user space.
3085 * We don't send the received data on
3086 * the event because it would require
3087 * us to do complex transcoding, and
3088 * we want to minimise the work done in
3089 * the irq handler. Use a request to
3090 * extract the data - Jean II */
3091 wrqu.data.length = 0;
3092 wrqu.data.flags = 0;
3093 wireless_send_event(dev, SIOCGIWSCAN, &wrqu, NULL);
3094 apriv->scan_timestamp = 0;
3096 if (down_trylock(&apriv->sem) != 0) {
3097 set_bit(JOB_EVENT, &apriv->flags);
3098 wake_up_interruptible(&apriv->thr_wait);
3100 airo_send_event(dev);
3102 memset(wrqu.ap_addr.sa_data, '\0', ETH_ALEN);
3103 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
3105 /* Send event to user space */
3106 wireless_send_event(dev, SIOCGIWAP, &wrqu,NULL);
3110 /* Check to see if there is something to receive */
3111 if ( status & EV_RX ) {
3112 struct sk_buff *skb = NULL;
3113 u16 fc, len, hdrlen = 0;
3127 if (test_bit(FLAG_MPI,&apriv->flags)) {
3128 if (test_bit(FLAG_802_11, &apriv->flags))
3129 mpi_receive_802_11(apriv);
3131 mpi_receive_802_3(apriv);
3132 OUT4500(apriv, EVACK, EV_RX);
3136 fid = IN4500( apriv, RXFID );
3138 /* Get the packet length */
3139 if (test_bit(FLAG_802_11, &apriv->flags)) {
3140 bap_setup (apriv, fid, 4, BAP0);
3141 bap_read (apriv, (u16*)&hdr, sizeof(hdr), BAP0);
3142 /* Bad CRC. Ignore packet */
3143 if (le16_to_cpu(hdr.status) & 2)
3145 if (apriv->wifidev == NULL)
3148 bap_setup (apriv, fid, 0x36, BAP0);
3149 bap_read (apriv, (u16*)&hdr.len, 2, BAP0);
3151 len = le16_to_cpu(hdr.len);
3154 printk( KERN_ERR "airo: Bad size %d\n", len );
3160 if (test_bit(FLAG_802_11, &apriv->flags)) {
3161 bap_read (apriv, (u16*)&fc, sizeof(fc), BAP0);
3162 fc = le16_to_cpu(fc);
3165 if ((fc & 0xe0) == 0xc0)
3171 if ((fc&0x300)==0x300){
3179 hdrlen = ETH_ALEN * 2;
3181 skb = dev_alloc_skb( len + hdrlen + 2 + 2 );
3183 apriv->stats.rx_dropped++;
3186 skb_reserve(skb, 2); /* This way the IP header is aligned */
3187 buffer = (u16*)skb_put (skb, len + hdrlen);
3188 if (test_bit(FLAG_802_11, &apriv->flags)) {
3190 bap_read (apriv, buffer + 1, hdrlen - 2, BAP0);
3192 bap_read (apriv, tmpbuf, 6, BAP0);
3194 bap_read (apriv, &gap, sizeof(gap), BAP0);
3195 gap = le16_to_cpu(gap);
3198 bap_read (apriv, tmpbuf, gap, BAP0);
3200 printk(KERN_ERR "airo: gaplen too big. Problems will follow...\n");
3202 bap_read (apriv, buffer + hdrlen/2, len, BAP0);
3207 bap_read (apriv, buffer, ETH_ALEN*2, BAP0);
3209 if (apriv->micstats.enabled) {
3210 bap_read (apriv,(u16*)&micbuf,sizeof(micbuf),BAP0);
3211 if (ntohs(micbuf.typelen) > 0x05DC)
3212 bap_setup (apriv, fid, 0x44, BAP0);
3214 if (len <= sizeof(micbuf))
3217 len -= sizeof(micbuf);
3218 skb_trim (skb, len + hdrlen);
3222 bap_read(apriv,buffer+ETH_ALEN,len,BAP0);
3224 if (decapsulate(apriv,&micbuf,(etherHead*)buffer,len)) {
3226 dev_kfree_skb_irq (skb);
3231 OUT4500( apriv, EVACK, EV_RX);
3236 if (apriv->spy_data.spy_number > 0) {
3238 struct iw_quality wstats;
3239 /* Prepare spy data : addr + qual */
3240 if (!test_bit(FLAG_802_11, &apriv->flags)) {
3241 sa = (char*)buffer + 6;
3242 bap_setup (apriv, fid, 8, BAP0);
3243 bap_read (apriv, (u16*)hdr.rssi, 2, BAP0);
3245 sa = (char*)buffer + 10;
3246 wstats.qual = hdr.rssi[0];
3248 wstats.level = 0x100 - apriv->rssi[hdr.rssi[1]].rssidBm;
3250 wstats.level = (hdr.rssi[1] + 321) / 2;
3252 /* Update spy records */
3253 wireless_spy_update(dev, sa, &wstats);
3255 #endif /* WIRELESS_SPY */
3256 OUT4500( apriv, EVACK, EV_RX);
3258 if (test_bit(FLAG_802_11, &apriv->flags)) {
3259 skb->mac.raw = skb->data;
3260 skb->pkt_type = PACKET_OTHERHOST;
3261 skb->dev = apriv->wifidev;
3262 skb->protocol = htons(ETH_P_802_2);
3265 skb->protocol = eth_type_trans(skb,dev);
3267 skb->dev->last_rx = jiffies;
3268 skb->ip_summed = CHECKSUM_NONE;
3274 /* Check to see if a packet has been transmitted */
3275 if ( status & ( EV_TX|EV_TXCPY|EV_TXEXC ) ) {
3280 if (test_bit(FLAG_MPI,&apriv->flags)) {
3281 unsigned long flags;
3283 if (status & EV_TXEXC)
3284 get_tx_error(apriv, -1);
3285 spin_lock_irqsave(&apriv->aux_lock, flags);
3286 if (skb_queue_len (&apriv->txq)) {
3287 spin_unlock_irqrestore(&apriv->aux_lock,flags);
3288 mpi_send_packet (dev);
3290 clear_bit(FLAG_PENDING_XMIT, &apriv->flags);
3291 spin_unlock_irqrestore(&apriv->aux_lock,flags);
3292 netif_wake_queue (dev);
3294 OUT4500( apriv, EVACK,
3295 status & (EV_TX|EV_TXCPY|EV_TXEXC));
3299 fid = IN4500(apriv, TXCOMPLFID);
3301 for( i = 0; i < MAX_FIDS; i++ ) {
3302 if ( ( apriv->fids[i] & 0xffff ) == fid ) {
3303 len = apriv->fids[i] >> 16;
3308 if (status & EV_TXEXC)
3309 get_tx_error(apriv, index);
3310 OUT4500( apriv, EVACK, status & (EV_TX | EV_TXEXC));
3311 /* Set up to be used again */
3312 apriv->fids[index] &= 0xffff;
3313 if (index < MAX_FIDS / 2) {
3314 if (!test_bit(FLAG_PENDING_XMIT, &apriv->flags))
3315 netif_wake_queue(dev);
3317 if (!test_bit(FLAG_PENDING_XMIT11, &apriv->flags))
3318 netif_wake_queue(apriv->wifidev);
3321 OUT4500( apriv, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3322 printk( KERN_ERR "airo: Unallocated FID was used to xmit\n" );
3326 if ( status & ~STATUS_INTS & ~IGNORE_INTS )
3327 printk( KERN_WARNING "airo: Got weird status %x\n",
3328 status & ~STATUS_INTS & ~IGNORE_INTS );
3331 if (savedInterrupts)
3332 OUT4500( apriv, EVINTEN, savedInterrupts );
3335 return IRQ_RETVAL(handled);
3339 * Routines to talk to the card
3343 * This was originally written for the 4500, hence the name
3344 * NOTE: If use with 8bit mode and SMP bad things will happen!
3345 * Why would some one do 8 bit IO in an SMP machine?!?
3347 static void OUT4500( struct airo_info *ai, u16 reg, u16 val ) {
3348 if (test_bit(FLAG_MPI,&ai->flags))
3351 outw( val, ai->dev->base_addr + reg );
3353 outb( val & 0xff, ai->dev->base_addr + reg );
3354 outb( val >> 8, ai->dev->base_addr + reg + 1 );
3358 static u16 IN4500( struct airo_info *ai, u16 reg ) {
3361 if (test_bit(FLAG_MPI,&ai->flags))
3364 rc = inw( ai->dev->base_addr + reg );
3366 rc = inb( ai->dev->base_addr + reg );
3367 rc += ((int)inb( ai->dev->base_addr + reg + 1 )) << 8;
3372 static int enable_MAC( struct airo_info *ai, Resp *rsp, int lock ) {
3376 /* FLAG_RADIO_OFF : Radio disabled via /proc or Wireless Extensions
3377 * FLAG_RADIO_DOWN : Radio disabled via "ifconfig ethX down"
3378 * Note : we could try to use !netif_running(dev) in enable_MAC()
3379 * instead of this flag, but I don't trust it *within* the
3380 * open/close functions, and testing both flags together is
3381 * "cheaper" - Jean II */
3382 if (ai->flags & FLAG_RADIO_MASK) return SUCCESS;
3384 if (lock && down_interruptible(&ai->sem))
3385 return -ERESTARTSYS;
3387 if (!test_bit(FLAG_ENABLED, &ai->flags)) {
3388 memset(&cmd, 0, sizeof(cmd));
3389 cmd.cmd = MAC_ENABLE;
3390 rc = issuecommand(ai, &cmd, rsp);
3392 set_bit(FLAG_ENABLED, &ai->flags);
3400 printk(KERN_ERR "%s: Cannot enable MAC, err=%d\n",
3405 static void disable_MAC( struct airo_info *ai, int lock ) {
3409 if (lock && down_interruptible(&ai->sem))
3412 if (test_bit(FLAG_ENABLED, &ai->flags)) {
3413 memset(&cmd, 0, sizeof(cmd));
3414 cmd.cmd = MAC_DISABLE; // disable in case already enabled
3415 issuecommand(ai, &cmd, &rsp);
3416 clear_bit(FLAG_ENABLED, &ai->flags);
3422 static void enable_interrupts( struct airo_info *ai ) {
3423 /* Enable the interrupts */
3424 OUT4500( ai, EVINTEN, STATUS_INTS );
3427 static void disable_interrupts( struct airo_info *ai ) {
3428 OUT4500( ai, EVINTEN, 0 );
3431 static void mpi_receive_802_3(struct airo_info *ai)
3435 struct sk_buff *skb;
3442 memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3443 /* Make sure we got something */
3444 if (rxd.rdy && rxd.valid == 0) {
3446 if (len < 12 && len > 2048)
3449 skb = dev_alloc_skb(len);
3451 ai->stats.rx_dropped++;
3454 buffer = skb_put(skb,len);
3456 memcpy(buffer, ai->rxfids[0].virtual_host_addr, ETH_ALEN * 2);
3457 if (ai->micstats.enabled) {
3459 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2,
3461 if (ntohs(micbuf.typelen) <= 0x05DC) {
3462 if (len <= sizeof(micbuf) + ETH_ALEN * 2)
3465 off = sizeof(micbuf);
3466 skb_trim (skb, len - off);
3469 memcpy(buffer + ETH_ALEN * 2,
3470 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2 + off,
3471 len - ETH_ALEN * 2 - off);
3472 if (decapsulate (ai, &micbuf, (etherHead*)buffer, len - off - ETH_ALEN * 2)) {
3474 dev_kfree_skb_irq (skb);
3478 memcpy(buffer, ai->rxfids[0].virtual_host_addr, len);
3481 if (ai->spy_data.spy_number > 0) {
3483 struct iw_quality wstats;
3484 /* Prepare spy data : addr + qual */
3485 sa = buffer + ETH_ALEN;
3486 wstats.qual = 0; /* XXX Where do I get that info from ??? */
3489 /* Update spy records */
3490 wireless_spy_update(ai->dev, sa, &wstats);
3492 #endif /* WIRELESS_SPY */
3495 skb->ip_summed = CHECKSUM_NONE;
3496 skb->protocol = eth_type_trans(skb, ai->dev);
3497 skb->dev->last_rx = jiffies;
3501 if (rxd.valid == 0) {
3505 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3509 void mpi_receive_802_11 (struct airo_info *ai)
3512 struct sk_buff *skb = NULL;
3513 u16 fc, len, hdrlen = 0;
3525 char *ptr = ai->rxfids[0].virtual_host_addr+4;
3527 memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3528 memcpy ((char *)&hdr, ptr, sizeof(hdr));
3530 /* Bad CRC. Ignore packet */
3531 if (le16_to_cpu(hdr.status) & 2)
3533 if (ai->wifidev == NULL)
3535 len = le16_to_cpu(hdr.len);
3537 printk( KERN_ERR "airo: Bad size %d\n", len );
3543 memcpy ((char *)&fc, ptr, sizeof(fc));
3544 fc = le16_to_cpu(fc);
3547 if ((fc & 0xe0) == 0xc0)
3553 if ((fc&0x300)==0x300){
3561 skb = dev_alloc_skb( len + hdrlen + 2 );
3563 ai->stats.rx_dropped++;
3566 buffer = (u16*)skb_put (skb, len + hdrlen);
3567 memcpy ((char *)buffer, ptr, hdrlen);
3571 memcpy ((char *)&gap, ptr, sizeof(gap));
3573 gap = le16_to_cpu(gap);
3579 "airo: gaplen too big. Problems will follow...\n");
3581 memcpy ((char *)buffer + hdrlen, ptr, len);
3583 #ifdef IW_WIRELESS_SPY /* defined in iw_handler.h */
3584 if (ai->spy_data.spy_number > 0) {
3586 struct iw_quality wstats;
3587 /* Prepare spy data : addr + qual */
3588 sa = (char*)buffer + 10;
3589 wstats.qual = hdr.rssi[0];
3591 wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3593 wstats.level = (hdr.rssi[1] + 321) / 2;
3595 /* Update spy records */
3596 wireless_spy_update(ai->dev, sa, &wstats);
3598 #endif /* IW_WIRELESS_SPY */
3599 skb->mac.raw = skb->data;
3600 skb->pkt_type = PACKET_OTHERHOST;
3601 skb->dev = ai->wifidev;
3602 skb->protocol = htons(ETH_P_802_2);
3603 skb->dev->last_rx = jiffies;
3604 skb->ip_summed = CHECKSUM_NONE;
3607 if (rxd.valid == 0) {
3611 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3615 static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
3626 memset( &mySsid, 0, sizeof( mySsid ) );
3632 /* The NOP is the first step in getting the card going */
3634 cmd.parm0 = cmd.parm1 = cmd.parm2 = 0;
3635 if (lock && down_interruptible(&ai->sem))
3637 if ( issuecommand( ai, &cmd, &rsp ) != SUCCESS ) {
3642 disable_MAC( ai, 0);
3644 // Let's figure out if we need to use the AUX port
3645 if (!test_bit(FLAG_MPI,&ai->flags)) {
3646 cmd.cmd = CMD_ENABLEAUX;
3647 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
3650 printk(KERN_ERR "airo: Error checking for AUX port\n");
3653 if (!aux_bap || rsp.status & 0xff00) {
3654 ai->bap_read = fast_bap_read;
3655 printk(KERN_DEBUG "airo: Doing fast bap_reads\n");
3657 ai->bap_read = aux_bap_read;
3658 printk(KERN_DEBUG "airo: Doing AUX bap_reads\n");
3663 if (ai->config.len == 0) {
3664 tdsRssiRid rssi_rid;
3665 CapabilityRid cap_rid;
3675 // general configuration (read/modify/write)
3676 status = readConfigRid(ai, lock);
3677 if ( status != SUCCESS ) return ERROR;
3679 status = readCapabilityRid(ai, &cap_rid, lock);
3680 if ( status != SUCCESS ) return ERROR;
3682 status = PC4500_readrid(ai,RID_RSSI,&rssi_rid,sizeof(rssi_rid),lock);
3683 if ( status == SUCCESS ) {
3684 if (ai->rssi || (ai->rssi = kmalloc(512, GFP_KERNEL)) != NULL)
3685 memcpy(ai->rssi, (u8*)&rssi_rid + 2, 512);
3692 if (cap_rid.softCap & 8)
3693 ai->config.rmode |= RXMODE_NORMALIZED_RSSI;
3695 printk(KERN_WARNING "airo: unknown received signal level scale\n");
3697 ai->config.opmode = adhoc ? MODE_STA_IBSS : MODE_STA_ESS;
3698 ai->config.authType = AUTH_OPEN;
3699 ai->config.modulation = MOD_CCK;
3702 if ((cap_rid.len>=sizeof(cap_rid)) && (cap_rid.extSoftCap&1) &&
3703 (micsetup(ai) == SUCCESS)) {
3704 ai->config.opmode |= MODE_MIC;
3705 set_bit(FLAG_MIC_CAPABLE, &ai->flags);
3709 /* Save off the MAC */
3710 for( i = 0; i < ETH_ALEN; i++ ) {
3711 mac[i] = ai->config.macAddr[i];
3714 /* Check to see if there are any insmod configured
3718 memset(ai->config.rates,0,sizeof(ai->config.rates));
3719 for( i = 0; i < 8 && rates[i]; i++ ) {
3720 ai->config.rates[i] = rates[i];
3723 if ( basic_rate > 0 ) {
3725 for( i = 0; i < 8; i++ ) {
3726 if ( ai->config.rates[i] == basic_rate ||
3727 !ai->config.rates ) {
3728 ai->config.rates[i] = basic_rate | 0x80;
3733 set_bit (FLAG_COMMIT, &ai->flags);
3736 /* Setup the SSIDs if present */
3739 for( i = 0; i < 3 && ssids[i]; i++ ) {
3740 mySsid.ssids[i].len = strlen(ssids[i]);
3741 if ( mySsid.ssids[i].len > 32 )
3742 mySsid.ssids[i].len = 32;
3743 memcpy(mySsid.ssids[i].ssid, ssids[i],
3744 mySsid.ssids[i].len);
3746 mySsid.len = sizeof(mySsid);
3749 status = writeConfigRid(ai, lock);
3750 if ( status != SUCCESS ) return ERROR;
3752 /* Set up the SSID list */
3754 status = writeSsidRid(ai, &mySsid, lock);
3755 if ( status != SUCCESS ) return ERROR;
3758 status = enable_MAC(ai, &rsp, lock);
3759 if ( status != SUCCESS || (rsp.status & 0xFF00) != 0) {
3760 printk( KERN_ERR "airo: Bad MAC enable reason = %x, rid = %x, offset = %d\n", rsp.rsp0, rsp.rsp1, rsp.rsp2 );
3764 /* Grab the initial wep key, we gotta save it for auto_wep */
3765 rc = readWepKeyRid(ai, &wkr, 1, lock);
3766 if (rc == SUCCESS) do {
3767 lastindex = wkr.kindex;
3768 if (wkr.kindex == 0xffff) {
3769 ai->defindex = wkr.mac[0];
3771 rc = readWepKeyRid(ai, &wkr, 0, lock);
3772 } while(lastindex != wkr.kindex);
3775 ai->expires = RUN_AT(3*HZ);
3776 wake_up_interruptible(&ai->thr_wait);
3782 static u16 issuecommand(struct airo_info *ai, Cmd *pCmd, Resp *pRsp) {
3783 // Im really paranoid about letting it run forever!
3784 int max_tries = 600000;
3786 if (IN4500(ai, EVSTAT) & EV_CMD)
3787 OUT4500(ai, EVACK, EV_CMD);
3789 OUT4500(ai, PARAM0, pCmd->parm0);
3790 OUT4500(ai, PARAM1, pCmd->parm1);
3791 OUT4500(ai, PARAM2, pCmd->parm2);
3792 OUT4500(ai, COMMAND, pCmd->cmd);
3794 while (max_tries-- && (IN4500(ai, EVSTAT) & EV_CMD) == 0) {
3795 if ((IN4500(ai, COMMAND)) == pCmd->cmd)
3796 // PC4500 didn't notice command, try again
3797 OUT4500(ai, COMMAND, pCmd->cmd);
3798 if (!in_atomic() && (max_tries & 255) == 0)
3802 if ( max_tries == -1 ) {
3804 "airo: Max tries exceeded when issueing command\n" );
3805 if (IN4500(ai, COMMAND) & COMMAND_BUSY)
3806 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3810 // command completed
3811 pRsp->status = IN4500(ai, STATUS);
3812 pRsp->rsp0 = IN4500(ai, RESP0);
3813 pRsp->rsp1 = IN4500(ai, RESP1);
3814 pRsp->rsp2 = IN4500(ai, RESP2);
3815 if ((pRsp->status & 0xff00)!=0 && pCmd->cmd != CMD_SOFTRESET) {
3816 printk (KERN_ERR "airo: cmd= %x\n", pCmd->cmd);
3817 printk (KERN_ERR "airo: status= %x\n", pRsp->status);
3818 printk (KERN_ERR "airo: Rsp0= %x\n", pRsp->rsp0);
3819 printk (KERN_ERR "airo: Rsp1= %x\n", pRsp->rsp1);
3820 printk (KERN_ERR "airo: Rsp2= %x\n", pRsp->rsp2);
3823 // clear stuck command busy if necessary
3824 if (IN4500(ai, COMMAND) & COMMAND_BUSY) {
3825 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3827 // acknowledge processing the status/response
3828 OUT4500(ai, EVACK, EV_CMD);
3833 /* Sets up the bap to start exchange data. whichbap should
3834 * be one of the BAP0 or BAP1 defines. Locks should be held before
3836 static int bap_setup(struct airo_info *ai, u16 rid, u16 offset, int whichbap )
3841 OUT4500(ai, SELECT0+whichbap, rid);
3842 OUT4500(ai, OFFSET0+whichbap, offset);
3844 int status = IN4500(ai, OFFSET0+whichbap);
3845 if (status & BAP_BUSY) {
3846 /* This isn't really a timeout, but its kinda
3851 } else if ( status & BAP_ERR ) {
3852 /* invalid rid or offset */
3853 printk( KERN_ERR "airo: BAP error %x %d\n",
3856 } else if (status & BAP_DONE) { // success
3859 if ( !(max_tries--) ) {
3861 "airo: BAP setup error too many retries\n" );
3864 // -- PC4500 missed it, try again
3865 OUT4500(ai, SELECT0+whichbap, rid);
3866 OUT4500(ai, OFFSET0+whichbap, offset);
3871 /* should only be called by aux_bap_read. This aux function and the
3872 following use concepts not documented in the developers guide. I
3873 got them from a patch given to my by Aironet */
3874 static u16 aux_setup(struct airo_info *ai, u16 page,
3875 u16 offset, u16 *len)
3879 OUT4500(ai, AUXPAGE, page);
3880 OUT4500(ai, AUXOFF, 0);
3881 next = IN4500(ai, AUXDATA);
3882 *len = IN4500(ai, AUXDATA)&0xff;
3883 if (offset != 4) OUT4500(ai, AUXOFF, offset);
3887 /* requires call to bap_setup() first */
3888 static int aux_bap_read(struct airo_info *ai, u16 *pu16Dst,
3889 int bytelen, int whichbap)
3897 unsigned long flags;
3899 spin_lock_irqsave(&ai->aux_lock, flags);
3900 page = IN4500(ai, SWS0+whichbap);
3901 offset = IN4500(ai, SWS2+whichbap);
3902 next = aux_setup(ai, page, offset, &len);
3903 words = (bytelen+1)>>1;
3905 for (i=0; i<words;) {
3907 count = (len>>1) < (words-i) ? (len>>1) : (words-i);
3909 insw( ai->dev->base_addr+DATA0+whichbap,
3912 insb( ai->dev->base_addr+DATA0+whichbap,
3913 pu16Dst+i, count << 1 );
3916 next = aux_setup(ai, next, 4, &len);
3919 spin_unlock_irqrestore(&ai->aux_lock, flags);
3924 /* requires call to bap_setup() first */
3925 static int fast_bap_read(struct airo_info *ai, u16 *pu16Dst,
3926 int bytelen, int whichbap)
3928 bytelen = (bytelen + 1) & (~1); // round up to even value
3930 insw( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen>>1 );
3932 insb( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen );
3936 /* requires call to bap_setup() first */
3937 static int bap_write(struct airo_info *ai, const u16 *pu16Src,
3938 int bytelen, int whichbap)
3940 bytelen = (bytelen + 1) & (~1); // round up to even value
3942 outsw( ai->dev->base_addr+DATA0+whichbap,
3943 pu16Src, bytelen>>1 );
3945 outsb( ai->dev->base_addr+DATA0+whichbap, pu16Src, bytelen );
3949 static int PC4500_accessrid(struct airo_info *ai, u16 rid, u16 accmd)
3951 Cmd cmd; /* for issuing commands */
3952 Resp rsp; /* response from commands */
3955 memset(&cmd, 0, sizeof(cmd));
3958 status = issuecommand(ai, &cmd, &rsp);
3959 if (status != 0) return status;
3960 if ( (rsp.status & 0x7F00) != 0) {
3961 return (accmd << 8) + (rsp.rsp0 & 0xFF);
3966 /* Note, that we are using BAP1 which is also used by transmit, so
3967 * we must get a lock. */
3968 static int PC4500_readrid(struct airo_info *ai, u16 rid, void *pBuf, int len, int lock)
3974 if (down_interruptible(&ai->sem))
3977 if (test_bit(FLAG_MPI,&ai->flags)) {
3981 memset(&cmd, 0, sizeof(cmd));
3982 memset(&rsp, 0, sizeof(rsp));
3983 ai->config_desc.rid_desc.valid = 1;
3984 ai->config_desc.rid_desc.len = RIDSIZE;
3985 ai->config_desc.rid_desc.rid = 0;
3986 ai->config_desc.rid_desc.host_addr = ai->ridbus;
3988 cmd.cmd = CMD_ACCESS;
3991 memcpy_toio(ai->config_desc.card_ram_off,
3992 &ai->config_desc.rid_desc, sizeof(Rid));
3994 rc = issuecommand(ai, &cmd, &rsp);
3996 if (rsp.status & 0x7f00)
3999 memcpy(pBuf, ai->config_desc.virtual_host_addr, len);
4002 if ((status = PC4500_accessrid(ai, rid, CMD_ACCESS))!=SUCCESS) {
4006 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4010 // read the rid length field
4011 bap_read(ai, pBuf, 2, BAP1);
4012 // length for remaining part of rid
4013 len = min(len, (int)le16_to_cpu(*(u16*)pBuf)) - 2;
4017 "airo: Rid %x has a length of %d which is too short\n",
4018 (int)rid, (int)len );
4022 // read remainder of the rid
4023 rc = bap_read(ai, ((u16*)pBuf)+1, len, BAP1);
4031 /* Note, that we are using BAP1 which is also used by transmit, so
4032 * make sure this isnt called when a transmit is happening */
4033 static int PC4500_writerid(struct airo_info *ai, u16 rid,
4034 const void *pBuf, int len, int lock)
4039 *(u16*)pBuf = cpu_to_le16((u16)len);
4042 if (down_interruptible(&ai->sem))
4045 if (test_bit(FLAG_MPI,&ai->flags)) {
4049 if (test_bit(FLAG_ENABLED, &ai->flags))
4051 "%s: MAC should be disabled (rid=%04x)\n",
4053 memset(&cmd, 0, sizeof(cmd));
4054 memset(&rsp, 0, sizeof(rsp));
4056 ai->config_desc.rid_desc.valid = 1;
4057 ai->config_desc.rid_desc.len = *((u16 *)pBuf);
4058 ai->config_desc.rid_desc.rid = 0;
4060 cmd.cmd = CMD_WRITERID;
4063 memcpy_toio(ai->config_desc.card_ram_off,
4064 &ai->config_desc.rid_desc, sizeof(Rid));
4066 if (len < 4 || len > 2047) {
4067 printk(KERN_ERR "%s: len=%d\n",__FUNCTION__,len);
4070 memcpy((char *)ai->config_desc.virtual_host_addr,
4073 rc = issuecommand(ai, &cmd, &rsp);
4074 if ((rc & 0xff00) != 0) {
4075 printk(KERN_ERR "%s: Write rid Error %d\n",
4077 printk(KERN_ERR "%s: Cmd=%04x\n",
4078 __FUNCTION__,cmd.cmd);
4081 if ((rsp.status & 0x7f00))
4085 // --- first access so that we can write the rid data
4086 if ( (status = PC4500_accessrid(ai, rid, CMD_ACCESS)) != 0) {
4090 // --- now write the rid data
4091 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4095 bap_write(ai, pBuf, len, BAP1);
4096 // ---now commit the rid data
4097 rc = PC4500_accessrid(ai, rid, 0x100|CMD_ACCESS);
4105 /* Allocates a FID to be used for transmitting packets. We only use
4107 static u16 transmit_allocate(struct airo_info *ai, int lenPayload, int raw)
4109 unsigned int loop = 3000;
4115 cmd.cmd = CMD_ALLOCATETX;
4116 cmd.parm0 = lenPayload;
4117 if (down_interruptible(&ai->sem))
4119 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
4123 if ( (rsp.status & 0xFF00) != 0) {
4127 /* wait for the allocate event/indication
4128 * It makes me kind of nervous that this can just sit here and spin,
4129 * but in practice it only loops like four times. */
4130 while (((IN4500(ai, EVSTAT) & EV_ALLOC) == 0) && --loop);
4136 // get the allocated fid and acknowledge
4137 txFid = IN4500(ai, TXALLOCFID);
4138 OUT4500(ai, EVACK, EV_ALLOC);
4140 /* The CARD is pretty cool since it converts the ethernet packet
4141 * into 802.11. Also note that we don't release the FID since we
4142 * will be using the same one over and over again. */
4143 /* We only have to setup the control once since we are not
4144 * releasing the fid. */
4146 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_11
4147 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4149 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_3
4150 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4151 if (bap_setup(ai, txFid, 0x0008, BAP1) != SUCCESS)
4154 bap_write(ai, &txControl, sizeof(txControl), BAP1);
4162 /* In general BAP1 is dedicated to transmiting packets. However,
4163 since we need a BAP when accessing RIDs, we also use BAP1 for that.
4164 Make sure the BAP1 spinlock is held when this is called. */
4165 static int transmit_802_3_packet(struct airo_info *ai, int len, char *pPacket)
4176 if (len <= ETH_ALEN * 2) {
4177 printk( KERN_WARNING "Short packet %d\n", len );
4180 len -= ETH_ALEN * 2;
4183 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
4184 (ntohs(((u16 *)pPacket)[6]) != 0x888E)) {
4185 if (encapsulate(ai,(etherHead *)pPacket,&pMic,len) != SUCCESS)
4187 miclen = sizeof(pMic);
4191 // packet is destination[6], source[6], payload[len-12]
4192 // write the payload length and dst/src/payload
4193 if (bap_setup(ai, txFid, 0x0036, BAP1) != SUCCESS) return ERROR;
4194 /* The hardware addresses aren't counted as part of the payload, so
4195 * we have to subtract the 12 bytes for the addresses off */
4196 payloadLen = cpu_to_le16(len + miclen);
4197 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4198 bap_write(ai, (const u16*)pPacket, sizeof(etherHead), BAP1);
4200 bap_write(ai, (const u16*)&pMic, miclen, BAP1);
4201 bap_write(ai, (const u16*)(pPacket + sizeof(etherHead)), len, BAP1);
4202 // issue the transmit command
4203 memset( &cmd, 0, sizeof( cmd ) );
4204 cmd.cmd = CMD_TRANSMIT;
4206 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4207 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4211 static int transmit_802_11_packet(struct airo_info *ai, int len, char *pPacket)
4226 fc = le16_to_cpu(*(const u16*)pPacket);
4229 if ((fc & 0xe0) == 0xc0)
4235 if ((fc&0x300)==0x300){
4244 printk( KERN_WARNING "Short packet %d\n", len );
4248 /* packet is 802.11 header + payload
4249 * write the payload length and dst/src/payload */
4250 if (bap_setup(ai, txFid, 6, BAP1) != SUCCESS) return ERROR;
4251 /* The 802.11 header aren't counted as part of the payload, so
4252 * we have to subtract the header bytes off */
4253 payloadLen = cpu_to_le16(len-hdrlen);
4254 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4255 if (bap_setup(ai, txFid, 0x0014, BAP1) != SUCCESS) return ERROR;
4256 bap_write(ai, (const u16*)pPacket, hdrlen, BAP1);
4257 bap_write(ai, hdrlen == 30 ?
4258 (const u16*)&gap.gaplen : (const u16*)&gap, 38 - hdrlen, BAP1);
4260 bap_write(ai, (const u16*)(pPacket + hdrlen), len - hdrlen, BAP1);
4261 // issue the transmit command
4262 memset( &cmd, 0, sizeof( cmd ) );
4263 cmd.cmd = CMD_TRANSMIT;
4265 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4266 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4271 * This is the proc_fs routines. It is a bit messier than I would
4272 * like! Feel free to clean it up!
4275 static ssize_t proc_read( struct file *file,
4276 char __user *buffer,
4280 static ssize_t proc_write( struct file *file,
4281 const char __user *buffer,
4284 static int proc_close( struct inode *inode, struct file *file );
4286 static int proc_stats_open( struct inode *inode, struct file *file );
4287 static int proc_statsdelta_open( struct inode *inode, struct file *file );
4288 static int proc_status_open( struct inode *inode, struct file *file );
4289 static int proc_SSID_open( struct inode *inode, struct file *file );
4290 static int proc_APList_open( struct inode *inode, struct file *file );
4291 static int proc_BSSList_open( struct inode *inode, struct file *file );
4292 static int proc_config_open( struct inode *inode, struct file *file );
4293 static int proc_wepkey_open( struct inode *inode, struct file *file );
4295 static struct file_operations proc_statsdelta_ops = {
4297 .open = proc_statsdelta_open,
4298 .release = proc_close
4301 static struct file_operations proc_stats_ops = {
4303 .open = proc_stats_open,
4304 .release = proc_close
4307 static struct file_operations proc_status_ops = {
4309 .open = proc_status_open,
4310 .release = proc_close
4313 static struct file_operations proc_SSID_ops = {
4315 .write = proc_write,
4316 .open = proc_SSID_open,
4317 .release = proc_close
4320 static struct file_operations proc_BSSList_ops = {
4322 .write = proc_write,
4323 .open = proc_BSSList_open,
4324 .release = proc_close
4327 static struct file_operations proc_APList_ops = {
4329 .write = proc_write,
4330 .open = proc_APList_open,
4331 .release = proc_close
4334 static struct file_operations proc_config_ops = {
4336 .write = proc_write,
4337 .open = proc_config_open,
4338 .release = proc_close
4341 static struct file_operations proc_wepkey_ops = {
4343 .write = proc_write,
4344 .open = proc_wepkey_open,
4345 .release = proc_close
4348 static struct proc_dir_entry *airo_entry;
4357 void (*on_close) (struct inode *, struct file *);
4361 #define SETPROC_OPS(entry, ops) (entry)->proc_fops = &(ops)
4364 static int setup_proc_entry( struct net_device *dev,
4365 struct airo_info *apriv ) {
4366 struct proc_dir_entry *entry;
4367 /* First setup the device directory */
4368 strcpy(apriv->proc_name,dev->name);
4369 apriv->proc_entry = create_proc_entry(apriv->proc_name,
4372 apriv->proc_entry->uid = proc_uid;
4373 apriv->proc_entry->gid = proc_gid;
4374 apriv->proc_entry->owner = THIS_MODULE;
4376 /* Setup the StatsDelta */
4377 entry = create_proc_entry("StatsDelta",
4378 S_IFREG | (S_IRUGO&proc_perm),
4380 entry->uid = proc_uid;
4381 entry->gid = proc_gid;
4383 entry->owner = THIS_MODULE;
4384 SETPROC_OPS(entry, proc_statsdelta_ops);
4386 /* Setup the Stats */
4387 entry = create_proc_entry("Stats",
4388 S_IFREG | (S_IRUGO&proc_perm),
4390 entry->uid = proc_uid;
4391 entry->gid = proc_gid;
4393 entry->owner = THIS_MODULE;
4394 SETPROC_OPS(entry, proc_stats_ops);
4396 /* Setup the Status */
4397 entry = create_proc_entry("Status",
4398 S_IFREG | (S_IRUGO&proc_perm),
4400 entry->uid = proc_uid;
4401 entry->gid = proc_gid;
4403 entry->owner = THIS_MODULE;
4404 SETPROC_OPS(entry, proc_status_ops);
4406 /* Setup the Config */
4407 entry = create_proc_entry("Config",
4408 S_IFREG | proc_perm,
4410 entry->uid = proc_uid;
4411 entry->gid = proc_gid;
4413 entry->owner = THIS_MODULE;
4414 SETPROC_OPS(entry, proc_config_ops);
4416 /* Setup the SSID */
4417 entry = create_proc_entry("SSID",
4418 S_IFREG | proc_perm,
4420 entry->uid = proc_uid;
4421 entry->gid = proc_gid;
4423 entry->owner = THIS_MODULE;
4424 SETPROC_OPS(entry, proc_SSID_ops);
4426 /* Setup the APList */
4427 entry = create_proc_entry("APList",
4428 S_IFREG | proc_perm,
4430 entry->uid = proc_uid;
4431 entry->gid = proc_gid;
4433 entry->owner = THIS_MODULE;
4434 SETPROC_OPS(entry, proc_APList_ops);
4436 /* Setup the BSSList */
4437 entry = create_proc_entry("BSSList",
4438 S_IFREG | proc_perm,
4440 entry->uid = proc_uid;
4441 entry->gid = proc_gid;
4443 entry->owner = THIS_MODULE;
4444 SETPROC_OPS(entry, proc_BSSList_ops);
4446 /* Setup the WepKey */
4447 entry = create_proc_entry("WepKey",
4448 S_IFREG | proc_perm,
4450 entry->uid = proc_uid;
4451 entry->gid = proc_gid;
4453 entry->owner = THIS_MODULE;
4454 SETPROC_OPS(entry, proc_wepkey_ops);
4459 static int takedown_proc_entry( struct net_device *dev,
4460 struct airo_info *apriv ) {
4461 if ( !apriv->proc_entry->namelen ) return 0;
4462 remove_proc_entry("Stats",apriv->proc_entry);
4463 remove_proc_entry("StatsDelta",apriv->proc_entry);
4464 remove_proc_entry("Status",apriv->proc_entry);
4465 remove_proc_entry("Config",apriv->proc_entry);
4466 remove_proc_entry("SSID",apriv->proc_entry);
4467 remove_proc_entry("APList",apriv->proc_entry);
4468 remove_proc_entry("BSSList",apriv->proc_entry);
4469 remove_proc_entry("WepKey",apriv->proc_entry);
4470 remove_proc_entry(apriv->proc_name,airo_entry);
4475 * What we want from the proc_fs is to be able to efficiently read
4476 * and write the configuration. To do this, we want to read the
4477 * configuration when the file is opened and write it when the file is
4478 * closed. So basically we allocate a read buffer at open and fill it
4479 * with data, and allocate a write buffer and read it at close.
4483 * The read routine is generic, it relies on the preallocated rbuffer
4484 * to supply the data.
4486 static ssize_t proc_read( struct file *file,
4487 char __user *buffer,
4491 loff_t pos = *offset;
4492 struct proc_data *priv = (struct proc_data*)file->private_data;
4499 if (pos >= priv->readlen)
4501 if (len > priv->readlen - pos)
4502 len = priv->readlen - pos;
4503 if (copy_to_user(buffer, priv->rbuffer + pos, len))
4505 *offset = pos + len;
4510 * The write routine is generic, it fills in a preallocated rbuffer
4511 * to supply the data.
4513 static ssize_t proc_write( struct file *file,
4514 const char __user *buffer,
4518 loff_t pos = *offset;
4519 struct proc_data *priv = (struct proc_data*)file->private_data;
4526 if (pos >= priv->maxwritelen)
4528 if (len > priv->maxwritelen - pos)
4529 len = priv->maxwritelen - pos;
4530 if (copy_from_user(priv->wbuffer + pos, buffer, len))
4532 if ( pos + len > priv->writelen )
4533 priv->writelen = len + file->f_pos;
4534 *offset = pos + len;
4538 static int proc_status_open( struct inode *inode, struct file *file ) {
4539 struct proc_data *data;
4540 struct proc_dir_entry *dp = PDE(inode);
4541 struct net_device *dev = dp->data;
4542 struct airo_info *apriv = dev->priv;
4543 CapabilityRid cap_rid;
4544 StatusRid status_rid;
4547 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4549 memset(file->private_data, 0, sizeof(struct proc_data));
4550 data = (struct proc_data *)file->private_data;
4551 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4552 kfree (file->private_data);
4556 readStatusRid(apriv, &status_rid, 1);
4557 readCapabilityRid(apriv, &cap_rid, 1);
4559 i = sprintf(data->rbuffer, "Status: %s%s%s%s%s%s%s%s%s\n",
4560 status_rid.mode & 1 ? "CFG ": "",
4561 status_rid.mode & 2 ? "ACT ": "",
4562 status_rid.mode & 0x10 ? "SYN ": "",
4563 status_rid.mode & 0x20 ? "LNK ": "",
4564 status_rid.mode & 0x40 ? "LEAP ": "",
4565 status_rid.mode & 0x80 ? "PRIV ": "",
4566 status_rid.mode & 0x100 ? "KEY ": "",
4567 status_rid.mode & 0x200 ? "WEP ": "",
4568 status_rid.mode & 0x8000 ? "ERR ": "");
4569 sprintf( data->rbuffer+i, "Mode: %x\n"
4570 "Signal Strength: %d\n"
4571 "Signal Quality: %d\n"
4576 "Driver Version: %s\n"
4577 "Device: %s\nManufacturer: %s\nFirmware Version: %s\n"
4578 "Radio type: %x\nCountry: %x\nHardware Version: %x\n"
4579 "Software Version: %x\nSoftware Subversion: %x\n"
4580 "Boot block version: %x\n",
4581 (int)status_rid.mode,
4582 (int)status_rid.normalizedSignalStrength,
4583 (int)status_rid.signalQuality,
4584 (int)status_rid.SSIDlen,
4587 (int)status_rid.channel,
4588 (int)status_rid.currentXmitRate/2,
4596 (int)cap_rid.softVer,
4597 (int)cap_rid.softSubVer,
4598 (int)cap_rid.bootBlockVer );
4599 data->readlen = strlen( data->rbuffer );
4603 static int proc_stats_rid_open(struct inode*, struct file*, u16);
4604 static int proc_statsdelta_open( struct inode *inode,
4605 struct file *file ) {
4606 if (file->f_mode&FMODE_WRITE) {
4607 return proc_stats_rid_open(inode, file, RID_STATSDELTACLEAR);
4609 return proc_stats_rid_open(inode, file, RID_STATSDELTA);
4612 static int proc_stats_open( struct inode *inode, struct file *file ) {
4613 return proc_stats_rid_open(inode, file, RID_STATS);
4616 static int proc_stats_rid_open( struct inode *inode,
4619 struct proc_data *data;
4620 struct proc_dir_entry *dp = PDE(inode);
4621 struct net_device *dev = dp->data;
4622 struct airo_info *apriv = dev->priv;
4625 u32 *vals = stats.vals;
4627 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4629 memset(file->private_data, 0, sizeof(struct proc_data));
4630 data = (struct proc_data *)file->private_data;
4631 if ((data->rbuffer = kmalloc( 4096, GFP_KERNEL )) == NULL) {
4632 kfree (file->private_data);
4636 readStatsRid(apriv, &stats, rid, 1);
4639 for(i=0; statsLabels[i]!=(char *)-1 &&
4640 i*4<stats.len; i++){
4641 if (!statsLabels[i]) continue;
4642 if (j+strlen(statsLabels[i])+16>4096) {
4644 "airo: Potentially disasterous buffer overflow averted!\n");
4647 j+=sprintf(data->rbuffer+j, "%s: %u\n", statsLabels[i], vals[i]);
4649 if (i*4>=stats.len){
4651 "airo: Got a short rid\n");
4657 static int get_dec_u16( char *buffer, int *start, int limit ) {
4660 for( value = 0; buffer[*start] >= '0' &&
4661 buffer[*start] <= '9' &&
4662 *start < limit; (*start)++ ) {
4665 value += buffer[*start] - '0';
4667 if ( !valid ) return -1;
4671 static int airo_config_commit(struct net_device *dev,
4672 struct iw_request_info *info, void *zwrq,
4675 static void proc_config_on_close( struct inode *inode, struct file *file ) {
4676 struct proc_data *data = file->private_data;
4677 struct proc_dir_entry *dp = PDE(inode);
4678 struct net_device *dev = dp->data;
4679 struct airo_info *ai = dev->priv;
4682 if ( !data->writelen ) return;
4684 readConfigRid(ai, 1);
4685 set_bit (FLAG_COMMIT, &ai->flags);
4687 line = data->wbuffer;
4689 /*** Mode processing */
4690 if ( !strncmp( line, "Mode: ", 6 ) ) {
4692 if ((ai->config.rmode & 0xff) >= RXMODE_RFMON)
4693 set_bit (FLAG_RESET, &ai->flags);
4694 ai->config.rmode &= 0xfe00;
4695 clear_bit (FLAG_802_11, &ai->flags);
4696 ai->config.opmode &= 0xFF00;
4697 ai->config.scanMode = SCANMODE_ACTIVE;
4698 if ( line[0] == 'a' ) {
4699 ai->config.opmode |= 0;
4701 ai->config.opmode |= 1;
4702 if ( line[0] == 'r' ) {
4703 ai->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
4704 ai->config.scanMode = SCANMODE_PASSIVE;
4705 set_bit (FLAG_802_11, &ai->flags);
4706 } else if ( line[0] == 'y' ) {
4707 ai->config.rmode |= RXMODE_RFMON_ANYBSS | RXMODE_DISABLE_802_3_HEADER;
4708 ai->config.scanMode = SCANMODE_PASSIVE;
4709 set_bit (FLAG_802_11, &ai->flags);
4710 } else if ( line[0] == 'l' )
4711 ai->config.rmode |= RXMODE_LANMON;
4713 set_bit (FLAG_COMMIT, &ai->flags);
4716 /*** Radio status */
4717 else if (!strncmp(line,"Radio: ", 7)) {
4719 if (!strncmp(line,"off",3)) {
4720 set_bit (FLAG_RADIO_OFF, &ai->flags);
4722 clear_bit (FLAG_RADIO_OFF, &ai->flags);
4725 /*** NodeName processing */
4726 else if ( !strncmp( line, "NodeName: ", 10 ) ) {
4730 memset( ai->config.nodeName, 0, 16 );
4731 /* Do the name, assume a space between the mode and node name */
4732 for( j = 0; j < 16 && line[j] != '\n'; j++ ) {
4733 ai->config.nodeName[j] = line[j];
4735 set_bit (FLAG_COMMIT, &ai->flags);
4738 /*** PowerMode processing */
4739 else if ( !strncmp( line, "PowerMode: ", 11 ) ) {
4741 if ( !strncmp( line, "PSPCAM", 6 ) ) {
4742 ai->config.powerSaveMode = POWERSAVE_PSPCAM;
4743 set_bit (FLAG_COMMIT, &ai->flags);
4744 } else if ( !strncmp( line, "PSP", 3 ) ) {
4745 ai->config.powerSaveMode = POWERSAVE_PSP;
4746 set_bit (FLAG_COMMIT, &ai->flags);
4748 ai->config.powerSaveMode = POWERSAVE_CAM;
4749 set_bit (FLAG_COMMIT, &ai->flags);
4751 } else if ( !strncmp( line, "DataRates: ", 11 ) ) {
4752 int v, i = 0, k = 0; /* i is index into line,
4753 k is index to rates */
4756 while((v = get_dec_u16(line, &i, 3))!=-1) {
4757 ai->config.rates[k++] = (u8)v;
4761 set_bit (FLAG_COMMIT, &ai->flags);
4762 } else if ( !strncmp( line, "Channel: ", 9 ) ) {
4765 v = get_dec_u16(line, &i, i+3);
4767 ai->config.channelSet = (u16)v;
4768 set_bit (FLAG_COMMIT, &ai->flags);
4770 } else if ( !strncmp( line, "XmitPower: ", 11 ) ) {
4773 v = get_dec_u16(line, &i, i+3);
4775 ai->config.txPower = (u16)v;
4776 set_bit (FLAG_COMMIT, &ai->flags);
4778 } else if ( !strncmp( line, "WEP: ", 5 ) ) {
4782 ai->config.authType = (u16)AUTH_SHAREDKEY;
4785 ai->config.authType = (u16)AUTH_ENCRYPT;
4788 ai->config.authType = (u16)AUTH_OPEN;
4791 set_bit (FLAG_COMMIT, &ai->flags);
4792 } else if ( !strncmp( line, "LongRetryLimit: ", 16 ) ) {
4796 v = get_dec_u16(line, &i, 3);
4797 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4798 ai->config.longRetryLimit = (u16)v;
4799 set_bit (FLAG_COMMIT, &ai->flags);
4800 } else if ( !strncmp( line, "ShortRetryLimit: ", 17 ) ) {
4804 v = get_dec_u16(line, &i, 3);
4805 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4806 ai->config.shortRetryLimit = (u16)v;
4807 set_bit (FLAG_COMMIT, &ai->flags);
4808 } else if ( !strncmp( line, "RTSThreshold: ", 14 ) ) {
4812 v = get_dec_u16(line, &i, 4);
4813 v = (v<0) ? 0 : ((v>2312) ? 2312 : v);
4814 ai->config.rtsThres = (u16)v;
4815 set_bit (FLAG_COMMIT, &ai->flags);
4816 } else if ( !strncmp( line, "TXMSDULifetime: ", 16 ) ) {
4820 v = get_dec_u16(line, &i, 5);
4822 ai->config.txLifetime = (u16)v;
4823 set_bit (FLAG_COMMIT, &ai->flags);
4824 } else if ( !strncmp( line, "RXMSDULifetime: ", 16 ) ) {
4828 v = get_dec_u16(line, &i, 5);
4830 ai->config.rxLifetime = (u16)v;
4831 set_bit (FLAG_COMMIT, &ai->flags);
4832 } else if ( !strncmp( line, "TXDiversity: ", 13 ) ) {
4833 ai->config.txDiversity =
4834 (line[13]=='l') ? 1 :
4835 ((line[13]=='r')? 2: 3);
4836 set_bit (FLAG_COMMIT, &ai->flags);
4837 } else if ( !strncmp( line, "RXDiversity: ", 13 ) ) {
4838 ai->config.rxDiversity =
4839 (line[13]=='l') ? 1 :
4840 ((line[13]=='r')? 2: 3);
4841 set_bit (FLAG_COMMIT, &ai->flags);
4842 } else if ( !strncmp( line, "FragThreshold: ", 15 ) ) {
4846 v = get_dec_u16(line, &i, 4);
4847 v = (v<256) ? 256 : ((v>2312) ? 2312 : v);
4848 v = v & 0xfffe; /* Make sure its even */
4849 ai->config.fragThresh = (u16)v;
4850 set_bit (FLAG_COMMIT, &ai->flags);
4851 } else if (!strncmp(line, "Modulation: ", 12)) {
4854 case 'd': ai->config.modulation=MOD_DEFAULT; set_bit(FLAG_COMMIT, &ai->flags); break;
4855 case 'c': ai->config.modulation=MOD_CCK; set_bit(FLAG_COMMIT, &ai->flags); break;
4856 case 'm': ai->config.modulation=MOD_MOK; set_bit(FLAG_COMMIT, &ai->flags); break;
4858 printk( KERN_WARNING "airo: Unknown modulation\n" );
4860 } else if (!strncmp(line, "Preamble: ", 10)) {
4863 case 'a': ai->config.preamble=PREAMBLE_AUTO; set_bit(FLAG_COMMIT, &ai->flags); break;
4864 case 'l': ai->config.preamble=PREAMBLE_LONG; set_bit(FLAG_COMMIT, &ai->flags); break;
4865 case 's': ai->config.preamble=PREAMBLE_SHORT; set_bit(FLAG_COMMIT, &ai->flags); break;
4866 default: printk(KERN_WARNING "airo: Unknown preamble\n");
4869 printk( KERN_WARNING "Couldn't figure out %s\n", line );
4871 while( line[0] && line[0] != '\n' ) line++;
4872 if ( line[0] ) line++;
4874 airo_config_commit(dev, NULL, NULL, NULL);
4877 static char *get_rmode(u16 mode) {
4879 case RXMODE_RFMON: return "rfmon";
4880 case RXMODE_RFMON_ANYBSS: return "yna (any) bss rfmon";
4881 case RXMODE_LANMON: return "lanmon";
4886 static int proc_config_open( struct inode *inode, struct file *file ) {
4887 struct proc_data *data;
4888 struct proc_dir_entry *dp = PDE(inode);
4889 struct net_device *dev = dp->data;
4890 struct airo_info *ai = dev->priv;
4893 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4895 memset(file->private_data, 0, sizeof(struct proc_data));
4896 data = (struct proc_data *)file->private_data;
4897 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4898 kfree (file->private_data);
4901 if ((data->wbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4902 kfree (data->rbuffer);
4903 kfree (file->private_data);
4906 memset( data->wbuffer, 0, 2048 );
4907 data->maxwritelen = 2048;
4908 data->on_close = proc_config_on_close;
4910 readConfigRid(ai, 1);
4912 i = sprintf( data->rbuffer,
4917 "DataRates: %d %d %d %d %d %d %d %d\n"
4920 (ai->config.opmode & 0xFF) == 0 ? "adhoc" :
4921 (ai->config.opmode & 0xFF) == 1 ? get_rmode(ai->config.rmode):
4922 (ai->config.opmode & 0xFF) == 2 ? "AP" :
4923 (ai->config.opmode & 0xFF) == 3 ? "AP RPTR" : "Error",
4924 test_bit(FLAG_RADIO_OFF, &ai->flags) ? "off" : "on",
4925 ai->config.nodeName,
4926 ai->config.powerSaveMode == 0 ? "CAM" :
4927 ai->config.powerSaveMode == 1 ? "PSP" :
4928 ai->config.powerSaveMode == 2 ? "PSPCAM" : "Error",
4929 (int)ai->config.rates[0],
4930 (int)ai->config.rates[1],
4931 (int)ai->config.rates[2],
4932 (int)ai->config.rates[3],
4933 (int)ai->config.rates[4],
4934 (int)ai->config.rates[5],
4935 (int)ai->config.rates[6],
4936 (int)ai->config.rates[7],
4937 (int)ai->config.channelSet,
4938 (int)ai->config.txPower
4940 sprintf( data->rbuffer + i,
4941 "LongRetryLimit: %d\n"
4942 "ShortRetryLimit: %d\n"
4943 "RTSThreshold: %d\n"
4944 "TXMSDULifetime: %d\n"
4945 "RXMSDULifetime: %d\n"
4948 "FragThreshold: %d\n"
4952 (int)ai->config.longRetryLimit,
4953 (int)ai->config.shortRetryLimit,
4954 (int)ai->config.rtsThres,
4955 (int)ai->config.txLifetime,
4956 (int)ai->config.rxLifetime,
4957 ai->config.txDiversity == 1 ? "left" :
4958 ai->config.txDiversity == 2 ? "right" : "both",
4959 ai->config.rxDiversity == 1 ? "left" :
4960 ai->config.rxDiversity == 2 ? "right" : "both",
4961 (int)ai->config.fragThresh,
4962 ai->config.authType == AUTH_ENCRYPT ? "encrypt" :
4963 ai->config.authType == AUTH_SHAREDKEY ? "shared" : "open",
4964 ai->config.modulation == 0 ? "default" :
4965 ai->config.modulation == MOD_CCK ? "cck" :
4966 ai->config.modulation == MOD_MOK ? "mok" : "error",
4967 ai->config.preamble == PREAMBLE_AUTO ? "auto" :
4968 ai->config.preamble == PREAMBLE_LONG ? "long" :
4969 ai->config.preamble == PREAMBLE_SHORT ? "short" : "error"
4971 data->readlen = strlen( data->rbuffer );
4975 static void proc_SSID_on_close( struct inode *inode, struct file *file ) {
4976 struct proc_data *data = (struct proc_data *)file->private_data;
4977 struct proc_dir_entry *dp = PDE(inode);
4978 struct net_device *dev = dp->data;
4979 struct airo_info *ai = dev->priv;
4985 if ( !data->writelen ) return;
4987 memset( &SSID_rid, 0, sizeof( SSID_rid ) );
4989 for( i = 0; i < 3; i++ ) {
4991 for( j = 0; j+offset < data->writelen && j < 32 &&
4992 data->wbuffer[offset+j] != '\n'; j++ ) {
4993 SSID_rid.ssids[i].ssid[j] = data->wbuffer[offset+j];
4995 if ( j == 0 ) break;
4996 SSID_rid.ssids[i].len = j;
4998 while( data->wbuffer[offset] != '\n' &&
4999 offset < data->writelen ) offset++;
5003 SSID_rid.len = sizeof(SSID_rid);
5005 writeSsidRid(ai, &SSID_rid, 1);
5006 enable_MAC(ai, &rsp, 1);
5009 inline static u8 hexVal(char c) {
5010 if (c>='0' && c<='9') return c -= '0';
5011 if (c>='a' && c<='f') return c -= 'a'-10;
5012 if (c>='A' && c<='F') return c -= 'A'-10;
5016 static void proc_APList_on_close( struct inode *inode, struct file *file ) {
5017 struct proc_data *data = (struct proc_data *)file->private_data;
5018 struct proc_dir_entry *dp = PDE(inode);
5019 struct net_device *dev = dp->data;
5020 struct airo_info *ai = dev->priv;
5021 APListRid APList_rid;
5025 if ( !data->writelen ) return;
5027 memset( &APList_rid, 0, sizeof(APList_rid) );
5028 APList_rid.len = sizeof(APList_rid);
5030 for( i = 0; i < 4 && data->writelen >= (i+1)*6*3; i++ ) {
5032 for( j = 0; j < 6*3 && data->wbuffer[j+i*6*3]; j++ ) {
5035 APList_rid.ap[i][j/3]=
5036 hexVal(data->wbuffer[j+i*6*3])<<4;
5039 APList_rid.ap[i][j/3]|=
5040 hexVal(data->wbuffer[j+i*6*3]);
5046 writeAPListRid(ai, &APList_rid, 1);
5047 enable_MAC(ai, &rsp, 1);
5050 /* This function wraps PC4500_writerid with a MAC disable */
5051 static int do_writerid( struct airo_info *ai, u16 rid, const void *rid_data,
5052 int len, int dummy ) {
5057 rc = PC4500_writerid(ai, rid, rid_data, len, 1);
5058 enable_MAC(ai, &rsp, 1);
5062 /* Returns the length of the key at the index. If index == 0xffff
5063 * the index of the transmit key is returned. If the key doesn't exist,
5064 * -1 will be returned.
5066 static int get_wep_key(struct airo_info *ai, u16 index) {
5071 rc = readWepKeyRid(ai, &wkr, 1, 1);
5072 if (rc == SUCCESS) do {
5073 lastindex = wkr.kindex;
5074 if (wkr.kindex == index) {
5075 if (index == 0xffff) {
5080 readWepKeyRid(ai, &wkr, 0, 1);
5081 } while(lastindex != wkr.kindex);
5085 static int set_wep_key(struct airo_info *ai, u16 index,
5086 const char *key, u16 keylen, int perm, int lock ) {
5087 static const unsigned char macaddr[ETH_ALEN] = { 0x01, 0, 0, 0, 0, 0 };
5091 memset(&wkr, 0, sizeof(wkr));
5093 // We are selecting which key to use
5094 wkr.len = sizeof(wkr);
5095 wkr.kindex = 0xffff;
5096 wkr.mac[0] = (char)index;
5097 if (perm) printk(KERN_INFO "Setting transmit key to %d\n", index);
5098 if (perm) ai->defindex = (char)index;
5100 // We are actually setting the key
5101 wkr.len = sizeof(wkr);
5104 memcpy( wkr.key, key, keylen );
5105 memcpy( wkr.mac, macaddr, ETH_ALEN );
5106 printk(KERN_INFO "Setting key %d\n", index);
5109 disable_MAC(ai, lock);
5110 writeWepKeyRid(ai, &wkr, perm, lock);
5111 enable_MAC(ai, &rsp, lock);
5115 static void proc_wepkey_on_close( struct inode *inode, struct file *file ) {
5116 struct proc_data *data;
5117 struct proc_dir_entry *dp = PDE(inode);
5118 struct net_device *dev = dp->data;
5119 struct airo_info *ai = dev->priv;
5125 memset(key, 0, sizeof(key));
5127 data = (struct proc_data *)file->private_data;
5128 if ( !data->writelen ) return;
5130 if (data->wbuffer[0] >= '0' && data->wbuffer[0] <= '3' &&
5131 (data->wbuffer[1] == ' ' || data->wbuffer[1] == '\n')) {
5132 index = data->wbuffer[0] - '0';
5133 if (data->wbuffer[1] == '\n') {
5134 set_wep_key(ai, index, NULL, 0, 1, 1);
5139 printk(KERN_ERR "airo: WepKey passed invalid key index\n");
5143 for( i = 0; i < 16*3 && data->wbuffer[i+j]; i++ ) {
5146 key[i/3] = hexVal(data->wbuffer[i+j])<<4;
5149 key[i/3] |= hexVal(data->wbuffer[i+j]);
5153 set_wep_key(ai, index, key, i/3, 1, 1);
5156 static int proc_wepkey_open( struct inode *inode, struct file *file ) {
5157 struct proc_data *data;
5158 struct proc_dir_entry *dp = PDE(inode);
5159 struct net_device *dev = dp->data;
5160 struct airo_info *ai = dev->priv;
5167 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5169 memset(file->private_data, 0, sizeof(struct proc_data));
5170 memset(&wkr, 0, sizeof(wkr));
5171 data = (struct proc_data *)file->private_data;
5172 if ((data->rbuffer = kmalloc( 180, GFP_KERNEL )) == NULL) {
5173 kfree (file->private_data);
5176 memset(data->rbuffer, 0, 180);
5178 data->maxwritelen = 80;
5179 if ((data->wbuffer = kmalloc( 80, GFP_KERNEL )) == NULL) {
5180 kfree (data->rbuffer);
5181 kfree (file->private_data);
5184 memset( data->wbuffer, 0, 80 );
5185 data->on_close = proc_wepkey_on_close;
5187 ptr = data->rbuffer;
5188 strcpy(ptr, "No wep keys\n");
5189 rc = readWepKeyRid(ai, &wkr, 1, 1);
5190 if (rc == SUCCESS) do {
5191 lastindex = wkr.kindex;
5192 if (wkr.kindex == 0xffff) {
5193 j += sprintf(ptr+j, "Tx key = %d\n",
5196 j += sprintf(ptr+j, "Key %d set with length = %d\n",
5197 (int)wkr.kindex, (int)wkr.klen);
5199 readWepKeyRid(ai, &wkr, 0, 1);
5200 } while((lastindex != wkr.kindex) && (j < 180-30));
5202 data->readlen = strlen( data->rbuffer );
5206 static int proc_SSID_open( struct inode *inode, struct file *file ) {
5207 struct proc_data *data;
5208 struct proc_dir_entry *dp = PDE(inode);
5209 struct net_device *dev = dp->data;
5210 struct airo_info *ai = dev->priv;
5215 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5217 memset(file->private_data, 0, sizeof(struct proc_data));
5218 data = (struct proc_data *)file->private_data;
5219 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5220 kfree (file->private_data);
5224 data->maxwritelen = 33*3;
5225 if ((data->wbuffer = kmalloc( 33*3, GFP_KERNEL )) == NULL) {
5226 kfree (data->rbuffer);
5227 kfree (file->private_data);
5230 memset( data->wbuffer, 0, 33*3 );
5231 data->on_close = proc_SSID_on_close;
5233 readSsidRid(ai, &SSID_rid);
5234 ptr = data->rbuffer;
5235 for( i = 0; i < 3; i++ ) {
5237 if ( !SSID_rid.ssids[i].len ) break;
5238 for( j = 0; j < 32 &&
5239 j < SSID_rid.ssids[i].len &&
5240 SSID_rid.ssids[i].ssid[j]; j++ ) {
5241 *ptr++ = SSID_rid.ssids[i].ssid[j];
5246 data->readlen = strlen( data->rbuffer );
5250 static int proc_APList_open( struct inode *inode, struct file *file ) {
5251 struct proc_data *data;
5252 struct proc_dir_entry *dp = PDE(inode);
5253 struct net_device *dev = dp->data;
5254 struct airo_info *ai = dev->priv;
5257 APListRid APList_rid;
5259 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5261 memset(file->private_data, 0, sizeof(struct proc_data));
5262 data = (struct proc_data *)file->private_data;
5263 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5264 kfree (file->private_data);
5268 data->maxwritelen = 4*6*3;
5269 if ((data->wbuffer = kmalloc( data->maxwritelen, GFP_KERNEL )) == NULL) {
5270 kfree (data->rbuffer);
5271 kfree (file->private_data);
5274 memset( data->wbuffer, 0, data->maxwritelen );
5275 data->on_close = proc_APList_on_close;
5277 readAPListRid(ai, &APList_rid);
5278 ptr = data->rbuffer;
5279 for( i = 0; i < 4; i++ ) {
5280 // We end when we find a zero MAC
5281 if ( !*(int*)APList_rid.ap[i] &&
5282 !*(int*)&APList_rid.ap[i][2]) break;
5283 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x\n",
5284 (int)APList_rid.ap[i][0],
5285 (int)APList_rid.ap[i][1],
5286 (int)APList_rid.ap[i][2],
5287 (int)APList_rid.ap[i][3],
5288 (int)APList_rid.ap[i][4],
5289 (int)APList_rid.ap[i][5]);
5291 if (i==0) ptr += sprintf(ptr, "Not using specific APs\n");
5294 data->readlen = strlen( data->rbuffer );
5298 static int proc_BSSList_open( struct inode *inode, struct file *file ) {
5299 struct proc_data *data;
5300 struct proc_dir_entry *dp = PDE(inode);
5301 struct net_device *dev = dp->data;
5302 struct airo_info *ai = dev->priv;
5304 BSSListRid BSSList_rid;
5306 /* If doLoseSync is not 1, we won't do a Lose Sync */
5307 int doLoseSync = -1;
5309 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5311 memset(file->private_data, 0, sizeof(struct proc_data));
5312 data = (struct proc_data *)file->private_data;
5313 if ((data->rbuffer = kmalloc( 1024, GFP_KERNEL )) == NULL) {
5314 kfree (file->private_data);
5318 data->maxwritelen = 0;
5319 data->wbuffer = NULL;
5320 data->on_close = NULL;
5322 if (file->f_mode & FMODE_WRITE) {
5323 if (!(file->f_mode & FMODE_READ)) {
5327 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
5328 memset(&cmd, 0, sizeof(cmd));
5329 cmd.cmd=CMD_LISTBSS;
5330 if (down_interruptible(&ai->sem))
5331 return -ERESTARTSYS;
5332 issuecommand(ai, &cmd, &rsp);
5339 ptr = data->rbuffer;
5340 /* There is a race condition here if there are concurrent opens.
5341 Since it is a rare condition, we'll just live with it, otherwise
5342 we have to add a spin lock... */
5343 rc = readBSSListRid(ai, doLoseSync, &BSSList_rid);
5344 while(rc == 0 && BSSList_rid.index != 0xffff) {
5345 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x %*s rssi = %d",
5346 (int)BSSList_rid.bssid[0],
5347 (int)BSSList_rid.bssid[1],
5348 (int)BSSList_rid.bssid[2],
5349 (int)BSSList_rid.bssid[3],
5350 (int)BSSList_rid.bssid[4],
5351 (int)BSSList_rid.bssid[5],
5352 (int)BSSList_rid.ssidLen,
5354 (int)BSSList_rid.rssi);
5355 ptr += sprintf(ptr, " channel = %d %s %s %s %s\n",
5356 (int)BSSList_rid.dsChannel,
5357 BSSList_rid.cap & CAP_ESS ? "ESS" : "",
5358 BSSList_rid.cap & CAP_IBSS ? "adhoc" : "",
5359 BSSList_rid.cap & CAP_PRIVACY ? "wep" : "",
5360 BSSList_rid.cap & CAP_SHORTHDR ? "shorthdr" : "");
5361 rc = readBSSListRid(ai, 0, &BSSList_rid);
5364 data->readlen = strlen( data->rbuffer );
5368 static int proc_close( struct inode *inode, struct file *file )
5370 struct proc_data *data = (struct proc_data *)file->private_data;
5371 if ( data->on_close != NULL ) data->on_close( inode, file );
5372 if ( data->rbuffer ) kfree( data->rbuffer );
5373 if ( data->wbuffer ) kfree( data->wbuffer );
5378 static struct net_device_list {
5379 struct net_device *dev;
5380 struct net_device_list *next;
5383 /* Since the card doesn't automatically switch to the right WEP mode,
5384 we will make it do it. If the card isn't associated, every secs we
5385 will switch WEP modes to see if that will help. If the card is
5386 associated we will check every minute to see if anything has
5388 static void timer_func( struct net_device *dev ) {
5389 struct airo_info *apriv = dev->priv;
5392 /* We don't have a link so try changing the authtype */
5393 readConfigRid(apriv, 0);
5394 disable_MAC(apriv, 0);
5395 switch(apriv->config.authType) {
5397 /* So drop to OPEN */
5398 apriv->config.authType = AUTH_OPEN;
5400 case AUTH_SHAREDKEY:
5401 if (apriv->keyindex < auto_wep) {
5402 set_wep_key(apriv, apriv->keyindex, NULL, 0, 0, 0);
5403 apriv->config.authType = AUTH_SHAREDKEY;
5406 /* Drop to ENCRYPT */
5407 apriv->keyindex = 0;
5408 set_wep_key(apriv, apriv->defindex, NULL, 0, 0, 0);
5409 apriv->config.authType = AUTH_ENCRYPT;
5412 default: /* We'll escalate to SHAREDKEY */
5413 apriv->config.authType = AUTH_SHAREDKEY;
5415 set_bit (FLAG_COMMIT, &apriv->flags);
5416 writeConfigRid(apriv, 0);
5417 enable_MAC(apriv, &rsp, 0);
5420 /* Schedule check to see if the change worked */
5421 clear_bit(JOB_AUTOWEP, &apriv->flags);
5422 apriv->expires = RUN_AT(HZ*3);
5425 static int add_airo_dev( struct net_device *dev ) {
5426 struct net_device_list *node = kmalloc( sizeof( *node ), GFP_KERNEL );
5431 node->next = airo_devices;
5432 airo_devices = node;
5437 static void del_airo_dev( struct net_device *dev ) {
5438 struct net_device_list **p = &airo_devices;
5439 while( *p && ( (*p)->dev != dev ) )
5441 if ( *p && (*p)->dev == dev )
5446 static int __devinit airo_pci_probe(struct pci_dev *pdev,
5447 const struct pci_device_id *pent)
5449 struct net_device *dev;
5451 if (pci_enable_device(pdev))
5453 pci_set_master(pdev);
5455 if (pdev->device == 0x5000 || pdev->device == 0xa504)
5456 dev = _init_airo_card(pdev->irq, pdev->resource[0].start, 0, pdev, &pdev->dev);
5458 dev = _init_airo_card(pdev->irq, pdev->resource[2].start, 0, pdev, &pdev->dev);
5462 pci_set_drvdata(pdev, dev);
5466 static void __devexit airo_pci_remove(struct pci_dev *pdev)
5470 static int airo_pci_suspend(struct pci_dev *pdev, u32 state)
5472 struct net_device *dev = pci_get_drvdata(pdev);
5473 struct airo_info *ai = dev->priv;
5477 if ((ai->APList == NULL) &&
5478 (ai->APList = kmalloc(sizeof(APListRid), GFP_KERNEL)) == NULL)
5480 if ((ai->SSID == NULL) &&
5481 (ai->SSID = kmalloc(sizeof(SsidRid), GFP_KERNEL)) == NULL)
5483 readAPListRid(ai, ai->APList);
5484 readSsidRid(ai, ai->SSID);
5485 memset(&cmd, 0, sizeof(cmd));
5486 /* the lock will be released at the end of the resume callback */
5487 if (down_interruptible(&ai->sem))
5490 netif_device_detach(dev);
5493 issuecommand(ai, &cmd, &rsp);
5495 pci_enable_wake(pdev, state, 1);
5496 pci_save_state(pdev);
5497 return pci_set_power_state(pdev, state);
5500 static int airo_pci_resume(struct pci_dev *pdev)
5502 struct net_device *dev = pci_get_drvdata(pdev);
5503 struct airo_info *ai = dev->priv;
5506 pci_set_power_state(pdev, 0);
5507 pci_restore_state(pdev);
5508 pci_enable_wake(pdev, ai->power, 0);
5510 if (ai->power > 1) {
5512 mpi_init_descriptors(ai);
5513 setup_card(ai, dev->dev_addr, 0);
5514 clear_bit(FLAG_RADIO_OFF, &ai->flags);
5515 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
5517 OUT4500(ai, EVACK, EV_AWAKEN);
5518 OUT4500(ai, EVACK, EV_AWAKEN);
5519 schedule_timeout(HZ/10);
5522 set_bit (FLAG_COMMIT, &ai->flags);
5524 schedule_timeout (HZ/5);
5526 writeSsidRid(ai, ai->SSID, 0);
5531 writeAPListRid(ai, ai->APList, 0);
5535 writeConfigRid(ai, 0);
5536 enable_MAC(ai, &rsp, 0);
5538 netif_device_attach(dev);
5539 netif_wake_queue(dev);
5540 enable_interrupts(ai);
5546 static int __init airo_init_module( void )
5548 int i, have_isa_dev = 0;
5550 airo_entry = create_proc_entry("aironet",
5551 S_IFDIR | airo_perm,
5553 airo_entry->uid = proc_uid;
5554 airo_entry->gid = proc_gid;
5556 for( i = 0; i < 4 && io[i] && irq[i]; i++ ) {
5558 "airo: Trying to configure ISA adapter at irq=%d io=0x%x\n",
5560 if (init_airo_card( irq[i], io[i], 0, NULL ))
5565 printk( KERN_INFO "airo: Probing for PCI adapters\n" );
5566 pci_register_driver(&airo_driver);
5567 printk( KERN_INFO "airo: Finished probing for PCI adapters\n" );
5570 /* Always exit with success, as we are a library module
5571 * as well as a driver module
5576 static void __exit airo_cleanup_module( void )
5578 while( airo_devices ) {
5579 printk( KERN_INFO "airo: Unregistering %s\n", airo_devices->dev->name );
5580 stop_airo_card( airo_devices->dev, 1 );
5583 pci_unregister_driver(&airo_driver);
5585 remove_proc_entry("aironet", proc_root_driver);
5590 * Initial Wireless Extension code for Aironet driver by :
5591 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 17 November 00
5592 * Conversion to new driver API by :
5593 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 26 March 02
5594 * Javier also did a good amount of work here, adding some new extensions
5595 * and fixing my code. Let's just say that without him this code just
5596 * would not work at all... - Jean II
5599 static int airo_get_quality (StatusRid *status_rid, CapabilityRid *cap_rid)
5603 if ((status_rid->mode & 0x3f) == 0x3f && (cap_rid->hardCap & 8)) {
5604 if (memcmp(cap_rid->prodName, "350", 3))
5605 if (status_rid->signalQuality > 0x20)
5608 quality = 0x20 - status_rid->signalQuality;
5610 if (status_rid->signalQuality > 0xb0)
5612 else if (status_rid->signalQuality < 0x10)
5615 quality = 0xb0 - status_rid->signalQuality;
5620 #define airo_get_max_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x20 : 0xa0)
5621 #define airo_get_avg_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x10 : 0x50);
5623 /*------------------------------------------------------------------*/
5625 * Wireless Handler : get protocol name
5627 static int airo_get_name(struct net_device *dev,
5628 struct iw_request_info *info,
5632 strcpy(cwrq, "IEEE 802.11-DS");
5636 /*------------------------------------------------------------------*/
5638 * Wireless Handler : set frequency
5640 static int airo_set_freq(struct net_device *dev,
5641 struct iw_request_info *info,
5642 struct iw_freq *fwrq,
5645 struct airo_info *local = dev->priv;
5646 int rc = -EINPROGRESS; /* Call commit handler */
5648 /* If setting by frequency, convert to a channel */
5649 if((fwrq->e == 1) &&
5650 (fwrq->m >= (int) 2.412e8) &&
5651 (fwrq->m <= (int) 2.487e8)) {
5652 int f = fwrq->m / 100000;
5654 while((c < 14) && (f != frequency_list[c]))
5656 /* Hack to fall through... */
5660 /* Setting by channel number */
5661 if((fwrq->m > 1000) || (fwrq->e > 0))
5664 int channel = fwrq->m;
5665 /* We should do a better check than that,
5666 * based on the card capability !!! */
5667 if((channel < 1) || (channel > 16)) {
5668 printk(KERN_DEBUG "%s: New channel value of %d is invalid!\n", dev->name, fwrq->m);
5671 readConfigRid(local, 1);
5672 /* Yes ! We can set it !!! */
5673 local->config.channelSet = (u16)(channel - 1);
5674 set_bit (FLAG_COMMIT, &local->flags);
5680 /*------------------------------------------------------------------*/
5682 * Wireless Handler : get frequency
5684 static int airo_get_freq(struct net_device *dev,
5685 struct iw_request_info *info,
5686 struct iw_freq *fwrq,
5689 struct airo_info *local = dev->priv;
5690 StatusRid status_rid; /* Card status info */
5692 readConfigRid(local, 1);
5693 if ((local->config.opmode & 0xFF) == MODE_STA_ESS)
5694 status_rid.channel = local->config.channelSet;
5696 readStatusRid(local, &status_rid, 1);
5698 #ifdef WEXT_USECHANNELS
5699 fwrq->m = ((int)status_rid.channel) + 1;
5703 int f = (int)status_rid.channel;
5704 fwrq->m = frequency_list[f] * 100000;
5712 /*------------------------------------------------------------------*/
5714 * Wireless Handler : set ESSID
5716 static int airo_set_essid(struct net_device *dev,
5717 struct iw_request_info *info,
5718 struct iw_point *dwrq,
5721 struct airo_info *local = dev->priv;
5723 SsidRid SSID_rid; /* SSIDs */
5725 /* Reload the list of current SSID */
5726 readSsidRid(local, &SSID_rid);
5728 /* Check if we asked for `any' */
5729 if(dwrq->flags == 0) {
5730 /* Just send an empty SSID list */
5731 memset(&SSID_rid, 0, sizeof(SSID_rid));
5733 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
5735 /* Check the size of the string */
5736 if(dwrq->length > IW_ESSID_MAX_SIZE+1) {
5739 /* Check if index is valid */
5740 if((index < 0) || (index >= 4)) {
5745 memset(SSID_rid.ssids[index].ssid, 0,
5746 sizeof(SSID_rid.ssids[index].ssid));
5747 memcpy(SSID_rid.ssids[index].ssid, extra, dwrq->length);
5748 SSID_rid.ssids[index].len = dwrq->length - 1;
5750 SSID_rid.len = sizeof(SSID_rid);
5751 /* Write it to the card */
5752 disable_MAC(local, 1);
5753 writeSsidRid(local, &SSID_rid, 1);
5754 enable_MAC(local, &rsp, 1);
5759 /*------------------------------------------------------------------*/
5761 * Wireless Handler : get ESSID
5763 static int airo_get_essid(struct net_device *dev,
5764 struct iw_request_info *info,
5765 struct iw_point *dwrq,
5768 struct airo_info *local = dev->priv;
5769 StatusRid status_rid; /* Card status info */
5771 readStatusRid(local, &status_rid, 1);
5773 /* Note : if dwrq->flags != 0, we should
5774 * get the relevant SSID from the SSID list... */
5776 /* Get the current SSID */
5777 memcpy(extra, status_rid.SSID, status_rid.SSIDlen);
5778 extra[status_rid.SSIDlen] = '\0';
5779 /* If none, we may want to get the one that was set */
5782 dwrq->length = status_rid.SSIDlen + 1;
5783 dwrq->flags = 1; /* active */
5788 /*------------------------------------------------------------------*/
5790 * Wireless Handler : set AP address
5792 static int airo_set_wap(struct net_device *dev,
5793 struct iw_request_info *info,
5794 struct sockaddr *awrq,
5797 struct airo_info *local = dev->priv;
5800 APListRid APList_rid;
5801 static const unsigned char bcast[ETH_ALEN] = { 255, 255, 255, 255, 255, 255 };
5803 if (awrq->sa_family != ARPHRD_ETHER)
5805 else if (!memcmp(bcast, awrq->sa_data, ETH_ALEN)) {
5806 memset(&cmd, 0, sizeof(cmd));
5807 cmd.cmd=CMD_LOSE_SYNC;
5808 if (down_interruptible(&local->sem))
5809 return -ERESTARTSYS;
5810 issuecommand(local, &cmd, &rsp);
5813 memset(&APList_rid, 0, sizeof(APList_rid));
5814 APList_rid.len = sizeof(APList_rid);
5815 memcpy(APList_rid.ap[0], awrq->sa_data, ETH_ALEN);
5816 disable_MAC(local, 1);
5817 writeAPListRid(local, &APList_rid, 1);
5818 enable_MAC(local, &rsp, 1);
5823 /*------------------------------------------------------------------*/
5825 * Wireless Handler : get AP address
5827 static int airo_get_wap(struct net_device *dev,
5828 struct iw_request_info *info,
5829 struct sockaddr *awrq,
5832 struct airo_info *local = dev->priv;
5833 StatusRid status_rid; /* Card status info */
5835 readStatusRid(local, &status_rid, 1);
5837 /* Tentative. This seems to work, wow, I'm lucky !!! */
5838 memcpy(awrq->sa_data, status_rid.bssid[0], ETH_ALEN);
5839 awrq->sa_family = ARPHRD_ETHER;
5844 /*------------------------------------------------------------------*/
5846 * Wireless Handler : set Nickname
5848 static int airo_set_nick(struct net_device *dev,
5849 struct iw_request_info *info,
5850 struct iw_point *dwrq,
5853 struct airo_info *local = dev->priv;
5855 /* Check the size of the string */
5856 if(dwrq->length > 16 + 1) {
5859 readConfigRid(local, 1);
5860 memset(local->config.nodeName, 0, sizeof(local->config.nodeName));
5861 memcpy(local->config.nodeName, extra, dwrq->length);
5862 set_bit (FLAG_COMMIT, &local->flags);
5864 return -EINPROGRESS; /* Call commit handler */
5867 /*------------------------------------------------------------------*/
5869 * Wireless Handler : get Nickname
5871 static int airo_get_nick(struct net_device *dev,
5872 struct iw_request_info *info,
5873 struct iw_point *dwrq,
5876 struct airo_info *local = dev->priv;
5878 readConfigRid(local, 1);
5879 strncpy(extra, local->config.nodeName, 16);
5881 dwrq->length = strlen(extra) + 1;
5886 /*------------------------------------------------------------------*/
5888 * Wireless Handler : set Bit-Rate
5890 static int airo_set_rate(struct net_device *dev,
5891 struct iw_request_info *info,
5892 struct iw_param *vwrq,
5895 struct airo_info *local = dev->priv;
5896 CapabilityRid cap_rid; /* Card capability info */
5900 /* First : get a valid bit rate value */
5901 readCapabilityRid(local, &cap_rid, 1);
5903 /* Which type of value ? */
5904 if((vwrq->value < 8) && (vwrq->value >= 0)) {
5905 /* Setting by rate index */
5906 /* Find value in the magic rate table */
5907 brate = cap_rid.supportedRates[vwrq->value];
5909 /* Setting by frequency value */
5910 u8 normvalue = (u8) (vwrq->value/500000);
5912 /* Check if rate is valid */
5913 for(i = 0 ; i < 8 ; i++) {
5914 if(normvalue == cap_rid.supportedRates[i]) {
5920 /* -1 designed the max rate (mostly auto mode) */
5921 if(vwrq->value == -1) {
5922 /* Get the highest available rate */
5923 for(i = 0 ; i < 8 ; i++) {
5924 if(cap_rid.supportedRates[i] == 0)
5928 brate = cap_rid.supportedRates[i - 1];
5930 /* Check that it is valid */
5935 readConfigRid(local, 1);
5936 /* Now, check if we want a fixed or auto value */
5937 if(vwrq->fixed == 0) {
5938 /* Fill all the rates up to this max rate */
5939 memset(local->config.rates, 0, 8);
5940 for(i = 0 ; i < 8 ; i++) {
5941 local->config.rates[i] = cap_rid.supportedRates[i];
5942 if(local->config.rates[i] == brate)
5947 /* One rate, fixed */
5948 memset(local->config.rates, 0, 8);
5949 local->config.rates[0] = brate;
5951 set_bit (FLAG_COMMIT, &local->flags);
5953 return -EINPROGRESS; /* Call commit handler */
5956 /*------------------------------------------------------------------*/
5958 * Wireless Handler : get Bit-Rate
5960 static int airo_get_rate(struct net_device *dev,
5961 struct iw_request_info *info,
5962 struct iw_param *vwrq,
5965 struct airo_info *local = dev->priv;
5966 StatusRid status_rid; /* Card status info */
5968 readStatusRid(local, &status_rid, 1);
5970 vwrq->value = status_rid.currentXmitRate * 500000;
5971 /* If more than one rate, set auto */
5972 readConfigRid(local, 1);
5973 vwrq->fixed = (local->config.rates[1] == 0);
5978 /*------------------------------------------------------------------*/
5980 * Wireless Handler : set RTS threshold
5982 static int airo_set_rts(struct net_device *dev,
5983 struct iw_request_info *info,
5984 struct iw_param *vwrq,
5987 struct airo_info *local = dev->priv;
5988 int rthr = vwrq->value;
5992 if((rthr < 0) || (rthr > 2312)) {
5995 readConfigRid(local, 1);
5996 local->config.rtsThres = rthr;
5997 set_bit (FLAG_COMMIT, &local->flags);
5999 return -EINPROGRESS; /* Call commit handler */
6002 /*------------------------------------------------------------------*/
6004 * Wireless Handler : get RTS threshold
6006 static int airo_get_rts(struct net_device *dev,
6007 struct iw_request_info *info,
6008 struct iw_param *vwrq,
6011 struct airo_info *local = dev->priv;
6013 readConfigRid(local, 1);
6014 vwrq->value = local->config.rtsThres;
6015 vwrq->disabled = (vwrq->value >= 2312);
6021 /*------------------------------------------------------------------*/
6023 * Wireless Handler : set Fragmentation threshold
6025 static int airo_set_frag(struct net_device *dev,
6026 struct iw_request_info *info,
6027 struct iw_param *vwrq,
6030 struct airo_info *local = dev->priv;
6031 int fthr = vwrq->value;
6035 if((fthr < 256) || (fthr > 2312)) {
6038 fthr &= ~0x1; /* Get an even value - is it really needed ??? */
6039 readConfigRid(local, 1);
6040 local->config.fragThresh = (u16)fthr;
6041 set_bit (FLAG_COMMIT, &local->flags);
6043 return -EINPROGRESS; /* Call commit handler */
6046 /*------------------------------------------------------------------*/
6048 * Wireless Handler : get Fragmentation threshold
6050 static int airo_get_frag(struct net_device *dev,
6051 struct iw_request_info *info,
6052 struct iw_param *vwrq,
6055 struct airo_info *local = dev->priv;
6057 readConfigRid(local, 1);
6058 vwrq->value = local->config.fragThresh;
6059 vwrq->disabled = (vwrq->value >= 2312);
6065 /*------------------------------------------------------------------*/
6067 * Wireless Handler : set Mode of Operation
6069 static int airo_set_mode(struct net_device *dev,
6070 struct iw_request_info *info,
6074 struct airo_info *local = dev->priv;
6077 readConfigRid(local, 1);
6078 if ((local->config.rmode & 0xff) >= RXMODE_RFMON)
6083 local->config.opmode &= 0xFF00;
6084 local->config.opmode |= MODE_STA_IBSS;
6085 local->config.rmode &= 0xfe00;
6086 local->config.scanMode = SCANMODE_ACTIVE;
6087 clear_bit (FLAG_802_11, &local->flags);
6090 local->config.opmode &= 0xFF00;
6091 local->config.opmode |= MODE_STA_ESS;
6092 local->config.rmode &= 0xfe00;
6093 local->config.scanMode = SCANMODE_ACTIVE;
6094 clear_bit (FLAG_802_11, &local->flags);
6096 case IW_MODE_MASTER:
6097 local->config.opmode &= 0xFF00;
6098 local->config.opmode |= MODE_AP;
6099 local->config.rmode &= 0xfe00;
6100 local->config.scanMode = SCANMODE_ACTIVE;
6101 clear_bit (FLAG_802_11, &local->flags);
6103 case IW_MODE_REPEAT:
6104 local->config.opmode &= 0xFF00;
6105 local->config.opmode |= MODE_AP_RPTR;
6106 local->config.rmode &= 0xfe00;
6107 local->config.scanMode = SCANMODE_ACTIVE;
6108 clear_bit (FLAG_802_11, &local->flags);
6110 case IW_MODE_MONITOR:
6111 local->config.opmode &= 0xFF00;
6112 local->config.opmode |= MODE_STA_ESS;
6113 local->config.rmode &= 0xfe00;
6114 local->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
6115 local->config.scanMode = SCANMODE_PASSIVE;
6116 set_bit (FLAG_802_11, &local->flags);
6122 set_bit (FLAG_RESET, &local->flags);
6123 set_bit (FLAG_COMMIT, &local->flags);
6125 return -EINPROGRESS; /* Call commit handler */
6128 /*------------------------------------------------------------------*/
6130 * Wireless Handler : get Mode of Operation
6132 static int airo_get_mode(struct net_device *dev,
6133 struct iw_request_info *info,
6137 struct airo_info *local = dev->priv;
6139 readConfigRid(local, 1);
6140 /* If not managed, assume it's ad-hoc */
6141 switch (local->config.opmode & 0xFF) {
6143 *uwrq = IW_MODE_INFRA;
6146 *uwrq = IW_MODE_MASTER;
6149 *uwrq = IW_MODE_REPEAT;
6152 *uwrq = IW_MODE_ADHOC;
6158 /*------------------------------------------------------------------*/
6160 * Wireless Handler : set Encryption Key
6162 static int airo_set_encode(struct net_device *dev,
6163 struct iw_request_info *info,
6164 struct iw_point *dwrq,
6167 struct airo_info *local = dev->priv;
6168 CapabilityRid cap_rid; /* Card capability info */
6170 /* Is WEP supported ? */
6171 readCapabilityRid(local, &cap_rid, 1);
6172 /* Older firmware doesn't support this...
6173 if(!(cap_rid.softCap & 2)) {
6176 readConfigRid(local, 1);
6178 /* Basic checking: do we have a key to set ?
6179 * Note : with the new API, it's impossible to get a NULL pointer.
6180 * Therefore, we need to check a key size == 0 instead.
6181 * New version of iwconfig properly set the IW_ENCODE_NOKEY flag
6182 * when no key is present (only change flags), but older versions
6183 * don't do it. - Jean II */
6184 if (dwrq->length > 0) {
6186 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6187 int current_index = get_wep_key(local, 0xffff);
6188 /* Check the size of the key */
6189 if (dwrq->length > MAX_KEY_SIZE) {
6192 /* Check the index (none -> use current) */
6193 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4:1)))
6194 index = current_index;
6195 /* Set the length */
6196 if (dwrq->length > MIN_KEY_SIZE)
6197 key.len = MAX_KEY_SIZE;
6199 if (dwrq->length > 0)
6200 key.len = MIN_KEY_SIZE;
6202 /* Disable the key */
6204 /* Check if the key is not marked as invalid */
6205 if(!(dwrq->flags & IW_ENCODE_NOKEY)) {
6207 memset(key.key, 0, MAX_KEY_SIZE);
6208 /* Copy the key in the driver */
6209 memcpy(key.key, extra, dwrq->length);
6210 /* Send the key to the card */
6211 set_wep_key(local, index, key.key, key.len, 1, 1);
6213 /* WE specify that if a valid key is set, encryption
6214 * should be enabled (user may turn it off later)
6215 * This is also how "iwconfig ethX key on" works */
6216 if((index == current_index) && (key.len > 0) &&
6217 (local->config.authType == AUTH_OPEN)) {
6218 local->config.authType = AUTH_ENCRYPT;
6219 set_bit (FLAG_COMMIT, &local->flags);
6222 /* Do we want to just set the transmit key index ? */
6223 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6224 if ((index >= 0) && (index < ((cap_rid.softCap & 0x80)?4:1))) {
6225 set_wep_key(local, index, NULL, 0, 1, 1);
6227 /* Don't complain if only change the mode */
6228 if(!dwrq->flags & IW_ENCODE_MODE) {
6232 /* Read the flags */
6233 if(dwrq->flags & IW_ENCODE_DISABLED)
6234 local->config.authType = AUTH_OPEN; // disable encryption
6235 if(dwrq->flags & IW_ENCODE_RESTRICTED)
6236 local->config.authType = AUTH_SHAREDKEY; // Only Both
6237 if(dwrq->flags & IW_ENCODE_OPEN)
6238 local->config.authType = AUTH_ENCRYPT; // Only Wep
6239 /* Commit the changes to flags if needed */
6240 if(dwrq->flags & IW_ENCODE_MODE)
6241 set_bit (FLAG_COMMIT, &local->flags);
6242 return -EINPROGRESS; /* Call commit handler */
6245 /*------------------------------------------------------------------*/
6247 * Wireless Handler : get Encryption Key
6249 static int airo_get_encode(struct net_device *dev,
6250 struct iw_request_info *info,
6251 struct iw_point *dwrq,
6254 struct airo_info *local = dev->priv;
6255 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6256 CapabilityRid cap_rid; /* Card capability info */
6258 /* Is it supported ? */
6259 readCapabilityRid(local, &cap_rid, 1);
6260 if(!(cap_rid.softCap & 2)) {
6263 readConfigRid(local, 1);
6264 /* Check encryption mode */
6265 switch(local->config.authType) {
6267 dwrq->flags = IW_ENCODE_OPEN;
6269 case AUTH_SHAREDKEY:
6270 dwrq->flags = IW_ENCODE_RESTRICTED;
6274 dwrq->flags = IW_ENCODE_DISABLED;
6277 /* We can't return the key, so set the proper flag and return zero */
6278 dwrq->flags |= IW_ENCODE_NOKEY;
6279 memset(extra, 0, 16);
6281 /* Which key do we want ? -1 -> tx index */
6282 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4 : 1)))
6283 index = get_wep_key(local, 0xffff);
6284 dwrq->flags |= index + 1;
6285 /* Copy the key to the user buffer */
6286 dwrq->length = get_wep_key(local, index);
6287 if (dwrq->length > 16) {
6293 /*------------------------------------------------------------------*/
6295 * Wireless Handler : set Tx-Power
6297 static int airo_set_txpow(struct net_device *dev,
6298 struct iw_request_info *info,
6299 struct iw_param *vwrq,
6302 struct airo_info *local = dev->priv;
6303 CapabilityRid cap_rid; /* Card capability info */
6307 readCapabilityRid(local, &cap_rid, 1);
6309 if (vwrq->disabled) {
6310 set_bit (FLAG_RADIO_OFF, &local->flags);
6311 set_bit (FLAG_COMMIT, &local->flags);
6312 return -EINPROGRESS; /* Call commit handler */
6314 if (vwrq->flags != IW_TXPOW_MWATT) {
6317 clear_bit (FLAG_RADIO_OFF, &local->flags);
6318 for (i = 0; cap_rid.txPowerLevels[i] && (i < 8); i++)
6319 if ((vwrq->value==cap_rid.txPowerLevels[i])) {
6320 readConfigRid(local, 1);
6321 local->config.txPower = vwrq->value;
6322 set_bit (FLAG_COMMIT, &local->flags);
6323 rc = -EINPROGRESS; /* Call commit handler */
6329 /*------------------------------------------------------------------*/
6331 * Wireless Handler : get Tx-Power
6333 static int airo_get_txpow(struct net_device *dev,
6334 struct iw_request_info *info,
6335 struct iw_param *vwrq,
6338 struct airo_info *local = dev->priv;
6340 readConfigRid(local, 1);
6341 vwrq->value = local->config.txPower;
6342 vwrq->fixed = 1; /* No power control */
6343 vwrq->disabled = test_bit(FLAG_RADIO_OFF, &local->flags);
6344 vwrq->flags = IW_TXPOW_MWATT;
6349 /*------------------------------------------------------------------*/
6351 * Wireless Handler : set Retry limits
6353 static int airo_set_retry(struct net_device *dev,
6354 struct iw_request_info *info,
6355 struct iw_param *vwrq,
6358 struct airo_info *local = dev->priv;
6361 if(vwrq->disabled) {
6364 readConfigRid(local, 1);
6365 if(vwrq->flags & IW_RETRY_LIMIT) {
6366 if(vwrq->flags & IW_RETRY_MAX)
6367 local->config.longRetryLimit = vwrq->value;
6368 else if (vwrq->flags & IW_RETRY_MIN)
6369 local->config.shortRetryLimit = vwrq->value;
6371 /* No modifier : set both */
6372 local->config.longRetryLimit = vwrq->value;
6373 local->config.shortRetryLimit = vwrq->value;
6375 set_bit (FLAG_COMMIT, &local->flags);
6376 rc = -EINPROGRESS; /* Call commit handler */
6378 if(vwrq->flags & IW_RETRY_LIFETIME) {
6379 local->config.txLifetime = vwrq->value / 1024;
6380 set_bit (FLAG_COMMIT, &local->flags);
6381 rc = -EINPROGRESS; /* Call commit handler */
6386 /*------------------------------------------------------------------*/
6388 * Wireless Handler : get Retry limits
6390 static int airo_get_retry(struct net_device *dev,
6391 struct iw_request_info *info,
6392 struct iw_param *vwrq,
6395 struct airo_info *local = dev->priv;
6397 vwrq->disabled = 0; /* Can't be disabled */
6399 readConfigRid(local, 1);
6400 /* Note : by default, display the min retry number */
6401 if((vwrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
6402 vwrq->flags = IW_RETRY_LIFETIME;
6403 vwrq->value = (int)local->config.txLifetime * 1024;
6404 } else if((vwrq->flags & IW_RETRY_MAX)) {
6405 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
6406 vwrq->value = (int)local->config.longRetryLimit;
6408 vwrq->flags = IW_RETRY_LIMIT;
6409 vwrq->value = (int)local->config.shortRetryLimit;
6410 if((int)local->config.shortRetryLimit != (int)local->config.longRetryLimit)
6411 vwrq->flags |= IW_RETRY_MIN;
6417 /*------------------------------------------------------------------*/
6419 * Wireless Handler : get range info
6421 static int airo_get_range(struct net_device *dev,
6422 struct iw_request_info *info,
6423 struct iw_point *dwrq,
6426 struct airo_info *local = dev->priv;
6427 struct iw_range *range = (struct iw_range *) extra;
6428 CapabilityRid cap_rid; /* Card capability info */
6432 readCapabilityRid(local, &cap_rid, 1);
6434 dwrq->length = sizeof(struct iw_range);
6435 memset(range, 0, sizeof(*range));
6436 range->min_nwid = 0x0000;
6437 range->max_nwid = 0x0000;
6438 range->num_channels = 14;
6439 /* Should be based on cap_rid.country to give only
6440 * what the current card support */
6442 for(i = 0; i < 14; i++) {
6443 range->freq[k].i = i + 1; /* List index */
6444 range->freq[k].m = frequency_list[i] * 100000;
6445 range->freq[k++].e = 1; /* Values in table in MHz -> * 10^5 * 10 */
6447 range->num_frequency = k;
6449 /* Hum... Should put the right values there */
6450 range->max_qual.qual = airo_get_max_quality(&cap_rid);
6451 range->max_qual.level = 0x100 - 120; /* -120 dBm */
6452 range->max_qual.noise = 0;
6453 range->sensitivity = 65535;
6455 for(i = 0 ; i < 8 ; i++) {
6456 range->bitrate[i] = cap_rid.supportedRates[i] * 500000;
6457 if(range->bitrate[i] == 0)
6460 range->num_bitrates = i;
6462 /* Set an indication of the max TCP throughput
6463 * in bit/s that we can expect using this interface.
6464 * May be use for QoS stuff... Jean II */
6466 range->throughput = 5000 * 1000;
6468 range->throughput = 1500 * 1000;
6471 range->max_rts = 2312;
6472 range->min_frag = 256;
6473 range->max_frag = 2312;
6475 if(cap_rid.softCap & 2) {
6477 range->encoding_size[0] = 5;
6479 if (cap_rid.softCap & 0x100) {
6480 range->encoding_size[1] = 13;
6481 range->num_encoding_sizes = 2;
6483 range->num_encoding_sizes = 1;
6484 range->max_encoding_tokens = (cap_rid.softCap & 0x80) ? 4 : 1;
6486 range->num_encoding_sizes = 0;
6487 range->max_encoding_tokens = 0;
6490 range->max_pmp = 5000000; /* 5 secs */
6492 range->max_pmt = 65535 * 1024; /* ??? */
6493 range->pmp_flags = IW_POWER_PERIOD;
6494 range->pmt_flags = IW_POWER_TIMEOUT;
6495 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
6497 /* Transmit Power - values are in mW */
6498 for(i = 0 ; i < 8 ; i++) {
6499 range->txpower[i] = cap_rid.txPowerLevels[i];
6500 if(range->txpower[i] == 0)
6503 range->num_txpower = i;
6504 range->txpower_capa = IW_TXPOW_MWATT;
6505 range->we_version_source = 12;
6506 range->we_version_compiled = WIRELESS_EXT;
6507 range->retry_capa = IW_RETRY_LIMIT | IW_RETRY_LIFETIME;
6508 range->retry_flags = IW_RETRY_LIMIT;
6509 range->r_time_flags = IW_RETRY_LIFETIME;
6510 range->min_retry = 1;
6511 range->max_retry = 65535;
6512 range->min_r_time = 1024;
6513 range->max_r_time = 65535 * 1024;
6514 /* Experimental measurements - boundary 11/5.5 Mb/s */
6515 /* Note : with or without the (local->rssi), results
6516 * are somewhat different. - Jean II */
6517 range->avg_qual.qual = airo_get_avg_quality(&cap_rid);
6519 range->avg_qual.level = 186; /* -70 dBm */
6521 range->avg_qual.level = 176; /* -80 dBm */
6522 range->avg_qual.noise = 0;
6524 /* Event capability (kernel + driver) */
6525 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
6526 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
6527 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
6528 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
6529 range->event_capa[1] = IW_EVENT_CAPA_K_1;
6530 range->event_capa[4] = IW_EVENT_CAPA_MASK(IWEVTXDROP);
6534 /*------------------------------------------------------------------*/
6536 * Wireless Handler : set Power Management
6538 static int airo_set_power(struct net_device *dev,
6539 struct iw_request_info *info,
6540 struct iw_param *vwrq,
6543 struct airo_info *local = dev->priv;
6545 readConfigRid(local, 1);
6546 if (vwrq->disabled) {
6547 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6550 local->config.powerSaveMode = POWERSAVE_CAM;
6551 local->config.rmode &= 0xFF00;
6552 local->config.rmode |= RXMODE_BC_MC_ADDR;
6553 set_bit (FLAG_COMMIT, &local->flags);
6554 return -EINPROGRESS; /* Call commit handler */
6556 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
6557 local->config.fastListenDelay = (vwrq->value + 500) / 1024;
6558 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6559 set_bit (FLAG_COMMIT, &local->flags);
6560 } else if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
6561 local->config.fastListenInterval = local->config.listenInterval = (vwrq->value + 500) / 1024;
6562 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6563 set_bit (FLAG_COMMIT, &local->flags);
6565 switch (vwrq->flags & IW_POWER_MODE) {
6566 case IW_POWER_UNICAST_R:
6567 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6570 local->config.rmode &= 0xFF00;
6571 local->config.rmode |= RXMODE_ADDR;
6572 set_bit (FLAG_COMMIT, &local->flags);
6574 case IW_POWER_ALL_R:
6575 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6578 local->config.rmode &= 0xFF00;
6579 local->config.rmode |= RXMODE_BC_MC_ADDR;
6580 set_bit (FLAG_COMMIT, &local->flags);
6586 // Note : we may want to factor local->need_commit here
6587 // Note2 : may also want to factor RXMODE_RFMON test
6588 return -EINPROGRESS; /* Call commit handler */
6591 /*------------------------------------------------------------------*/
6593 * Wireless Handler : get Power Management
6595 static int airo_get_power(struct net_device *dev,
6596 struct iw_request_info *info,
6597 struct iw_param *vwrq,
6600 struct airo_info *local = dev->priv;
6603 readConfigRid(local, 1);
6604 mode = local->config.powerSaveMode;
6605 if ((vwrq->disabled = (mode == POWERSAVE_CAM)))
6607 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
6608 vwrq->value = (int)local->config.fastListenDelay * 1024;
6609 vwrq->flags = IW_POWER_TIMEOUT;
6611 vwrq->value = (int)local->config.fastListenInterval * 1024;
6612 vwrq->flags = IW_POWER_PERIOD;
6614 if ((local->config.rmode & 0xFF) == RXMODE_ADDR)
6615 vwrq->flags |= IW_POWER_UNICAST_R;
6617 vwrq->flags |= IW_POWER_ALL_R;
6622 /*------------------------------------------------------------------*/
6624 * Wireless Handler : set Sensitivity
6626 static int airo_set_sens(struct net_device *dev,
6627 struct iw_request_info *info,
6628 struct iw_param *vwrq,
6631 struct airo_info *local = dev->priv;
6633 readConfigRid(local, 1);
6634 local->config.rssiThreshold = vwrq->disabled ? RSSI_DEFAULT : vwrq->value;
6635 set_bit (FLAG_COMMIT, &local->flags);
6637 return -EINPROGRESS; /* Call commit handler */
6640 /*------------------------------------------------------------------*/
6642 * Wireless Handler : get Sensitivity
6644 static int airo_get_sens(struct net_device *dev,
6645 struct iw_request_info *info,
6646 struct iw_param *vwrq,
6649 struct airo_info *local = dev->priv;
6651 readConfigRid(local, 1);
6652 vwrq->value = local->config.rssiThreshold;
6653 vwrq->disabled = (vwrq->value == 0);
6659 /*------------------------------------------------------------------*/
6661 * Wireless Handler : get AP List
6662 * Note : this is deprecated in favor of IWSCAN
6664 static int airo_get_aplist(struct net_device *dev,
6665 struct iw_request_info *info,
6666 struct iw_point *dwrq,
6669 struct airo_info *local = dev->priv;
6670 struct sockaddr *address = (struct sockaddr *) extra;
6671 struct iw_quality qual[IW_MAX_AP];
6674 int loseSync = capable(CAP_NET_ADMIN) ? 1: -1;
6676 for (i = 0; i < IW_MAX_AP; i++) {
6677 if (readBSSListRid(local, loseSync, &BSSList))
6680 memcpy(address[i].sa_data, BSSList.bssid, ETH_ALEN);
6681 address[i].sa_family = ARPHRD_ETHER;
6683 qual[i].level = 0x100 - local->rssi[BSSList.rssi].rssidBm;
6685 qual[i].level = (BSSList.rssi + 321) / 2;
6686 qual[i].qual = qual[i].noise = 0;
6687 qual[i].updated = 2;
6688 if (BSSList.index == 0xffff)
6692 StatusRid status_rid; /* Card status info */
6693 readStatusRid(local, &status_rid, 1);
6695 i < min(IW_MAX_AP, 4) &&
6696 (status_rid.bssid[i][0]
6697 & status_rid.bssid[i][1]
6698 & status_rid.bssid[i][2]
6699 & status_rid.bssid[i][3]
6700 & status_rid.bssid[i][4]
6701 & status_rid.bssid[i][5])!=0xff &&
6702 (status_rid.bssid[i][0]
6703 | status_rid.bssid[i][1]
6704 | status_rid.bssid[i][2]
6705 | status_rid.bssid[i][3]
6706 | status_rid.bssid[i][4]
6707 | status_rid.bssid[i][5]);
6709 memcpy(address[i].sa_data,
6710 status_rid.bssid[i], ETH_ALEN);
6711 address[i].sa_family = ARPHRD_ETHER;
6714 dwrq->flags = 1; /* Should be define'd */
6715 memcpy(extra + sizeof(struct sockaddr)*i,
6716 &qual, sizeof(struct iw_quality)*i);
6723 /*------------------------------------------------------------------*/
6725 * Wireless Handler : Initiate Scan
6727 static int airo_set_scan(struct net_device *dev,
6728 struct iw_request_info *info,
6729 struct iw_param *vwrq,
6732 struct airo_info *ai = dev->priv;
6736 /* Note : you may have realised that, as this is a SET operation,
6737 * this is privileged and therefore a normal user can't
6739 * This is not an error, while the device perform scanning,
6740 * traffic doesn't flow, so it's a perfect DoS...
6742 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
6744 /* Initiate a scan command */
6745 memset(&cmd, 0, sizeof(cmd));
6746 cmd.cmd=CMD_LISTBSS;
6747 if (down_interruptible(&ai->sem))
6748 return -ERESTARTSYS;
6749 issuecommand(ai, &cmd, &rsp);
6750 ai->scan_timestamp = jiffies;
6753 /* At this point, just return to the user. */
6758 /*------------------------------------------------------------------*/
6760 * Translate scan data returned from the card to a card independent
6761 * format that the Wireless Tools will understand - Jean II
6763 static inline char *airo_translate_scan(struct net_device *dev,
6768 struct airo_info *ai = dev->priv;
6769 struct iw_event iwe; /* Temporary buffer */
6771 char * current_val; /* For rates */
6774 /* First entry *MUST* be the AP MAC address */
6775 iwe.cmd = SIOCGIWAP;
6776 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
6777 memcpy(iwe.u.ap_addr.sa_data, list->bssid, ETH_ALEN);
6778 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_ADDR_LEN);
6780 /* Other entries will be displayed in the order we give them */
6783 iwe.u.data.length = list->ssidLen;
6784 if(iwe.u.data.length > 32)
6785 iwe.u.data.length = 32;
6786 iwe.cmd = SIOCGIWESSID;
6787 iwe.u.data.flags = 1;
6788 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, list->ssid);
6791 iwe.cmd = SIOCGIWMODE;
6792 capabilities = le16_to_cpu(list->cap);
6793 if(capabilities & (CAP_ESS | CAP_IBSS)) {
6794 if(capabilities & CAP_ESS)
6795 iwe.u.mode = IW_MODE_MASTER;
6797 iwe.u.mode = IW_MODE_ADHOC;
6798 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_UINT_LEN);
6802 iwe.cmd = SIOCGIWFREQ;
6803 iwe.u.freq.m = le16_to_cpu(list->dsChannel);
6804 iwe.u.freq.m = frequency_list[iwe.u.freq.m] * 100000;
6806 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_FREQ_LEN);
6808 /* Add quality statistics */
6811 iwe.u.qual.level = 0x100 - ai->rssi[list->rssi].rssidBm;
6813 iwe.u.qual.level = (list->rssi + 321) / 2;
6814 iwe.u.qual.noise = 0;
6815 iwe.u.qual.qual = 0;
6816 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
6818 /* Add encryption capability */
6819 iwe.cmd = SIOCGIWENCODE;
6820 if(capabilities & CAP_PRIVACY)
6821 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
6823 iwe.u.data.flags = IW_ENCODE_DISABLED;
6824 iwe.u.data.length = 0;
6825 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, list->ssid);
6827 /* Rate : stuffing multiple values in a single event require a bit
6828 * more of magic - Jean II */
6829 current_val = current_ev + IW_EV_LCP_LEN;
6831 iwe.cmd = SIOCGIWRATE;
6832 /* Those two flags are ignored... */
6833 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
6835 for(i = 0 ; i < 8 ; i++) {
6836 /* NULL terminated */
6837 if(list->rates[i] == 0)
6839 /* Bit rate given in 500 kb/s units (+ 0x80) */
6840 iwe.u.bitrate.value = ((list->rates[i] & 0x7f) * 500000);
6841 /* Add new value to event */
6842 current_val = iwe_stream_add_value(current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
6844 /* Check if we added any event */
6845 if((current_val - current_ev) > IW_EV_LCP_LEN)
6846 current_ev = current_val;
6848 /* The other data in the scan result are not really
6849 * interesting, so for now drop it - Jean II */
6853 /*------------------------------------------------------------------*/
6855 * Wireless Handler : Read Scan Results
6857 static int airo_get_scan(struct net_device *dev,
6858 struct iw_request_info *info,
6859 struct iw_point *dwrq,
6862 struct airo_info *ai = dev->priv;
6865 char *current_ev = extra;
6867 /* When we are associated again, the scan has surely finished.
6868 * Just in case, let's make sure enough time has elapsed since
6869 * we started the scan. - Javier */
6870 if(ai->scan_timestamp && time_before(jiffies,ai->scan_timestamp+3*HZ)) {
6871 /* Important note : we don't want to block the caller
6872 * until results are ready for various reasons.
6873 * First, managing wait queues is complex and racy
6874 * (there may be multiple simultaneous callers).
6875 * Second, we grab some rtnetlink lock before comming
6876 * here (in dev_ioctl()).
6877 * Third, the caller can wait on the Wireless Event
6881 ai->scan_timestamp = 0;
6883 /* There's only a race with proc_BSSList_open(), but its
6884 * consequences are begnign. So I don't bother fixing it - Javier */
6886 /* Try to read the first entry of the scan result */
6887 rc = PC4500_readrid(ai, RID_BSSLISTFIRST, &BSSList, sizeof(BSSList), 1);
6888 if((rc) || (BSSList.index == 0xffff)) {
6889 /* Client error, no scan results...
6890 * The caller need to restart the scan. */
6894 /* Read and parse all entries */
6895 while((!rc) && (BSSList.index != 0xffff)) {
6896 /* Translate to WE format this entry */
6897 current_ev = airo_translate_scan(dev, current_ev,
6898 extra + dwrq->length,
6901 /* Check if there is space for one more entry */
6902 if((extra + dwrq->length - current_ev) <= IW_EV_ADDR_LEN) {
6903 /* Ask user space to try again with a bigger buffer */
6907 /* Read next entry */
6908 rc = PC4500_readrid(ai, RID_BSSLISTNEXT,
6909 &BSSList, sizeof(BSSList), 1);
6911 /* Length of data */
6912 dwrq->length = (current_ev - extra);
6913 dwrq->flags = 0; /* todo */
6918 /*------------------------------------------------------------------*/
6920 * Commit handler : called after a bunch of SET operations
6922 static int airo_config_commit(struct net_device *dev,
6923 struct iw_request_info *info, /* NULL */
6924 void *zwrq, /* NULL */
6925 char *extra) /* NULL */
6927 struct airo_info *local = dev->priv;
6930 if (!test_bit (FLAG_COMMIT, &local->flags))
6933 /* Some of the "SET" function may have modified some of the
6934 * parameters. It's now time to commit them in the card */
6935 disable_MAC(local, 1);
6936 if (test_bit (FLAG_RESET, &local->flags)) {
6937 APListRid APList_rid;
6940 readAPListRid(local, &APList_rid);
6941 readSsidRid(local, &SSID_rid);
6942 if (test_bit(FLAG_MPI,&local->flags))
6943 setup_card(local, dev->dev_addr, 1 );
6945 reset_airo_card(dev);
6946 disable_MAC(local, 1);
6947 writeSsidRid(local, &SSID_rid, 1);
6948 writeAPListRid(local, &APList_rid, 1);
6950 if (down_interruptible(&local->sem))
6951 return -ERESTARTSYS;
6952 writeConfigRid(local, 0);
6953 enable_MAC(local, &rsp, 0);
6954 if (test_bit (FLAG_RESET, &local->flags))
6955 airo_set_promisc(local);
6962 /*------------------------------------------------------------------*/
6964 * Structures to export the Wireless Handlers
6967 static const struct iw_priv_args airo_private_args[] = {
6968 /*{ cmd, set_args, get_args, name } */
6969 { AIROIOCTL, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
6970 IW_PRIV_TYPE_BYTE | 2047, "airoioctl" },
6971 { AIROIDIFC, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
6972 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "airoidifc" },
6975 static const iw_handler airo_handler[] =
6977 (iw_handler) airo_config_commit, /* SIOCSIWCOMMIT */
6978 (iw_handler) airo_get_name, /* SIOCGIWNAME */
6979 (iw_handler) NULL, /* SIOCSIWNWID */
6980 (iw_handler) NULL, /* SIOCGIWNWID */
6981 (iw_handler) airo_set_freq, /* SIOCSIWFREQ */
6982 (iw_handler) airo_get_freq, /* SIOCGIWFREQ */
6983 (iw_handler) airo_set_mode, /* SIOCSIWMODE */
6984 (iw_handler) airo_get_mode, /* SIOCGIWMODE */
6985 (iw_handler) airo_set_sens, /* SIOCSIWSENS */
6986 (iw_handler) airo_get_sens, /* SIOCGIWSENS */
6987 (iw_handler) NULL, /* SIOCSIWRANGE */
6988 (iw_handler) airo_get_range, /* SIOCGIWRANGE */
6989 (iw_handler) NULL, /* SIOCSIWPRIV */
6990 (iw_handler) NULL, /* SIOCGIWPRIV */
6991 (iw_handler) NULL, /* SIOCSIWSTATS */
6992 (iw_handler) NULL, /* SIOCGIWSTATS */
6993 iw_handler_set_spy, /* SIOCSIWSPY */
6994 iw_handler_get_spy, /* SIOCGIWSPY */
6995 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
6996 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
6997 (iw_handler) airo_set_wap, /* SIOCSIWAP */
6998 (iw_handler) airo_get_wap, /* SIOCGIWAP */
6999 (iw_handler) NULL, /* -- hole -- */
7000 (iw_handler) airo_get_aplist, /* SIOCGIWAPLIST */
7001 (iw_handler) airo_set_scan, /* SIOCSIWSCAN */
7002 (iw_handler) airo_get_scan, /* SIOCGIWSCAN */
7003 (iw_handler) airo_set_essid, /* SIOCSIWESSID */
7004 (iw_handler) airo_get_essid, /* SIOCGIWESSID */
7005 (iw_handler) airo_set_nick, /* SIOCSIWNICKN */
7006 (iw_handler) airo_get_nick, /* SIOCGIWNICKN */
7007 (iw_handler) NULL, /* -- hole -- */
7008 (iw_handler) NULL, /* -- hole -- */
7009 (iw_handler) airo_set_rate, /* SIOCSIWRATE */
7010 (iw_handler) airo_get_rate, /* SIOCGIWRATE */
7011 (iw_handler) airo_set_rts, /* SIOCSIWRTS */
7012 (iw_handler) airo_get_rts, /* SIOCGIWRTS */
7013 (iw_handler) airo_set_frag, /* SIOCSIWFRAG */
7014 (iw_handler) airo_get_frag, /* SIOCGIWFRAG */
7015 (iw_handler) airo_set_txpow, /* SIOCSIWTXPOW */
7016 (iw_handler) airo_get_txpow, /* SIOCGIWTXPOW */
7017 (iw_handler) airo_set_retry, /* SIOCSIWRETRY */
7018 (iw_handler) airo_get_retry, /* SIOCGIWRETRY */
7019 (iw_handler) airo_set_encode, /* SIOCSIWENCODE */
7020 (iw_handler) airo_get_encode, /* SIOCGIWENCODE */
7021 (iw_handler) airo_set_power, /* SIOCSIWPOWER */
7022 (iw_handler) airo_get_power, /* SIOCGIWPOWER */
7025 /* Note : don't describe AIROIDIFC and AIROOLDIDIFC in here.
7026 * We want to force the use of the ioctl code, because those can't be
7027 * won't work the iw_handler code (because they simultaneously read
7028 * and write data and iw_handler can't do that).
7029 * Note that it's perfectly legal to read/write on a single ioctl command,
7030 * you just can't use iwpriv and need to force it via the ioctl handler.
7032 static const iw_handler airo_private_handler[] =
7034 NULL, /* SIOCIWFIRSTPRIV */
7037 static const struct iw_handler_def airo_handler_def =
7039 .num_standard = sizeof(airo_handler)/sizeof(iw_handler),
7040 .num_private = sizeof(airo_private_handler)/sizeof(iw_handler),
7041 .num_private_args = sizeof(airo_private_args)/sizeof(struct iw_priv_args),
7042 .standard = airo_handler,
7043 .private = airo_private_handler,
7044 .private_args = airo_private_args,
7045 .get_wireless_stats = airo_get_wireless_stats,
7048 #endif /* WIRELESS_EXT */
7051 * This defines the configuration part of the Wireless Extensions
7052 * Note : irq and spinlock protection will occur in the subroutines
7055 * o Check input value more carefully and fill correct values in range
7056 * o Test and shakeout the bugs (if any)
7060 * Javier Achirica did a great job of merging code from the unnamed CISCO
7061 * developer that added support for flashing the card.
7063 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
7066 struct airo_info *ai = (struct airo_info *)dev->priv;
7078 int val = AIROMAGIC;
7080 if (copy_from_user(&com,rq->ifr_data,sizeof(com)))
7082 else if (copy_to_user(com.data,(char *)&val,sizeof(val)))
7091 /* Get the command struct and hand it off for evaluation by
7092 * the proper subfunction
7096 if (copy_from_user(&com,rq->ifr_data,sizeof(com))) {
7101 /* Separate R/W functions bracket legality here
7103 if ( com.command == AIRORSWVERSION ) {
7104 if (copy_to_user(com.data, swversion, sizeof(swversion)))
7109 else if ( com.command <= AIRORRID)
7110 rc = readrids(dev,&com);
7111 else if ( com.command >= AIROPCAP && com.command <= (AIROPLEAPUSR+2) )
7112 rc = writerids(dev,&com);
7113 else if ( com.command >= AIROFLSHRST && com.command <= AIRORESTART )
7114 rc = flashcard(dev,&com);
7116 rc = -EINVAL; /* Bad command in ioctl */
7119 #endif /* CISCO_EXT */
7121 // All other calls are currently unsupported
7130 * Get the Wireless stats out of the driver
7131 * Note : irq and spinlock protection will occur in the subroutines
7134 * o Check if work in Ad-Hoc mode (otherwise, use SPY, as in wvlan_cs)
7138 static void airo_read_wireless_stats(struct airo_info *local)
7140 StatusRid status_rid;
7142 CapabilityRid cap_rid;
7143 u32 *vals = stats_rid.vals;
7145 /* Get stats out of the card */
7146 clear_bit(JOB_WSTATS, &local->flags);
7151 readCapabilityRid(local, &cap_rid, 0);
7152 readStatusRid(local, &status_rid, 0);
7153 readStatsRid(local, &stats_rid, RID_STATS, 0);
7157 local->wstats.status = status_rid.mode;
7159 /* Signal quality and co. But where is the noise level ??? */
7160 local->wstats.qual.qual = airo_get_quality(&status_rid, &cap_rid);
7162 local->wstats.qual.level = 0x100 - local->rssi[status_rid.sigQuality].rssidBm;
7164 local->wstats.qual.level = (status_rid.normalizedSignalStrength + 321) / 2;
7165 if (status_rid.len >= 124) {
7166 local->wstats.qual.noise = 256 - status_rid.noisedBm;
7167 local->wstats.qual.updated = 7;
7169 local->wstats.qual.noise = 0;
7170 local->wstats.qual.updated = 3;
7173 /* Packets discarded in the wireless adapter due to wireless
7174 * specific problems */
7175 local->wstats.discard.nwid = vals[56] + vals[57] + vals[58];/* SSID Mismatch */
7176 local->wstats.discard.code = vals[6];/* RxWepErr */
7177 local->wstats.discard.fragment = vals[30];
7178 local->wstats.discard.retries = vals[10];
7179 local->wstats.discard.misc = vals[1] + vals[32];
7180 local->wstats.miss.beacon = vals[34];
7183 struct iw_statistics *airo_get_wireless_stats(struct net_device *dev)
7185 struct airo_info *local = dev->priv;
7187 if (!test_bit(JOB_WSTATS, &local->flags)) {
7188 /* Get stats out of the card if available */
7189 if (down_trylock(&local->sem) != 0) {
7190 set_bit(JOB_WSTATS, &local->flags);
7191 wake_up_interruptible(&local->thr_wait);
7193 airo_read_wireless_stats(local);
7196 return &local->wstats;
7198 #endif /* WIRELESS_EXT */
7202 * This just translates from driver IOCTL codes to the command codes to
7203 * feed to the radio's host interface. Things can be added/deleted
7204 * as needed. This represents the READ side of control I/O to
7207 static int readrids(struct net_device *dev, aironet_ioctl *comp) {
7208 unsigned short ridcode;
7209 unsigned char *iobuf;
7211 struct airo_info *ai = dev->priv;
7214 if (test_bit(FLAG_FLASHING, &ai->flags))
7217 switch(comp->command)
7219 case AIROGCAP: ridcode = RID_CAPABILITIES; break;
7220 case AIROGCFG: ridcode = RID_CONFIG;
7221 if (test_bit(FLAG_COMMIT, &ai->flags)) {
7222 disable_MAC (ai, 1);
7223 writeConfigRid (ai, 1);
7224 enable_MAC (ai, &rsp, 1);
7227 case AIROGSLIST: ridcode = RID_SSID; break;
7228 case AIROGVLIST: ridcode = RID_APLIST; break;
7229 case AIROGDRVNAM: ridcode = RID_DRVNAME; break;
7230 case AIROGEHTENC: ridcode = RID_ETHERENCAP; break;
7231 case AIROGWEPKTMP: ridcode = RID_WEP_TEMP;
7232 /* Only super-user can read WEP keys */
7233 if (!capable(CAP_NET_ADMIN))
7236 case AIROGWEPKNV: ridcode = RID_WEP_PERM;
7237 /* Only super-user can read WEP keys */
7238 if (!capable(CAP_NET_ADMIN))
7241 case AIROGSTAT: ridcode = RID_STATUS; break;
7242 case AIROGSTATSD32: ridcode = RID_STATSDELTA; break;
7243 case AIROGSTATSC32: ridcode = RID_STATS; break;
7246 if (copy_to_user(comp->data, &ai->micstats,
7247 min((int)comp->len,(int)sizeof(ai->micstats))))
7251 case AIRORRID: ridcode = comp->ridnum; break;
7257 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7260 PC4500_readrid(ai,ridcode,iobuf,RIDSIZE, 1);
7261 /* get the count of bytes in the rid docs say 1st 2 bytes is it.
7262 * then return it to the user
7263 * 9/22/2000 Honor user given length
7267 if (copy_to_user(comp->data, iobuf, min(len, (int)RIDSIZE))) {
7276 * Danger Will Robinson write the rids here
7279 static int writerids(struct net_device *dev, aironet_ioctl *comp) {
7280 struct airo_info *ai = dev->priv;
7286 static int (* writer)(struct airo_info *, u16 rid, const void *, int, int);
7287 unsigned char *iobuf;
7289 /* Only super-user can write RIDs */
7290 if (!capable(CAP_NET_ADMIN))
7293 if (test_bit(FLAG_FLASHING, &ai->flags))
7297 writer = do_writerid;
7299 switch(comp->command)
7301 case AIROPSIDS: ridcode = RID_SSID; break;
7302 case AIROPCAP: ridcode = RID_CAPABILITIES; break;
7303 case AIROPAPLIST: ridcode = RID_APLIST; break;
7304 case AIROPCFG: ai->config.len = 0;
7305 clear_bit(FLAG_COMMIT, &ai->flags);
7306 ridcode = RID_CONFIG; break;
7307 case AIROPWEPKEYNV: ridcode = RID_WEP_PERM; break;
7308 case AIROPLEAPUSR: ridcode = RID_LEAPUSERNAME; break;
7309 case AIROPLEAPPWD: ridcode = RID_LEAPPASSWORD; break;
7310 case AIROPWEPKEY: ridcode = RID_WEP_TEMP; writer = PC4500_writerid;
7312 case AIROPLEAPUSR+1: ridcode = 0xFF2A; break;
7313 case AIROPLEAPUSR+2: ridcode = 0xFF2B; break;
7315 /* this is not really a rid but a command given to the card
7319 if (enable_MAC(ai, &rsp, 1) != 0)
7324 * Evidently this code in the airo driver does not get a symbol
7325 * as disable_MAC. it's probably so short the compiler does not gen one.
7331 /* This command merely clears the counts does not actually store any data
7332 * only reads rid. But as it changes the cards state, I put it in the
7333 * writerid routines.
7336 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7339 PC4500_readrid(ai,RID_STATSDELTACLEAR,iobuf,RIDSIZE, 1);
7342 enabled = ai->micstats.enabled;
7343 memset(&ai->micstats,0,sizeof(ai->micstats));
7344 ai->micstats.enabled = enabled;
7347 if (copy_to_user(comp->data, iobuf,
7348 min((int)comp->len, (int)RIDSIZE))) {
7356 return -EOPNOTSUPP; /* Blarg! */
7358 if(comp->len > RIDSIZE)
7361 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7364 if (copy_from_user(iobuf,comp->data,comp->len)) {
7369 if (comp->command == AIROPCFG) {
7370 ConfigRid *cfg = (ConfigRid *)iobuf;
7372 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags))
7373 cfg->opmode |= MODE_MIC;
7375 if ((cfg->opmode & 0xFF) == MODE_STA_IBSS)
7376 set_bit (FLAG_ADHOC, &ai->flags);
7378 clear_bit (FLAG_ADHOC, &ai->flags);
7381 if((*writer)(ai, ridcode, iobuf,comp->len,1)) {
7389 /*****************************************************************************
7390 * Ancillary flash / mod functions much black magic lurkes here *
7391 *****************************************************************************
7395 * Flash command switch table
7398 int flashcard(struct net_device *dev, aironet_ioctl *comp) {
7400 int cmdreset(struct airo_info *);
7401 int setflashmode(struct airo_info *);
7402 int flashgchar(struct airo_info *,int,int);
7403 int flashpchar(struct airo_info *,int,int);
7404 int flashputbuf(struct airo_info *);
7405 int flashrestart(struct airo_info *,struct net_device *);
7407 /* Only super-user can modify flash */
7408 if (!capable(CAP_NET_ADMIN))
7411 switch(comp->command)
7414 return cmdreset((struct airo_info *)dev->priv);
7417 if (!((struct airo_info *)dev->priv)->flash &&
7418 (((struct airo_info *)dev->priv)->flash = kmalloc (FLASHSIZE, GFP_KERNEL)) == NULL)
7420 return setflashmode((struct airo_info *)dev->priv);
7422 case AIROFLSHGCHR: /* Get char from aux */
7423 if(comp->len != sizeof(int))
7425 if (copy_from_user(&z,comp->data,comp->len))
7427 return flashgchar((struct airo_info *)dev->priv,z,8000);
7429 case AIROFLSHPCHR: /* Send char to card. */
7430 if(comp->len != sizeof(int))
7432 if (copy_from_user(&z,comp->data,comp->len))
7434 return flashpchar((struct airo_info *)dev->priv,z,8000);
7436 case AIROFLPUTBUF: /* Send 32k to card */
7437 if (!((struct airo_info *)dev->priv)->flash)
7439 if(comp->len > FLASHSIZE)
7441 if(copy_from_user(((struct airo_info *)dev->priv)->flash,comp->data,comp->len))
7444 flashputbuf((struct airo_info *)dev->priv);
7448 if(flashrestart((struct airo_info *)dev->priv,dev))
7455 #define FLASH_COMMAND 0x7e7e
7459 * Disable MAC and do soft reset on
7463 int cmdreset(struct airo_info *ai) {
7467 printk(KERN_INFO "Waitbusy hang before RESET\n");
7471 OUT4500(ai,COMMAND,CMD_SOFTRESET);
7473 set_current_state (TASK_UNINTERRUPTIBLE);
7474 schedule_timeout (HZ); /* WAS 600 12/7/00 */
7477 printk(KERN_INFO "Waitbusy hang AFTER RESET\n");
7484 * Put the card in legendary flash
7488 int setflashmode (struct airo_info *ai) {
7489 set_bit (FLAG_FLASHING, &ai->flags);
7491 OUT4500(ai, SWS0, FLASH_COMMAND);
7492 OUT4500(ai, SWS1, FLASH_COMMAND);
7494 OUT4500(ai, SWS0, FLASH_COMMAND);
7495 OUT4500(ai, COMMAND,0x10);
7497 OUT4500(ai, SWS2, FLASH_COMMAND);
7498 OUT4500(ai, SWS3, FLASH_COMMAND);
7499 OUT4500(ai, COMMAND,0);
7501 set_current_state (TASK_UNINTERRUPTIBLE);
7502 schedule_timeout (HZ/2); /* 500ms delay */
7505 clear_bit (FLAG_FLASHING, &ai->flags);
7506 printk(KERN_INFO "Waitbusy hang after setflash mode\n");
7512 /* Put character to SWS0 wait for dwelltime
7516 int flashpchar(struct airo_info *ai,int byte,int dwelltime) {
7527 /* Wait for busy bit d15 to go false indicating buffer empty */
7528 while ((IN4500 (ai, SWS0) & 0x8000) && waittime > 0) {
7533 /* timeout for busy clear wait */
7535 printk(KERN_INFO "flash putchar busywait timeout! \n");
7539 /* Port is clear now write byte and wait for it to echo back */
7541 OUT4500(ai,SWS0,byte);
7544 echo = IN4500(ai,SWS1);
7545 } while (dwelltime >= 0 && echo != byte);
7549 return (echo == byte) ? 0 : -EIO;
7553 * Get a character from the card matching matchbyte
7556 int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime){
7558 unsigned char rbyte=0;
7561 rchar = IN4500(ai,SWS1);
7563 if(dwelltime && !(0x8000 & rchar)){
7568 rbyte = 0xff & rchar;
7570 if( (rbyte == matchbyte) && (0x8000 & rchar) ){
7574 if( rbyte == 0x81 || rbyte == 0x82 || rbyte == 0x83 || rbyte == 0x1a || 0xffff == rchar)
7578 }while(dwelltime > 0);
7583 * Transfer 32k of firmware data from user buffer to our buffer and
7587 int flashputbuf(struct airo_info *ai){
7591 if (test_bit(FLAG_MPI,&ai->flags))
7592 memcpy_toio(ai->pciaux + 0x8000, ai->flash, FLASHSIZE);
7594 OUT4500(ai,AUXPAGE,0x100);
7595 OUT4500(ai,AUXOFF,0);
7597 for(nwords=0;nwords != FLASHSIZE / 2;nwords++){
7598 OUT4500(ai,AUXDATA,ai->flash[nwords] & 0xffff);
7601 OUT4500(ai,SWS0,0x8000);
7609 int flashrestart(struct airo_info *ai,struct net_device *dev){
7612 set_current_state (TASK_UNINTERRUPTIBLE);
7613 schedule_timeout (HZ); /* Added 12/7/00 */
7614 clear_bit (FLAG_FLASHING, &ai->flags);
7615 if (test_bit(FLAG_MPI, &ai->flags)) {
7616 status = mpi_init_descriptors(ai);
7617 if (status != SUCCESS)
7620 status = setup_card(ai, dev->dev_addr, 1);
7622 if (!test_bit(FLAG_MPI,&ai->flags))
7623 for( i = 0; i < MAX_FIDS; i++ ) {
7624 ai->fids[i] = transmit_allocate
7625 ( ai, 2312, i >= MAX_FIDS / 2 );
7628 set_current_state (TASK_UNINTERRUPTIBLE);
7629 schedule_timeout (HZ); /* Added 12/7/00 */
7632 #endif /* CISCO_EXT */
7635 This program is free software; you can redistribute it and/or
7636 modify it under the terms of the GNU General Public License
7637 as published by the Free Software Foundation; either version 2
7638 of the License, or (at your option) any later version.
7640 This program is distributed in the hope that it will be useful,
7641 but WITHOUT ANY WARRANTY; without even the implied warranty of
7642 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
7643 GNU General Public License for more details.
7647 Redistribution and use in source and binary forms, with or without
7648 modification, are permitted provided that the following conditions
7651 1. Redistributions of source code must retain the above copyright
7652 notice, this list of conditions and the following disclaimer.
7653 2. Redistributions in binary form must reproduce the above copyright
7654 notice, this list of conditions and the following disclaimer in the
7655 documentation and/or other materials provided with the distribution.
7656 3. The name of the author may not be used to endorse or promote
7657 products derived from this software without specific prior written
7660 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
7661 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
7662 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
7663 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
7664 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
7665 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
7666 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
7667 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
7668 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
7669 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
7670 POSSIBILITY OF SUCH DAMAGE.
7673 module_init(airo_init_module);
7674 module_exit(airo_cleanup_module);