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>
29 #include <linux/sched.h>
30 #include <linux/ptrace.h>
31 #include <linux/slab.h>
32 #include <linux/string.h>
33 #include <linux/timer.h>
34 #include <linux/interrupt.h>
35 #include <linux/suspend.h>
38 #include <asm/system.h>
39 #include <asm/bitops.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) 0
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_PARM(io,"1-4i");
249 MODULE_PARM(irq,"1-4i");
250 MODULE_PARM(basic_rate,"i");
251 MODULE_PARM(rates,"1-8i");
252 MODULE_PARM(ssids,"1-3s");
253 MODULE_PARM(auto_wep,"i");
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_PARM(aux_bap,"i");
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_PARM(maxencrypt, "i");
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_PARM(adhoc, "i");
267 MODULE_PARM_DESC(adhoc, "If non-zero, the card will start in adhoc mode.");
268 MODULE_PARM(probe, "i");
269 MODULE_PARM_DESC(probe, "If zero, the driver won't start the card.");
271 MODULE_PARM(proc_uid, "i");
272 MODULE_PARM_DESC(proc_uid, "The uid that the /proc files will belong to.");
273 MODULE_PARM(proc_gid, "i");
274 MODULE_PARM_DESC(proc_gid, "The gid that the /proc files will belong to.");
275 MODULE_PARM(airo_perm, "i");
276 MODULE_PARM_DESC(airo_perm, "The permission bits of /proc/[driver/]aironet.");
277 MODULE_PARM(proc_perm, "i");
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 *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 *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 *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 #endif /* WIRELESS_EXT */
1194 struct crypto_tfm *tfm;
1196 mic_statistics micstats;
1198 HostRxDesc rxfids[MPI_MAX_FIDS]; // rx/tx/config MPI350 descriptors
1199 HostTxDesc txfids[MPI_MAX_FIDS];
1200 HostRidDesc config_desc;
1201 unsigned long ridbus; // phys addr of config_desc
1202 struct sk_buff_head txq;// tx queue used by mpi350 code
1203 struct pci_dev *pci;
1204 unsigned char *pcimem;
1205 unsigned char *pciaux;
1206 unsigned char *shared;
1207 dma_addr_t shared_dma;
1211 #define PCI_SHARED_LEN 2*MPI_MAX_FIDS*PKTSIZE+RIDSIZE
1214 static inline int bap_read(struct airo_info *ai, u16 *pu16Dst, int bytelen,
1216 return ai->bap_read(ai, pu16Dst, bytelen, whichbap);
1219 static int setup_proc_entry( struct net_device *dev,
1220 struct airo_info *apriv );
1221 static int takedown_proc_entry( struct net_device *dev,
1222 struct airo_info *apriv );
1225 /***********************************************************************
1227 ***********************************************************************
1230 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq);
1231 static void MoveWindow(miccntx *context, u32 micSeq);
1232 void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct crypto_tfm *);
1233 void emmh32_init(emmh32_context *context);
1234 void emmh32_update(emmh32_context *context, u8 *pOctets, int len);
1235 void emmh32_final(emmh32_context *context, u8 digest[4]);
1237 /* micinit - Initialize mic seed */
1239 static void micinit(struct airo_info *ai)
1243 clear_bit(JOB_MIC, &ai->flags);
1244 PC4500_readrid(ai, RID_MIC, &mic_rid, sizeof(mic_rid), 0);
1247 ai->micstats.enabled = (mic_rid.state & 0x00FF) ? 1 : 0;
1249 if (ai->micstats.enabled) {
1250 /* Key must be valid and different */
1251 if (mic_rid.multicastValid && (!ai->mod[0].mCtx.valid ||
1252 (memcmp (ai->mod[0].mCtx.key, mic_rid.multicast,
1253 sizeof(ai->mod[0].mCtx.key)) != 0))) {
1254 /* Age current mic Context */
1255 memcpy(&ai->mod[1].mCtx,&ai->mod[0].mCtx,sizeof(miccntx));
1256 /* Initialize new context */
1257 memcpy(&ai->mod[0].mCtx.key,mic_rid.multicast,sizeof(mic_rid.multicast));
1258 ai->mod[0].mCtx.window = 33; //Window always points to the middle
1259 ai->mod[0].mCtx.rx = 0; //Rx Sequence numbers
1260 ai->mod[0].mCtx.tx = 0; //Tx sequence numbers
1261 ai->mod[0].mCtx.valid = 1; //Key is now valid
1263 /* Give key to mic seed */
1264 emmh32_setseed(&ai->mod[0].mCtx.seed,mic_rid.multicast,sizeof(mic_rid.multicast), ai->tfm);
1267 /* Key must be valid and different */
1268 if (mic_rid.unicastValid && (!ai->mod[0].uCtx.valid ||
1269 (memcmp(ai->mod[0].uCtx.key, mic_rid.unicast,
1270 sizeof(ai->mod[0].uCtx.key)) != 0))) {
1271 /* Age current mic Context */
1272 memcpy(&ai->mod[1].uCtx,&ai->mod[0].uCtx,sizeof(miccntx));
1273 /* Initialize new context */
1274 memcpy(&ai->mod[0].uCtx.key,mic_rid.unicast,sizeof(mic_rid.unicast));
1276 ai->mod[0].uCtx.window = 33; //Window always points to the middle
1277 ai->mod[0].uCtx.rx = 0; //Rx Sequence numbers
1278 ai->mod[0].uCtx.tx = 0; //Tx sequence numbers
1279 ai->mod[0].uCtx.valid = 1; //Key is now valid
1281 //Give key to mic seed
1282 emmh32_setseed(&ai->mod[0].uCtx.seed, mic_rid.unicast, sizeof(mic_rid.unicast), ai->tfm);
1285 /* So next time we have a valid key and mic is enabled, we will update
1286 * the sequence number if the key is the same as before.
1288 ai->mod[0].uCtx.valid = 0;
1289 ai->mod[0].mCtx.valid = 0;
1293 /* micsetup - Get ready for business */
1295 static int micsetup(struct airo_info *ai) {
1298 if (ai->tfm == NULL)
1299 ai->tfm = crypto_alloc_tfm("aes", 0);
1301 if (ai->tfm == NULL) {
1302 printk(KERN_ERR "airo: failed to load transform for AES\n");
1306 for (i=0; i < NUM_MODULES; i++) {
1307 memset(&ai->mod[i].mCtx,0,sizeof(miccntx));
1308 memset(&ai->mod[i].uCtx,0,sizeof(miccntx));
1313 char micsnap[]= {0xAA,0xAA,0x03,0x00,0x40,0x96,0x00,0x02};
1315 /*===========================================================================
1316 * Description: Mic a packet
1318 * Inputs: etherHead * pointer to an 802.3 frame
1320 * Returns: BOOLEAN if successful, otherwise false.
1321 * PacketTxLen will be updated with the mic'd packets size.
1323 * Caveats: It is assumed that the frame buffer will already
1324 * be big enough to hold the largets mic message possible.
1325 * (No memory allocation is done here).
1327 * Author: sbraneky (10/15/01)
1328 * Merciless hacks by rwilcher (1/14/02)
1331 static int encapsulate(struct airo_info *ai ,etherHead *frame, MICBuffer *mic, int payLen)
1335 // Determine correct context
1336 // If not adhoc, always use unicast key
1338 if (test_bit(FLAG_ADHOC, &ai->flags) && (frame->da[0] & 0x1))
1339 context = &ai->mod[0].mCtx;
1341 context = &ai->mod[0].uCtx;
1343 if (!context->valid)
1346 mic->typelen = htons(payLen + 16); //Length of Mic'd packet
1348 memcpy(&mic->u.snap, micsnap, sizeof(micsnap)); // Add Snap
1351 mic->seq = htonl(context->tx);
1354 emmh32_init(&context->seed); // Mic the packet
1355 emmh32_update(&context->seed,frame->da,ETH_ALEN * 2); // DA,SA
1356 emmh32_update(&context->seed,(u8*)&mic->typelen,10); // Type/Length and Snap
1357 emmh32_update(&context->seed,(u8*)&mic->seq,sizeof(mic->seq)); //SEQ
1358 emmh32_update(&context->seed,frame->da + ETH_ALEN * 2,payLen); //payload
1359 emmh32_final(&context->seed, (u8*)&mic->mic);
1361 /* New Type/length ?????????? */
1362 mic->typelen = 0; //Let NIC know it could be an oversized packet
1374 /*===========================================================================
1375 * Description: Decapsulates a MIC'd packet and returns the 802.3 packet
1376 * (removes the MIC stuff) if packet is a valid packet.
1378 * Inputs: etherHead pointer to the 802.3 packet
1380 * Returns: BOOLEAN - TRUE if packet should be dropped otherwise FALSE
1382 * Author: sbraneky (10/15/01)
1383 * Merciless hacks by rwilcher (1/14/02)
1384 *---------------------------------------------------------------------------
1387 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *eth, u16 payLen)
1393 mic_error micError = NONE;
1395 // Check if the packet is a Mic'd packet
1397 if (!ai->micstats.enabled) {
1398 //No Mic set or Mic OFF but we received a MIC'd packet.
1399 if (memcmp ((u8*)eth + 14, micsnap, sizeof(micsnap)) == 0) {
1400 ai->micstats.rxMICPlummed++;
1406 if (ntohs(mic->typelen) == 0x888E)
1409 if (memcmp (mic->u.snap, micsnap, sizeof(micsnap)) != 0) {
1410 // Mic enabled but packet isn't Mic'd
1411 ai->micstats.rxMICPlummed++;
1415 micSEQ = ntohl(mic->seq); //store SEQ as CPU order
1417 //At this point we a have a mic'd packet and mic is enabled
1418 //Now do the mic error checking.
1420 //Receive seq must be odd
1421 if ( (micSEQ & 1) == 0 ) {
1422 ai->micstats.rxWrongSequence++;
1426 for (i = 0; i < NUM_MODULES; i++) {
1427 int mcast = eth->da[0] & 1;
1428 //Determine proper context
1429 context = mcast ? &ai->mod[i].mCtx : &ai->mod[i].uCtx;
1431 //Make sure context is valid
1432 if (!context->valid) {
1434 micError = NOMICPLUMMED;
1440 mic->typelen = htons(payLen + sizeof(MICBuffer) - 2);
1442 emmh32_init(&context->seed);
1443 emmh32_update(&context->seed, eth->da, ETH_ALEN*2);
1444 emmh32_update(&context->seed, (u8 *)&mic->typelen, sizeof(mic->typelen)+sizeof(mic->u.snap));
1445 emmh32_update(&context->seed, (u8 *)&mic->seq,sizeof(mic->seq));
1446 emmh32_update(&context->seed, eth->da + ETH_ALEN*2,payLen);
1448 emmh32_final(&context->seed, digest);
1450 if (memcmp(digest, &mic->mic, 4)) { //Make sure the mics match
1453 micError = INCORRECTMIC;
1457 //Check Sequence number if mics pass
1458 if (RxSeqValid(ai, context, mcast, micSEQ) == SUCCESS) {
1459 ai->micstats.rxSuccess++;
1463 micError = SEQUENCE;
1466 // Update statistics
1468 case NOMICPLUMMED: ai->micstats.rxMICPlummed++; break;
1469 case SEQUENCE: ai->micstats.rxWrongSequence++; break;
1470 case INCORRECTMIC: ai->micstats.rxIncorrectMIC++; break;
1477 /*===========================================================================
1478 * Description: Checks the Rx Seq number to make sure it is valid
1479 * and hasn't already been received
1481 * Inputs: miccntx - mic context to check seq against
1482 * micSeq - the Mic seq number
1484 * Returns: TRUE if valid otherwise FALSE.
1486 * Author: sbraneky (10/15/01)
1487 * Merciless hacks by rwilcher (1/14/02)
1488 *---------------------------------------------------------------------------
1491 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq)
1495 //Allow for the ap being rebooted - if it is then use the next
1496 //sequence number of the current sequence number - might go backwards
1499 if (test_bit(FLAG_UPDATE_MULTI, &ai->flags)) {
1500 clear_bit (FLAG_UPDATE_MULTI, &ai->flags);
1501 context->window = (micSeq > 33) ? micSeq : 33;
1502 context->rx = 0; // Reset rx
1504 } else if (test_bit(FLAG_UPDATE_UNI, &ai->flags)) {
1505 clear_bit (FLAG_UPDATE_UNI, &ai->flags);
1506 context->window = (micSeq > 33) ? micSeq : 33; // Move window
1507 context->rx = 0; // Reset rx
1510 //Make sequence number relative to START of window
1511 seq = micSeq - (context->window - 33);
1513 //Too old of a SEQ number to check.
1518 //Window is infinite forward
1519 MoveWindow(context,micSeq);
1523 // We are in the window. Now check the context rx bit to see if it was already sent
1524 seq >>= 1; //divide by 2 because we only have odd numbers
1525 index = 1 << seq; //Get an index number
1527 if (!(context->rx & index)) {
1528 //micSEQ falls inside the window.
1529 //Add seqence number to the list of received numbers.
1530 context->rx |= index;
1532 MoveWindow(context,micSeq);
1539 static void MoveWindow(miccntx *context, u32 micSeq)
1543 //Move window if seq greater than the middle of the window
1544 if (micSeq > context->window) {
1545 shift = (micSeq - context->window) >> 1;
1549 context->rx >>= shift;
1553 context->window = micSeq; //Move window
1557 /*==============================================*/
1558 /*========== EMMH ROUTINES ====================*/
1559 /*==============================================*/
1561 /* mic accumulate */
1562 #define MIC_ACCUM(val) \
1563 context->accum += (u64)(val) * context->coeff[coeff_position++];
1565 static unsigned char aes_counter[16];
1567 /* expand the key to fill the MMH coefficient array */
1568 void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct crypto_tfm *tfm)
1570 /* take the keying material, expand if necessary, truncate at 16-bytes */
1571 /* run through AES counter mode to generate context->coeff[] */
1575 u8 *cipher, plain[16];
1576 struct scatterlist sg[1];
1578 crypto_cipher_setkey(tfm, pkey, 16);
1580 for (i = 0; i < (sizeof(context->coeff)/sizeof(context->coeff[0])); ) {
1581 aes_counter[15] = (u8)(counter >> 0);
1582 aes_counter[14] = (u8)(counter >> 8);
1583 aes_counter[13] = (u8)(counter >> 16);
1584 aes_counter[12] = (u8)(counter >> 24);
1586 memcpy (plain, aes_counter, 16);
1587 sg[0].page = virt_to_page(plain);
1588 sg[0].offset = ((long) plain & ~PAGE_MASK);
1590 crypto_cipher_encrypt(tfm, sg, sg, 16);
1591 cipher = kmap(sg[0].page) + sg[0].offset;
1592 for (j=0; (j<16) && (i< (sizeof(context->coeff)/sizeof(context->coeff[0]))); ) {
1593 context->coeff[i++] = ntohl(*(u32 *)&cipher[j]);
1599 /* prepare for calculation of a new mic */
1600 void emmh32_init(emmh32_context *context)
1602 /* prepare for new mic calculation */
1604 context->position = 0;
1607 /* add some bytes to the mic calculation */
1608 void emmh32_update(emmh32_context *context, u8 *pOctets, int len)
1610 int coeff_position, byte_position;
1612 if (len == 0) return;
1614 coeff_position = context->position >> 2;
1616 /* deal with partial 32-bit word left over from last update */
1617 byte_position = context->position & 3;
1618 if (byte_position) {
1619 /* have a partial word in part to deal with */
1621 if (len == 0) return;
1622 context->part.d8[byte_position++] = *pOctets++;
1623 context->position++;
1625 } while (byte_position < 4);
1626 MIC_ACCUM(htonl(context->part.d32));
1629 /* deal with full 32-bit words */
1631 MIC_ACCUM(htonl(*(u32 *)pOctets));
1632 context->position += 4;
1637 /* deal with partial 32-bit word that will be left over from this update */
1640 context->part.d8[byte_position++] = *pOctets++;
1641 context->position++;
1646 /* mask used to zero empty bytes for final partial word */
1647 static u32 mask32[4] = { 0x00000000L, 0xFF000000L, 0xFFFF0000L, 0xFFFFFF00L };
1649 /* calculate the mic */
1650 void emmh32_final(emmh32_context *context, u8 digest[4])
1652 int coeff_position, byte_position;
1658 coeff_position = context->position >> 2;
1660 /* deal with partial 32-bit word left over from last update */
1661 byte_position = context->position & 3;
1662 if (byte_position) {
1663 /* have a partial word in part to deal with */
1664 val = htonl(context->part.d32);
1665 MIC_ACCUM(val & mask32[byte_position]); /* zero empty bytes */
1668 /* reduce the accumulated u64 to a 32-bit MIC */
1669 sum = context->accum;
1670 stmp = (sum & 0xffffffffLL) - ((sum >> 32) * 15);
1671 utmp = (stmp & 0xffffffffLL) - ((stmp >> 32) * 15);
1672 sum = utmp & 0xffffffffLL;
1673 if (utmp > 0x10000000fLL)
1677 digest[0] = (val>>24) & 0xFF;
1678 digest[1] = (val>>16) & 0xFF;
1679 digest[2] = (val>>8) & 0xFF;
1680 digest[3] = val & 0xFF;
1684 static int readBSSListRid(struct airo_info *ai, int first,
1691 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
1692 memset(&cmd, 0, sizeof(cmd));
1693 cmd.cmd=CMD_LISTBSS;
1694 if (down_interruptible(&ai->sem))
1695 return -ERESTARTSYS;
1696 issuecommand(ai, &cmd, &rsp);
1698 /* Let the command take effect */
1699 set_current_state (TASK_INTERRUPTIBLE);
1701 schedule_timeout (3*HZ);
1704 rc = PC4500_readrid(ai, first ? RID_BSSLISTFIRST : RID_BSSLISTNEXT,
1705 list, sizeof(*list), 1);
1707 list->len = le16_to_cpu(list->len);
1708 list->index = le16_to_cpu(list->index);
1709 list->radioType = le16_to_cpu(list->radioType);
1710 list->cap = le16_to_cpu(list->cap);
1711 list->beaconInterval = le16_to_cpu(list->beaconInterval);
1712 list->fh.dwell = le16_to_cpu(list->fh.dwell);
1713 list->dsChannel = le16_to_cpu(list->dsChannel);
1714 list->atimWindow = le16_to_cpu(list->atimWindow);
1718 static int readWepKeyRid(struct airo_info*ai, WepKeyRid *wkr, int temp, int lock) {
1719 int rc = PC4500_readrid(ai, temp ? RID_WEP_TEMP : RID_WEP_PERM,
1720 wkr, sizeof(*wkr), lock);
1722 wkr->len = le16_to_cpu(wkr->len);
1723 wkr->kindex = le16_to_cpu(wkr->kindex);
1724 wkr->klen = le16_to_cpu(wkr->klen);
1727 /* In the writeXXXRid routines we copy the rids so that we don't screwup
1728 * the originals when we endian them... */
1729 static int writeWepKeyRid(struct airo_info*ai, WepKeyRid *pwkr, int perm, int lock) {
1731 WepKeyRid wkr = *pwkr;
1733 wkr.len = cpu_to_le16(wkr.len);
1734 wkr.kindex = cpu_to_le16(wkr.kindex);
1735 wkr.klen = cpu_to_le16(wkr.klen);
1736 rc = PC4500_writerid(ai, RID_WEP_TEMP, &wkr, sizeof(wkr), lock);
1737 if (rc!=SUCCESS) printk(KERN_ERR "airo: WEP_TEMP set %x\n", rc);
1739 rc = PC4500_writerid(ai, RID_WEP_PERM, &wkr, sizeof(wkr), lock);
1741 printk(KERN_ERR "airo: WEP_PERM set %x\n", rc);
1747 static int readSsidRid(struct airo_info*ai, SsidRid *ssidr) {
1749 int rc = PC4500_readrid(ai, RID_SSID, ssidr, sizeof(*ssidr), 1);
1751 ssidr->len = le16_to_cpu(ssidr->len);
1752 for(i = 0; i < 3; i++) {
1753 ssidr->ssids[i].len = le16_to_cpu(ssidr->ssids[i].len);
1757 static int writeSsidRid(struct airo_info*ai, SsidRid *pssidr, int lock) {
1760 SsidRid ssidr = *pssidr;
1762 ssidr.len = cpu_to_le16(ssidr.len);
1763 for(i = 0; i < 3; i++) {
1764 ssidr.ssids[i].len = cpu_to_le16(ssidr.ssids[i].len);
1766 rc = PC4500_writerid(ai, RID_SSID, &ssidr, sizeof(ssidr), lock);
1769 static int readConfigRid(struct airo_info*ai, int lock) {
1777 rc = PC4500_readrid(ai, RID_ACTUALCONFIG, &cfg, sizeof(cfg), lock);
1781 for(s = &cfg.len; s <= &cfg.rtsThres; s++) *s = le16_to_cpu(*s);
1783 for(s = &cfg.shortRetryLimit; s <= &cfg.radioType; s++)
1784 *s = le16_to_cpu(*s);
1786 for(s = &cfg.txPower; s <= &cfg.radioSpecific; s++)
1787 *s = le16_to_cpu(*s);
1789 for(s = &cfg.arlThreshold; s <= &cfg._reserved4[0]; s++)
1790 *s = cpu_to_le16(*s);
1792 for(s = &cfg.autoWake; s <= &cfg.autoWake; s++)
1793 *s = cpu_to_le16(*s);
1798 static inline void checkThrottle(struct airo_info *ai) {
1800 /* Old hardware had a limit on encryption speed */
1801 if (ai->config.authType != AUTH_OPEN && maxencrypt) {
1802 for(i=0; i<8; i++) {
1803 if (ai->config.rates[i] > maxencrypt) {
1804 ai->config.rates[i] = 0;
1809 static int writeConfigRid(struct airo_info*ai, int lock) {
1813 if (!test_bit (FLAG_COMMIT, &ai->flags))
1816 clear_bit (FLAG_COMMIT | FLAG_RESET, &ai->flags);
1820 if ((cfgr.opmode & 0xFF) == MODE_STA_IBSS)
1821 set_bit(FLAG_ADHOC, &ai->flags);
1823 clear_bit(FLAG_ADHOC, &ai->flags);
1825 for(s = &cfgr.len; s <= &cfgr.rtsThres; s++) *s = cpu_to_le16(*s);
1827 for(s = &cfgr.shortRetryLimit; s <= &cfgr.radioType; s++)
1828 *s = cpu_to_le16(*s);
1830 for(s = &cfgr.txPower; s <= &cfgr.radioSpecific; s++)
1831 *s = cpu_to_le16(*s);
1833 for(s = &cfgr.arlThreshold; s <= &cfgr._reserved4[0]; s++)
1834 *s = cpu_to_le16(*s);
1836 for(s = &cfgr.autoWake; s <= &cfgr.autoWake; s++)
1837 *s = cpu_to_le16(*s);
1839 return PC4500_writerid( ai, RID_CONFIG, &cfgr, sizeof(cfgr), lock);
1841 static int readStatusRid(struct airo_info*ai, StatusRid *statr, int lock) {
1842 int rc = PC4500_readrid(ai, RID_STATUS, statr, sizeof(*statr), lock);
1845 statr->len = le16_to_cpu(statr->len);
1846 for(s = &statr->mode; s <= &statr->SSIDlen; s++) *s = le16_to_cpu(*s);
1848 for(s = &statr->beaconPeriod; s <= &statr->shortPreamble; s++)
1849 *s = le16_to_cpu(*s);
1850 statr->load = le16_to_cpu(statr->load);
1851 statr->assocStatus = le16_to_cpu(statr->assocStatus);
1854 static int readAPListRid(struct airo_info*ai, APListRid *aplr) {
1855 int rc = PC4500_readrid(ai, RID_APLIST, aplr, sizeof(*aplr), 1);
1856 aplr->len = le16_to_cpu(aplr->len);
1859 static int writeAPListRid(struct airo_info*ai, APListRid *aplr, int lock) {
1861 aplr->len = cpu_to_le16(aplr->len);
1862 rc = PC4500_writerid(ai, RID_APLIST, aplr, sizeof(*aplr), lock);
1865 static int readCapabilityRid(struct airo_info*ai, CapabilityRid *capr, int lock) {
1866 int rc = PC4500_readrid(ai, RID_CAPABILITIES, capr, sizeof(*capr), lock);
1869 capr->len = le16_to_cpu(capr->len);
1870 capr->prodNum = le16_to_cpu(capr->prodNum);
1871 capr->radioType = le16_to_cpu(capr->radioType);
1872 capr->country = le16_to_cpu(capr->country);
1873 for(s = &capr->txPowerLevels[0]; s <= &capr->requiredHard; s++)
1874 *s = le16_to_cpu(*s);
1877 static int readStatsRid(struct airo_info*ai, StatsRid *sr, int rid, int lock) {
1878 int rc = PC4500_readrid(ai, rid, sr, sizeof(*sr), lock);
1881 sr->len = le16_to_cpu(sr->len);
1882 for(i = &sr->vals[0]; i <= &sr->vals[99]; i++) *i = le32_to_cpu(*i);
1886 static int airo_open(struct net_device *dev) {
1887 struct airo_info *info = dev->priv;
1890 if (test_bit(FLAG_FLASHING, &info->flags))
1893 /* Make sure the card is configured.
1894 * Wireless Extensions may postpone config changes until the card
1895 * is open (to pipeline changes and speed-up card setup). If
1896 * those changes are not yet commited, do it now - Jean II */
1897 if (test_bit (FLAG_COMMIT, &info->flags)) {
1898 disable_MAC(info, 1);
1899 writeConfigRid(info, 1);
1902 if (info->wifidev != dev) {
1903 /* Power on the MAC controller (which may have been disabled) */
1904 clear_bit(FLAG_RADIO_DOWN, &info->flags);
1905 enable_interrupts(info);
1907 enable_MAC(info, &rsp, 1);
1909 netif_start_queue(dev);
1913 static int mpi_start_xmit(struct sk_buff *skb, struct net_device *dev) {
1914 int npacks, pending;
1915 unsigned long flags;
1916 struct airo_info *ai = dev->priv;
1919 printk(KERN_ERR "airo: %s: skb==NULL\n",__FUNCTION__);
1922 npacks = skb_queue_len (&ai->txq);
1924 if (npacks >= MAXTXQ - 1) {
1925 netif_stop_queue (dev);
1926 if (npacks > MAXTXQ) {
1927 ai->stats.tx_fifo_errors++;
1930 skb_queue_tail (&ai->txq, skb);
1934 spin_lock_irqsave(&ai->aux_lock, flags);
1935 skb_queue_tail (&ai->txq, skb);
1936 pending = test_bit(FLAG_PENDING_XMIT, &ai->flags);
1937 spin_unlock_irqrestore(&ai->aux_lock,flags);
1938 netif_wake_queue (dev);
1941 set_bit(FLAG_PENDING_XMIT, &ai->flags);
1942 mpi_send_packet (dev);
1950 * Attempt to transmit a packet. Can be called from interrupt
1951 * or transmit . return number of packets we tried to send
1954 static int mpi_send_packet (struct net_device *dev)
1956 struct sk_buff *skb;
1957 unsigned char *buffer;
1958 s16 len, *payloadLen;
1959 struct airo_info *ai = dev->priv;
1962 /* get a packet to send */
1964 if ((skb = skb_dequeue(&ai->txq)) == 0) {
1966 "airo_mpi: %s: Dequeue'd zero in send_packet()\n",
1971 /* check min length*/
1972 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1975 ai->txfids[0].tx_desc.offset = 0;
1976 ai->txfids[0].tx_desc.valid = 1;
1977 ai->txfids[0].tx_desc.eoc = 1;
1978 ai->txfids[0].tx_desc.len =len+sizeof(WifiHdr);
1980 memcpy((char *)ai->txfids[0].card_ram_off,
1981 (char *)&ai->txfids[0].tx_desc, sizeof(TxFid));
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 /* copy data into airo dma buffer */
2013 memcpy (sendbuf, buffer, sizeof(etherHead));
2014 buffer += sizeof(etherHead);
2015 sendbuf += sizeof(etherHead);
2016 memcpy (sendbuf, &pMic, sizeof(pMic));
2017 sendbuf += sizeof(pMic);
2018 memcpy (sendbuf, buffer, len - sizeof(etherHead));
2022 *payloadLen = cpu_to_le16(len - sizeof(etherHead));
2024 dev->trans_start = jiffies;
2026 /* copy data into airo dma buffer */
2027 memcpy(sendbuf, buffer, len);
2030 OUT4500(ai, EVACK, 8);
2032 dev_kfree_skb_any(skb);
2036 static void get_tx_error(struct airo_info *ai, u32 fid)
2041 status = ((WifiCtlHdr *)ai->txfids[0].virtual_host_addr)->ctlhdr.status;
2043 if (bap_setup(ai, ai->fids[fid] & 0xffff, 4, BAP0) != SUCCESS)
2045 bap_read(ai, &status, 2, BAP0);
2047 if (le16_to_cpu(status) & 2) /* Too many retries */
2048 ai->stats.tx_aborted_errors++;
2049 if (le16_to_cpu(status) & 4) /* Transmit lifetime exceeded */
2050 ai->stats.tx_heartbeat_errors++;
2051 if (le16_to_cpu(status) & 8) /* Aid fail */
2053 if (le16_to_cpu(status) & 0x10) /* MAC disabled */
2054 ai->stats.tx_carrier_errors++;
2055 if (le16_to_cpu(status) & 0x20) /* Association lost */
2057 /* We produce a TXDROP event only for retry or lifetime
2058 * exceeded, because that's the only status that really mean
2059 * that this particular node went away.
2060 * Other errors means that *we* screwed up. - Jean II */
2061 if ((le16_to_cpu(status) & 2) ||
2062 (le16_to_cpu(status) & 4)) {
2063 union iwreq_data wrqu;
2066 /* Faster to skip over useless data than to do
2067 * another bap_setup(). We are at offset 0x6 and
2068 * need to go to 0x18 and read 6 bytes - Jean II */
2069 bap_read(ai, (u16 *) junk, 0x18, BAP0);
2071 /* Copy 802.11 dest address.
2072 * We use the 802.11 header because the frame may
2073 * not be 802.3 or may be mangled...
2074 * In Ad-Hoc mode, it will be the node address.
2075 * In managed mode, it will be most likely the AP addr
2076 * User space will figure out how to convert it to
2077 * whatever it needs (IP address or else).
2079 memcpy(wrqu.addr.sa_data, junk + 0x12, ETH_ALEN);
2080 wrqu.addr.sa_family = ARPHRD_ETHER;
2082 /* Send event to user space */
2083 wireless_send_event(ai->dev, IWEVTXDROP, &wrqu, NULL);
2087 static void airo_end_xmit(struct net_device *dev) {
2090 struct airo_info *priv = dev->priv;
2091 struct sk_buff *skb = priv->xmit.skb;
2092 int fid = priv->xmit.fid;
2093 u32 *fids = priv->fids;
2095 clear_bit(JOB_XMIT, &priv->flags);
2096 clear_bit(FLAG_PENDING_XMIT, &priv->flags);
2097 status = transmit_802_3_packet (priv, fids[fid], skb->data);
2101 if ( status == SUCCESS ) {
2102 dev->trans_start = jiffies;
2103 for (; i < MAX_FIDS / 2 && (priv->fids[i] & 0xffff0000); i++);
2105 priv->fids[fid] &= 0xffff;
2106 priv->stats.tx_window_errors++;
2108 if (i < MAX_FIDS / 2)
2109 netif_wake_queue(dev);
2113 static int airo_start_xmit(struct sk_buff *skb, struct net_device *dev) {
2116 struct airo_info *priv = dev->priv;
2117 u32 *fids = priv->fids;
2119 if ( skb == NULL ) {
2120 printk( KERN_ERR "airo: skb == NULL!!!\n" );
2124 /* Find a vacant FID */
2125 for( i = 0; i < MAX_FIDS / 2 && (fids[i] & 0xffff0000); i++ );
2126 for( j = i + 1; j < MAX_FIDS / 2 && (fids[j] & 0xffff0000); j++ );
2128 if ( j >= MAX_FIDS / 2 ) {
2129 netif_stop_queue(dev);
2131 if (i == MAX_FIDS / 2) {
2132 priv->stats.tx_fifo_errors++;
2136 /* check min length*/
2137 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2138 /* Mark fid as used & save length for later */
2139 fids[i] |= (len << 16);
2140 priv->xmit.skb = skb;
2142 if (down_trylock(&priv->sem) != 0) {
2143 set_bit(FLAG_PENDING_XMIT, &priv->flags);
2144 netif_stop_queue(dev);
2145 set_bit(JOB_XMIT, &priv->flags);
2146 wake_up_interruptible(&priv->thr_wait);
2152 static void airo_end_xmit11(struct net_device *dev) {
2155 struct airo_info *priv = dev->priv;
2156 struct sk_buff *skb = priv->xmit11.skb;
2157 int fid = priv->xmit11.fid;
2158 u32 *fids = priv->fids;
2160 clear_bit(JOB_XMIT11, &priv->flags);
2161 clear_bit(FLAG_PENDING_XMIT11, &priv->flags);
2162 status = transmit_802_11_packet (priv, fids[fid], skb->data);
2166 if ( status == SUCCESS ) {
2167 dev->trans_start = jiffies;
2168 for (; i < MAX_FIDS && (priv->fids[i] & 0xffff0000); i++);
2170 priv->fids[fid] &= 0xffff;
2171 priv->stats.tx_window_errors++;
2174 netif_wake_queue(dev);
2178 static int airo_start_xmit11(struct sk_buff *skb, struct net_device *dev) {
2181 struct airo_info *priv = dev->priv;
2182 u32 *fids = priv->fids;
2184 if ( skb == NULL ) {
2185 printk( KERN_ERR "airo: skb == NULL!!!\n" );
2189 /* Find a vacant FID */
2190 for( i = MAX_FIDS / 2; i < MAX_FIDS && (fids[i] & 0xffff0000); i++ );
2191 for( j = i + 1; j < MAX_FIDS && (fids[j] & 0xffff0000); j++ );
2193 if ( j >= MAX_FIDS ) {
2194 netif_stop_queue(dev);
2196 if (i == MAX_FIDS) {
2197 priv->stats.tx_fifo_errors++;
2201 /* check min length*/
2202 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2203 /* Mark fid as used & save length for later */
2204 fids[i] |= (len << 16);
2205 priv->xmit11.skb = skb;
2206 priv->xmit11.fid = i;
2207 if (down_trylock(&priv->sem) != 0) {
2208 set_bit(FLAG_PENDING_XMIT11, &priv->flags);
2209 netif_stop_queue(dev);
2210 set_bit(JOB_XMIT11, &priv->flags);
2211 wake_up_interruptible(&priv->thr_wait);
2213 airo_end_xmit11(dev);
2217 static void airo_read_stats(struct airo_info *ai) {
2219 u32 *vals = stats_rid.vals;
2221 clear_bit(JOB_STATS, &ai->flags);
2226 readStatsRid(ai, &stats_rid, RID_STATS, 0);
2229 ai->stats.rx_packets = vals[43] + vals[44] + vals[45];
2230 ai->stats.tx_packets = vals[39] + vals[40] + vals[41];
2231 ai->stats.rx_bytes = vals[92];
2232 ai->stats.tx_bytes = vals[91];
2233 ai->stats.rx_errors = vals[0] + vals[2] + vals[3] + vals[4];
2234 ai->stats.tx_errors = vals[42] + ai->stats.tx_fifo_errors;
2235 ai->stats.multicast = vals[43];
2236 ai->stats.collisions = vals[89];
2238 /* detailed rx_errors: */
2239 ai->stats.rx_length_errors = vals[3];
2240 ai->stats.rx_crc_errors = vals[4];
2241 ai->stats.rx_frame_errors = vals[2];
2242 ai->stats.rx_fifo_errors = vals[0];
2245 struct net_device_stats *airo_get_stats(struct net_device *dev)
2247 struct airo_info *local = dev->priv;
2249 /* Get stats out of the card if available */
2250 if (down_trylock(&local->sem) != 0) {
2251 set_bit(JOB_STATS, &local->flags);
2252 wake_up_interruptible(&local->thr_wait);
2254 airo_read_stats(local);
2256 return &local->stats;
2259 static void airo_set_promisc(struct airo_info *ai) {
2263 memset(&cmd, 0, sizeof(cmd));
2264 cmd.cmd=CMD_SETMODE;
2265 clear_bit(JOB_PROMISC, &ai->flags);
2266 cmd.parm0=(ai->flags&IFF_PROMISC) ? PROMISC : NOPROMISC;
2267 issuecommand(ai, &cmd, &rsp);
2271 static void airo_set_multicast_list(struct net_device *dev) {
2272 struct airo_info *ai = dev->priv;
2274 if ((dev->flags ^ ai->flags) & IFF_PROMISC) {
2275 change_bit(FLAG_PROMISC, &ai->flags);
2276 if (down_trylock(&ai->sem) != 0) {
2277 set_bit(JOB_PROMISC, &ai->flags);
2278 wake_up_interruptible(&ai->thr_wait);
2280 airo_set_promisc(ai);
2283 if ((dev->flags&IFF_ALLMULTI)||dev->mc_count>0) {
2284 /* Turn on multicast. (Should be already setup...) */
2288 static int airo_set_mac_address(struct net_device *dev, void *p)
2290 struct airo_info *ai = dev->priv;
2291 struct sockaddr *addr = p;
2294 readConfigRid(ai, 1);
2295 memcpy (ai->config.macAddr, addr->sa_data, dev->addr_len);
2296 set_bit (FLAG_COMMIT, &ai->flags);
2298 writeConfigRid (ai, 1);
2299 enable_MAC(ai, &rsp, 1);
2300 memcpy (ai->dev->dev_addr, addr->sa_data, dev->addr_len);
2302 memcpy (ai->wifidev->dev_addr, addr->sa_data, dev->addr_len);
2306 static int airo_change_mtu(struct net_device *dev, int new_mtu)
2308 if ((new_mtu < 68) || (new_mtu > 2400))
2315 static int airo_close(struct net_device *dev) {
2316 struct airo_info *ai = dev->priv;
2318 netif_stop_queue(dev);
2320 if (ai->wifidev != dev) {
2321 #ifdef POWER_ON_DOWN
2322 /* Shut power to the card. The idea is that the user can save
2323 * power when he doesn't need the card with "ifconfig down".
2324 * That's the method that is most friendly towards the network
2325 * stack (i.e. the network stack won't try to broadcast
2326 * anything on the interface and routes are gone. Jean II */
2327 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2330 disable_interrupts( ai );
2335 static void del_airo_dev( struct net_device *dev );
2337 void stop_airo_card( struct net_device *dev, int freeres )
2339 struct airo_info *ai = dev->priv;
2340 disable_interrupts(ai);
2341 free_irq( dev->irq, dev );
2342 takedown_proc_entry( dev, ai );
2343 if (test_bit(FLAG_REGISTERED, &ai->flags)) {
2344 unregister_netdev( dev );
2346 unregister_netdev(ai->wifidev);
2347 free_netdev(ai->wifidev);
2350 clear_bit(FLAG_REGISTERED, &ai->flags);
2352 set_bit(JOB_DIE, &ai->flags);
2353 kill_proc(ai->thr_pid, SIGTERM, 1);
2354 wait_for_completion(&ai->thr_exited);
2357 * Clean out tx queue
2359 if (test_bit(FLAG_MPI, &ai->flags) && skb_queue_len (&ai->txq) > 0) {
2360 struct sk_buff *skb = 0;
2361 for (;(skb = skb_dequeue(&ai->txq));)
2374 /* PCMCIA frees this stuff, so only for PCI and ISA */
2375 release_region( dev->base_addr, 64 );
2376 if (test_bit(FLAG_MPI, &ai->flags)) {
2378 mpi_unmap_card(ai->pci);
2380 iounmap(ai->pcimem);
2382 iounmap(ai->pciaux);
2383 pci_free_consistent(ai->pci, PCI_SHARED_LEN,
2384 ai->shared, ai->shared_dma);
2389 crypto_free_tfm(ai->tfm);
2391 del_airo_dev( dev );
2395 EXPORT_SYMBOL(stop_airo_card);
2397 static int add_airo_dev( struct net_device *dev );
2399 int wll_header_parse(struct sk_buff *skb, unsigned char *haddr)
2401 memcpy(haddr, skb->mac.raw + 10, ETH_ALEN);
2405 static void mpi_unmap_card(struct pci_dev *pci)
2407 unsigned long mem_start = pci_resource_start(pci, 1);
2408 unsigned long mem_len = pci_resource_len(pci, 1);
2409 unsigned long aux_start = pci_resource_start(pci, 2);
2410 unsigned long aux_len = AUXMEMSIZE;
2412 release_mem_region(aux_start, aux_len);
2413 release_mem_region(mem_start, mem_len);
2416 /*************************************************************
2417 * This routine assumes that descriptors have been setup .
2418 * Run at insmod time or after reset when the decriptors
2419 * have been initialized . Returns 0 if all is well nz
2420 * otherwise . Does not allocate memory but sets up card
2421 * using previously allocated descriptors.
2423 static int mpi_init_descriptors (struct airo_info *ai)
2430 /* Alloc card RX descriptors */
2431 netif_stop_queue(ai->dev);
2433 memset(&rsp,0,sizeof(rsp));
2434 memset(&cmd,0,sizeof(cmd));
2436 cmd.cmd = CMD_ALLOCATEAUX;
2438 cmd.parm1 = (ai->rxfids[0].card_ram_off - ai->pciaux);
2439 cmd.parm2 = MPI_MAX_FIDS;
2440 rc=issuecommand(ai, &cmd, &rsp);
2441 if (rc != SUCCESS) {
2442 printk(KERN_ERR "airo: Couldn't allocate RX FID\n");
2446 for (i=0; i<MPI_MAX_FIDS; i++) {
2447 memcpy(ai->rxfids[i].card_ram_off,
2448 &ai->rxfids[i].rx_desc, sizeof(RxFid));
2451 /* Alloc card TX descriptors */
2453 memset(&rsp,0,sizeof(rsp));
2454 memset(&cmd,0,sizeof(cmd));
2456 cmd.cmd = CMD_ALLOCATEAUX;
2458 cmd.parm1 = (ai->txfids[0].card_ram_off - ai->pciaux);
2459 cmd.parm2 = MPI_MAX_FIDS;
2461 for (i=0; i<MPI_MAX_FIDS; i++) {
2462 ai->txfids[i].tx_desc.valid = 1;
2463 memcpy((char *)ai->txfids[i].card_ram_off,
2464 &ai->txfids[i].tx_desc, sizeof(TxFid));
2466 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2468 rc=issuecommand(ai, &cmd, &rsp);
2469 if (rc != SUCCESS) {
2470 printk(KERN_ERR "airo: Couldn't allocate TX FID\n");
2474 /* Alloc card Rid descriptor */
2475 memset(&rsp,0,sizeof(rsp));
2476 memset(&cmd,0,sizeof(cmd));
2478 cmd.cmd = CMD_ALLOCATEAUX;
2480 cmd.parm1 = (ai->config_desc.card_ram_off - ai->pciaux);
2481 cmd.parm2 = 1; /* Magic number... */
2482 rc=issuecommand(ai, &cmd, &rsp);
2483 if (rc != SUCCESS) {
2484 printk(KERN_ERR "airo: Couldn't allocate RID\n");
2488 memcpy((char *)ai->config_desc.card_ram_off,
2489 (char *)&ai->config_desc.rid_desc, sizeof(Rid));
2495 * We are setting up three things here:
2496 * 1) Map AUX memory for descriptors: Rid, TxFid, or RxFid.
2497 * 2) Map PCI memory for issueing commands.
2498 * 3) Allocate memory (shared) to send and receive ethernet frames.
2500 static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci,
2503 unsigned long mem_start, mem_len, aux_start, aux_len;
2506 unsigned char *busaddroff,*vpackoff;
2507 unsigned char *pciaddroff;
2509 mem_start = pci_resource_start(pci, 1);
2510 mem_len = pci_resource_len(pci, 1);
2511 aux_start = pci_resource_start(pci, 2);
2512 aux_len = AUXMEMSIZE;
2514 if (!request_mem_region(mem_start, mem_len, name)) {
2515 printk(KERN_ERR "airo: Couldn't get region %x[%x] for %s\n",
2516 (int)mem_start, (int)mem_len, name);
2519 if (!request_mem_region(aux_start, aux_len, name)) {
2520 printk(KERN_ERR "airo: Couldn't get region %x[%x] for %s\n",
2521 (int)aux_start, (int)aux_len, name);
2525 ai->pcimem = ioremap(mem_start, mem_len);
2527 printk(KERN_ERR "airo: Couldn't map region %x[%x] for %s\n",
2528 (int)mem_start, (int)mem_len, name);
2531 ai->pciaux = ioremap(aux_start, aux_len);
2533 printk(KERN_ERR "airo: Couldn't map region %x[%x] for %s\n",
2534 (int)aux_start, (int)aux_len, name);
2538 /* Reserve PKTSIZE for each fid and 2K for the Rids */
2539 ai->shared = pci_alloc_consistent(pci, PCI_SHARED_LEN, &ai->shared_dma);
2541 printk(KERN_ERR "airo: Couldn't alloc_consistent %d\n",
2547 * Setup descriptor RX, TX, CONFIG
2549 busaddroff = (unsigned char *)ai->shared_dma;
2550 pciaddroff = ai->pciaux + AUX_OFFSET;
2551 vpackoff = ai->shared;
2553 /* RX descriptor setup */
2554 for(i = 0; i < MPI_MAX_FIDS; i++) {
2555 ai->rxfids[i].pending = 0;
2556 ai->rxfids[i].card_ram_off = pciaddroff;
2557 ai->rxfids[i].virtual_host_addr = vpackoff;
2558 ai->rxfids[i].rx_desc.host_addr = (dma_addr_t) busaddroff;
2559 ai->rxfids[i].rx_desc.valid = 1;
2560 ai->rxfids[i].rx_desc.len = PKTSIZE;
2561 ai->rxfids[i].rx_desc.rdy = 0;
2563 pciaddroff += sizeof(RxFid);
2564 busaddroff += PKTSIZE;
2565 vpackoff += PKTSIZE;
2568 /* TX descriptor setup */
2569 for(i = 0; i < MPI_MAX_FIDS; i++) {
2570 ai->txfids[i].card_ram_off = pciaddroff;
2571 ai->txfids[i].virtual_host_addr = vpackoff;
2572 ai->txfids[i].tx_desc.valid = 1;
2573 ai->txfids[i].tx_desc.host_addr = (dma_addr_t) busaddroff;
2574 memcpy(ai->txfids[i].virtual_host_addr,
2575 &wifictlhdr8023, sizeof(wifictlhdr8023));
2577 pciaddroff += sizeof(TxFid);
2578 busaddroff += PKTSIZE;
2579 vpackoff += PKTSIZE;
2581 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2583 /* Rid descriptor setup */
2584 ai->config_desc.card_ram_off = pciaddroff;
2585 ai->config_desc.virtual_host_addr = vpackoff;
2586 ai->config_desc.rid_desc.host_addr = (dma_addr_t) busaddroff;
2587 ai->ridbus = (dma_addr_t)busaddroff;
2588 ai->config_desc.rid_desc.rid = 0;
2589 ai->config_desc.rid_desc.len = RIDSIZE;
2590 ai->config_desc.rid_desc.valid = 1;
2591 pciaddroff += sizeof(Rid);
2592 busaddroff += RIDSIZE;
2593 vpackoff += RIDSIZE;
2595 /* Tell card about descriptors */
2596 if (mpi_init_descriptors (ai) != SUCCESS)
2601 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2603 iounmap(ai->pciaux);
2605 iounmap(ai->pcimem);
2607 release_mem_region(aux_start, aux_len);
2609 release_mem_region(mem_start, mem_len);
2614 static void wifi_setup(struct net_device *dev)
2616 dev->hard_header = 0;
2617 dev->rebuild_header = 0;
2618 dev->hard_header_cache = 0;
2619 dev->header_cache_update= 0;
2621 dev->hard_header_parse = wll_header_parse;
2622 dev->hard_start_xmit = &airo_start_xmit11;
2623 dev->get_stats = &airo_get_stats;
2624 dev->set_mac_address = &airo_set_mac_address;
2625 dev->do_ioctl = &airo_ioctl;
2627 dev->get_wireless_stats = airo_get_wireless_stats;
2628 dev->wireless_handlers = (struct iw_handler_def *)&airo_handler_def;
2629 #endif /* WIRELESS_EXT */
2630 dev->change_mtu = &airo_change_mtu;
2631 dev->open = &airo_open;
2632 dev->stop = &airo_close;
2634 dev->type = ARPHRD_IEEE80211;
2635 dev->hard_header_len = ETH_HLEN;
2637 dev->addr_len = ETH_ALEN;
2638 dev->tx_queue_len = 100;
2640 memset(dev->broadcast,0xFF, ETH_ALEN);
2642 dev->flags = IFF_BROADCAST|IFF_MULTICAST;
2645 static struct net_device *init_wifidev(struct airo_info *ai,
2646 struct net_device *ethdev)
2649 struct net_device *dev = alloc_netdev(0, "wifi%d", wifi_setup);
2652 dev->priv = ethdev->priv;
2653 dev->irq = ethdev->irq;
2654 dev->base_addr = ethdev->base_addr;
2655 memcpy(dev->dev_addr, ethdev->dev_addr, dev->addr_len);
2656 err = register_netdev(dev);
2664 int reset_card( struct net_device *dev , int lock) {
2665 struct airo_info *ai = dev->priv;
2667 if (lock && down_interruptible(&ai->sem))
2670 OUT4500(ai,COMMAND,CMD_SOFTRESET);
2671 set_current_state (TASK_UNINTERRUPTIBLE);
2672 schedule_timeout (HZ/5);
2674 set_current_state (TASK_UNINTERRUPTIBLE);
2675 schedule_timeout (HZ/5);
2681 struct net_device *_init_airo_card( unsigned short irq, int port,
2682 int is_pcmcia, struct pci_dev *pci )
2684 struct net_device *dev;
2685 struct airo_info *ai;
2688 /* Create the network device object. */
2689 dev = alloc_etherdev(sizeof(*ai));
2691 printk(KERN_ERR "airo: Couldn't alloc_etherdev\n");
2694 if (dev_alloc_name(dev, dev->name) < 0) {
2695 printk(KERN_ERR "airo: Couldn't get name!\n");
2702 if (pci && (pci->device == 0x5000 || pci->device == 0xa504)) {
2703 printk(KERN_DEBUG "airo: Found an MPI350 card\n");
2704 set_bit(FLAG_MPI, &ai->flags);
2707 ai->aux_lock = SPIN_LOCK_UNLOCKED;
2708 sema_init(&ai->sem, 1);
2711 init_waitqueue_head (&ai->thr_wait);
2712 init_completion (&ai->thr_exited);
2713 ai->thr_pid = kernel_thread(airo_thread, dev, CLONE_FS | CLONE_FILES);
2714 if (ai->thr_pid < 0)
2719 rc = add_airo_dev( dev );
2723 /* The Airo-specific entries in the device structure. */
2724 if (test_bit(FLAG_MPI,&ai->flags)) {
2725 skb_queue_head_init (&ai->txq);
2726 dev->hard_start_xmit = &mpi_start_xmit;
2728 dev->hard_start_xmit = &airo_start_xmit;
2729 dev->get_stats = &airo_get_stats;
2730 dev->set_multicast_list = &airo_set_multicast_list;
2731 dev->set_mac_address = &airo_set_mac_address;
2732 dev->do_ioctl = &airo_ioctl;
2734 dev->get_wireless_stats = airo_get_wireless_stats;
2735 dev->wireless_handlers = (struct iw_handler_def *)&airo_handler_def;
2736 #endif /* WIRELESS_EXT */
2737 dev->change_mtu = &airo_change_mtu;
2738 dev->open = &airo_open;
2739 dev->stop = &airo_close;
2741 dev->base_addr = port;
2743 /* what is with PCMCIA ??? */
2745 SET_NETDEV_DEV(dev, &pci->dev);
2748 rc = request_irq( dev->irq, airo_interrupt, SA_SHIRQ, dev->name, dev );
2750 printk(KERN_ERR "airo: register interrupt %d failed, rc %d\n", irq, rc );
2751 goto err_out_unlink;
2754 if (!request_region( dev->base_addr, 64, dev->name )) {
2756 printk(KERN_ERR "airo: Couldn't request region\n");
2761 if (test_bit(FLAG_MPI,&ai->flags)) {
2762 if (mpi_map_card(ai, pci, dev->name)) {
2763 printk(KERN_ERR "airo: Could not map memory\n");
2769 if ( setup_card( ai, dev->dev_addr, 1 ) != SUCCESS ) {
2770 printk( KERN_ERR "airo: MAC could not be enabled\n" );
2774 } else if (!test_bit(FLAG_MPI,&ai->flags)) {
2775 ai->bap_read = fast_bap_read;
2776 set_bit(FLAG_FLASHING, &ai->flags);
2779 rc = register_netdev(dev);
2781 printk(KERN_ERR "airo: Couldn't register_netdev\n");
2784 ai->wifidev = init_wifidev(ai, dev);
2786 set_bit(FLAG_REGISTERED,&ai->flags);
2787 printk( KERN_INFO "airo: MAC enabled %s %x:%x:%x:%x:%x:%x\n",
2789 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
2790 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5] );
2792 /* Allocate the transmit buffers */
2793 if (probe && !test_bit(FLAG_MPI,&ai->flags))
2794 for( i = 0; i < MAX_FIDS; i++ )
2795 ai->fids[i] = transmit_allocate(ai,2312,i>=MAX_FIDS/2);
2797 setup_proc_entry( dev, dev->priv ); /* XXX check for failure */
2798 netif_start_queue(dev);
2799 SET_MODULE_OWNER(dev);
2803 if (test_bit(FLAG_MPI,&ai->flags) && pci) {
2804 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2805 iounmap(ai->pciaux);
2806 iounmap(ai->pcimem);
2807 mpi_unmap_card(ai->pci);
2811 release_region( dev->base_addr, 64 );
2813 free_irq(dev->irq, dev);
2817 set_bit(JOB_DIE, &ai->flags);
2818 kill_proc(ai->thr_pid, SIGTERM, 1);
2819 wait_for_completion(&ai->thr_exited);
2825 struct net_device *init_airo_card( unsigned short irq, int port, int is_pcmcia )
2827 return _init_airo_card ( irq, port, is_pcmcia, 0);
2830 EXPORT_SYMBOL(init_airo_card);
2832 static int waitbusy (struct airo_info *ai) {
2834 while ((IN4500 (ai, COMMAND) & COMMAND_BUSY) & (delay < 10000)) {
2836 if ((++delay % 20) == 0)
2837 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
2839 return delay < 10000;
2842 int reset_airo_card( struct net_device *dev )
2845 struct airo_info *ai = dev->priv;
2847 if (reset_card (dev, 1))
2850 if ( setup_card(ai, dev->dev_addr, 1 ) != SUCCESS ) {
2851 printk( KERN_ERR "airo: MAC could not be enabled\n" );
2854 printk( KERN_INFO "airo: MAC enabled %s %x:%x:%x:%x:%x:%x\n", dev->name,
2855 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
2856 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
2857 /* Allocate the transmit buffers if needed */
2858 if (!test_bit(FLAG_MPI,&ai->flags))
2859 for( i = 0; i < MAX_FIDS; i++ )
2860 ai->fids[i] = transmit_allocate (ai,2312,i>=MAX_FIDS/2);
2862 enable_interrupts( ai );
2863 netif_wake_queue(dev);
2867 EXPORT_SYMBOL(reset_airo_card);
2869 static void airo_send_event(struct net_device *dev) {
2870 struct airo_info *ai = dev->priv;
2871 union iwreq_data wrqu;
2872 StatusRid status_rid;
2874 clear_bit(JOB_EVENT, &ai->flags);
2875 PC4500_readrid(ai, RID_STATUS, &status_rid, sizeof(status_rid), 0);
2877 wrqu.data.length = 0;
2878 wrqu.data.flags = 0;
2879 memcpy(wrqu.ap_addr.sa_data, status_rid.bssid[0], ETH_ALEN);
2880 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
2882 /* Send event to user space */
2883 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
2886 static int airo_thread(void *data) {
2887 struct net_device *dev = data;
2888 struct airo_info *ai = dev->priv;
2891 daemonize("%s", dev->name);
2892 allow_signal(SIGTERM);
2895 if (signal_pending(current))
2896 flush_signals(current);
2898 /* make swsusp happy with our thread */
2899 if (current->flags & PF_FREEZE)
2900 refrigerator(PF_FREEZE);
2902 if (test_bit(JOB_DIE, &ai->flags))
2905 if (ai->flags & JOB_MASK) {
2906 locked = down_interruptible(&ai->sem);
2910 init_waitqueue_entry(&wait, current);
2911 add_wait_queue(&ai->thr_wait, &wait);
2913 set_current_state(TASK_INTERRUPTIBLE);
2914 if (ai->flags & JOB_MASK)
2917 if (time_after_eq(jiffies,ai->expires)){
2918 set_bit(JOB_AUTOWEP,&ai->flags);
2921 if (!signal_pending(current)) {
2922 schedule_timeout(ai->expires - jiffies);
2925 } else if (!signal_pending(current)) {
2931 current->state = TASK_RUNNING;
2932 remove_wait_queue(&ai->thr_wait, &wait);
2939 if (test_bit(JOB_DIE, &ai->flags)) {
2944 if (ai->power || test_bit(FLAG_FLASHING, &ai->flags)) {
2949 if (test_bit(JOB_XMIT, &ai->flags))
2951 else if (test_bit(JOB_XMIT11, &ai->flags))
2952 airo_end_xmit11(dev);
2953 else if (test_bit(JOB_STATS, &ai->flags))
2954 airo_read_stats(ai);
2955 else if (test_bit(JOB_WSTATS, &ai->flags))
2956 airo_read_wireless_stats(ai);
2957 else if (test_bit(JOB_PROMISC, &ai->flags))
2958 airo_set_promisc(ai);
2960 else if (test_bit(JOB_MIC, &ai->flags))
2963 else if (test_bit(JOB_EVENT, &ai->flags))
2964 airo_send_event(dev);
2965 else if (test_bit(JOB_AUTOWEP, &ai->flags))
2968 complete_and_exit (&ai->thr_exited, 0);
2971 static irqreturn_t airo_interrupt ( int irq, void* dev_id, struct pt_regs *regs) {
2972 struct net_device *dev = (struct net_device *)dev_id;
2975 struct airo_info *apriv = dev->priv;
2976 u16 savedInterrupts = 0;
2979 if (!netif_device_present(dev))
2983 status = IN4500( apriv, EVSTAT );
2984 if ( !(status & STATUS_INTS) || status == 0xffff ) break;
2988 if ( status & EV_AWAKE ) {
2989 OUT4500( apriv, EVACK, EV_AWAKE );
2990 OUT4500( apriv, EVACK, EV_AWAKE );
2993 if (!savedInterrupts) {
2994 savedInterrupts = IN4500( apriv, EVINTEN );
2995 OUT4500( apriv, EVINTEN, 0 );
2998 if ( status & EV_MIC ) {
2999 OUT4500( apriv, EVACK, EV_MIC );
3001 if (test_bit(FLAG_MIC_CAPABLE, &apriv->flags)) {
3002 set_bit(JOB_MIC, &apriv->flags);
3003 wake_up_interruptible(&apriv->thr_wait);
3007 if ( status & EV_LINK ) {
3008 union iwreq_data wrqu;
3009 /* The link status has changed, if you want to put a
3010 monitor hook in, do it here. (Remember that
3011 interrupts are still disabled!)
3013 u16 newStatus = IN4500(apriv, LINKSTAT);
3014 OUT4500( apriv, EVACK, EV_LINK);
3015 /* Here is what newStatus means: */
3016 #define NOBEACON 0x8000 /* Loss of sync - missed beacons */
3017 #define MAXRETRIES 0x8001 /* Loss of sync - max retries */
3018 #define MAXARL 0x8002 /* Loss of sync - average retry level exceeded*/
3019 #define FORCELOSS 0x8003 /* Loss of sync - host request */
3020 #define TSFSYNC 0x8004 /* Loss of sync - TSF synchronization */
3021 #define DEAUTH 0x8100 /* Deauthentication (low byte is reason code) */
3022 #define DISASS 0x8200 /* Disassociation (low byte is reason code) */
3023 #define ASSFAIL 0x8400 /* Association failure (low byte is reason
3025 #define AUTHFAIL 0x0300 /* Authentication failure (low byte is reason
3027 #define ASSOCIATED 0x0400 /* Assocatied */
3028 #define RC_RESERVED 0 /* Reserved return code */
3029 #define RC_NOREASON 1 /* Unspecified reason */
3030 #define RC_AUTHINV 2 /* Previous authentication invalid */
3031 #define RC_DEAUTH 3 /* Deauthenticated because sending station is
3033 #define RC_NOACT 4 /* Disassociated due to inactivity */
3034 #define RC_MAXLOAD 5 /* Disassociated because AP is unable to handle
3035 all currently associated stations */
3036 #define RC_BADCLASS2 6 /* Class 2 frame received from
3037 non-Authenticated station */
3038 #define RC_BADCLASS3 7 /* Class 3 frame received from
3039 non-Associated station */
3040 #define RC_STATLEAVE 8 /* Disassociated because sending station is
3042 #define RC_NOAUTH 9 /* Station requesting (Re)Association is not
3043 Authenticated with the responding station */
3044 if (newStatus != ASSOCIATED) {
3045 if (auto_wep && !apriv->expires) {
3046 apriv->expires = RUN_AT(3*HZ);
3047 wake_up_interruptible(&apriv->thr_wait);
3050 struct task_struct *task = apriv->task;
3054 wake_up_process (task);
3055 set_bit(FLAG_UPDATE_UNI, &apriv->flags);
3056 set_bit(FLAG_UPDATE_MULTI, &apriv->flags);
3058 /* Question : is ASSOCIATED the only status
3059 * that is valid ? We want to catch handover
3060 * and reassociations as valid status
3062 if(newStatus == ASSOCIATED) {
3063 if (apriv->scan_timestamp) {
3064 /* Send an empty event to user space.
3065 * We don't send the received data on
3066 * the event because it would require
3067 * us to do complex transcoding, and
3068 * we want to minimise the work done in
3069 * the irq handler. Use a request to
3070 * extract the data - Jean II */
3071 wrqu.data.length = 0;
3072 wrqu.data.flags = 0;
3073 wireless_send_event(dev, SIOCGIWSCAN, &wrqu, NULL);
3074 apriv->scan_timestamp = 0;
3076 if (down_trylock(&apriv->sem) != 0) {
3077 set_bit(JOB_EVENT, &apriv->flags);
3078 wake_up_interruptible(&apriv->thr_wait);
3080 airo_send_event(dev);
3082 memset(wrqu.ap_addr.sa_data, '\0', ETH_ALEN);
3083 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
3085 /* Send event to user space */
3086 wireless_send_event(dev, SIOCGIWAP, &wrqu,NULL);
3090 /* Check to see if there is something to receive */
3091 if ( status & EV_RX ) {
3092 struct sk_buff *skb = NULL;
3093 u16 fc, len, hdrlen = 0;
3107 if (test_bit(FLAG_MPI,&apriv->flags)) {
3108 if (test_bit(FLAG_802_11, &apriv->flags))
3109 mpi_receive_802_11(apriv);
3111 mpi_receive_802_3(apriv);
3112 OUT4500(apriv, EVACK, EV_RX);
3116 fid = IN4500( apriv, RXFID );
3118 /* Get the packet length */
3119 if (test_bit(FLAG_802_11, &apriv->flags)) {
3120 bap_setup (apriv, fid, 4, BAP0);
3121 bap_read (apriv, (u16*)&hdr, sizeof(hdr), BAP0);
3122 /* Bad CRC. Ignore packet */
3123 if (le16_to_cpu(hdr.status) & 2)
3125 if (apriv->wifidev == NULL)
3128 bap_setup (apriv, fid, 0x36, BAP0);
3129 bap_read (apriv, (u16*)&hdr.len, 2, BAP0);
3131 len = le16_to_cpu(hdr.len);
3134 printk( KERN_ERR "airo: Bad size %d\n", len );
3140 if (test_bit(FLAG_802_11, &apriv->flags)) {
3141 bap_read (apriv, (u16*)&fc, sizeof(fc), BAP0);
3142 fc = le16_to_cpu(fc);
3145 if ((fc & 0xe0) == 0xc0)
3151 if ((fc&0x300)==0x300){
3159 hdrlen = ETH_ALEN * 2;
3161 skb = dev_alloc_skb( len + hdrlen + 2 );
3163 apriv->stats.rx_dropped++;
3166 buffer = (u16*)skb_put (skb, len + hdrlen);
3167 if (test_bit(FLAG_802_11, &apriv->flags)) {
3169 bap_read (apriv, buffer + 1, hdrlen - 2, BAP0);
3171 bap_read (apriv, tmpbuf, 6, BAP0);
3173 bap_read (apriv, &gap, sizeof(gap), BAP0);
3174 gap = le16_to_cpu(gap);
3177 bap_read (apriv, tmpbuf, gap, BAP0);
3179 printk(KERN_ERR "airo: gaplen too big. Problems will follow...\n");
3181 bap_read (apriv, buffer + hdrlen/2, len, BAP0);
3186 bap_read (apriv, buffer, ETH_ALEN*2, BAP0);
3188 if (apriv->micstats.enabled) {
3189 bap_read (apriv,(u16*)&micbuf,sizeof(micbuf),BAP0);
3190 if (ntohs(micbuf.typelen) > 0x05DC)
3191 bap_setup (apriv, fid, 0x44, BAP0);
3193 if (len <= sizeof(micbuf))
3196 len -= sizeof(micbuf);
3197 skb_trim (skb, len + hdrlen);
3201 bap_read(apriv,buffer+ETH_ALEN,len,BAP0);
3203 if (decapsulate(apriv,&micbuf,(etherHead*)buffer,len)) {
3205 dev_kfree_skb_irq (skb);
3210 OUT4500( apriv, EVACK, EV_RX);
3214 #ifdef IW_WIRELESS_SPY /* defined in iw_handler.h */
3215 if (apriv->spy_data.spy_number > 0) {
3217 struct iw_quality wstats;
3218 /* Prepare spy data : addr + qual */
3219 if (!test_bit(FLAG_802_11, &apriv->flags)) {
3220 sa = (char*)buffer + 6;
3221 bap_setup (apriv, fid, 8, BAP0);
3222 bap_read (apriv, (u16*)hdr.rssi, 2, BAP0);
3224 sa = (char*)buffer + 10;
3225 wstats.qual = hdr.rssi[0];
3227 wstats.level = 0x100 - apriv->rssi[hdr.rssi[1]].rssidBm;
3229 wstats.level = (hdr.rssi[1] + 321) / 2;
3231 /* Update spy records */
3232 wireless_spy_update(dev, sa, &wstats);
3234 #endif /* IW_WIRELESS_SPY */
3235 OUT4500( apriv, EVACK, EV_RX);
3237 if (test_bit(FLAG_802_11, &apriv->flags)) {
3238 skb->mac.raw = skb->data;
3239 skb->pkt_type = PACKET_OTHERHOST;
3240 skb->dev = apriv->wifidev;
3241 skb->protocol = htons(ETH_P_802_2);
3244 skb->protocol = eth_type_trans(skb,dev);
3246 skb->dev->last_rx = jiffies;
3247 skb->ip_summed = CHECKSUM_NONE;
3253 /* Check to see if a packet has been transmitted */
3254 if ( status & ( EV_TX|EV_TXCPY|EV_TXEXC ) ) {
3259 if (test_bit(FLAG_MPI,&apriv->flags)) {
3260 unsigned long flags;
3262 if (status & EV_TXEXC)
3263 get_tx_error(apriv, -1);
3264 spin_lock_irqsave(&apriv->aux_lock, flags);
3265 if (skb_queue_len (&apriv->txq)) {
3266 spin_unlock_irqrestore(&apriv->aux_lock,flags);
3267 mpi_send_packet (dev);
3269 clear_bit(FLAG_PENDING_XMIT, &apriv->flags);
3270 spin_unlock_irqrestore(&apriv->aux_lock,flags);
3271 netif_wake_queue (dev);
3273 OUT4500( apriv, EVACK,
3274 status & (EV_TX|EV_TXCPY|EV_TXEXC));
3278 fid = IN4500(apriv, TXCOMPLFID);
3280 for( i = 0; i < MAX_FIDS; i++ ) {
3281 if ( ( apriv->fids[i] & 0xffff ) == fid ) {
3282 len = apriv->fids[i] >> 16;
3287 if (status & EV_TXEXC)
3288 get_tx_error(apriv, index);
3289 OUT4500( apriv, EVACK, status & (EV_TX | EV_TXEXC));
3290 /* Set up to be used again */
3291 apriv->fids[index] &= 0xffff;
3292 if (index < MAX_FIDS / 2) {
3293 if (!test_bit(FLAG_PENDING_XMIT, &apriv->flags))
3294 netif_wake_queue(dev);
3296 if (!test_bit(FLAG_PENDING_XMIT11, &apriv->flags))
3297 netif_wake_queue(apriv->wifidev);
3300 OUT4500( apriv, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3301 printk( KERN_ERR "airo: Unallocated FID was used to xmit\n" );
3305 if ( status & ~STATUS_INTS & ~IGNORE_INTS )
3306 printk( KERN_WARNING "airo: Got weird status %x\n",
3307 status & ~STATUS_INTS & ~IGNORE_INTS );
3310 if (savedInterrupts)
3311 OUT4500( apriv, EVINTEN, savedInterrupts );
3314 return IRQ_RETVAL(handled);
3318 * Routines to talk to the card
3322 * This was originally written for the 4500, hence the name
3323 * NOTE: If use with 8bit mode and SMP bad things will happen!
3324 * Why would some one do 8 bit IO in an SMP machine?!?
3326 static void OUT4500( struct airo_info *ai, u16 reg, u16 val ) {
3327 if (test_bit(FLAG_MPI,&ai->flags))
3330 outw( val, ai->dev->base_addr + reg );
3332 outb( val & 0xff, ai->dev->base_addr + reg );
3333 outb( val >> 8, ai->dev->base_addr + reg + 1 );
3337 static u16 IN4500( struct airo_info *ai, u16 reg ) {
3340 if (test_bit(FLAG_MPI,&ai->flags))
3343 rc = inw( ai->dev->base_addr + reg );
3345 rc = inb( ai->dev->base_addr + reg );
3346 rc += ((int)inb( ai->dev->base_addr + reg + 1 )) << 8;
3351 static int enable_MAC( struct airo_info *ai, Resp *rsp, int lock ) {
3355 /* FLAG_RADIO_OFF : Radio disabled via /proc or Wireless Extensions
3356 * FLAG_RADIO_DOWN : Radio disabled via "ifconfig ethX down"
3357 * Note : we could try to use !netif_running(dev) in enable_MAC()
3358 * instead of this flag, but I don't trust it *within* the
3359 * open/close functions, and testing both flags together is
3360 * "cheaper" - Jean II */
3361 if (ai->flags & FLAG_RADIO_MASK) return SUCCESS;
3363 if (lock && down_interruptible(&ai->sem))
3364 return -ERESTARTSYS;
3366 if (!test_bit(FLAG_ENABLED, &ai->flags)) {
3367 memset(&cmd, 0, sizeof(cmd));
3368 cmd.cmd = MAC_ENABLE;
3369 rc = issuecommand(ai, &cmd, rsp);
3371 set_bit(FLAG_ENABLED, &ai->flags);
3379 printk(KERN_ERR "%s: Cannot enable MAC, err=%d\n",
3384 static void disable_MAC( struct airo_info *ai, int lock ) {
3388 if (lock && down_interruptible(&ai->sem))
3391 if (test_bit(FLAG_ENABLED, &ai->flags)) {
3392 memset(&cmd, 0, sizeof(cmd));
3393 cmd.cmd = MAC_DISABLE; // disable in case already enabled
3394 issuecommand(ai, &cmd, &rsp);
3395 clear_bit(FLAG_ENABLED, &ai->flags);
3401 static void enable_interrupts( struct airo_info *ai ) {
3402 /* Reset the status register */
3403 u16 status = IN4500( ai, EVSTAT );
3404 OUT4500( ai, EVACK, status );
3405 /* Enable the interrupts */
3406 OUT4500( ai, EVINTEN, STATUS_INTS );
3407 /* Note there is a race condition between the last two lines that
3408 I don't know how to get rid of right now... */
3411 static void disable_interrupts( struct airo_info *ai ) {
3412 OUT4500( ai, EVINTEN, 0 );
3415 static void mpi_receive_802_3(struct airo_info *ai)
3419 struct sk_buff *skb;
3426 memcpy ((char *)&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3427 /* Make sure we got something */
3428 if (rxd.rdy && rxd.valid == 0) {
3430 if (len < 12 && len > 2048)
3433 skb = dev_alloc_skb(len);
3435 ai->stats.rx_dropped++;
3438 buffer = skb_put(skb,len);
3440 memcpy(buffer, ai->rxfids[0].virtual_host_addr, ETH_ALEN * 2);
3441 if (ai->micstats.enabled) {
3443 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2,
3445 if (ntohs(micbuf.typelen) <= 0x05DC) {
3446 if (len <= sizeof(micbuf) + ETH_ALEN * 2)
3449 off = sizeof(micbuf);
3450 skb_trim (skb, len - off);
3453 memcpy(buffer + ETH_ALEN * 2,
3454 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2 + off,
3455 len - ETH_ALEN * 2 - off);
3456 if (decapsulate (ai, &micbuf, (etherHead*)buffer, len - off)) {
3458 dev_kfree_skb_irq (skb);
3462 memcpy(buffer, ai->rxfids[0].virtual_host_addr, len);
3464 #ifdef IW_WIRELESS_SPY /* defined in iw_handler.h */
3465 if (ai->spy_data.spy_number > 0) {
3467 struct iw_quality wstats;
3468 /* Prepare spy data : addr + qual */
3469 sa = buffer + ETH_ALEN;
3470 wstats.qual = 0; /* XXX Where do I get that info from ??? */
3473 /* Update spy records */
3474 wireless_spy_update(ai->dev, sa, &wstats);
3476 #endif /* IW_WIRELESS_SPY */
3479 skb->ip_summed = CHECKSUM_NONE;
3480 skb->protocol = eth_type_trans(skb, ai->dev);
3481 skb->dev->last_rx = jiffies;
3485 if (rxd.valid == 0) {
3489 memcpy (ai->rxfids[0].card_ram_off, (char *)&rxd, sizeof(rxd));
3493 void mpi_receive_802_11 (struct airo_info *ai)
3496 struct sk_buff *skb = NULL;
3497 u16 fc, len, hdrlen = 0;
3509 char *ptr = ai->rxfids[0].virtual_host_addr+4;
3511 memcpy ((char *)&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3512 memcpy ((char *)&hdr, ptr, sizeof(hdr));
3514 /* Bad CRC. Ignore packet */
3515 if (le16_to_cpu(hdr.status) & 2)
3517 if (ai->wifidev == NULL)
3519 len = le16_to_cpu(hdr.len);
3521 printk( KERN_ERR "airo: Bad size %d\n", len );
3527 memcpy ((char *)&fc, ptr, sizeof(fc));
3528 fc = le16_to_cpu(fc);
3531 if ((fc & 0xe0) == 0xc0)
3537 if ((fc&0x300)==0x300){
3545 skb = dev_alloc_skb( len + hdrlen + 2 );
3547 ai->stats.rx_dropped++;
3550 buffer = (u16*)skb_put (skb, len + hdrlen);
3551 memcpy ((char *)buffer, ptr, hdrlen);
3555 memcpy ((char *)&gap, ptr, sizeof(gap));
3557 gap = le16_to_cpu(gap);
3563 "airo: gaplen too big. Problems will follow...\n");
3565 memcpy ((char *)buffer + hdrlen, ptr, len);
3567 #ifdef IW_WIRELESS_SPY /* defined in iw_handler.h */
3568 if (ai->spy_data.spy_number > 0) {
3570 struct iw_quality wstats;
3571 /* Prepare spy data : addr + qual */
3572 sa = (char*)buffer + 10;
3573 wstats.qual = hdr.rssi[0];
3575 wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3577 wstats.level = (hdr.rssi[1] + 321) / 2;
3579 /* Update spy records */
3580 wireless_spy_update(ai->dev, sa, &wstats);
3582 #endif /* IW_WIRELESS_SPY */
3583 skb->mac.raw = skb->data;
3584 skb->pkt_type = PACKET_OTHERHOST;
3585 skb->dev = ai->wifidev;
3586 skb->protocol = htons(ETH_P_802_2);
3587 skb->dev->last_rx = jiffies;
3588 skb->ip_summed = CHECKSUM_NONE;
3591 if (rxd.valid == 0) {
3595 memcpy (ai->rxfids[0].card_ram_off, (char *)&rxd, sizeof(rxd));
3599 static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
3610 memset( &mySsid, 0, sizeof( mySsid ) );
3616 /* The NOP is the first step in getting the card going */
3618 cmd.parm0 = cmd.parm1 = cmd.parm2 = 0;
3619 if (lock && down_interruptible(&ai->sem))
3621 if ( issuecommand( ai, &cmd, &rsp ) != SUCCESS ) {
3626 disable_MAC( ai, 0);
3628 // Let's figure out if we need to use the AUX port
3629 if (!test_bit(FLAG_MPI,&ai->flags)) {
3630 cmd.cmd = CMD_ENABLEAUX;
3631 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
3634 printk(KERN_ERR "airo: Error checking for AUX port\n");
3637 if (!aux_bap || rsp.status & 0xff00) {
3638 ai->bap_read = fast_bap_read;
3639 printk(KERN_DEBUG "airo: Doing fast bap_reads\n");
3641 ai->bap_read = aux_bap_read;
3642 printk(KERN_DEBUG "airo: Doing AUX bap_reads\n");
3647 if (ai->config.len == 0) {
3648 tdsRssiRid rssi_rid;
3649 CapabilityRid cap_rid;
3659 // general configuration (read/modify/write)
3660 status = readConfigRid(ai, lock);
3661 if ( status != SUCCESS ) return ERROR;
3663 status = readCapabilityRid(ai, &cap_rid, lock);
3664 if ( status != SUCCESS ) return ERROR;
3667 * This driver supports MPI350 firmwares up to, and
3670 if (test_bit(FLAG_MPI, &ai->flags) &&
3671 strncmp (cap_rid.prodVer, "5.00.", 5) &&
3672 strncmp (cap_rid.prodVer, "5b00.", 5) &&
3673 strncmp (cap_rid.prodVer, "5.02.", 5) &&
3674 strncmp (cap_rid.prodVer, "5.20.", 5) &&
3675 strncmp (cap_rid.prodVer, "5.30.", 5))
3676 printk(KERN_ERR "airo: Firmware version %s is not supported. Use it at your own risk!\n", cap_rid.prodVer);
3678 status = PC4500_readrid(ai,RID_RSSI,&rssi_rid,sizeof(rssi_rid),lock);
3679 if ( status == SUCCESS ) {
3680 if (ai->rssi || (ai->rssi = kmalloc(512, GFP_KERNEL)) != NULL)
3681 memcpy(ai->rssi, (u8*)&rssi_rid + 2, 512);
3688 if (cap_rid.softCap & 8)
3689 ai->config.rmode |= RXMODE_NORMALIZED_RSSI;
3691 printk(KERN_WARNING "airo: unknown received signal level scale\n");
3693 ai->config.opmode = adhoc ? MODE_STA_IBSS : MODE_STA_ESS;
3694 ai->config.authType = AUTH_OPEN;
3695 ai->config.modulation = MOD_CCK;
3698 if ((cap_rid.len>=sizeof(cap_rid)) && (cap_rid.extSoftCap&1) &&
3699 (micsetup(ai) == SUCCESS)) {
3700 ai->config.opmode |= MODE_MIC;
3701 set_bit(FLAG_MIC_CAPABLE, &ai->flags);
3705 /* Save off the MAC */
3706 for( i = 0; i < ETH_ALEN; i++ ) {
3707 mac[i] = ai->config.macAddr[i];
3710 /* Check to see if there are any insmod configured
3714 if ( rates[0] ) memset(ai->config.rates,0,sizeof(ai->config.rates));
3715 for( i = 0; i < 8 && rates[i]; i++ ) {
3716 ai->config.rates[i] = rates[i];
3719 if ( basic_rate > 0 ) {
3721 for( i = 0; i < 8; i++ ) {
3722 if ( ai->config.rates[i] == basic_rate ||
3723 !ai->config.rates ) {
3724 ai->config.rates[i] = basic_rate | 0x80;
3729 set_bit (FLAG_COMMIT, &ai->flags);
3732 /* Setup the SSIDs if present */
3735 for( i = 0; i < 3 && ssids[i]; i++ ) {
3736 mySsid.ssids[i].len = strlen(ssids[i]);
3737 if ( mySsid.ssids[i].len > 32 )
3738 mySsid.ssids[i].len = 32;
3739 memcpy(mySsid.ssids[i].ssid, ssids[i],
3740 mySsid.ssids[i].len);
3742 mySsid.len = sizeof(mySsid);
3745 status = writeConfigRid(ai, lock);
3746 if ( status != SUCCESS ) return ERROR;
3748 /* Set up the SSID list */
3750 status = writeSsidRid(ai, &mySsid, lock);
3751 if ( status != SUCCESS ) return ERROR;
3754 status = enable_MAC(ai, &rsp, lock);
3755 if ( status != SUCCESS || (rsp.status & 0xFF00) != 0) {
3756 printk( KERN_ERR "airo: Bad MAC enable reason = %x, rid = %x, offset = %d\n", rsp.rsp0, rsp.rsp1, rsp.rsp2 );
3760 /* Grab the initial wep key, we gotta save it for auto_wep */
3761 rc = readWepKeyRid(ai, &wkr, 1, lock);
3762 if (rc == SUCCESS) do {
3763 lastindex = wkr.kindex;
3764 if (wkr.kindex == 0xffff) {
3765 ai->defindex = wkr.mac[0];
3767 rc = readWepKeyRid(ai, &wkr, 0, lock);
3768 } while(lastindex != wkr.kindex);
3771 ai->expires = RUN_AT(3*HZ);
3772 wake_up_interruptible(&ai->thr_wait);
3778 static u16 issuecommand(struct airo_info *ai, Cmd *pCmd, Resp *pRsp) {
3779 // Im really paranoid about letting it run forever!
3780 int max_tries = 600000;
3783 if (IN4500(ai, EVSTAT) & EV_CMD)
3784 OUT4500(ai, EVACK, EV_CMD);
3786 OUT4500(ai, PARAM0, pCmd->parm0);
3787 OUT4500(ai, PARAM1, pCmd->parm1);
3788 OUT4500(ai, PARAM2, pCmd->parm2);
3789 OUT4500(ai, COMMAND, pCmd->cmd);
3790 while ( max_tries-- && (IN4500(ai, EVSTAT) & EV_CMD) == 0 &&
3791 (cmd = IN4500(ai, COMMAND)) != 0 )
3792 if (cmd == pCmd->cmd)
3793 // PC4500 didn't notice command, try again
3794 OUT4500(ai, COMMAND, pCmd->cmd);
3795 if ( max_tries == -1 ) {
3797 "airo: Max tries exceeded when issueing command\n" );
3801 while (max_tries-- && (IN4500(ai, EVSTAT) & EV_CMD) == 0) {
3802 if (!in_atomic() && (max_tries & 255) == 0)
3805 if ( max_tries == -1 ) {
3807 "airo: Max tries exceeded waiting for command\n" );
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((char *)ai->config_desc.card_ram_off,
3992 (char *)&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))
4050 printk(KERN_ERR "%s: MAC should be disabled (rid=%d)\n",
4052 memset(&cmd, 0, sizeof(cmd));
4053 memset(&rsp, 0, sizeof(rsp));
4055 ai->config_desc.rid_desc.valid = 1;
4056 ai->config_desc.rid_desc.len = *((u16 *)pBuf);
4057 ai->config_desc.rid_desc.rid = 0;
4059 cmd.cmd = CMD_WRITERID;
4062 memcpy((char *)ai->config_desc.card_ram_off,
4063 (char *)&ai->config_desc.rid_desc, sizeof(Rid));
4065 if (len < 4 || len > 2047) {
4066 printk(KERN_ERR "%s: len=%d\n",__FUNCTION__,len);
4069 memcpy((char *)ai->config_desc.virtual_host_addr,
4072 rc = issuecommand(ai, &cmd, &rsp);
4073 if ((rc & 0xff00) != 0) {
4074 printk(KERN_ERR "%s: Write rid Error %d\n",
4076 printk(KERN_ERR "%s: Cmd=%04x\n",
4077 __FUNCTION__,cmd.cmd);
4080 if ((rsp.status & 0x7f00))
4084 // --- first access so that we can write the rid data
4085 if ( (status = PC4500_accessrid(ai, rid, CMD_ACCESS)) != 0) {
4089 // --- now write the rid data
4090 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4094 bap_write(ai, pBuf, len, BAP1);
4095 // ---now commit the rid data
4096 rc = PC4500_accessrid(ai, rid, 0x100|CMD_ACCESS);
4104 /* Allocates a FID to be used for transmitting packets. We only use
4106 static u16 transmit_allocate(struct airo_info *ai, int lenPayload, int raw)
4108 unsigned int loop = 3000;
4114 cmd.cmd = CMD_ALLOCATETX;
4115 cmd.parm0 = lenPayload;
4116 if (down_interruptible(&ai->sem))
4118 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
4122 if ( (rsp.status & 0xFF00) != 0) {
4126 /* wait for the allocate event/indication
4127 * It makes me kind of nervous that this can just sit here and spin,
4128 * but in practice it only loops like four times. */
4129 while (((IN4500(ai, EVSTAT) & EV_ALLOC) == 0) && --loop);
4135 // get the allocated fid and acknowledge
4136 txFid = IN4500(ai, TXALLOCFID);
4137 OUT4500(ai, EVACK, EV_ALLOC);
4139 /* The CARD is pretty cool since it converts the ethernet packet
4140 * into 802.11. Also note that we don't release the FID since we
4141 * will be using the same one over and over again. */
4142 /* We only have to setup the control once since we are not
4143 * releasing the fid. */
4145 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_11
4146 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4148 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_3
4149 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4150 if (bap_setup(ai, txFid, 0x0008, BAP1) != SUCCESS)
4153 bap_write(ai, &txControl, sizeof(txControl), BAP1);
4161 /* In general BAP1 is dedicated to transmiting packets. However,
4162 since we need a BAP when accessing RIDs, we also use BAP1 for that.
4163 Make sure the BAP1 spinlock is held when this is called. */
4164 static int transmit_802_3_packet(struct airo_info *ai, int len, char *pPacket)
4175 if (len <= ETH_ALEN * 2) {
4176 printk( KERN_WARNING "Short packet %d\n", len );
4179 len -= ETH_ALEN * 2;
4182 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
4183 (ntohs(((u16 *)pPacket)[6]) != 0x888E)) {
4184 if (encapsulate(ai,(etherHead *)pPacket,&pMic,len) != SUCCESS)
4186 miclen = sizeof(pMic);
4190 // packet is destination[6], source[6], payload[len-12]
4191 // write the payload length and dst/src/payload
4192 if (bap_setup(ai, txFid, 0x0036, BAP1) != SUCCESS) return ERROR;
4193 /* The hardware addresses aren't counted as part of the payload, so
4194 * we have to subtract the 12 bytes for the addresses off */
4195 payloadLen = cpu_to_le16(len + miclen);
4196 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4197 bap_write(ai, (const u16*)pPacket, sizeof(etherHead), BAP1);
4199 bap_write(ai, (const u16*)&pMic, miclen, BAP1);
4200 bap_write(ai, (const u16*)(pPacket + sizeof(etherHead)), len, BAP1);
4201 // issue the transmit command
4202 memset( &cmd, 0, sizeof( cmd ) );
4203 cmd.cmd = CMD_TRANSMIT;
4205 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4206 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4210 static int transmit_802_11_packet(struct airo_info *ai, int len, char *pPacket)
4225 fc = le16_to_cpu(*(const u16*)pPacket);
4228 if ((fc & 0xe0) == 0xc0)
4234 if ((fc&0x300)==0x300){
4243 printk( KERN_WARNING "Short packet %d\n", len );
4247 /* packet is 802.11 header + payload
4248 * write the payload length and dst/src/payload */
4249 if (bap_setup(ai, txFid, 6, BAP1) != SUCCESS) return ERROR;
4250 /* The 802.11 header aren't counted as part of the payload, so
4251 * we have to subtract the header bytes off */
4252 payloadLen = cpu_to_le16(len-hdrlen);
4253 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4254 if (bap_setup(ai, txFid, 0x0014, BAP1) != SUCCESS) return ERROR;
4255 bap_write(ai, (const u16*)pPacket, hdrlen, BAP1);
4256 bap_write(ai, hdrlen == 30 ?
4257 (const u16*)&gap.gaplen : (const u16*)&gap, 38 - hdrlen, BAP1);
4259 bap_write(ai, (const u16*)(pPacket + hdrlen), len - hdrlen, BAP1);
4260 // issue the transmit command
4261 memset( &cmd, 0, sizeof( cmd ) );
4262 cmd.cmd = CMD_TRANSMIT;
4264 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4265 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4270 * This is the proc_fs routines. It is a bit messier than I would
4271 * like! Feel free to clean it up!
4274 static ssize_t proc_read( struct file *file,
4275 char __user *buffer,
4279 static ssize_t proc_write( struct file *file,
4280 const char __user *buffer,
4283 static int proc_close( struct inode *inode, struct file *file );
4285 static int proc_stats_open( struct inode *inode, struct file *file );
4286 static int proc_statsdelta_open( struct inode *inode, struct file *file );
4287 static int proc_status_open( struct inode *inode, struct file *file );
4288 static int proc_SSID_open( struct inode *inode, struct file *file );
4289 static int proc_APList_open( struct inode *inode, struct file *file );
4290 static int proc_BSSList_open( struct inode *inode, struct file *file );
4291 static int proc_config_open( struct inode *inode, struct file *file );
4292 static int proc_wepkey_open( struct inode *inode, struct file *file );
4294 static struct file_operations proc_statsdelta_ops = {
4296 .open = proc_statsdelta_open,
4297 .release = proc_close
4300 static struct file_operations proc_stats_ops = {
4302 .open = proc_stats_open,
4303 .release = proc_close
4306 static struct file_operations proc_status_ops = {
4308 .open = proc_status_open,
4309 .release = proc_close
4312 static struct file_operations proc_SSID_ops = {
4314 .write = proc_write,
4315 .open = proc_SSID_open,
4316 .release = proc_close
4319 static struct file_operations proc_BSSList_ops = {
4321 .write = proc_write,
4322 .open = proc_BSSList_open,
4323 .release = proc_close
4326 static struct file_operations proc_APList_ops = {
4328 .write = proc_write,
4329 .open = proc_APList_open,
4330 .release = proc_close
4333 static struct file_operations proc_config_ops = {
4335 .write = proc_write,
4336 .open = proc_config_open,
4337 .release = proc_close
4340 static struct file_operations proc_wepkey_ops = {
4342 .write = proc_write,
4343 .open = proc_wepkey_open,
4344 .release = proc_close
4347 static struct proc_dir_entry *airo_entry = 0;
4356 void (*on_close) (struct inode *, struct file *);
4360 #define SETPROC_OPS(entry, ops) (entry)->proc_fops = &(ops)
4363 static int setup_proc_entry( struct net_device *dev,
4364 struct airo_info *apriv ) {
4365 struct proc_dir_entry *entry;
4366 /* First setup the device directory */
4367 apriv->proc_entry = create_proc_entry(dev->name,
4370 apriv->proc_entry->uid = proc_uid;
4371 apriv->proc_entry->gid = proc_gid;
4372 apriv->proc_entry->owner = THIS_MODULE;
4374 /* Setup the StatsDelta */
4375 entry = create_proc_entry("StatsDelta",
4376 S_IFREG | (S_IRUGO&proc_perm),
4378 entry->uid = proc_uid;
4379 entry->gid = proc_gid;
4381 entry->owner = THIS_MODULE;
4382 SETPROC_OPS(entry, proc_statsdelta_ops);
4384 /* Setup the Stats */
4385 entry = create_proc_entry("Stats",
4386 S_IFREG | (S_IRUGO&proc_perm),
4388 entry->uid = proc_uid;
4389 entry->gid = proc_gid;
4391 entry->owner = THIS_MODULE;
4392 SETPROC_OPS(entry, proc_stats_ops);
4394 /* Setup the Status */
4395 entry = create_proc_entry("Status",
4396 S_IFREG | (S_IRUGO&proc_perm),
4398 entry->uid = proc_uid;
4399 entry->gid = proc_gid;
4401 entry->owner = THIS_MODULE;
4402 SETPROC_OPS(entry, proc_status_ops);
4404 /* Setup the Config */
4405 entry = create_proc_entry("Config",
4406 S_IFREG | proc_perm,
4408 entry->uid = proc_uid;
4409 entry->gid = proc_gid;
4411 entry->owner = THIS_MODULE;
4412 SETPROC_OPS(entry, proc_config_ops);
4414 /* Setup the SSID */
4415 entry = create_proc_entry("SSID",
4416 S_IFREG | proc_perm,
4418 entry->uid = proc_uid;
4419 entry->gid = proc_gid;
4421 entry->owner = THIS_MODULE;
4422 SETPROC_OPS(entry, proc_SSID_ops);
4424 /* Setup the APList */
4425 entry = create_proc_entry("APList",
4426 S_IFREG | proc_perm,
4428 entry->uid = proc_uid;
4429 entry->gid = proc_gid;
4431 entry->owner = THIS_MODULE;
4432 SETPROC_OPS(entry, proc_APList_ops);
4434 /* Setup the BSSList */
4435 entry = create_proc_entry("BSSList",
4436 S_IFREG | proc_perm,
4438 entry->uid = proc_uid;
4439 entry->gid = proc_gid;
4441 entry->owner = THIS_MODULE;
4442 SETPROC_OPS(entry, proc_BSSList_ops);
4444 /* Setup the WepKey */
4445 entry = create_proc_entry("WepKey",
4446 S_IFREG | proc_perm,
4448 entry->uid = proc_uid;
4449 entry->gid = proc_gid;
4451 entry->owner = THIS_MODULE;
4452 SETPROC_OPS(entry, proc_wepkey_ops);
4457 static int takedown_proc_entry( struct net_device *dev,
4458 struct airo_info *apriv ) {
4459 if ( !apriv->proc_entry->namelen ) return 0;
4460 remove_proc_entry("Stats",apriv->proc_entry);
4461 remove_proc_entry("StatsDelta",apriv->proc_entry);
4462 remove_proc_entry("Status",apriv->proc_entry);
4463 remove_proc_entry("Config",apriv->proc_entry);
4464 remove_proc_entry("SSID",apriv->proc_entry);
4465 remove_proc_entry("APList",apriv->proc_entry);
4466 remove_proc_entry("BSSList",apriv->proc_entry);
4467 remove_proc_entry("WepKey",apriv->proc_entry);
4468 remove_proc_entry(dev->name,airo_entry);
4473 * What we want from the proc_fs is to be able to efficiently read
4474 * and write the configuration. To do this, we want to read the
4475 * configuration when the file is opened and write it when the file is
4476 * closed. So basically we allocate a read buffer at open and fill it
4477 * with data, and allocate a write buffer and read it at close.
4481 * The read routine is generic, it relies on the preallocated rbuffer
4482 * to supply the data.
4484 static ssize_t proc_read( struct file *file,
4485 char __user *buffer,
4489 loff_t pos = *offset;
4490 struct proc_data *priv = (struct proc_data*)file->private_data;
4497 if (pos >= priv->readlen)
4499 if (len > priv->readlen - pos)
4500 len = priv->readlen - pos;
4501 if (copy_to_user(buffer, priv->rbuffer + pos, len))
4503 *offset = pos + len;
4508 * The write routine is generic, it fills in a preallocated rbuffer
4509 * to supply the data.
4511 static ssize_t proc_write( struct file *file,
4512 const char __user *buffer,
4516 loff_t pos = *offset;
4517 struct proc_data *priv = (struct proc_data*)file->private_data;
4524 if (pos >= priv->maxwritelen)
4526 if (len > priv->maxwritelen - pos)
4527 len = priv->maxwritelen - pos;
4528 if (copy_from_user(priv->wbuffer + pos, buffer, len))
4530 *offset = pos + len;
4534 static int proc_status_open( struct inode *inode, struct file *file ) {
4535 struct proc_data *data;
4536 struct proc_dir_entry *dp = PDE(inode);
4537 struct net_device *dev = dp->data;
4538 struct airo_info *apriv = dev->priv;
4539 CapabilityRid cap_rid;
4540 StatusRid status_rid;
4543 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4545 memset(file->private_data, 0, sizeof(struct proc_data));
4546 data = (struct proc_data *)file->private_data;
4547 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4548 kfree (file->private_data);
4552 readStatusRid(apriv, &status_rid, 1);
4553 readCapabilityRid(apriv, &cap_rid, 1);
4555 i = sprintf(data->rbuffer, "Status: %s%s%s%s%s%s%s%s%s\n",
4556 status_rid.mode & 1 ? "CFG ": "",
4557 status_rid.mode & 2 ? "ACT ": "",
4558 status_rid.mode & 0x10 ? "SYN ": "",
4559 status_rid.mode & 0x20 ? "LNK ": "",
4560 status_rid.mode & 0x40 ? "LEAP ": "",
4561 status_rid.mode & 0x80 ? "PRIV ": "",
4562 status_rid.mode & 0x100 ? "KEY ": "",
4563 status_rid.mode & 0x200 ? "WEP ": "",
4564 status_rid.mode & 0x8000 ? "ERR ": "");
4565 sprintf( data->rbuffer+i, "Mode: %x\n"
4566 "Signal Strength: %d\n"
4567 "Signal Quality: %d\n"
4572 "Driver Version: %s\n"
4573 "Device: %s\nManufacturer: %s\nFirmware Version: %s\n"
4574 "Radio type: %x\nCountry: %x\nHardware Version: %x\n"
4575 "Software Version: %x\nSoftware Subversion: %x\n"
4576 "Boot block version: %x\n",
4577 (int)status_rid.mode,
4578 (int)status_rid.normalizedSignalStrength,
4579 (int)status_rid.signalQuality,
4580 (int)status_rid.SSIDlen,
4583 (int)status_rid.channel,
4584 (int)status_rid.currentXmitRate/2,
4592 (int)cap_rid.softVer,
4593 (int)cap_rid.softSubVer,
4594 (int)cap_rid.bootBlockVer );
4595 data->readlen = strlen( data->rbuffer );
4599 static int proc_stats_rid_open(struct inode*, struct file*, u16);
4600 static int proc_statsdelta_open( struct inode *inode,
4601 struct file *file ) {
4602 if (file->f_mode&FMODE_WRITE) {
4603 return proc_stats_rid_open(inode, file, RID_STATSDELTACLEAR);
4605 return proc_stats_rid_open(inode, file, RID_STATSDELTA);
4608 static int proc_stats_open( struct inode *inode, struct file *file ) {
4609 return proc_stats_rid_open(inode, file, RID_STATS);
4612 static int proc_stats_rid_open( struct inode *inode,
4615 struct proc_data *data;
4616 struct proc_dir_entry *dp = PDE(inode);
4617 struct net_device *dev = dp->data;
4618 struct airo_info *apriv = dev->priv;
4621 u32 *vals = stats.vals;
4623 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4625 memset(file->private_data, 0, sizeof(struct proc_data));
4626 data = (struct proc_data *)file->private_data;
4627 if ((data->rbuffer = kmalloc( 4096, GFP_KERNEL )) == NULL) {
4628 kfree (file->private_data);
4632 readStatsRid(apriv, &stats, rid, 1);
4635 for(i=0; statsLabels[i]!=(char *)-1 &&
4636 i*4<stats.len; i++){
4637 if (!statsLabels[i]) continue;
4638 if (j+strlen(statsLabels[i])+16>4096) {
4640 "airo: Potentially disasterous buffer overflow averted!\n");
4643 j+=sprintf(data->rbuffer+j, "%s: %u\n", statsLabels[i], vals[i]);
4645 if (i*4>=stats.len){
4647 "airo: Got a short rid\n");
4653 static int get_dec_u16( char *buffer, int *start, int limit ) {
4656 for( value = 0; buffer[*start] >= '0' &&
4657 buffer[*start] <= '9' &&
4658 *start < limit; (*start)++ ) {
4661 value += buffer[*start] - '0';
4663 if ( !valid ) return -1;
4667 static int airo_config_commit(struct net_device *dev,
4668 struct iw_request_info *info, void *zwrq,
4671 static void proc_config_on_close( struct inode *inode, struct file *file ) {
4672 struct proc_data *data = file->private_data;
4673 struct proc_dir_entry *dp = PDE(inode);
4674 struct net_device *dev = dp->data;
4675 struct airo_info *ai = dev->priv;
4678 if ( !data->writelen ) return;
4680 readConfigRid(ai, 1);
4681 set_bit (FLAG_COMMIT, &ai->flags);
4683 line = data->wbuffer;
4685 /*** Mode processing */
4686 if ( !strncmp( line, "Mode: ", 6 ) ) {
4688 if ((ai->config.rmode & 0xff) >= RXMODE_RFMON)
4689 set_bit (FLAG_RESET, &ai->flags);
4690 ai->config.rmode &= 0xfe00;
4691 clear_bit (FLAG_802_11, &ai->flags);
4692 ai->config.opmode &= 0xFF00;
4693 ai->config.scanMode = SCANMODE_ACTIVE;
4694 if ( line[0] == 'a' ) {
4695 ai->config.opmode |= 0;
4697 ai->config.opmode |= 1;
4698 if ( line[0] == 'r' ) {
4699 ai->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
4700 ai->config.scanMode = SCANMODE_PASSIVE;
4701 set_bit (FLAG_802_11, &ai->flags);
4702 } else if ( line[0] == 'y' ) {
4703 ai->config.rmode |= RXMODE_RFMON_ANYBSS | RXMODE_DISABLE_802_3_HEADER;
4704 ai->config.scanMode = SCANMODE_PASSIVE;
4705 set_bit (FLAG_802_11, &ai->flags);
4706 } else if ( line[0] == 'l' )
4707 ai->config.rmode |= RXMODE_LANMON;
4709 set_bit (FLAG_COMMIT, &ai->flags);
4712 /*** Radio status */
4713 else if (!strncmp(line,"Radio: ", 7)) {
4715 if (!strncmp(line,"off",3)) {
4716 set_bit (FLAG_RADIO_OFF, &ai->flags);
4718 clear_bit (FLAG_RADIO_OFF, &ai->flags);
4721 /*** NodeName processing */
4722 else if ( !strncmp( line, "NodeName: ", 10 ) ) {
4726 memset( ai->config.nodeName, 0, 16 );
4727 /* Do the name, assume a space between the mode and node name */
4728 for( j = 0; j < 16 && line[j] != '\n'; j++ ) {
4729 ai->config.nodeName[j] = line[j];
4731 set_bit (FLAG_COMMIT, &ai->flags);
4734 /*** PowerMode processing */
4735 else if ( !strncmp( line, "PowerMode: ", 11 ) ) {
4737 if ( !strncmp( line, "PSPCAM", 6 ) ) {
4738 ai->config.powerSaveMode = POWERSAVE_PSPCAM;
4739 set_bit (FLAG_COMMIT, &ai->flags);
4740 } else if ( !strncmp( line, "PSP", 3 ) ) {
4741 ai->config.powerSaveMode = POWERSAVE_PSP;
4742 set_bit (FLAG_COMMIT, &ai->flags);
4744 ai->config.powerSaveMode = POWERSAVE_CAM;
4745 set_bit (FLAG_COMMIT, &ai->flags);
4747 } else if ( !strncmp( line, "DataRates: ", 11 ) ) {
4748 int v, i = 0, k = 0; /* i is index into line,
4749 k is index to rates */
4752 while((v = get_dec_u16(line, &i, 3))!=-1) {
4753 ai->config.rates[k++] = (u8)v;
4757 set_bit (FLAG_COMMIT, &ai->flags);
4758 } else if ( !strncmp( line, "Channel: ", 9 ) ) {
4761 v = get_dec_u16(line, &i, i+3);
4763 ai->config.channelSet = (u16)v;
4764 set_bit (FLAG_COMMIT, &ai->flags);
4766 } else if ( !strncmp( line, "XmitPower: ", 11 ) ) {
4769 v = get_dec_u16(line, &i, i+3);
4771 ai->config.txPower = (u16)v;
4772 set_bit (FLAG_COMMIT, &ai->flags);
4774 } else if ( !strncmp( line, "WEP: ", 5 ) ) {
4778 ai->config.authType = (u16)AUTH_SHAREDKEY;
4781 ai->config.authType = (u16)AUTH_ENCRYPT;
4784 ai->config.authType = (u16)AUTH_OPEN;
4787 set_bit (FLAG_COMMIT, &ai->flags);
4788 } else if ( !strncmp( line, "LongRetryLimit: ", 16 ) ) {
4792 v = get_dec_u16(line, &i, 3);
4793 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4794 ai->config.longRetryLimit = (u16)v;
4795 set_bit (FLAG_COMMIT, &ai->flags);
4796 } else if ( !strncmp( line, "ShortRetryLimit: ", 17 ) ) {
4800 v = get_dec_u16(line, &i, 3);
4801 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4802 ai->config.shortRetryLimit = (u16)v;
4803 set_bit (FLAG_COMMIT, &ai->flags);
4804 } else if ( !strncmp( line, "RTSThreshold: ", 14 ) ) {
4808 v = get_dec_u16(line, &i, 4);
4809 v = (v<0) ? 0 : ((v>2312) ? 2312 : v);
4810 ai->config.rtsThres = (u16)v;
4811 set_bit (FLAG_COMMIT, &ai->flags);
4812 } else if ( !strncmp( line, "TXMSDULifetime: ", 16 ) ) {
4816 v = get_dec_u16(line, &i, 5);
4818 ai->config.txLifetime = (u16)v;
4819 set_bit (FLAG_COMMIT, &ai->flags);
4820 } else if ( !strncmp( line, "RXMSDULifetime: ", 16 ) ) {
4824 v = get_dec_u16(line, &i, 5);
4826 ai->config.rxLifetime = (u16)v;
4827 set_bit (FLAG_COMMIT, &ai->flags);
4828 } else if ( !strncmp( line, "TXDiversity: ", 13 ) ) {
4829 ai->config.txDiversity =
4830 (line[13]=='l') ? 1 :
4831 ((line[13]=='r')? 2: 3);
4832 set_bit (FLAG_COMMIT, &ai->flags);
4833 } else if ( !strncmp( line, "RXDiversity: ", 13 ) ) {
4834 ai->config.rxDiversity =
4835 (line[13]=='l') ? 1 :
4836 ((line[13]=='r')? 2: 3);
4837 set_bit (FLAG_COMMIT, &ai->flags);
4838 } else if ( !strncmp( line, "FragThreshold: ", 15 ) ) {
4842 v = get_dec_u16(line, &i, 4);
4843 v = (v<256) ? 256 : ((v>2312) ? 2312 : v);
4844 v = v & 0xfffe; /* Make sure its even */
4845 ai->config.fragThresh = (u16)v;
4846 set_bit (FLAG_COMMIT, &ai->flags);
4847 } else if (!strncmp(line, "Modulation: ", 12)) {
4850 case 'd': ai->config.modulation=MOD_DEFAULT; set_bit(FLAG_COMMIT, &ai->flags); break;
4851 case 'c': ai->config.modulation=MOD_CCK; set_bit(FLAG_COMMIT, &ai->flags); break;
4852 case 'm': ai->config.modulation=MOD_MOK; set_bit(FLAG_COMMIT, &ai->flags); break;
4854 printk( KERN_WARNING "airo: Unknown modulation\n" );
4856 } else if (!strncmp(line, "Preamble: ", 10)) {
4859 case 'a': ai->config.preamble=PREAMBLE_AUTO; set_bit(FLAG_COMMIT, &ai->flags); break;
4860 case 'l': ai->config.preamble=PREAMBLE_LONG; set_bit(FLAG_COMMIT, &ai->flags); break;
4861 case 's': ai->config.preamble=PREAMBLE_SHORT; set_bit(FLAG_COMMIT, &ai->flags); break;
4862 default: printk(KERN_WARNING "airo: Unknown preamble\n");
4865 printk( KERN_WARNING "Couldn't figure out %s\n", line );
4867 while( line[0] && line[0] != '\n' ) line++;
4868 if ( line[0] ) line++;
4870 airo_config_commit(dev, NULL, NULL, NULL);
4873 static char *get_rmode(u16 mode) {
4875 case RXMODE_RFMON: return "rfmon";
4876 case RXMODE_RFMON_ANYBSS: return "yna (any) bss rfmon";
4877 case RXMODE_LANMON: return "lanmon";
4882 static int proc_config_open( struct inode *inode, struct file *file ) {
4883 struct proc_data *data;
4884 struct proc_dir_entry *dp = PDE(inode);
4885 struct net_device *dev = dp->data;
4886 struct airo_info *ai = dev->priv;
4889 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4891 memset(file->private_data, 0, sizeof(struct proc_data));
4892 data = (struct proc_data *)file->private_data;
4893 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4894 kfree (file->private_data);
4897 if ((data->wbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4898 kfree (data->rbuffer);
4899 kfree (file->private_data);
4902 memset( data->wbuffer, 0, 2048 );
4903 data->maxwritelen = 2048;
4904 data->on_close = proc_config_on_close;
4906 readConfigRid(ai, 1);
4908 i = sprintf( data->rbuffer,
4913 "DataRates: %d %d %d %d %d %d %d %d\n"
4916 (ai->config.opmode & 0xFF) == 0 ? "adhoc" :
4917 (ai->config.opmode & 0xFF) == 1 ? get_rmode(ai->config.rmode):
4918 (ai->config.opmode & 0xFF) == 2 ? "AP" :
4919 (ai->config.opmode & 0xFF) == 3 ? "AP RPTR" : "Error",
4920 test_bit(FLAG_RADIO_OFF, &ai->flags) ? "off" : "on",
4921 ai->config.nodeName,
4922 ai->config.powerSaveMode == 0 ? "CAM" :
4923 ai->config.powerSaveMode == 1 ? "PSP" :
4924 ai->config.powerSaveMode == 2 ? "PSPCAM" : "Error",
4925 (int)ai->config.rates[0],
4926 (int)ai->config.rates[1],
4927 (int)ai->config.rates[2],
4928 (int)ai->config.rates[3],
4929 (int)ai->config.rates[4],
4930 (int)ai->config.rates[5],
4931 (int)ai->config.rates[6],
4932 (int)ai->config.rates[7],
4933 (int)ai->config.channelSet,
4934 (int)ai->config.txPower
4936 sprintf( data->rbuffer + i,
4937 "LongRetryLimit: %d\n"
4938 "ShortRetryLimit: %d\n"
4939 "RTSThreshold: %d\n"
4940 "TXMSDULifetime: %d\n"
4941 "RXMSDULifetime: %d\n"
4944 "FragThreshold: %d\n"
4948 (int)ai->config.longRetryLimit,
4949 (int)ai->config.shortRetryLimit,
4950 (int)ai->config.rtsThres,
4951 (int)ai->config.txLifetime,
4952 (int)ai->config.rxLifetime,
4953 ai->config.txDiversity == 1 ? "left" :
4954 ai->config.txDiversity == 2 ? "right" : "both",
4955 ai->config.rxDiversity == 1 ? "left" :
4956 ai->config.rxDiversity == 2 ? "right" : "both",
4957 (int)ai->config.fragThresh,
4958 ai->config.authType == AUTH_ENCRYPT ? "encrypt" :
4959 ai->config.authType == AUTH_SHAREDKEY ? "shared" : "open",
4960 ai->config.modulation == 0 ? "default" :
4961 ai->config.modulation == MOD_CCK ? "cck" :
4962 ai->config.modulation == MOD_MOK ? "mok" : "error",
4963 ai->config.preamble == PREAMBLE_AUTO ? "auto" :
4964 ai->config.preamble == PREAMBLE_LONG ? "long" :
4965 ai->config.preamble == PREAMBLE_SHORT ? "short" : "error"
4967 data->readlen = strlen( data->rbuffer );
4971 static void proc_SSID_on_close( struct inode *inode, struct file *file ) {
4972 struct proc_data *data = (struct proc_data *)file->private_data;
4973 struct proc_dir_entry *dp = PDE(inode);
4974 struct net_device *dev = dp->data;
4975 struct airo_info *ai = dev->priv;
4981 if ( !data->writelen ) return;
4983 memset( &SSID_rid, 0, sizeof( SSID_rid ) );
4985 for( i = 0; i < 3; i++ ) {
4987 for( j = 0; j+offset < data->writelen && j < 32 &&
4988 data->wbuffer[offset+j] != '\n'; j++ ) {
4989 SSID_rid.ssids[i].ssid[j] = data->wbuffer[offset+j];
4991 if ( j == 0 ) break;
4992 SSID_rid.ssids[i].len = j;
4994 while( data->wbuffer[offset] != '\n' &&
4995 offset < data->writelen ) offset++;
4999 SSID_rid.len = sizeof(SSID_rid);
5001 writeSsidRid(ai, &SSID_rid, 1);
5002 enable_MAC(ai, &rsp, 1);
5005 inline static u8 hexVal(char c) {
5006 if (c>='0' && c<='9') return c -= '0';
5007 if (c>='a' && c<='f') return c -= 'a'-10;
5008 if (c>='A' && c<='F') return c -= 'A'-10;
5012 static void proc_APList_on_close( struct inode *inode, struct file *file ) {
5013 struct proc_data *data = (struct proc_data *)file->private_data;
5014 struct proc_dir_entry *dp = PDE(inode);
5015 struct net_device *dev = dp->data;
5016 struct airo_info *ai = dev->priv;
5017 APListRid APList_rid;
5021 if ( !data->writelen ) return;
5023 memset( &APList_rid, 0, sizeof(APList_rid) );
5024 APList_rid.len = sizeof(APList_rid);
5026 for( i = 0; i < 4 && data->writelen >= (i+1)*6*3; i++ ) {
5028 for( j = 0; j < 6*3 && data->wbuffer[j+i*6*3]; j++ ) {
5031 APList_rid.ap[i][j/3]=
5032 hexVal(data->wbuffer[j+i*6*3])<<4;
5035 APList_rid.ap[i][j/3]|=
5036 hexVal(data->wbuffer[j+i*6*3]);
5042 writeAPListRid(ai, &APList_rid, 1);
5043 enable_MAC(ai, &rsp, 1);
5046 /* This function wraps PC4500_writerid with a MAC disable */
5047 static int do_writerid( struct airo_info *ai, u16 rid, const void *rid_data,
5048 int len, int dummy ) {
5053 rc = PC4500_writerid(ai, rid, rid_data, len, 1);
5054 enable_MAC(ai, &rsp, 1);
5058 /* Returns the length of the key at the index. If index == 0xffff
5059 * the index of the transmit key is returned. If the key doesn't exist,
5060 * -1 will be returned.
5062 static int get_wep_key(struct airo_info *ai, u16 index) {
5067 rc = readWepKeyRid(ai, &wkr, 1, 1);
5068 if (rc == SUCCESS) do {
5069 lastindex = wkr.kindex;
5070 if (wkr.kindex == index) {
5071 if (index == 0xffff) {
5076 readWepKeyRid(ai, &wkr, 0, 1);
5077 } while(lastindex != wkr.kindex);
5081 static int set_wep_key(struct airo_info *ai, u16 index,
5082 const char *key, u16 keylen, int perm, int lock ) {
5083 static const unsigned char macaddr[ETH_ALEN] = { 0x01, 0, 0, 0, 0, 0 };
5087 memset(&wkr, 0, sizeof(wkr));
5089 // We are selecting which key to use
5090 wkr.len = sizeof(wkr);
5091 wkr.kindex = 0xffff;
5092 wkr.mac[0] = (char)index;
5093 if (perm) printk(KERN_INFO "Setting transmit key to %d\n", index);
5094 if (perm) ai->defindex = (char)index;
5096 // We are actually setting the key
5097 wkr.len = sizeof(wkr);
5100 memcpy( wkr.key, key, keylen );
5101 memcpy( wkr.mac, macaddr, ETH_ALEN );
5102 printk(KERN_INFO "Setting key %d\n", index);
5105 disable_MAC(ai, lock);
5106 writeWepKeyRid(ai, &wkr, perm, lock);
5107 enable_MAC(ai, &rsp, lock);
5111 static void proc_wepkey_on_close( struct inode *inode, struct file *file ) {
5112 struct proc_data *data;
5113 struct proc_dir_entry *dp = PDE(inode);
5114 struct net_device *dev = dp->data;
5115 struct airo_info *ai = dev->priv;
5121 memset(key, 0, sizeof(key));
5123 data = (struct proc_data *)file->private_data;
5124 if ( !data->writelen ) return;
5126 if (data->wbuffer[0] >= '0' && data->wbuffer[0] <= '3' &&
5127 (data->wbuffer[1] == ' ' || data->wbuffer[1] == '\n')) {
5128 index = data->wbuffer[0] - '0';
5129 if (data->wbuffer[1] == '\n') {
5130 set_wep_key(ai, index, 0, 0, 1, 1);
5135 printk(KERN_ERR "airo: WepKey passed invalid key index\n");
5139 for( i = 0; i < 16*3 && data->wbuffer[i+j]; i++ ) {
5142 key[i/3] = hexVal(data->wbuffer[i+j])<<4;
5145 key[i/3] |= hexVal(data->wbuffer[i+j]);
5149 set_wep_key(ai, index, key, i/3, 1, 1);
5152 static int proc_wepkey_open( struct inode *inode, struct file *file ) {
5153 struct proc_data *data;
5154 struct proc_dir_entry *dp = PDE(inode);
5155 struct net_device *dev = dp->data;
5156 struct airo_info *ai = dev->priv;
5163 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5165 memset(file->private_data, 0, sizeof(struct proc_data));
5166 memset(&wkr, 0, sizeof(wkr));
5167 data = (struct proc_data *)file->private_data;
5168 if ((data->rbuffer = kmalloc( 180, GFP_KERNEL )) == NULL) {
5169 kfree (file->private_data);
5172 memset(data->rbuffer, 0, 180);
5174 data->maxwritelen = 80;
5175 if ((data->wbuffer = kmalloc( 80, GFP_KERNEL )) == NULL) {
5176 kfree (data->rbuffer);
5177 kfree (file->private_data);
5180 memset( data->wbuffer, 0, 80 );
5181 data->on_close = proc_wepkey_on_close;
5183 ptr = data->rbuffer;
5184 strcpy(ptr, "No wep keys\n");
5185 rc = readWepKeyRid(ai, &wkr, 1, 1);
5186 if (rc == SUCCESS) do {
5187 lastindex = wkr.kindex;
5188 if (wkr.kindex == 0xffff) {
5189 j += sprintf(ptr+j, "Tx key = %d\n",
5192 j += sprintf(ptr+j, "Key %d set with length = %d\n",
5193 (int)wkr.kindex, (int)wkr.klen);
5195 readWepKeyRid(ai, &wkr, 0, 1);
5196 } while((lastindex != wkr.kindex) && (j < 180-30));
5198 data->readlen = strlen( data->rbuffer );
5202 static int proc_SSID_open( struct inode *inode, struct file *file ) {
5203 struct proc_data *data;
5204 struct proc_dir_entry *dp = PDE(inode);
5205 struct net_device *dev = dp->data;
5206 struct airo_info *ai = dev->priv;
5211 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5213 memset(file->private_data, 0, sizeof(struct proc_data));
5214 data = (struct proc_data *)file->private_data;
5215 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5216 kfree (file->private_data);
5220 data->maxwritelen = 33*3;
5221 if ((data->wbuffer = kmalloc( 33*3, GFP_KERNEL )) == NULL) {
5222 kfree (data->rbuffer);
5223 kfree (file->private_data);
5226 memset( data->wbuffer, 0, 33*3 );
5227 data->on_close = proc_SSID_on_close;
5229 readSsidRid(ai, &SSID_rid);
5230 ptr = data->rbuffer;
5231 for( i = 0; i < 3; i++ ) {
5233 if ( !SSID_rid.ssids[i].len ) break;
5234 for( j = 0; j < 32 &&
5235 j < SSID_rid.ssids[i].len &&
5236 SSID_rid.ssids[i].ssid[j]; j++ ) {
5237 *ptr++ = SSID_rid.ssids[i].ssid[j];
5242 data->readlen = strlen( data->rbuffer );
5246 static int proc_APList_open( struct inode *inode, struct file *file ) {
5247 struct proc_data *data;
5248 struct proc_dir_entry *dp = PDE(inode);
5249 struct net_device *dev = dp->data;
5250 struct airo_info *ai = dev->priv;
5253 APListRid APList_rid;
5255 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5257 memset(file->private_data, 0, sizeof(struct proc_data));
5258 data = (struct proc_data *)file->private_data;
5259 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5260 kfree (file->private_data);
5264 data->maxwritelen = 4*6*3;
5265 if ((data->wbuffer = kmalloc( data->maxwritelen, GFP_KERNEL )) == NULL) {
5266 kfree (data->rbuffer);
5267 kfree (file->private_data);
5270 memset( data->wbuffer, 0, data->maxwritelen );
5271 data->on_close = proc_APList_on_close;
5273 readAPListRid(ai, &APList_rid);
5274 ptr = data->rbuffer;
5275 for( i = 0; i < 4; i++ ) {
5276 // We end when we find a zero MAC
5277 if ( !*(int*)APList_rid.ap[i] &&
5278 !*(int*)&APList_rid.ap[i][2]) break;
5279 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x\n",
5280 (int)APList_rid.ap[i][0],
5281 (int)APList_rid.ap[i][1],
5282 (int)APList_rid.ap[i][2],
5283 (int)APList_rid.ap[i][3],
5284 (int)APList_rid.ap[i][4],
5285 (int)APList_rid.ap[i][5]);
5287 if (i==0) ptr += sprintf(ptr, "Not using specific APs\n");
5290 data->readlen = strlen( data->rbuffer );
5294 static int proc_BSSList_open( struct inode *inode, struct file *file ) {
5295 struct proc_data *data;
5296 struct proc_dir_entry *dp = PDE(inode);
5297 struct net_device *dev = dp->data;
5298 struct airo_info *ai = dev->priv;
5300 BSSListRid BSSList_rid;
5302 /* If doLoseSync is not 1, we won't do a Lose Sync */
5303 int doLoseSync = -1;
5305 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5307 memset(file->private_data, 0, sizeof(struct proc_data));
5308 data = (struct proc_data *)file->private_data;
5309 if ((data->rbuffer = kmalloc( 1024, GFP_KERNEL )) == NULL) {
5310 kfree (file->private_data);
5314 data->maxwritelen = 0;
5318 if (file->f_mode & FMODE_WRITE) {
5319 if (!(file->f_mode & FMODE_READ)) {
5323 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
5324 memset(&cmd, 0, sizeof(cmd));
5325 cmd.cmd=CMD_LISTBSS;
5326 if (down_interruptible(&ai->sem))
5327 return -ERESTARTSYS;
5328 issuecommand(ai, &cmd, &rsp);
5335 ptr = data->rbuffer;
5336 /* There is a race condition here if there are concurrent opens.
5337 Since it is a rare condition, we'll just live with it, otherwise
5338 we have to add a spin lock... */
5339 rc = readBSSListRid(ai, doLoseSync, &BSSList_rid);
5340 while(rc == 0 && BSSList_rid.index != 0xffff) {
5341 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x %*s rssi = %d",
5342 (int)BSSList_rid.bssid[0],
5343 (int)BSSList_rid.bssid[1],
5344 (int)BSSList_rid.bssid[2],
5345 (int)BSSList_rid.bssid[3],
5346 (int)BSSList_rid.bssid[4],
5347 (int)BSSList_rid.bssid[5],
5348 (int)BSSList_rid.ssidLen,
5350 (int)BSSList_rid.rssi);
5351 ptr += sprintf(ptr, " channel = %d %s %s %s %s\n",
5352 (int)BSSList_rid.dsChannel,
5353 BSSList_rid.cap & CAP_ESS ? "ESS" : "",
5354 BSSList_rid.cap & CAP_IBSS ? "adhoc" : "",
5355 BSSList_rid.cap & CAP_PRIVACY ? "wep" : "",
5356 BSSList_rid.cap & CAP_SHORTHDR ? "shorthdr" : "");
5357 rc = readBSSListRid(ai, 0, &BSSList_rid);
5360 data->readlen = strlen( data->rbuffer );
5364 static int proc_close( struct inode *inode, struct file *file )
5366 struct proc_data *data = (struct proc_data *)file->private_data;
5367 if ( data->on_close != NULL ) data->on_close( inode, file );
5368 if ( data->rbuffer ) kfree( data->rbuffer );
5369 if ( data->wbuffer ) kfree( data->wbuffer );
5374 static struct net_device_list {
5375 struct net_device *dev;
5376 struct net_device_list *next;
5377 } *airo_devices = 0;
5379 /* Since the card doesn't automatically switch to the right WEP mode,
5380 we will make it do it. If the card isn't associated, every secs we
5381 will switch WEP modes to see if that will help. If the card is
5382 associated we will check every minute to see if anything has
5384 static void timer_func( struct net_device *dev ) {
5385 struct airo_info *apriv = dev->priv;
5388 /* We don't have a link so try changing the authtype */
5389 readConfigRid(apriv, 0);
5390 disable_MAC(apriv, 0);
5391 switch(apriv->config.authType) {
5393 /* So drop to OPEN */
5394 apriv->config.authType = AUTH_OPEN;
5396 case AUTH_SHAREDKEY:
5397 if (apriv->keyindex < auto_wep) {
5398 set_wep_key(apriv, apriv->keyindex, 0, 0, 0, 0);
5399 apriv->config.authType = AUTH_SHAREDKEY;
5402 /* Drop to ENCRYPT */
5403 apriv->keyindex = 0;
5404 set_wep_key(apriv, apriv->defindex, 0, 0, 0, 0);
5405 apriv->config.authType = AUTH_ENCRYPT;
5408 default: /* We'll escalate to SHAREDKEY */
5409 apriv->config.authType = AUTH_SHAREDKEY;
5411 set_bit (FLAG_COMMIT, &apriv->flags);
5412 writeConfigRid(apriv, 0);
5413 enable_MAC(apriv, &rsp, 0);
5416 /* Schedule check to see if the change worked */
5417 clear_bit(JOB_AUTOWEP, &apriv->flags);
5418 apriv->expires = RUN_AT(HZ*3);
5421 static int add_airo_dev( struct net_device *dev ) {
5422 struct net_device_list *node = kmalloc( sizeof( *node ), GFP_KERNEL );
5427 node->next = airo_devices;
5428 airo_devices = node;
5433 static void del_airo_dev( struct net_device *dev ) {
5434 struct net_device_list **p = &airo_devices;
5435 while( *p && ( (*p)->dev != dev ) )
5437 if ( *p && (*p)->dev == dev )
5442 static int __devinit airo_pci_probe(struct pci_dev *pdev,
5443 const struct pci_device_id *pent)
5445 struct net_device *dev;
5447 if (pci_enable_device(pdev))
5449 pci_set_master(pdev);
5451 if (pdev->device == 0x5000 || pdev->device == 0xa504)
5452 dev = _init_airo_card(pdev->irq, pdev->resource[0].start, 0, pdev);
5454 dev = _init_airo_card(pdev->irq, pdev->resource[2].start, 0, pdev);
5458 pci_set_drvdata(pdev, dev);
5462 static void __devexit airo_pci_remove(struct pci_dev *pdev)
5466 static int airo_pci_suspend(struct pci_dev *pdev, u32 state)
5468 struct net_device *dev = pci_get_drvdata(pdev);
5469 struct airo_info *ai = dev->priv;
5473 printk(KERN_DEBUG "%s: airo_mpi entering sleep mode (state=%d)\n",
5476 if ((ai->APList == NULL) &&
5477 (ai->APList = kmalloc(sizeof(APListRid), GFP_KERNEL)) == NULL)
5479 if ((ai->SSID == NULL) &&
5480 (ai->SSID = kmalloc(sizeof(SsidRid), GFP_KERNEL)) == NULL)
5482 readAPListRid(ai, ai->APList);
5483 readSsidRid(ai, ai->SSID);
5484 memset(&cmd, 0, sizeof(cmd));
5485 /* the lock will be released at the end of the resume callback */
5486 if (down_interruptible(&ai->sem))
5489 netif_device_detach(dev);
5492 issuecommand(ai, &cmd, &rsp);
5496 static int airo_pci_resume(struct pci_dev *pdev)
5498 struct net_device *dev = pci_get_drvdata(pdev);
5499 struct airo_info *ai = dev->priv;
5502 printk(KERN_DEBUG "%s: airo_mpi waking up\n", dev->name);
5507 if (ai->power > 1) {
5508 mpi_init_descriptors(ai);
5509 setup_card(ai, dev->dev_addr, 0);
5510 clear_bit(FLAG_RADIO_OFF, &ai->flags);
5511 clear_bit(FLAG_RADIO_DOWN, &ai->flags);
5512 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
5514 OUT4500(ai, EVACK, EV_AWAKEN);
5515 OUT4500(ai, EVACK, EV_AWAKEN);
5516 schedule_timeout(HZ/10);
5519 set_bit (FLAG_COMMIT, &ai->flags);
5521 schedule_timeout (HZ/5);
5523 writeSsidRid(ai, ai->SSID, 0);
5528 writeAPListRid(ai, ai->APList, 0);
5532 writeConfigRid(ai, 0);
5533 enable_MAC(ai, &rsp, 0);
5535 netif_device_attach(dev);
5536 netif_wake_queue(dev);
5537 enable_interrupts(ai);
5543 static int __init airo_init_module( void )
5545 int i, have_isa_dev = 0;
5547 airo_entry = create_proc_entry("aironet",
5548 S_IFDIR | airo_perm,
5550 airo_entry->uid = proc_uid;
5551 airo_entry->gid = proc_gid;
5553 for( i = 0; i < 4 && io[i] && irq[i]; i++ ) {
5555 "airo: Trying to configure ISA adapter at irq=%d io=0x%x\n",
5557 if (init_airo_card( irq[i], io[i], 0 ))
5562 printk( KERN_INFO "airo: Probing for PCI adapters\n" );
5563 pci_register_driver(&airo_driver);
5564 printk( KERN_INFO "airo: Finished probing for PCI adapters\n" );
5567 /* Always exit with success, as we are a library module
5568 * as well as a driver module
5573 static void __exit airo_cleanup_module( void )
5575 while( airo_devices ) {
5576 printk( KERN_INFO "airo: Unregistering %s\n", airo_devices->dev->name );
5577 stop_airo_card( airo_devices->dev, 1 );
5580 pci_unregister_driver(&airo_driver);
5582 remove_proc_entry("aironet", proc_root_driver);
5587 * Initial Wireless Extension code for Aironet driver by :
5588 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 17 November 00
5589 * Conversion to new driver API by :
5590 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 26 March 02
5591 * Javier also did a good amount of work here, adding some new extensions
5592 * and fixing my code. Let's just say that without him this code just
5593 * would not work at all... - Jean II
5596 /*------------------------------------------------------------------*/
5598 * Wireless Handler : get protocol name
5600 static int airo_get_name(struct net_device *dev,
5601 struct iw_request_info *info,
5605 strcpy(cwrq, "IEEE 802.11-DS");
5609 /*------------------------------------------------------------------*/
5611 * Wireless Handler : set frequency
5613 static int airo_set_freq(struct net_device *dev,
5614 struct iw_request_info *info,
5615 struct iw_freq *fwrq,
5618 struct airo_info *local = dev->priv;
5619 int rc = -EINPROGRESS; /* Call commit handler */
5621 /* If setting by frequency, convert to a channel */
5622 if((fwrq->e == 1) &&
5623 (fwrq->m >= (int) 2.412e8) &&
5624 (fwrq->m <= (int) 2.487e8)) {
5625 int f = fwrq->m / 100000;
5627 while((c < 14) && (f != frequency_list[c]))
5629 /* Hack to fall through... */
5633 /* Setting by channel number */
5634 if((fwrq->m > 1000) || (fwrq->e > 0))
5637 int channel = fwrq->m;
5638 /* We should do a better check than that,
5639 * based on the card capability !!! */
5640 if((channel < 1) || (channel > 16)) {
5641 printk(KERN_DEBUG "%s: New channel value of %d is invalid!\n", dev->name, fwrq->m);
5644 readConfigRid(local, 1);
5645 /* Yes ! We can set it !!! */
5646 local->config.channelSet = (u16)(channel - 1);
5647 set_bit (FLAG_COMMIT, &local->flags);
5653 /*------------------------------------------------------------------*/
5655 * Wireless Handler : get frequency
5657 static int airo_get_freq(struct net_device *dev,
5658 struct iw_request_info *info,
5659 struct iw_freq *fwrq,
5662 struct airo_info *local = dev->priv;
5663 StatusRid status_rid; /* Card status info */
5665 readConfigRid(local, 1);
5666 if ((local->config.opmode & 0xFF) == MODE_STA_ESS)
5667 status_rid.channel = local->config.channelSet;
5669 readStatusRid(local, &status_rid, 1);
5671 #ifdef WEXT_USECHANNELS
5672 fwrq->m = ((int)status_rid.channel) + 1;
5676 int f = (int)status_rid.channel;
5677 fwrq->m = frequency_list[f] * 100000;
5685 /*------------------------------------------------------------------*/
5687 * Wireless Handler : set ESSID
5689 static int airo_set_essid(struct net_device *dev,
5690 struct iw_request_info *info,
5691 struct iw_point *dwrq,
5694 struct airo_info *local = dev->priv;
5696 SsidRid SSID_rid; /* SSIDs */
5698 /* Reload the list of current SSID */
5699 readSsidRid(local, &SSID_rid);
5701 /* Check if we asked for `any' */
5702 if(dwrq->flags == 0) {
5703 /* Just send an empty SSID list */
5704 memset(&SSID_rid, 0, sizeof(SSID_rid));
5706 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
5708 /* Check the size of the string */
5709 if(dwrq->length > IW_ESSID_MAX_SIZE+1) {
5712 /* Check if index is valid */
5713 if((index < 0) || (index >= 4)) {
5718 memset(SSID_rid.ssids[index].ssid, 0,
5719 sizeof(SSID_rid.ssids[index].ssid));
5720 memcpy(SSID_rid.ssids[index].ssid, extra, dwrq->length);
5721 SSID_rid.ssids[index].len = dwrq->length - 1;
5723 SSID_rid.len = sizeof(SSID_rid);
5724 /* Write it to the card */
5725 disable_MAC(local, 1);
5726 writeSsidRid(local, &SSID_rid, 1);
5727 enable_MAC(local, &rsp, 1);
5732 /*------------------------------------------------------------------*/
5734 * Wireless Handler : get ESSID
5736 static int airo_get_essid(struct net_device *dev,
5737 struct iw_request_info *info,
5738 struct iw_point *dwrq,
5741 struct airo_info *local = dev->priv;
5742 StatusRid status_rid; /* Card status info */
5744 readStatusRid(local, &status_rid, 1);
5746 /* Note : if dwrq->flags != 0, we should
5747 * get the relevant SSID from the SSID list... */
5749 /* Get the current SSID */
5750 memcpy(extra, status_rid.SSID, status_rid.SSIDlen);
5751 extra[status_rid.SSIDlen] = '\0';
5752 /* If none, we may want to get the one that was set */
5755 dwrq->length = status_rid.SSIDlen + 1;
5756 dwrq->flags = 1; /* active */
5761 /*------------------------------------------------------------------*/
5763 * Wireless Handler : set AP address
5765 static int airo_set_wap(struct net_device *dev,
5766 struct iw_request_info *info,
5767 struct sockaddr *awrq,
5770 struct airo_info *local = dev->priv;
5773 APListRid APList_rid;
5774 static const unsigned char bcast[ETH_ALEN] = { 255, 255, 255, 255, 255, 255 };
5776 if (awrq->sa_family != ARPHRD_ETHER)
5778 else if (!memcmp(bcast, awrq->sa_data, ETH_ALEN)) {
5779 memset(&cmd, 0, sizeof(cmd));
5780 cmd.cmd=CMD_LOSE_SYNC;
5781 if (down_interruptible(&local->sem))
5782 return -ERESTARTSYS;
5783 issuecommand(local, &cmd, &rsp);
5786 memset(&APList_rid, 0, sizeof(APList_rid));
5787 APList_rid.len = sizeof(APList_rid);
5788 memcpy(APList_rid.ap[0], awrq->sa_data, ETH_ALEN);
5789 disable_MAC(local, 1);
5790 writeAPListRid(local, &APList_rid, 1);
5791 enable_MAC(local, &rsp, 1);
5796 /*------------------------------------------------------------------*/
5798 * Wireless Handler : get AP address
5800 static int airo_get_wap(struct net_device *dev,
5801 struct iw_request_info *info,
5802 struct sockaddr *awrq,
5805 struct airo_info *local = dev->priv;
5806 StatusRid status_rid; /* Card status info */
5808 readStatusRid(local, &status_rid, 1);
5810 /* Tentative. This seems to work, wow, I'm lucky !!! */
5811 memcpy(awrq->sa_data, status_rid.bssid[0], ETH_ALEN);
5812 awrq->sa_family = ARPHRD_ETHER;
5817 /*------------------------------------------------------------------*/
5819 * Wireless Handler : set Nickname
5821 static int airo_set_nick(struct net_device *dev,
5822 struct iw_request_info *info,
5823 struct iw_point *dwrq,
5826 struct airo_info *local = dev->priv;
5828 /* Check the size of the string */
5829 if(dwrq->length > 16 + 1) {
5832 readConfigRid(local, 1);
5833 memset(local->config.nodeName, 0, sizeof(local->config.nodeName));
5834 memcpy(local->config.nodeName, extra, dwrq->length);
5835 set_bit (FLAG_COMMIT, &local->flags);
5837 return -EINPROGRESS; /* Call commit handler */
5840 /*------------------------------------------------------------------*/
5842 * Wireless Handler : get Nickname
5844 static int airo_get_nick(struct net_device *dev,
5845 struct iw_request_info *info,
5846 struct iw_point *dwrq,
5849 struct airo_info *local = dev->priv;
5851 readConfigRid(local, 1);
5852 strncpy(extra, local->config.nodeName, 16);
5854 dwrq->length = strlen(extra) + 1;
5859 /*------------------------------------------------------------------*/
5861 * Wireless Handler : set Bit-Rate
5863 static int airo_set_rate(struct net_device *dev,
5864 struct iw_request_info *info,
5865 struct iw_param *vwrq,
5868 struct airo_info *local = dev->priv;
5869 CapabilityRid cap_rid; /* Card capability info */
5873 /* First : get a valid bit rate value */
5874 readCapabilityRid(local, &cap_rid, 1);
5876 /* Which type of value ? */
5877 if((vwrq->value < 8) && (vwrq->value >= 0)) {
5878 /* Setting by rate index */
5879 /* Find value in the magic rate table */
5880 brate = cap_rid.supportedRates[vwrq->value];
5882 /* Setting by frequency value */
5883 u8 normvalue = (u8) (vwrq->value/500000);
5885 /* Check if rate is valid */
5886 for(i = 0 ; i < 8 ; i++) {
5887 if(normvalue == cap_rid.supportedRates[i]) {
5893 /* -1 designed the max rate (mostly auto mode) */
5894 if(vwrq->value == -1) {
5895 /* Get the highest available rate */
5896 for(i = 0 ; i < 8 ; i++) {
5897 if(cap_rid.supportedRates[i] == 0)
5901 brate = cap_rid.supportedRates[i - 1];
5903 /* Check that it is valid */
5908 readConfigRid(local, 1);
5909 /* Now, check if we want a fixed or auto value */
5910 if(vwrq->fixed == 0) {
5911 /* Fill all the rates up to this max rate */
5912 memset(local->config.rates, 0, 8);
5913 for(i = 0 ; i < 8 ; i++) {
5914 local->config.rates[i] = cap_rid.supportedRates[i];
5915 if(local->config.rates[i] == brate)
5920 /* One rate, fixed */
5921 memset(local->config.rates, 0, 8);
5922 local->config.rates[0] = brate;
5924 set_bit (FLAG_COMMIT, &local->flags);
5926 return -EINPROGRESS; /* Call commit handler */
5929 /*------------------------------------------------------------------*/
5931 * Wireless Handler : get Bit-Rate
5933 static int airo_get_rate(struct net_device *dev,
5934 struct iw_request_info *info,
5935 struct iw_param *vwrq,
5938 struct airo_info *local = dev->priv;
5939 StatusRid status_rid; /* Card status info */
5941 readStatusRid(local, &status_rid, 1);
5943 vwrq->value = status_rid.currentXmitRate * 500000;
5944 /* If more than one rate, set auto */
5945 readConfigRid(local, 1);
5946 vwrq->fixed = (local->config.rates[1] == 0);
5951 /*------------------------------------------------------------------*/
5953 * Wireless Handler : set RTS threshold
5955 static int airo_set_rts(struct net_device *dev,
5956 struct iw_request_info *info,
5957 struct iw_param *vwrq,
5960 struct airo_info *local = dev->priv;
5961 int rthr = vwrq->value;
5965 if((rthr < 0) || (rthr > 2312)) {
5968 readConfigRid(local, 1);
5969 local->config.rtsThres = rthr;
5970 set_bit (FLAG_COMMIT, &local->flags);
5972 return -EINPROGRESS; /* Call commit handler */
5975 /*------------------------------------------------------------------*/
5977 * Wireless Handler : get RTS threshold
5979 static int airo_get_rts(struct net_device *dev,
5980 struct iw_request_info *info,
5981 struct iw_param *vwrq,
5984 struct airo_info *local = dev->priv;
5986 readConfigRid(local, 1);
5987 vwrq->value = local->config.rtsThres;
5988 vwrq->disabled = (vwrq->value >= 2312);
5994 /*------------------------------------------------------------------*/
5996 * Wireless Handler : set Fragmentation threshold
5998 static int airo_set_frag(struct net_device *dev,
5999 struct iw_request_info *info,
6000 struct iw_param *vwrq,
6003 struct airo_info *local = dev->priv;
6004 int fthr = vwrq->value;
6008 if((fthr < 256) || (fthr > 2312)) {
6011 fthr &= ~0x1; /* Get an even value - is it really needed ??? */
6012 readConfigRid(local, 1);
6013 local->config.fragThresh = (u16)fthr;
6014 set_bit (FLAG_COMMIT, &local->flags);
6016 return -EINPROGRESS; /* Call commit handler */
6019 /*------------------------------------------------------------------*/
6021 * Wireless Handler : get Fragmentation threshold
6023 static int airo_get_frag(struct net_device *dev,
6024 struct iw_request_info *info,
6025 struct iw_param *vwrq,
6028 struct airo_info *local = dev->priv;
6030 readConfigRid(local, 1);
6031 vwrq->value = local->config.fragThresh;
6032 vwrq->disabled = (vwrq->value >= 2312);
6038 /*------------------------------------------------------------------*/
6040 * Wireless Handler : set Mode of Operation
6042 static int airo_set_mode(struct net_device *dev,
6043 struct iw_request_info *info,
6047 struct airo_info *local = dev->priv;
6050 readConfigRid(local, 1);
6051 if ((local->config.rmode & 0xff) >= RXMODE_RFMON)
6056 local->config.opmode &= 0xFF00;
6057 local->config.opmode |= MODE_STA_IBSS;
6058 local->config.rmode &= 0xfe00;
6059 local->config.scanMode = SCANMODE_ACTIVE;
6060 clear_bit (FLAG_802_11, &local->flags);
6063 local->config.opmode &= 0xFF00;
6064 local->config.opmode |= MODE_STA_ESS;
6065 local->config.rmode &= 0xfe00;
6066 local->config.scanMode = SCANMODE_ACTIVE;
6067 clear_bit (FLAG_802_11, &local->flags);
6069 case IW_MODE_MASTER:
6070 local->config.opmode &= 0xFF00;
6071 local->config.opmode |= MODE_AP;
6072 local->config.rmode &= 0xfe00;
6073 local->config.scanMode = SCANMODE_ACTIVE;
6074 clear_bit (FLAG_802_11, &local->flags);
6076 case IW_MODE_REPEAT:
6077 local->config.opmode &= 0xFF00;
6078 local->config.opmode |= MODE_AP_RPTR;
6079 local->config.rmode &= 0xfe00;
6080 local->config.scanMode = SCANMODE_ACTIVE;
6081 clear_bit (FLAG_802_11, &local->flags);
6083 case IW_MODE_MONITOR:
6084 local->config.opmode &= 0xFF00;
6085 local->config.opmode |= MODE_STA_ESS;
6086 local->config.rmode &= 0xfe00;
6087 local->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
6088 local->config.scanMode = SCANMODE_PASSIVE;
6089 set_bit (FLAG_802_11, &local->flags);
6095 set_bit (FLAG_RESET, &local->flags);
6096 set_bit (FLAG_COMMIT, &local->flags);
6098 return -EINPROGRESS; /* Call commit handler */
6101 /*------------------------------------------------------------------*/
6103 * Wireless Handler : get Mode of Operation
6105 static int airo_get_mode(struct net_device *dev,
6106 struct iw_request_info *info,
6110 struct airo_info *local = dev->priv;
6112 readConfigRid(local, 1);
6113 /* If not managed, assume it's ad-hoc */
6114 switch (local->config.opmode & 0xFF) {
6116 *uwrq = IW_MODE_INFRA;
6119 *uwrq = IW_MODE_MASTER;
6122 *uwrq = IW_MODE_REPEAT;
6125 *uwrq = IW_MODE_ADHOC;
6131 /*------------------------------------------------------------------*/
6133 * Wireless Handler : set Encryption Key
6135 static int airo_set_encode(struct net_device *dev,
6136 struct iw_request_info *info,
6137 struct iw_point *dwrq,
6140 struct airo_info *local = dev->priv;
6141 CapabilityRid cap_rid; /* Card capability info */
6143 /* Is WEP supported ? */
6144 readCapabilityRid(local, &cap_rid, 1);
6145 /* Older firmware doesn't support this...
6146 if(!(cap_rid.softCap & 2)) {
6149 readConfigRid(local, 1);
6151 /* Basic checking: do we have a key to set ?
6152 * Note : with the new API, it's impossible to get a NULL pointer.
6153 * Therefore, we need to check a key size == 0 instead.
6154 * New version of iwconfig properly set the IW_ENCODE_NOKEY flag
6155 * when no key is present (only change flags), but older versions
6156 * don't do it. - Jean II */
6157 if (dwrq->length > 0) {
6159 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6160 int current_index = get_wep_key(local, 0xffff);
6161 /* Check the size of the key */
6162 if (dwrq->length > MAX_KEY_SIZE) {
6165 /* Check the index (none -> use current) */
6166 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4:1)))
6167 index = current_index;
6168 /* Set the length */
6169 if (dwrq->length > MIN_KEY_SIZE)
6170 key.len = MAX_KEY_SIZE;
6172 if (dwrq->length > 0)
6173 key.len = MIN_KEY_SIZE;
6175 /* Disable the key */
6177 /* Check if the key is not marked as invalid */
6178 if(!(dwrq->flags & IW_ENCODE_NOKEY)) {
6180 memset(key.key, 0, MAX_KEY_SIZE);
6181 /* Copy the key in the driver */
6182 memcpy(key.key, extra, dwrq->length);
6183 /* Send the key to the card */
6184 set_wep_key(local, index, key.key, key.len, 1, 1);
6186 /* WE specify that if a valid key is set, encryption
6187 * should be enabled (user may turn it off later)
6188 * This is also how "iwconfig ethX key on" works */
6189 if((index == current_index) && (key.len > 0) &&
6190 (local->config.authType == AUTH_OPEN)) {
6191 local->config.authType = AUTH_ENCRYPT;
6192 set_bit (FLAG_COMMIT, &local->flags);
6195 /* Do we want to just set the transmit key index ? */
6196 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6197 if ((index >= 0) && (index < ((cap_rid.softCap & 0x80)?4:1))) {
6198 set_wep_key(local, index, 0, 0, 1, 1);
6200 /* Don't complain if only change the mode */
6201 if(!dwrq->flags & IW_ENCODE_MODE) {
6205 /* Read the flags */
6206 if(dwrq->flags & IW_ENCODE_DISABLED)
6207 local->config.authType = AUTH_OPEN; // disable encryption
6208 if(dwrq->flags & IW_ENCODE_RESTRICTED)
6209 local->config.authType = AUTH_SHAREDKEY; // Only Both
6210 if(dwrq->flags & IW_ENCODE_OPEN)
6211 local->config.authType = AUTH_ENCRYPT; // Only Wep
6212 /* Commit the changes to flags if needed */
6213 if(dwrq->flags & IW_ENCODE_MODE)
6214 set_bit (FLAG_COMMIT, &local->flags);
6215 return -EINPROGRESS; /* Call commit handler */
6218 /*------------------------------------------------------------------*/
6220 * Wireless Handler : get Encryption Key
6222 static int airo_get_encode(struct net_device *dev,
6223 struct iw_request_info *info,
6224 struct iw_point *dwrq,
6227 struct airo_info *local = dev->priv;
6228 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6229 CapabilityRid cap_rid; /* Card capability info */
6231 /* Is it supported ? */
6232 readCapabilityRid(local, &cap_rid, 1);
6233 if(!(cap_rid.softCap & 2)) {
6236 readConfigRid(local, 1);
6237 /* Check encryption mode */
6238 switch(local->config.authType) {
6240 dwrq->flags = IW_ENCODE_OPEN;
6242 case AUTH_SHAREDKEY:
6243 dwrq->flags = IW_ENCODE_RESTRICTED;
6247 dwrq->flags = IW_ENCODE_DISABLED;
6250 /* We can't return the key, so set the proper flag and return zero */
6251 dwrq->flags |= IW_ENCODE_NOKEY;
6252 memset(extra, 0, 16);
6254 /* Which key do we want ? -1 -> tx index */
6255 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4 : 1)))
6256 index = get_wep_key(local, 0xffff);
6257 dwrq->flags |= index + 1;
6258 /* Copy the key to the user buffer */
6259 dwrq->length = get_wep_key(local, index);
6260 if (dwrq->length > 16) {
6266 /*------------------------------------------------------------------*/
6268 * Wireless Handler : set Tx-Power
6270 static int airo_set_txpow(struct net_device *dev,
6271 struct iw_request_info *info,
6272 struct iw_param *vwrq,
6275 struct airo_info *local = dev->priv;
6276 CapabilityRid cap_rid; /* Card capability info */
6280 readCapabilityRid(local, &cap_rid, 1);
6282 if (vwrq->disabled) {
6283 set_bit (FLAG_RADIO_OFF | FLAG_COMMIT, &local->flags);
6284 return -EINPROGRESS; /* Call commit handler */
6286 if (vwrq->flags != IW_TXPOW_MWATT) {
6289 clear_bit (FLAG_RADIO_OFF, &local->flags);
6290 for (i = 0; cap_rid.txPowerLevels[i] && (i < 8); i++)
6291 if ((vwrq->value==cap_rid.txPowerLevels[i])) {
6292 readConfigRid(local, 1);
6293 local->config.txPower = vwrq->value;
6294 set_bit (FLAG_COMMIT, &local->flags);
6295 rc = -EINPROGRESS; /* Call commit handler */
6301 /*------------------------------------------------------------------*/
6303 * Wireless Handler : get Tx-Power
6305 static int airo_get_txpow(struct net_device *dev,
6306 struct iw_request_info *info,
6307 struct iw_param *vwrq,
6310 struct airo_info *local = dev->priv;
6312 readConfigRid(local, 1);
6313 vwrq->value = local->config.txPower;
6314 vwrq->fixed = 1; /* No power control */
6315 vwrq->disabled = test_bit(FLAG_RADIO_OFF, &local->flags);
6316 vwrq->flags = IW_TXPOW_MWATT;
6321 /*------------------------------------------------------------------*/
6323 * Wireless Handler : set Retry limits
6325 static int airo_set_retry(struct net_device *dev,
6326 struct iw_request_info *info,
6327 struct iw_param *vwrq,
6330 struct airo_info *local = dev->priv;
6333 if(vwrq->disabled) {
6336 readConfigRid(local, 1);
6337 if(vwrq->flags & IW_RETRY_LIMIT) {
6338 if(vwrq->flags & IW_RETRY_MAX)
6339 local->config.longRetryLimit = vwrq->value;
6340 else if (vwrq->flags & IW_RETRY_MIN)
6341 local->config.shortRetryLimit = vwrq->value;
6343 /* No modifier : set both */
6344 local->config.longRetryLimit = vwrq->value;
6345 local->config.shortRetryLimit = vwrq->value;
6347 set_bit (FLAG_COMMIT, &local->flags);
6348 rc = -EINPROGRESS; /* Call commit handler */
6350 if(vwrq->flags & IW_RETRY_LIFETIME) {
6351 local->config.txLifetime = vwrq->value / 1024;
6352 set_bit (FLAG_COMMIT, &local->flags);
6353 rc = -EINPROGRESS; /* Call commit handler */
6358 /*------------------------------------------------------------------*/
6360 * Wireless Handler : get Retry limits
6362 static int airo_get_retry(struct net_device *dev,
6363 struct iw_request_info *info,
6364 struct iw_param *vwrq,
6367 struct airo_info *local = dev->priv;
6369 vwrq->disabled = 0; /* Can't be disabled */
6371 readConfigRid(local, 1);
6372 /* Note : by default, display the min retry number */
6373 if((vwrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
6374 vwrq->flags = IW_RETRY_LIFETIME;
6375 vwrq->value = (int)local->config.txLifetime * 1024;
6376 } else if((vwrq->flags & IW_RETRY_MAX)) {
6377 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
6378 vwrq->value = (int)local->config.longRetryLimit;
6380 vwrq->flags = IW_RETRY_LIMIT;
6381 vwrq->value = (int)local->config.shortRetryLimit;
6382 if((int)local->config.shortRetryLimit != (int)local->config.longRetryLimit)
6383 vwrq->flags |= IW_RETRY_MIN;
6389 /*------------------------------------------------------------------*/
6391 * Wireless Handler : get range info
6393 static int airo_get_range(struct net_device *dev,
6394 struct iw_request_info *info,
6395 struct iw_point *dwrq,
6398 struct airo_info *local = dev->priv;
6399 struct iw_range *range = (struct iw_range *) extra;
6400 CapabilityRid cap_rid; /* Card capability info */
6404 readCapabilityRid(local, &cap_rid, 1);
6406 dwrq->length = sizeof(struct iw_range);
6407 memset(range, 0, sizeof(*range));
6408 range->min_nwid = 0x0000;
6409 range->max_nwid = 0x0000;
6410 range->num_channels = 14;
6411 /* Should be based on cap_rid.country to give only
6412 * what the current card support */
6414 for(i = 0; i < 14; i++) {
6415 range->freq[k].i = i + 1; /* List index */
6416 range->freq[k].m = frequency_list[i] * 100000;
6417 range->freq[k++].e = 1; /* Values in table in MHz -> * 10^5 * 10 */
6419 range->num_frequency = k;
6421 /* Hum... Should put the right values there */
6422 range->max_qual.qual = 10;
6423 range->max_qual.level = 0x100 - 120; /* -120 dBm */
6424 range->max_qual.noise = 0;
6425 range->sensitivity = 65535;
6427 for(i = 0 ; i < 8 ; i++) {
6428 range->bitrate[i] = cap_rid.supportedRates[i] * 500000;
6429 if(range->bitrate[i] == 0)
6432 range->num_bitrates = i;
6434 /* Set an indication of the max TCP throughput
6435 * in bit/s that we can expect using this interface.
6436 * May be use for QoS stuff... Jean II */
6438 range->throughput = 5000 * 1000;
6440 range->throughput = 1500 * 1000;
6443 range->max_rts = 2312;
6444 range->min_frag = 256;
6445 range->max_frag = 2312;
6447 if(cap_rid.softCap & 2) {
6449 range->encoding_size[0] = 5;
6451 if (cap_rid.softCap & 0x100) {
6452 range->encoding_size[1] = 13;
6453 range->num_encoding_sizes = 2;
6455 range->num_encoding_sizes = 1;
6456 range->max_encoding_tokens = (cap_rid.softCap & 0x80) ? 4 : 1;
6458 range->num_encoding_sizes = 0;
6459 range->max_encoding_tokens = 0;
6462 range->max_pmp = 5000000; /* 5 secs */
6464 range->max_pmt = 65535 * 1024; /* ??? */
6465 range->pmp_flags = IW_POWER_PERIOD;
6466 range->pmt_flags = IW_POWER_TIMEOUT;
6467 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
6469 /* Transmit Power - values are in mW */
6470 for(i = 0 ; i < 8 ; i++) {
6471 range->txpower[i] = cap_rid.txPowerLevels[i];
6472 if(range->txpower[i] == 0)
6475 range->num_txpower = i;
6476 range->txpower_capa = IW_TXPOW_MWATT;
6477 range->we_version_source = 12;
6478 range->we_version_compiled = WIRELESS_EXT;
6479 range->retry_capa = IW_RETRY_LIMIT | IW_RETRY_LIFETIME;
6480 range->retry_flags = IW_RETRY_LIMIT;
6481 range->r_time_flags = IW_RETRY_LIFETIME;
6482 range->min_retry = 1;
6483 range->max_retry = 65535;
6484 range->min_r_time = 1024;
6485 range->max_r_time = 65535 * 1024;
6486 /* Experimental measurements - boundary 11/5.5 Mb/s */
6487 /* Note : with or without the (local->rssi), results
6488 * are somewhat different. - Jean II */
6489 range->avg_qual.qual = 6;
6491 range->avg_qual.level = 186; /* -70 dBm */
6493 range->avg_qual.level = 176; /* -80 dBm */
6494 range->avg_qual.noise = 0;
6499 /*------------------------------------------------------------------*/
6501 * Wireless Handler : set Power Management
6503 static int airo_set_power(struct net_device *dev,
6504 struct iw_request_info *info,
6505 struct iw_param *vwrq,
6508 struct airo_info *local = dev->priv;
6510 readConfigRid(local, 1);
6511 if (vwrq->disabled) {
6512 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6515 local->config.powerSaveMode = POWERSAVE_CAM;
6516 local->config.rmode &= 0xFF00;
6517 local->config.rmode |= RXMODE_BC_MC_ADDR;
6518 set_bit (FLAG_COMMIT, &local->flags);
6519 return -EINPROGRESS; /* Call commit handler */
6521 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
6522 local->config.fastListenDelay = (vwrq->value + 500) / 1024;
6523 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6524 set_bit (FLAG_COMMIT, &local->flags);
6525 } else if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
6526 local->config.fastListenInterval = local->config.listenInterval = (vwrq->value + 500) / 1024;
6527 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6528 set_bit (FLAG_COMMIT, &local->flags);
6530 switch (vwrq->flags & IW_POWER_MODE) {
6531 case IW_POWER_UNICAST_R:
6532 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6535 local->config.rmode &= 0xFF00;
6536 local->config.rmode |= RXMODE_ADDR;
6537 set_bit (FLAG_COMMIT, &local->flags);
6539 case IW_POWER_ALL_R:
6540 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6543 local->config.rmode &= 0xFF00;
6544 local->config.rmode |= RXMODE_BC_MC_ADDR;
6545 set_bit (FLAG_COMMIT, &local->flags);
6551 // Note : we may want to factor local->need_commit here
6552 // Note2 : may also want to factor RXMODE_RFMON test
6553 return -EINPROGRESS; /* Call commit handler */
6556 /*------------------------------------------------------------------*/
6558 * Wireless Handler : get Power Management
6560 static int airo_get_power(struct net_device *dev,
6561 struct iw_request_info *info,
6562 struct iw_param *vwrq,
6565 struct airo_info *local = dev->priv;
6568 readConfigRid(local, 1);
6569 mode = local->config.powerSaveMode;
6570 if ((vwrq->disabled = (mode == POWERSAVE_CAM)))
6572 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
6573 vwrq->value = (int)local->config.fastListenDelay * 1024;
6574 vwrq->flags = IW_POWER_TIMEOUT;
6576 vwrq->value = (int)local->config.fastListenInterval * 1024;
6577 vwrq->flags = IW_POWER_PERIOD;
6579 if ((local->config.rmode & 0xFF) == RXMODE_ADDR)
6580 vwrq->flags |= IW_POWER_UNICAST_R;
6582 vwrq->flags |= IW_POWER_ALL_R;
6587 /*------------------------------------------------------------------*/
6589 * Wireless Handler : set Sensitivity
6591 static int airo_set_sens(struct net_device *dev,
6592 struct iw_request_info *info,
6593 struct iw_param *vwrq,
6596 struct airo_info *local = dev->priv;
6598 readConfigRid(local, 1);
6599 local->config.rssiThreshold = vwrq->disabled ? RSSI_DEFAULT : vwrq->value;
6600 set_bit (FLAG_COMMIT, &local->flags);
6602 return -EINPROGRESS; /* Call commit handler */
6605 /*------------------------------------------------------------------*/
6607 * Wireless Handler : get Sensitivity
6609 static int airo_get_sens(struct net_device *dev,
6610 struct iw_request_info *info,
6611 struct iw_param *vwrq,
6614 struct airo_info *local = dev->priv;
6616 readConfigRid(local, 1);
6617 vwrq->value = local->config.rssiThreshold;
6618 vwrq->disabled = (vwrq->value == 0);
6624 /*------------------------------------------------------------------*/
6626 * Wireless Handler : get AP List
6627 * Note : this is deprecated in favor of IWSCAN
6629 static int airo_get_aplist(struct net_device *dev,
6630 struct iw_request_info *info,
6631 struct iw_point *dwrq,
6634 struct airo_info *local = dev->priv;
6635 struct sockaddr *address = (struct sockaddr *) extra;
6636 struct iw_quality qual[IW_MAX_AP];
6639 int loseSync = capable(CAP_NET_ADMIN) ? 1: -1;
6641 for (i = 0; i < IW_MAX_AP; i++) {
6642 if (readBSSListRid(local, loseSync, &BSSList))
6645 memcpy(address[i].sa_data, BSSList.bssid, ETH_ALEN);
6646 address[i].sa_family = ARPHRD_ETHER;
6648 qual[i].level = 0x100 - local->rssi[BSSList.rssi].rssidBm;
6650 qual[i].level = (BSSList.rssi + 321) / 2;
6651 qual[i].qual = qual[i].noise = 0;
6652 qual[i].updated = 2;
6653 if (BSSList.index == 0xffff)
6657 StatusRid status_rid; /* Card status info */
6658 readStatusRid(local, &status_rid, 1);
6660 i < min(IW_MAX_AP, 4) &&
6661 (status_rid.bssid[i][0]
6662 & status_rid.bssid[i][1]
6663 & status_rid.bssid[i][2]
6664 & status_rid.bssid[i][3]
6665 & status_rid.bssid[i][4]
6666 & status_rid.bssid[i][5])!=0xff &&
6667 (status_rid.bssid[i][0]
6668 | status_rid.bssid[i][1]
6669 | status_rid.bssid[i][2]
6670 | status_rid.bssid[i][3]
6671 | status_rid.bssid[i][4]
6672 | status_rid.bssid[i][5]);
6674 memcpy(address[i].sa_data,
6675 status_rid.bssid[i], ETH_ALEN);
6676 address[i].sa_family = ARPHRD_ETHER;
6679 dwrq->flags = 1; /* Should be define'd */
6680 memcpy(extra + sizeof(struct sockaddr)*i,
6681 &qual, sizeof(struct iw_quality)*i);
6688 /*------------------------------------------------------------------*/
6690 * Wireless Handler : Initiate Scan
6692 static int airo_set_scan(struct net_device *dev,
6693 struct iw_request_info *info,
6694 struct iw_param *vwrq,
6697 struct airo_info *ai = dev->priv;
6701 /* Note : you may have realised that, as this is a SET operation,
6702 * this is privileged and therefore a normal user can't
6704 * This is not an error, while the device perform scanning,
6705 * traffic doesn't flow, so it's a perfect DoS...
6707 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
6709 /* Initiate a scan command */
6710 memset(&cmd, 0, sizeof(cmd));
6711 cmd.cmd=CMD_LISTBSS;
6712 if (down_interruptible(&ai->sem))
6713 return -ERESTARTSYS;
6714 issuecommand(ai, &cmd, &rsp);
6715 ai->scan_timestamp = jiffies;
6718 /* At this point, just return to the user. */
6723 /*------------------------------------------------------------------*/
6725 * Translate scan data returned from the card to a card independent
6726 * format that the Wireless Tools will understand - Jean II
6728 static inline char *airo_translate_scan(struct net_device *dev,
6733 struct airo_info *ai = dev->priv;
6734 struct iw_event iwe; /* Temporary buffer */
6736 char * current_val; /* For rates */
6739 /* First entry *MUST* be the AP MAC address */
6740 iwe.cmd = SIOCGIWAP;
6741 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
6742 memcpy(iwe.u.ap_addr.sa_data, list->bssid, ETH_ALEN);
6743 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_ADDR_LEN);
6745 /* Other entries will be displayed in the order we give them */
6748 iwe.u.data.length = list->ssidLen;
6749 if(iwe.u.data.length > 32)
6750 iwe.u.data.length = 32;
6751 iwe.cmd = SIOCGIWESSID;
6752 iwe.u.data.flags = 1;
6753 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, list->ssid);
6756 iwe.cmd = SIOCGIWMODE;
6757 capabilities = le16_to_cpu(list->cap);
6758 if(capabilities & (CAP_ESS | CAP_IBSS)) {
6759 if(capabilities & CAP_ESS)
6760 iwe.u.mode = IW_MODE_MASTER;
6762 iwe.u.mode = IW_MODE_ADHOC;
6763 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_UINT_LEN);
6767 iwe.cmd = SIOCGIWFREQ;
6768 iwe.u.freq.m = le16_to_cpu(list->dsChannel);
6769 iwe.u.freq.m = frequency_list[iwe.u.freq.m] * 100000;
6771 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_FREQ_LEN);
6773 /* Add quality statistics */
6776 iwe.u.qual.level = 0x100 - ai->rssi[list->rssi].rssidBm;
6778 iwe.u.qual.level = (list->rssi + 321) / 2;
6779 iwe.u.qual.noise = 0;
6780 iwe.u.qual.qual = 0;
6781 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
6783 /* Add encryption capability */
6784 iwe.cmd = SIOCGIWENCODE;
6785 if(capabilities & CAP_PRIVACY)
6786 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
6788 iwe.u.data.flags = IW_ENCODE_DISABLED;
6789 iwe.u.data.length = 0;
6790 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, list->ssid);
6792 /* Rate : stuffing multiple values in a single event require a bit
6793 * more of magic - Jean II */
6794 current_val = current_ev + IW_EV_LCP_LEN;
6796 iwe.cmd = SIOCGIWRATE;
6797 /* Those two flags are ignored... */
6798 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
6800 for(i = 0 ; i < 8 ; i++) {
6801 /* NULL terminated */
6802 if(list->rates[i] == 0)
6804 /* Bit rate given in 500 kb/s units (+ 0x80) */
6805 iwe.u.bitrate.value = ((list->rates[i] & 0x7f) * 500000);
6806 /* Add new value to event */
6807 current_val = iwe_stream_add_value(current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
6809 /* Check if we added any event */
6810 if((current_val - current_ev) > IW_EV_LCP_LEN)
6811 current_ev = current_val;
6813 /* The other data in the scan result are not really
6814 * interesting, so for now drop it - Jean II */
6818 /*------------------------------------------------------------------*/
6820 * Wireless Handler : Read Scan Results
6822 static int airo_get_scan(struct net_device *dev,
6823 struct iw_request_info *info,
6824 struct iw_point *dwrq,
6827 struct airo_info *ai = dev->priv;
6830 char *current_ev = extra;
6832 /* When we are associated again, the scan has surely finished.
6833 * Just in case, let's make sure enough time has elapsed since
6834 * we started the scan. - Javier */
6835 if(ai->scan_timestamp && time_before(jiffies,ai->scan_timestamp+3*HZ)) {
6836 /* Important note : we don't want to block the caller
6837 * until results are ready for various reasons.
6838 * First, managing wait queues is complex and racy
6839 * (there may be multiple simultaneous callers).
6840 * Second, we grab some rtnetlink lock before comming
6841 * here (in dev_ioctl()).
6842 * Third, the caller can wait on the Wireless Event
6846 ai->scan_timestamp = 0;
6848 /* There's only a race with proc_BSSList_open(), but its
6849 * consequences are begnign. So I don't bother fixing it - Javier */
6851 /* Try to read the first entry of the scan result */
6852 rc = PC4500_readrid(ai, RID_BSSLISTFIRST, &BSSList, sizeof(BSSList), 1);
6853 if((rc) || (BSSList.index == 0xffff)) {
6854 /* Client error, no scan results...
6855 * The caller need to restart the scan. */
6859 /* Read and parse all entries */
6860 while((!rc) && (BSSList.index != 0xffff)) {
6861 /* Translate to WE format this entry */
6862 current_ev = airo_translate_scan(dev, current_ev,
6863 extra + IW_SCAN_MAX_DATA,
6866 /* Read next entry */
6867 rc = PC4500_readrid(ai, RID_BSSLISTNEXT,
6868 &BSSList, sizeof(BSSList), 1);
6870 /* Length of data */
6871 dwrq->length = (current_ev - extra);
6872 dwrq->flags = 0; /* todo */
6877 /*------------------------------------------------------------------*/
6879 * Commit handler : called after a bunch of SET operations
6881 static int airo_config_commit(struct net_device *dev,
6882 struct iw_request_info *info, /* NULL */
6883 void *zwrq, /* NULL */
6884 char *extra) /* NULL */
6886 struct airo_info *local = dev->priv;
6889 if (!test_bit (FLAG_COMMIT, &local->flags))
6892 /* Some of the "SET" function may have modified some of the
6893 * parameters. It's now time to commit them in the card */
6894 disable_MAC(local, 1);
6895 if (test_bit (FLAG_RESET, &local->flags)) {
6896 APListRid APList_rid;
6899 readAPListRid(local, &APList_rid);
6900 readSsidRid(local, &SSID_rid);
6901 if (test_bit(FLAG_MPI,&local->flags))
6902 setup_card(local, dev->dev_addr, 1 );
6904 reset_airo_card(dev);
6905 disable_MAC(local, 1);
6906 writeSsidRid(local, &SSID_rid, 1);
6907 writeAPListRid(local, &APList_rid, 1);
6909 if (down_interruptible(&local->sem))
6910 return -ERESTARTSYS;
6911 writeConfigRid(local, 0);
6912 enable_MAC(local, &rsp, 0);
6913 if (test_bit (FLAG_RESET, &local->flags))
6914 airo_set_promisc(local);
6921 /*------------------------------------------------------------------*/
6923 * Structures to export the Wireless Handlers
6926 static const struct iw_priv_args airo_private_args[] = {
6927 /*{ cmd, set_args, get_args, name } */
6928 { AIROIOCTL, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
6929 IW_PRIV_TYPE_BYTE | 2047, "airoioctl" },
6930 { AIROIDIFC, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
6931 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "airoidifc" },
6934 static const iw_handler airo_handler[] =
6936 (iw_handler) airo_config_commit, /* SIOCSIWCOMMIT */
6937 (iw_handler) airo_get_name, /* SIOCGIWNAME */
6938 (iw_handler) NULL, /* SIOCSIWNWID */
6939 (iw_handler) NULL, /* SIOCGIWNWID */
6940 (iw_handler) airo_set_freq, /* SIOCSIWFREQ */
6941 (iw_handler) airo_get_freq, /* SIOCGIWFREQ */
6942 (iw_handler) airo_set_mode, /* SIOCSIWMODE */
6943 (iw_handler) airo_get_mode, /* SIOCGIWMODE */
6944 (iw_handler) airo_set_sens, /* SIOCSIWSENS */
6945 (iw_handler) airo_get_sens, /* SIOCGIWSENS */
6946 (iw_handler) NULL, /* SIOCSIWRANGE */
6947 (iw_handler) airo_get_range, /* SIOCGIWRANGE */
6948 (iw_handler) NULL, /* SIOCSIWPRIV */
6949 (iw_handler) NULL, /* SIOCGIWPRIV */
6950 (iw_handler) NULL, /* SIOCSIWSTATS */
6951 (iw_handler) NULL, /* SIOCGIWSTATS */
6952 iw_handler_set_spy, /* SIOCSIWSPY */
6953 iw_handler_get_spy, /* SIOCGIWSPY */
6954 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
6955 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
6956 (iw_handler) airo_set_wap, /* SIOCSIWAP */
6957 (iw_handler) airo_get_wap, /* SIOCGIWAP */
6958 (iw_handler) NULL, /* -- hole -- */
6959 (iw_handler) airo_get_aplist, /* SIOCGIWAPLIST */
6960 (iw_handler) airo_set_scan, /* SIOCSIWSCAN */
6961 (iw_handler) airo_get_scan, /* SIOCGIWSCAN */
6962 (iw_handler) airo_set_essid, /* SIOCSIWESSID */
6963 (iw_handler) airo_get_essid, /* SIOCGIWESSID */
6964 (iw_handler) airo_set_nick, /* SIOCSIWNICKN */
6965 (iw_handler) airo_get_nick, /* SIOCGIWNICKN */
6966 (iw_handler) NULL, /* -- hole -- */
6967 (iw_handler) NULL, /* -- hole -- */
6968 (iw_handler) airo_set_rate, /* SIOCSIWRATE */
6969 (iw_handler) airo_get_rate, /* SIOCGIWRATE */
6970 (iw_handler) airo_set_rts, /* SIOCSIWRTS */
6971 (iw_handler) airo_get_rts, /* SIOCGIWRTS */
6972 (iw_handler) airo_set_frag, /* SIOCSIWFRAG */
6973 (iw_handler) airo_get_frag, /* SIOCGIWFRAG */
6974 (iw_handler) airo_set_txpow, /* SIOCSIWTXPOW */
6975 (iw_handler) airo_get_txpow, /* SIOCGIWTXPOW */
6976 (iw_handler) airo_set_retry, /* SIOCSIWRETRY */
6977 (iw_handler) airo_get_retry, /* SIOCGIWRETRY */
6978 (iw_handler) airo_set_encode, /* SIOCSIWENCODE */
6979 (iw_handler) airo_get_encode, /* SIOCGIWENCODE */
6980 (iw_handler) airo_set_power, /* SIOCSIWPOWER */
6981 (iw_handler) airo_get_power, /* SIOCGIWPOWER */
6984 /* Note : don't describe AIROIDIFC and AIROOLDIDIFC in here.
6985 * We want to force the use of the ioctl code, because those can't be
6986 * won't work the iw_handler code (because they simultaneously read
6987 * and write data and iw_handler can't do that).
6988 * Note that it's perfectly legal to read/write on a single ioctl command,
6989 * you just can't use iwpriv and need to force it via the ioctl handler.
6991 static const iw_handler airo_private_handler[] =
6993 NULL, /* SIOCIWFIRSTPRIV */
6996 static const struct iw_handler_def airo_handler_def =
6998 .num_standard = sizeof(airo_handler)/sizeof(iw_handler),
6999 .num_private = sizeof(airo_private_handler)/sizeof(iw_handler),
7000 .num_private_args = sizeof(airo_private_args)/sizeof(struct iw_priv_args),
7001 .standard = (iw_handler *) airo_handler,
7002 .private = (iw_handler *) airo_private_handler,
7003 .private_args = (struct iw_priv_args *) airo_private_args,
7004 .spy_offset = ((void *) (&((struct airo_info *) NULL)->spy_data) -
7009 #endif /* WIRELESS_EXT */
7012 * This defines the configuration part of the Wireless Extensions
7013 * Note : irq and spinlock protection will occur in the subroutines
7016 * o Check input value more carefully and fill correct values in range
7017 * o Test and shakeout the bugs (if any)
7021 * Javier Achirica did a great job of merging code from the unnamed CISCO
7022 * developer that added support for flashing the card.
7024 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
7027 struct airo_info *ai = (struct airo_info *)dev->priv;
7039 int val = AIROMAGIC;
7041 if (copy_from_user(&com,rq->ifr_data,sizeof(com)))
7043 else if (copy_to_user(com.data,(char *)&val,sizeof(val)))
7052 /* Get the command struct and hand it off for evaluation by
7053 * the proper subfunction
7057 if (copy_from_user(&com,rq->ifr_data,sizeof(com))) {
7062 /* Separate R/W functions bracket legality here
7064 if ( com.command == AIRORSWVERSION ) {
7065 if (copy_to_user(com.data, swversion, sizeof(swversion)))
7070 else if ( com.command <= AIRORRID)
7071 rc = readrids(dev,&com);
7072 else if ( com.command >= AIROPCAP && com.command <= (AIROPLEAPUSR+2) )
7073 rc = writerids(dev,&com);
7074 else if ( com.command >= AIROFLSHRST && com.command <= AIRORESTART )
7075 rc = flashcard(dev,&com);
7077 rc = -EINVAL; /* Bad command in ioctl */
7080 #endif /* CISCO_EXT */
7082 // All other calls are currently unsupported
7091 * Get the Wireless stats out of the driver
7092 * Note : irq and spinlock protection will occur in the subroutines
7095 * o Check if work in Ad-Hoc mode (otherwise, use SPY, as in wvlan_cs)
7099 static void airo_read_wireless_stats(struct airo_info *local)
7101 StatusRid status_rid;
7103 u32 *vals = stats_rid.vals;
7105 /* Get stats out of the card */
7106 clear_bit(JOB_WSTATS, &local->flags);
7111 readStatusRid(local, &status_rid, 0);
7112 readStatsRid(local, &stats_rid, RID_STATS, 0);
7116 local->wstats.status = status_rid.mode;
7118 /* Signal quality and co. But where is the noise level ??? */
7119 local->wstats.qual.qual = status_rid.signalQuality;
7121 local->wstats.qual.level = 0x100 - local->rssi[status_rid.sigQuality].rssidBm;
7123 local->wstats.qual.level = (status_rid.normalizedSignalStrength + 321) / 2;
7124 if (status_rid.len >= 124) {
7125 local->wstats.qual.noise = 256 - status_rid.noisedBm;
7126 local->wstats.qual.updated = 7;
7128 local->wstats.qual.noise = 0;
7129 local->wstats.qual.updated = 3;
7132 /* Packets discarded in the wireless adapter due to wireless
7133 * specific problems */
7134 local->wstats.discard.nwid = vals[56] + vals[57] + vals[58];/* SSID Mismatch */
7135 local->wstats.discard.code = vals[6];/* RxWepErr */
7136 local->wstats.discard.fragment = vals[30];
7137 local->wstats.discard.retries = vals[10];
7138 local->wstats.discard.misc = vals[1] + vals[32];
7139 local->wstats.miss.beacon = vals[34];
7142 struct iw_statistics *airo_get_wireless_stats(struct net_device *dev)
7144 struct airo_info *local = dev->priv;
7146 /* Get stats out of the card if available */
7147 if (down_trylock(&local->sem) != 0) {
7148 set_bit(JOB_WSTATS, &local->flags);
7149 wake_up_interruptible(&local->thr_wait);
7151 airo_read_wireless_stats(local);
7153 return &local->wstats;
7155 #endif /* WIRELESS_EXT */
7159 * This just translates from driver IOCTL codes to the command codes to
7160 * feed to the radio's host interface. Things can be added/deleted
7161 * as needed. This represents the READ side of control I/O to
7164 static int readrids(struct net_device *dev, aironet_ioctl *comp) {
7165 unsigned short ridcode;
7166 unsigned char *iobuf;
7168 struct airo_info *ai = dev->priv;
7170 if (test_bit(FLAG_FLASHING, &ai->flags))
7173 switch(comp->command)
7175 case AIROGCAP: ridcode = RID_CAPABILITIES; break;
7176 case AIROGCFG: writeConfigRid (ai, 1);
7177 ridcode = RID_CONFIG; break;
7178 case AIROGSLIST: ridcode = RID_SSID; break;
7179 case AIROGVLIST: ridcode = RID_APLIST; break;
7180 case AIROGDRVNAM: ridcode = RID_DRVNAME; break;
7181 case AIROGEHTENC: ridcode = RID_ETHERENCAP; break;
7182 case AIROGWEPKTMP: ridcode = RID_WEP_TEMP;
7183 /* Only super-user can read WEP keys */
7184 if (!capable(CAP_NET_ADMIN))
7187 case AIROGWEPKNV: ridcode = RID_WEP_PERM;
7188 /* Only super-user can read WEP keys */
7189 if (!capable(CAP_NET_ADMIN))
7192 case AIROGSTAT: ridcode = RID_STATUS; break;
7193 case AIROGSTATSD32: ridcode = RID_STATSDELTA; break;
7194 case AIROGSTATSC32: ridcode = RID_STATS; break;
7197 if (copy_to_user(comp->data, &ai->micstats,
7198 min((int)comp->len,(int)sizeof(ai->micstats))))
7202 case AIRORRID: ridcode = comp->ridnum; break;
7208 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7211 PC4500_readrid(ai,ridcode,iobuf,RIDSIZE, 1);
7212 /* get the count of bytes in the rid docs say 1st 2 bytes is it.
7213 * then return it to the user
7214 * 9/22/2000 Honor user given length
7218 if (copy_to_user(comp->data, iobuf, min(len, (int)RIDSIZE))) {
7227 * Danger Will Robinson write the rids here
7230 static int writerids(struct net_device *dev, aironet_ioctl *comp) {
7231 struct airo_info *ai = dev->priv;
7237 static int (* writer)(struct airo_info *, u16 rid, const void *, int, int);
7238 unsigned char *iobuf;
7240 /* Only super-user can write RIDs */
7241 if (!capable(CAP_NET_ADMIN))
7244 if (test_bit(FLAG_FLASHING, &ai->flags))
7248 writer = do_writerid;
7250 switch(comp->command)
7252 case AIROPSIDS: ridcode = RID_SSID; break;
7253 case AIROPCAP: ridcode = RID_CAPABILITIES; break;
7254 case AIROPAPLIST: ridcode = RID_APLIST; break;
7255 case AIROPCFG: ai->config.len = 0;
7256 ridcode = RID_CONFIG; break;
7257 case AIROPWEPKEYNV: ridcode = RID_WEP_PERM; break;
7258 case AIROPLEAPUSR: ridcode = RID_LEAPUSERNAME; break;
7259 case AIROPLEAPPWD: ridcode = RID_LEAPPASSWORD; break;
7260 case AIROPWEPKEY: ridcode = RID_WEP_TEMP; writer = PC4500_writerid;
7262 case AIROPLEAPUSR+1: ridcode = 0xFF2A; break;
7263 case AIROPLEAPUSR+2: ridcode = 0xFF2B; break;
7265 /* this is not really a rid but a command given to the card
7269 if (enable_MAC(ai, &rsp, 1) != 0)
7274 * Evidently this code in the airo driver does not get a symbol
7275 * as disable_MAC. it's probably so short the compiler does not gen one.
7281 /* This command merely clears the counts does not actually store any data
7282 * only reads rid. But as it changes the cards state, I put it in the
7283 * writerid routines.
7286 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7289 PC4500_readrid(ai,RID_STATSDELTACLEAR,iobuf,RIDSIZE, 1);
7292 enabled = ai->micstats.enabled;
7293 memset(&ai->micstats,0,sizeof(ai->micstats));
7294 ai->micstats.enabled = enabled;
7297 if (copy_to_user(comp->data, iobuf,
7298 min((int)comp->len, (int)RIDSIZE))) {
7306 return -EOPNOTSUPP; /* Blarg! */
7308 if(comp->len > RIDSIZE)
7311 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7314 if (copy_from_user(iobuf,comp->data,comp->len)) {
7319 if (comp->command == AIROPCFG) {
7320 ConfigRid *cfg = (ConfigRid *)iobuf;
7322 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags))
7323 cfg->opmode |= MODE_MIC;
7325 if ((cfg->opmode & 0xFF) == MODE_STA_IBSS)
7326 set_bit (FLAG_ADHOC, &ai->flags);
7328 clear_bit (FLAG_ADHOC, &ai->flags);
7331 if((*writer)(ai, ridcode, iobuf,comp->len,1)) {
7339 /*****************************************************************************
7340 * Ancillary flash / mod functions much black magic lurkes here *
7341 *****************************************************************************
7345 * Flash command switch table
7348 int flashcard(struct net_device *dev, aironet_ioctl *comp) {
7350 int cmdreset(struct airo_info *);
7351 int setflashmode(struct airo_info *);
7352 int flashgchar(struct airo_info *,int,int);
7353 int flashpchar(struct airo_info *,int,int);
7354 int flashputbuf(struct airo_info *);
7355 int flashrestart(struct airo_info *,struct net_device *);
7357 /* Only super-user can modify flash */
7358 if (!capable(CAP_NET_ADMIN))
7361 switch(comp->command)
7364 return cmdreset((struct airo_info *)dev->priv);
7367 if (!((struct airo_info *)dev->priv)->flash &&
7368 (((struct airo_info *)dev->priv)->flash = kmalloc (FLASHSIZE, GFP_KERNEL)) == NULL)
7370 return setflashmode((struct airo_info *)dev->priv);
7372 case AIROFLSHGCHR: /* Get char from aux */
7373 if(comp->len != sizeof(int))
7375 if (copy_from_user(&z,comp->data,comp->len))
7377 return flashgchar((struct airo_info *)dev->priv,z,8000);
7379 case AIROFLSHPCHR: /* Send char to card. */
7380 if(comp->len != sizeof(int))
7382 if (copy_from_user(&z,comp->data,comp->len))
7384 return flashpchar((struct airo_info *)dev->priv,z,8000);
7386 case AIROFLPUTBUF: /* Send 32k to card */
7387 if (!((struct airo_info *)dev->priv)->flash)
7389 if(comp->len > FLASHSIZE)
7391 if(copy_from_user(((struct airo_info *)dev->priv)->flash,comp->data,comp->len))
7394 flashputbuf((struct airo_info *)dev->priv);
7398 if(flashrestart((struct airo_info *)dev->priv,dev))
7405 #define FLASH_COMMAND 0x7e7e
7409 * Disable MAC and do soft reset on
7413 int cmdreset(struct airo_info *ai) {
7417 printk(KERN_INFO "Waitbusy hang before RESET\n");
7421 OUT4500(ai,COMMAND,CMD_SOFTRESET);
7423 set_current_state (TASK_UNINTERRUPTIBLE);
7424 schedule_timeout (HZ); /* WAS 600 12/7/00 */
7427 printk(KERN_INFO "Waitbusy hang AFTER RESET\n");
7434 * Put the card in legendary flash
7438 int setflashmode (struct airo_info *ai) {
7439 set_bit (FLAG_FLASHING, &ai->flags);
7441 OUT4500(ai, SWS0, FLASH_COMMAND);
7442 OUT4500(ai, SWS1, FLASH_COMMAND);
7444 OUT4500(ai, SWS0, FLASH_COMMAND);
7445 OUT4500(ai, COMMAND,0x10);
7447 OUT4500(ai, SWS2, FLASH_COMMAND);
7448 OUT4500(ai, SWS3, FLASH_COMMAND);
7449 OUT4500(ai, COMMAND,0);
7451 set_current_state (TASK_UNINTERRUPTIBLE);
7452 schedule_timeout (HZ/2); /* 500ms delay */
7455 clear_bit (FLAG_FLASHING, &ai->flags);
7456 printk(KERN_INFO "Waitbusy hang after setflash mode\n");
7462 /* Put character to SWS0 wait for dwelltime
7466 int flashpchar(struct airo_info *ai,int byte,int dwelltime) {
7477 /* Wait for busy bit d15 to go false indicating buffer empty */
7478 while ((IN4500 (ai, SWS0) & 0x8000) && waittime > 0) {
7483 /* timeout for busy clear wait */
7485 printk(KERN_INFO "flash putchar busywait timeout! \n");
7489 /* Port is clear now write byte and wait for it to echo back */
7491 OUT4500(ai,SWS0,byte);
7494 echo = IN4500(ai,SWS1);
7495 } while (dwelltime >= 0 && echo != byte);
7499 return (echo == byte) ? 0 : -EIO;
7503 * Get a character from the card matching matchbyte
7506 int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime){
7508 unsigned char rbyte=0;
7511 rchar = IN4500(ai,SWS1);
7513 if(dwelltime && !(0x8000 & rchar)){
7518 rbyte = 0xff & rchar;
7520 if( (rbyte == matchbyte) && (0x8000 & rchar) ){
7524 if( rbyte == 0x81 || rbyte == 0x82 || rbyte == 0x83 || rbyte == 0x1a || 0xffff == rchar)
7528 }while(dwelltime > 0);
7533 * Transfer 32k of firmware data from user buffer to our buffer and
7537 int flashputbuf(struct airo_info *ai){
7541 if (test_bit(FLAG_MPI,&ai->flags))
7542 memcpy(ai->pciaux + 0x8000, ai->flash, FLASHSIZE);
7544 OUT4500(ai,AUXPAGE,0x100);
7545 OUT4500(ai,AUXOFF,0);
7547 for(nwords=0;nwords != FLASHSIZE / 2;nwords++){
7548 OUT4500(ai,AUXDATA,ai->flash[nwords] & 0xffff);
7551 OUT4500(ai,SWS0,0x8000);
7559 int flashrestart(struct airo_info *ai,struct net_device *dev){
7562 set_current_state (TASK_UNINTERRUPTIBLE);
7563 schedule_timeout (HZ); /* Added 12/7/00 */
7564 clear_bit (FLAG_FLASHING, &ai->flags);
7565 status = setup_card(ai, dev->dev_addr, 1);
7567 if (!test_bit(FLAG_MPI,&ai->flags))
7568 for( i = 0; i < MAX_FIDS; i++ ) {
7569 ai->fids[i] = transmit_allocate
7570 ( ai, 2312, i >= MAX_FIDS / 2 );
7573 set_current_state (TASK_UNINTERRUPTIBLE);
7574 schedule_timeout (HZ); /* Added 12/7/00 */
7577 #endif /* CISCO_EXT */
7580 This program is free software; you can redistribute it and/or
7581 modify it under the terms of the GNU General Public License
7582 as published by the Free Software Foundation; either version 2
7583 of the License, or (at your option) any later version.
7585 This program is distributed in the hope that it will be useful,
7586 but WITHOUT ANY WARRANTY; without even the implied warranty of
7587 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
7588 GNU General Public License for more details.
7592 Redistribution and use in source and binary forms, with or without
7593 modification, are permitted provided that the following conditions
7596 1. Redistributions of source code must retain the above copyright
7597 notice, this list of conditions and the following disclaimer.
7598 2. Redistributions in binary form must reproduce the above copyright
7599 notice, this list of conditions and the following disclaimer in the
7600 documentation and/or other materials provided with the distribution.
7601 3. The name of the author may not be used to endorse or promote
7602 products derived from this software without specific prior written
7605 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
7606 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
7607 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
7608 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
7609 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
7610 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
7611 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
7612 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
7613 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
7614 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
7615 POSSIBILITY OF SUCH DAMAGE.
7618 module_init(airo_init_module);
7619 module_exit(airo_cleanup_module);