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 *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,
4279 static ssize_t proc_write( struct file *file,
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,
4491 struct proc_data *priv = (struct proc_data*)file->private_data;
4493 if( !priv->rbuffer ) return -EINVAL;
4496 for( i = 0; i+pos < priv->readlen && i < len; i++ ) {
4497 if (put_user( priv->rbuffer[i+pos], buffer+i ))
4505 * The write routine is generic, it fills in a preallocated rbuffer
4506 * to supply the data.
4508 static ssize_t proc_write( struct file *file,
4515 struct proc_data *priv = (struct proc_data*)file->private_data;
4517 if ( !priv->wbuffer ) {
4523 for( i = 0; i + pos < priv->maxwritelen &&
4525 if (get_user( priv->wbuffer[i+pos], buffer + i ))
4528 if ( i+pos > priv->writelen ) priv->writelen = i+file->f_pos;
4533 static int proc_status_open( struct inode *inode, struct file *file ) {
4534 struct proc_data *data;
4535 struct proc_dir_entry *dp = PDE(inode);
4536 struct net_device *dev = dp->data;
4537 struct airo_info *apriv = dev->priv;
4538 CapabilityRid cap_rid;
4539 StatusRid status_rid;
4542 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4544 memset(file->private_data, 0, sizeof(struct proc_data));
4545 data = (struct proc_data *)file->private_data;
4546 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4547 kfree (file->private_data);
4551 readStatusRid(apriv, &status_rid, 1);
4552 readCapabilityRid(apriv, &cap_rid, 1);
4554 i = sprintf(data->rbuffer, "Status: %s%s%s%s%s%s%s%s%s\n",
4555 status_rid.mode & 1 ? "CFG ": "",
4556 status_rid.mode & 2 ? "ACT ": "",
4557 status_rid.mode & 0x10 ? "SYN ": "",
4558 status_rid.mode & 0x20 ? "LNK ": "",
4559 status_rid.mode & 0x40 ? "LEAP ": "",
4560 status_rid.mode & 0x80 ? "PRIV ": "",
4561 status_rid.mode & 0x100 ? "KEY ": "",
4562 status_rid.mode & 0x200 ? "WEP ": "",
4563 status_rid.mode & 0x8000 ? "ERR ": "");
4564 sprintf( data->rbuffer+i, "Mode: %x\n"
4565 "Signal Strength: %d\n"
4566 "Signal Quality: %d\n"
4571 "Driver Version: %s\n"
4572 "Device: %s\nManufacturer: %s\nFirmware Version: %s\n"
4573 "Radio type: %x\nCountry: %x\nHardware Version: %x\n"
4574 "Software Version: %x\nSoftware Subversion: %x\n"
4575 "Boot block version: %x\n",
4576 (int)status_rid.mode,
4577 (int)status_rid.normalizedSignalStrength,
4578 (int)status_rid.signalQuality,
4579 (int)status_rid.SSIDlen,
4582 (int)status_rid.channel,
4583 (int)status_rid.currentXmitRate/2,
4591 (int)cap_rid.softVer,
4592 (int)cap_rid.softSubVer,
4593 (int)cap_rid.bootBlockVer );
4594 data->readlen = strlen( data->rbuffer );
4598 static int proc_stats_rid_open(struct inode*, struct file*, u16);
4599 static int proc_statsdelta_open( struct inode *inode,
4600 struct file *file ) {
4601 if (file->f_mode&FMODE_WRITE) {
4602 return proc_stats_rid_open(inode, file, RID_STATSDELTACLEAR);
4604 return proc_stats_rid_open(inode, file, RID_STATSDELTA);
4607 static int proc_stats_open( struct inode *inode, struct file *file ) {
4608 return proc_stats_rid_open(inode, file, RID_STATS);
4611 static int proc_stats_rid_open( struct inode *inode,
4614 struct proc_data *data;
4615 struct proc_dir_entry *dp = PDE(inode);
4616 struct net_device *dev = dp->data;
4617 struct airo_info *apriv = dev->priv;
4620 u32 *vals = stats.vals;
4622 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4624 memset(file->private_data, 0, sizeof(struct proc_data));
4625 data = (struct proc_data *)file->private_data;
4626 if ((data->rbuffer = kmalloc( 4096, GFP_KERNEL )) == NULL) {
4627 kfree (file->private_data);
4631 readStatsRid(apriv, &stats, rid, 1);
4634 for(i=0; statsLabels[i]!=(char *)-1 &&
4635 i*4<stats.len; i++){
4636 if (!statsLabels[i]) continue;
4637 if (j+strlen(statsLabels[i])+16>4096) {
4639 "airo: Potentially disasterous buffer overflow averted!\n");
4642 j+=sprintf(data->rbuffer+j, "%s: %u\n", statsLabels[i], vals[i]);
4644 if (i*4>=stats.len){
4646 "airo: Got a short rid\n");
4652 static int get_dec_u16( char *buffer, int *start, int limit ) {
4655 for( value = 0; buffer[*start] >= '0' &&
4656 buffer[*start] <= '9' &&
4657 *start < limit; (*start)++ ) {
4660 value += buffer[*start] - '0';
4662 if ( !valid ) return -1;
4666 static int airo_config_commit(struct net_device *dev,
4667 struct iw_request_info *info, void *zwrq,
4670 static void proc_config_on_close( struct inode *inode, struct file *file ) {
4671 struct proc_data *data = file->private_data;
4672 struct proc_dir_entry *dp = PDE(inode);
4673 struct net_device *dev = dp->data;
4674 struct airo_info *ai = dev->priv;
4677 if ( !data->writelen ) return;
4679 readConfigRid(ai, 1);
4680 set_bit (FLAG_COMMIT, &ai->flags);
4682 line = data->wbuffer;
4684 /*** Mode processing */
4685 if ( !strncmp( line, "Mode: ", 6 ) ) {
4687 if ((ai->config.rmode & 0xff) >= RXMODE_RFMON)
4688 set_bit (FLAG_RESET, &ai->flags);
4689 ai->config.rmode &= 0xfe00;
4690 clear_bit (FLAG_802_11, &ai->flags);
4691 ai->config.opmode &= 0xFF00;
4692 ai->config.scanMode = SCANMODE_ACTIVE;
4693 if ( line[0] == 'a' ) {
4694 ai->config.opmode |= 0;
4696 ai->config.opmode |= 1;
4697 if ( line[0] == 'r' ) {
4698 ai->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
4699 ai->config.scanMode = SCANMODE_PASSIVE;
4700 set_bit (FLAG_802_11, &ai->flags);
4701 } else if ( line[0] == 'y' ) {
4702 ai->config.rmode |= RXMODE_RFMON_ANYBSS | RXMODE_DISABLE_802_3_HEADER;
4703 ai->config.scanMode = SCANMODE_PASSIVE;
4704 set_bit (FLAG_802_11, &ai->flags);
4705 } else if ( line[0] == 'l' )
4706 ai->config.rmode |= RXMODE_LANMON;
4708 set_bit (FLAG_COMMIT, &ai->flags);
4711 /*** Radio status */
4712 else if (!strncmp(line,"Radio: ", 7)) {
4714 if (!strncmp(line,"off",3)) {
4715 set_bit (FLAG_RADIO_OFF, &ai->flags);
4717 clear_bit (FLAG_RADIO_OFF, &ai->flags);
4720 /*** NodeName processing */
4721 else if ( !strncmp( line, "NodeName: ", 10 ) ) {
4725 memset( ai->config.nodeName, 0, 16 );
4726 /* Do the name, assume a space between the mode and node name */
4727 for( j = 0; j < 16 && line[j] != '\n'; j++ ) {
4728 ai->config.nodeName[j] = line[j];
4730 set_bit (FLAG_COMMIT, &ai->flags);
4733 /*** PowerMode processing */
4734 else if ( !strncmp( line, "PowerMode: ", 11 ) ) {
4736 if ( !strncmp( line, "PSPCAM", 6 ) ) {
4737 ai->config.powerSaveMode = POWERSAVE_PSPCAM;
4738 set_bit (FLAG_COMMIT, &ai->flags);
4739 } else if ( !strncmp( line, "PSP", 3 ) ) {
4740 ai->config.powerSaveMode = POWERSAVE_PSP;
4741 set_bit (FLAG_COMMIT, &ai->flags);
4743 ai->config.powerSaveMode = POWERSAVE_CAM;
4744 set_bit (FLAG_COMMIT, &ai->flags);
4746 } else if ( !strncmp( line, "DataRates: ", 11 ) ) {
4747 int v, i = 0, k = 0; /* i is index into line,
4748 k is index to rates */
4751 while((v = get_dec_u16(line, &i, 3))!=-1) {
4752 ai->config.rates[k++] = (u8)v;
4756 set_bit (FLAG_COMMIT, &ai->flags);
4757 } else if ( !strncmp( line, "Channel: ", 9 ) ) {
4760 v = get_dec_u16(line, &i, i+3);
4762 ai->config.channelSet = (u16)v;
4763 set_bit (FLAG_COMMIT, &ai->flags);
4765 } else if ( !strncmp( line, "XmitPower: ", 11 ) ) {
4768 v = get_dec_u16(line, &i, i+3);
4770 ai->config.txPower = (u16)v;
4771 set_bit (FLAG_COMMIT, &ai->flags);
4773 } else if ( !strncmp( line, "WEP: ", 5 ) ) {
4777 ai->config.authType = (u16)AUTH_SHAREDKEY;
4780 ai->config.authType = (u16)AUTH_ENCRYPT;
4783 ai->config.authType = (u16)AUTH_OPEN;
4786 set_bit (FLAG_COMMIT, &ai->flags);
4787 } else if ( !strncmp( line, "LongRetryLimit: ", 16 ) ) {
4791 v = get_dec_u16(line, &i, 3);
4792 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4793 ai->config.longRetryLimit = (u16)v;
4794 set_bit (FLAG_COMMIT, &ai->flags);
4795 } else if ( !strncmp( line, "ShortRetryLimit: ", 17 ) ) {
4799 v = get_dec_u16(line, &i, 3);
4800 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4801 ai->config.shortRetryLimit = (u16)v;
4802 set_bit (FLAG_COMMIT, &ai->flags);
4803 } else if ( !strncmp( line, "RTSThreshold: ", 14 ) ) {
4807 v = get_dec_u16(line, &i, 4);
4808 v = (v<0) ? 0 : ((v>2312) ? 2312 : v);
4809 ai->config.rtsThres = (u16)v;
4810 set_bit (FLAG_COMMIT, &ai->flags);
4811 } else if ( !strncmp( line, "TXMSDULifetime: ", 16 ) ) {
4815 v = get_dec_u16(line, &i, 5);
4817 ai->config.txLifetime = (u16)v;
4818 set_bit (FLAG_COMMIT, &ai->flags);
4819 } else if ( !strncmp( line, "RXMSDULifetime: ", 16 ) ) {
4823 v = get_dec_u16(line, &i, 5);
4825 ai->config.rxLifetime = (u16)v;
4826 set_bit (FLAG_COMMIT, &ai->flags);
4827 } else if ( !strncmp( line, "TXDiversity: ", 13 ) ) {
4828 ai->config.txDiversity =
4829 (line[13]=='l') ? 1 :
4830 ((line[13]=='r')? 2: 3);
4831 set_bit (FLAG_COMMIT, &ai->flags);
4832 } else if ( !strncmp( line, "RXDiversity: ", 13 ) ) {
4833 ai->config.rxDiversity =
4834 (line[13]=='l') ? 1 :
4835 ((line[13]=='r')? 2: 3);
4836 set_bit (FLAG_COMMIT, &ai->flags);
4837 } else if ( !strncmp( line, "FragThreshold: ", 15 ) ) {
4841 v = get_dec_u16(line, &i, 4);
4842 v = (v<256) ? 256 : ((v>2312) ? 2312 : v);
4843 v = v & 0xfffe; /* Make sure its even */
4844 ai->config.fragThresh = (u16)v;
4845 set_bit (FLAG_COMMIT, &ai->flags);
4846 } else if (!strncmp(line, "Modulation: ", 12)) {
4849 case 'd': ai->config.modulation=MOD_DEFAULT; set_bit(FLAG_COMMIT, &ai->flags); break;
4850 case 'c': ai->config.modulation=MOD_CCK; set_bit(FLAG_COMMIT, &ai->flags); break;
4851 case 'm': ai->config.modulation=MOD_MOK; set_bit(FLAG_COMMIT, &ai->flags); break;
4853 printk( KERN_WARNING "airo: Unknown modulation\n" );
4855 } else if (!strncmp(line, "Preamble: ", 10)) {
4858 case 'a': ai->config.preamble=PREAMBLE_AUTO; set_bit(FLAG_COMMIT, &ai->flags); break;
4859 case 'l': ai->config.preamble=PREAMBLE_LONG; set_bit(FLAG_COMMIT, &ai->flags); break;
4860 case 's': ai->config.preamble=PREAMBLE_SHORT; set_bit(FLAG_COMMIT, &ai->flags); break;
4861 default: printk(KERN_WARNING "airo: Unknown preamble\n");
4864 printk( KERN_WARNING "Couldn't figure out %s\n", line );
4866 while( line[0] && line[0] != '\n' ) line++;
4867 if ( line[0] ) line++;
4869 airo_config_commit(dev, NULL, NULL, NULL);
4872 static char *get_rmode(u16 mode) {
4874 case RXMODE_RFMON: return "rfmon";
4875 case RXMODE_RFMON_ANYBSS: return "yna (any) bss rfmon";
4876 case RXMODE_LANMON: return "lanmon";
4881 static int proc_config_open( struct inode *inode, struct file *file ) {
4882 struct proc_data *data;
4883 struct proc_dir_entry *dp = PDE(inode);
4884 struct net_device *dev = dp->data;
4885 struct airo_info *ai = dev->priv;
4888 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4890 memset(file->private_data, 0, sizeof(struct proc_data));
4891 data = (struct proc_data *)file->private_data;
4892 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4893 kfree (file->private_data);
4896 if ((data->wbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4897 kfree (data->rbuffer);
4898 kfree (file->private_data);
4901 memset( data->wbuffer, 0, 2048 );
4902 data->maxwritelen = 2048;
4903 data->on_close = proc_config_on_close;
4905 readConfigRid(ai, 1);
4907 i = sprintf( data->rbuffer,
4912 "DataRates: %d %d %d %d %d %d %d %d\n"
4915 (ai->config.opmode & 0xFF) == 0 ? "adhoc" :
4916 (ai->config.opmode & 0xFF) == 1 ? get_rmode(ai->config.rmode):
4917 (ai->config.opmode & 0xFF) == 2 ? "AP" :
4918 (ai->config.opmode & 0xFF) == 3 ? "AP RPTR" : "Error",
4919 test_bit(FLAG_RADIO_OFF, &ai->flags) ? "off" : "on",
4920 ai->config.nodeName,
4921 ai->config.powerSaveMode == 0 ? "CAM" :
4922 ai->config.powerSaveMode == 1 ? "PSP" :
4923 ai->config.powerSaveMode == 2 ? "PSPCAM" : "Error",
4924 (int)ai->config.rates[0],
4925 (int)ai->config.rates[1],
4926 (int)ai->config.rates[2],
4927 (int)ai->config.rates[3],
4928 (int)ai->config.rates[4],
4929 (int)ai->config.rates[5],
4930 (int)ai->config.rates[6],
4931 (int)ai->config.rates[7],
4932 (int)ai->config.channelSet,
4933 (int)ai->config.txPower
4935 sprintf( data->rbuffer + i,
4936 "LongRetryLimit: %d\n"
4937 "ShortRetryLimit: %d\n"
4938 "RTSThreshold: %d\n"
4939 "TXMSDULifetime: %d\n"
4940 "RXMSDULifetime: %d\n"
4943 "FragThreshold: %d\n"
4947 (int)ai->config.longRetryLimit,
4948 (int)ai->config.shortRetryLimit,
4949 (int)ai->config.rtsThres,
4950 (int)ai->config.txLifetime,
4951 (int)ai->config.rxLifetime,
4952 ai->config.txDiversity == 1 ? "left" :
4953 ai->config.txDiversity == 2 ? "right" : "both",
4954 ai->config.rxDiversity == 1 ? "left" :
4955 ai->config.rxDiversity == 2 ? "right" : "both",
4956 (int)ai->config.fragThresh,
4957 ai->config.authType == AUTH_ENCRYPT ? "encrypt" :
4958 ai->config.authType == AUTH_SHAREDKEY ? "shared" : "open",
4959 ai->config.modulation == 0 ? "default" :
4960 ai->config.modulation == MOD_CCK ? "cck" :
4961 ai->config.modulation == MOD_MOK ? "mok" : "error",
4962 ai->config.preamble == PREAMBLE_AUTO ? "auto" :
4963 ai->config.preamble == PREAMBLE_LONG ? "long" :
4964 ai->config.preamble == PREAMBLE_SHORT ? "short" : "error"
4966 data->readlen = strlen( data->rbuffer );
4970 static void proc_SSID_on_close( struct inode *inode, struct file *file ) {
4971 struct proc_data *data = (struct proc_data *)file->private_data;
4972 struct proc_dir_entry *dp = PDE(inode);
4973 struct net_device *dev = dp->data;
4974 struct airo_info *ai = dev->priv;
4980 if ( !data->writelen ) return;
4982 memset( &SSID_rid, 0, sizeof( SSID_rid ) );
4984 for( i = 0; i < 3; i++ ) {
4986 for( j = 0; j+offset < data->writelen && j < 32 &&
4987 data->wbuffer[offset+j] != '\n'; j++ ) {
4988 SSID_rid.ssids[i].ssid[j] = data->wbuffer[offset+j];
4990 if ( j == 0 ) break;
4991 SSID_rid.ssids[i].len = j;
4993 while( data->wbuffer[offset] != '\n' &&
4994 offset < data->writelen ) offset++;
4998 SSID_rid.len = sizeof(SSID_rid);
5000 writeSsidRid(ai, &SSID_rid, 1);
5001 enable_MAC(ai, &rsp, 1);
5004 inline static u8 hexVal(char c) {
5005 if (c>='0' && c<='9') return c -= '0';
5006 if (c>='a' && c<='f') return c -= 'a'-10;
5007 if (c>='A' && c<='F') return c -= 'A'-10;
5011 static void proc_APList_on_close( struct inode *inode, struct file *file ) {
5012 struct proc_data *data = (struct proc_data *)file->private_data;
5013 struct proc_dir_entry *dp = PDE(inode);
5014 struct net_device *dev = dp->data;
5015 struct airo_info *ai = dev->priv;
5016 APListRid APList_rid;
5020 if ( !data->writelen ) return;
5022 memset( &APList_rid, 0, sizeof(APList_rid) );
5023 APList_rid.len = sizeof(APList_rid);
5025 for( i = 0; i < 4 && data->writelen >= (i+1)*6*3; i++ ) {
5027 for( j = 0; j < 6*3 && data->wbuffer[j+i*6*3]; j++ ) {
5030 APList_rid.ap[i][j/3]=
5031 hexVal(data->wbuffer[j+i*6*3])<<4;
5034 APList_rid.ap[i][j/3]|=
5035 hexVal(data->wbuffer[j+i*6*3]);
5041 writeAPListRid(ai, &APList_rid, 1);
5042 enable_MAC(ai, &rsp, 1);
5045 /* This function wraps PC4500_writerid with a MAC disable */
5046 static int do_writerid( struct airo_info *ai, u16 rid, const void *rid_data,
5047 int len, int dummy ) {
5052 rc = PC4500_writerid(ai, rid, rid_data, len, 1);
5053 enable_MAC(ai, &rsp, 1);
5057 /* Returns the length of the key at the index. If index == 0xffff
5058 * the index of the transmit key is returned. If the key doesn't exist,
5059 * -1 will be returned.
5061 static int get_wep_key(struct airo_info *ai, u16 index) {
5066 rc = readWepKeyRid(ai, &wkr, 1, 1);
5067 if (rc == SUCCESS) do {
5068 lastindex = wkr.kindex;
5069 if (wkr.kindex == index) {
5070 if (index == 0xffff) {
5075 readWepKeyRid(ai, &wkr, 0, 1);
5076 } while(lastindex != wkr.kindex);
5080 static int set_wep_key(struct airo_info *ai, u16 index,
5081 const char *key, u16 keylen, int perm, int lock ) {
5082 static const unsigned char macaddr[ETH_ALEN] = { 0x01, 0, 0, 0, 0, 0 };
5086 memset(&wkr, 0, sizeof(wkr));
5088 // We are selecting which key to use
5089 wkr.len = sizeof(wkr);
5090 wkr.kindex = 0xffff;
5091 wkr.mac[0] = (char)index;
5092 if (perm) printk(KERN_INFO "Setting transmit key to %d\n", index);
5093 if (perm) ai->defindex = (char)index;
5095 // We are actually setting the key
5096 wkr.len = sizeof(wkr);
5099 memcpy( wkr.key, key, keylen );
5100 memcpy( wkr.mac, macaddr, ETH_ALEN );
5101 printk(KERN_INFO "Setting key %d\n", index);
5104 disable_MAC(ai, lock);
5105 writeWepKeyRid(ai, &wkr, perm, lock);
5106 enable_MAC(ai, &rsp, lock);
5110 static void proc_wepkey_on_close( struct inode *inode, struct file *file ) {
5111 struct proc_data *data;
5112 struct proc_dir_entry *dp = PDE(inode);
5113 struct net_device *dev = dp->data;
5114 struct airo_info *ai = dev->priv;
5120 memset(key, 0, sizeof(key));
5122 data = (struct proc_data *)file->private_data;
5123 if ( !data->writelen ) return;
5125 if (data->wbuffer[0] >= '0' && data->wbuffer[0] <= '3' &&
5126 (data->wbuffer[1] == ' ' || data->wbuffer[1] == '\n')) {
5127 index = data->wbuffer[0] - '0';
5128 if (data->wbuffer[1] == '\n') {
5129 set_wep_key(ai, index, 0, 0, 1, 1);
5134 printk(KERN_ERR "airo: WepKey passed invalid key index\n");
5138 for( i = 0; i < 16*3 && data->wbuffer[i+j]; i++ ) {
5141 key[i/3] = hexVal(data->wbuffer[i+j])<<4;
5144 key[i/3] |= hexVal(data->wbuffer[i+j]);
5148 set_wep_key(ai, index, key, i/3, 1, 1);
5151 static int proc_wepkey_open( struct inode *inode, struct file *file ) {
5152 struct proc_data *data;
5153 struct proc_dir_entry *dp = PDE(inode);
5154 struct net_device *dev = dp->data;
5155 struct airo_info *ai = dev->priv;
5162 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5164 memset(file->private_data, 0, sizeof(struct proc_data));
5165 memset(&wkr, 0, sizeof(wkr));
5166 data = (struct proc_data *)file->private_data;
5167 if ((data->rbuffer = kmalloc( 180, GFP_KERNEL )) == NULL) {
5168 kfree (file->private_data);
5171 memset(data->rbuffer, 0, 180);
5173 data->maxwritelen = 80;
5174 if ((data->wbuffer = kmalloc( 80, GFP_KERNEL )) == NULL) {
5175 kfree (data->rbuffer);
5176 kfree (file->private_data);
5179 memset( data->wbuffer, 0, 80 );
5180 data->on_close = proc_wepkey_on_close;
5182 ptr = data->rbuffer;
5183 strcpy(ptr, "No wep keys\n");
5184 rc = readWepKeyRid(ai, &wkr, 1, 1);
5185 if (rc == SUCCESS) do {
5186 lastindex = wkr.kindex;
5187 if (wkr.kindex == 0xffff) {
5188 j += sprintf(ptr+j, "Tx key = %d\n",
5191 j += sprintf(ptr+j, "Key %d set with length = %d\n",
5192 (int)wkr.kindex, (int)wkr.klen);
5194 readWepKeyRid(ai, &wkr, 0, 1);
5195 } while((lastindex != wkr.kindex) && (j < 180-30));
5197 data->readlen = strlen( data->rbuffer );
5201 static int proc_SSID_open( struct inode *inode, struct file *file ) {
5202 struct proc_data *data;
5203 struct proc_dir_entry *dp = PDE(inode);
5204 struct net_device *dev = dp->data;
5205 struct airo_info *ai = dev->priv;
5210 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5212 memset(file->private_data, 0, sizeof(struct proc_data));
5213 data = (struct proc_data *)file->private_data;
5214 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5215 kfree (file->private_data);
5219 data->maxwritelen = 33*3;
5220 if ((data->wbuffer = kmalloc( 33*3, GFP_KERNEL )) == NULL) {
5221 kfree (data->rbuffer);
5222 kfree (file->private_data);
5225 memset( data->wbuffer, 0, 33*3 );
5226 data->on_close = proc_SSID_on_close;
5228 readSsidRid(ai, &SSID_rid);
5229 ptr = data->rbuffer;
5230 for( i = 0; i < 3; i++ ) {
5232 if ( !SSID_rid.ssids[i].len ) break;
5233 for( j = 0; j < 32 &&
5234 j < SSID_rid.ssids[i].len &&
5235 SSID_rid.ssids[i].ssid[j]; j++ ) {
5236 *ptr++ = SSID_rid.ssids[i].ssid[j];
5241 data->readlen = strlen( data->rbuffer );
5245 static int proc_APList_open( struct inode *inode, struct file *file ) {
5246 struct proc_data *data;
5247 struct proc_dir_entry *dp = PDE(inode);
5248 struct net_device *dev = dp->data;
5249 struct airo_info *ai = dev->priv;
5252 APListRid APList_rid;
5254 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5256 memset(file->private_data, 0, sizeof(struct proc_data));
5257 data = (struct proc_data *)file->private_data;
5258 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5259 kfree (file->private_data);
5263 data->maxwritelen = 4*6*3;
5264 if ((data->wbuffer = kmalloc( data->maxwritelen, GFP_KERNEL )) == NULL) {
5265 kfree (data->rbuffer);
5266 kfree (file->private_data);
5269 memset( data->wbuffer, 0, data->maxwritelen );
5270 data->on_close = proc_APList_on_close;
5272 readAPListRid(ai, &APList_rid);
5273 ptr = data->rbuffer;
5274 for( i = 0; i < 4; i++ ) {
5275 // We end when we find a zero MAC
5276 if ( !*(int*)APList_rid.ap[i] &&
5277 !*(int*)&APList_rid.ap[i][2]) break;
5278 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x\n",
5279 (int)APList_rid.ap[i][0],
5280 (int)APList_rid.ap[i][1],
5281 (int)APList_rid.ap[i][2],
5282 (int)APList_rid.ap[i][3],
5283 (int)APList_rid.ap[i][4],
5284 (int)APList_rid.ap[i][5]);
5286 if (i==0) ptr += sprintf(ptr, "Not using specific APs\n");
5289 data->readlen = strlen( data->rbuffer );
5293 static int proc_BSSList_open( struct inode *inode, struct file *file ) {
5294 struct proc_data *data;
5295 struct proc_dir_entry *dp = PDE(inode);
5296 struct net_device *dev = dp->data;
5297 struct airo_info *ai = dev->priv;
5299 BSSListRid BSSList_rid;
5301 /* If doLoseSync is not 1, we won't do a Lose Sync */
5302 int doLoseSync = -1;
5304 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5306 memset(file->private_data, 0, sizeof(struct proc_data));
5307 data = (struct proc_data *)file->private_data;
5308 if ((data->rbuffer = kmalloc( 1024, GFP_KERNEL )) == NULL) {
5309 kfree (file->private_data);
5313 data->maxwritelen = 0;
5317 if (file->f_mode & FMODE_WRITE) {
5318 if (!(file->f_mode & FMODE_READ)) {
5322 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
5323 memset(&cmd, 0, sizeof(cmd));
5324 cmd.cmd=CMD_LISTBSS;
5325 if (down_interruptible(&ai->sem))
5326 return -ERESTARTSYS;
5327 issuecommand(ai, &cmd, &rsp);
5334 ptr = data->rbuffer;
5335 /* There is a race condition here if there are concurrent opens.
5336 Since it is a rare condition, we'll just live with it, otherwise
5337 we have to add a spin lock... */
5338 rc = readBSSListRid(ai, doLoseSync, &BSSList_rid);
5339 while(rc == 0 && BSSList_rid.index != 0xffff) {
5340 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x %*s rssi = %d",
5341 (int)BSSList_rid.bssid[0],
5342 (int)BSSList_rid.bssid[1],
5343 (int)BSSList_rid.bssid[2],
5344 (int)BSSList_rid.bssid[3],
5345 (int)BSSList_rid.bssid[4],
5346 (int)BSSList_rid.bssid[5],
5347 (int)BSSList_rid.ssidLen,
5349 (int)BSSList_rid.rssi);
5350 ptr += sprintf(ptr, " channel = %d %s %s %s %s\n",
5351 (int)BSSList_rid.dsChannel,
5352 BSSList_rid.cap & CAP_ESS ? "ESS" : "",
5353 BSSList_rid.cap & CAP_IBSS ? "adhoc" : "",
5354 BSSList_rid.cap & CAP_PRIVACY ? "wep" : "",
5355 BSSList_rid.cap & CAP_SHORTHDR ? "shorthdr" : "");
5356 rc = readBSSListRid(ai, 0, &BSSList_rid);
5359 data->readlen = strlen( data->rbuffer );
5363 static int proc_close( struct inode *inode, struct file *file )
5365 struct proc_data *data = (struct proc_data *)file->private_data;
5366 if ( data->on_close != NULL ) data->on_close( inode, file );
5367 if ( data->rbuffer ) kfree( data->rbuffer );
5368 if ( data->wbuffer ) kfree( data->wbuffer );
5373 static struct net_device_list {
5374 struct net_device *dev;
5375 struct net_device_list *next;
5376 } *airo_devices = 0;
5378 /* Since the card doesn't automatically switch to the right WEP mode,
5379 we will make it do it. If the card isn't associated, every secs we
5380 will switch WEP modes to see if that will help. If the card is
5381 associated we will check every minute to see if anything has
5383 static void timer_func( struct net_device *dev ) {
5384 struct airo_info *apriv = dev->priv;
5387 /* We don't have a link so try changing the authtype */
5388 readConfigRid(apriv, 0);
5389 disable_MAC(apriv, 0);
5390 switch(apriv->config.authType) {
5392 /* So drop to OPEN */
5393 apriv->config.authType = AUTH_OPEN;
5395 case AUTH_SHAREDKEY:
5396 if (apriv->keyindex < auto_wep) {
5397 set_wep_key(apriv, apriv->keyindex, 0, 0, 0, 0);
5398 apriv->config.authType = AUTH_SHAREDKEY;
5401 /* Drop to ENCRYPT */
5402 apriv->keyindex = 0;
5403 set_wep_key(apriv, apriv->defindex, 0, 0, 0, 0);
5404 apriv->config.authType = AUTH_ENCRYPT;
5407 default: /* We'll escalate to SHAREDKEY */
5408 apriv->config.authType = AUTH_SHAREDKEY;
5410 set_bit (FLAG_COMMIT, &apriv->flags);
5411 writeConfigRid(apriv, 0);
5412 enable_MAC(apriv, &rsp, 0);
5415 /* Schedule check to see if the change worked */
5416 clear_bit(JOB_AUTOWEP, &apriv->flags);
5417 apriv->expires = RUN_AT(HZ*3);
5420 static int add_airo_dev( struct net_device *dev ) {
5421 struct net_device_list *node = kmalloc( sizeof( *node ), GFP_KERNEL );
5426 node->next = airo_devices;
5427 airo_devices = node;
5432 static void del_airo_dev( struct net_device *dev ) {
5433 struct net_device_list **p = &airo_devices;
5434 while( *p && ( (*p)->dev != dev ) )
5436 if ( *p && (*p)->dev == dev )
5441 static int __devinit airo_pci_probe(struct pci_dev *pdev,
5442 const struct pci_device_id *pent)
5444 struct net_device *dev;
5446 if (pci_enable_device(pdev))
5448 pci_set_master(pdev);
5450 if (pdev->device == 0x5000 || pdev->device == 0xa504)
5451 dev = _init_airo_card(pdev->irq, pdev->resource[0].start, 0, pdev);
5453 dev = _init_airo_card(pdev->irq, pdev->resource[2].start, 0, pdev);
5457 pci_set_drvdata(pdev, dev);
5461 static void __devexit airo_pci_remove(struct pci_dev *pdev)
5465 static int airo_pci_suspend(struct pci_dev *pdev, u32 state)
5467 struct net_device *dev = pci_get_drvdata(pdev);
5468 struct airo_info *ai = dev->priv;
5472 printk(KERN_DEBUG "%s: airo_mpi entering sleep mode (state=%d)\n",
5475 if ((ai->APList == NULL) &&
5476 (ai->APList = kmalloc(sizeof(APListRid), GFP_KERNEL)) == NULL)
5478 if ((ai->SSID == NULL) &&
5479 (ai->SSID = kmalloc(sizeof(SsidRid), GFP_KERNEL)) == NULL)
5481 readAPListRid(ai, ai->APList);
5482 readSsidRid(ai, ai->SSID);
5483 memset(&cmd, 0, sizeof(cmd));
5484 /* the lock will be released at the end of the resume callback */
5485 if (down_interruptible(&ai->sem))
5488 netif_device_detach(dev);
5491 issuecommand(ai, &cmd, &rsp);
5495 static int airo_pci_resume(struct pci_dev *pdev)
5497 struct net_device *dev = pci_get_drvdata(pdev);
5498 struct airo_info *ai = dev->priv;
5501 printk(KERN_DEBUG "%s: airo_mpi waking up\n", dev->name);
5506 if (ai->power > 1) {
5507 mpi_init_descriptors(ai);
5508 setup_card(ai, dev->dev_addr, 0);
5509 clear_bit(FLAG_RADIO_OFF, &ai->flags);
5510 clear_bit(FLAG_RADIO_DOWN, &ai->flags);
5511 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
5513 OUT4500(ai, EVACK, EV_AWAKEN);
5514 OUT4500(ai, EVACK, EV_AWAKEN);
5515 schedule_timeout(HZ/10);
5518 set_bit (FLAG_COMMIT, &ai->flags);
5520 schedule_timeout (HZ/5);
5522 writeSsidRid(ai, ai->SSID, 0);
5527 writeAPListRid(ai, ai->APList, 0);
5531 writeConfigRid(ai, 0);
5532 enable_MAC(ai, &rsp, 0);
5534 netif_device_attach(dev);
5535 netif_wake_queue(dev);
5536 enable_interrupts(ai);
5542 static int __init airo_init_module( void )
5544 int i, have_isa_dev = 0;
5546 airo_entry = create_proc_entry("aironet",
5547 S_IFDIR | airo_perm,
5549 airo_entry->uid = proc_uid;
5550 airo_entry->gid = proc_gid;
5552 for( i = 0; i < 4 && io[i] && irq[i]; i++ ) {
5554 "airo: Trying to configure ISA adapter at irq=%d io=0x%x\n",
5556 if (init_airo_card( irq[i], io[i], 0 ))
5561 printk( KERN_INFO "airo: Probing for PCI adapters\n" );
5562 pci_register_driver(&airo_driver);
5563 printk( KERN_INFO "airo: Finished probing for PCI adapters\n" );
5566 /* Always exit with success, as we are a library module
5567 * as well as a driver module
5572 static void __exit airo_cleanup_module( void )
5574 while( airo_devices ) {
5575 printk( KERN_INFO "airo: Unregistering %s\n", airo_devices->dev->name );
5576 stop_airo_card( airo_devices->dev, 1 );
5579 pci_unregister_driver(&airo_driver);
5581 remove_proc_entry("aironet", proc_root_driver);
5586 * Initial Wireless Extension code for Aironet driver by :
5587 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 17 November 00
5588 * Conversion to new driver API by :
5589 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 26 March 02
5590 * Javier also did a good amount of work here, adding some new extensions
5591 * and fixing my code. Let's just say that without him this code just
5592 * would not work at all... - Jean II
5595 /*------------------------------------------------------------------*/
5597 * Wireless Handler : get protocol name
5599 static int airo_get_name(struct net_device *dev,
5600 struct iw_request_info *info,
5604 strcpy(cwrq, "IEEE 802.11-DS");
5608 /*------------------------------------------------------------------*/
5610 * Wireless Handler : set frequency
5612 static int airo_set_freq(struct net_device *dev,
5613 struct iw_request_info *info,
5614 struct iw_freq *fwrq,
5617 struct airo_info *local = dev->priv;
5618 int rc = -EINPROGRESS; /* Call commit handler */
5620 /* If setting by frequency, convert to a channel */
5621 if((fwrq->e == 1) &&
5622 (fwrq->m >= (int) 2.412e8) &&
5623 (fwrq->m <= (int) 2.487e8)) {
5624 int f = fwrq->m / 100000;
5626 while((c < 14) && (f != frequency_list[c]))
5628 /* Hack to fall through... */
5632 /* Setting by channel number */
5633 if((fwrq->m > 1000) || (fwrq->e > 0))
5636 int channel = fwrq->m;
5637 /* We should do a better check than that,
5638 * based on the card capability !!! */
5639 if((channel < 1) || (channel > 16)) {
5640 printk(KERN_DEBUG "%s: New channel value of %d is invalid!\n", dev->name, fwrq->m);
5643 readConfigRid(local, 1);
5644 /* Yes ! We can set it !!! */
5645 local->config.channelSet = (u16)(channel - 1);
5646 set_bit (FLAG_COMMIT, &local->flags);
5652 /*------------------------------------------------------------------*/
5654 * Wireless Handler : get frequency
5656 static int airo_get_freq(struct net_device *dev,
5657 struct iw_request_info *info,
5658 struct iw_freq *fwrq,
5661 struct airo_info *local = dev->priv;
5662 StatusRid status_rid; /* Card status info */
5664 readConfigRid(local, 1);
5665 if ((local->config.opmode & 0xFF) == MODE_STA_ESS)
5666 status_rid.channel = local->config.channelSet;
5668 readStatusRid(local, &status_rid, 1);
5670 #ifdef WEXT_USECHANNELS
5671 fwrq->m = ((int)status_rid.channel) + 1;
5675 int f = (int)status_rid.channel;
5676 fwrq->m = frequency_list[f] * 100000;
5684 /*------------------------------------------------------------------*/
5686 * Wireless Handler : set ESSID
5688 static int airo_set_essid(struct net_device *dev,
5689 struct iw_request_info *info,
5690 struct iw_point *dwrq,
5693 struct airo_info *local = dev->priv;
5695 SsidRid SSID_rid; /* SSIDs */
5697 /* Reload the list of current SSID */
5698 readSsidRid(local, &SSID_rid);
5700 /* Check if we asked for `any' */
5701 if(dwrq->flags == 0) {
5702 /* Just send an empty SSID list */
5703 memset(&SSID_rid, 0, sizeof(SSID_rid));
5705 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
5707 /* Check the size of the string */
5708 if(dwrq->length > IW_ESSID_MAX_SIZE+1) {
5711 /* Check if index is valid */
5712 if((index < 0) || (index >= 4)) {
5717 memset(SSID_rid.ssids[index].ssid, 0,
5718 sizeof(SSID_rid.ssids[index].ssid));
5719 memcpy(SSID_rid.ssids[index].ssid, extra, dwrq->length);
5720 SSID_rid.ssids[index].len = dwrq->length - 1;
5722 SSID_rid.len = sizeof(SSID_rid);
5723 /* Write it to the card */
5724 disable_MAC(local, 1);
5725 writeSsidRid(local, &SSID_rid, 1);
5726 enable_MAC(local, &rsp, 1);
5731 /*------------------------------------------------------------------*/
5733 * Wireless Handler : get ESSID
5735 static int airo_get_essid(struct net_device *dev,
5736 struct iw_request_info *info,
5737 struct iw_point *dwrq,
5740 struct airo_info *local = dev->priv;
5741 StatusRid status_rid; /* Card status info */
5743 readStatusRid(local, &status_rid, 1);
5745 /* Note : if dwrq->flags != 0, we should
5746 * get the relevant SSID from the SSID list... */
5748 /* Get the current SSID */
5749 memcpy(extra, status_rid.SSID, status_rid.SSIDlen);
5750 extra[status_rid.SSIDlen] = '\0';
5751 /* If none, we may want to get the one that was set */
5754 dwrq->length = status_rid.SSIDlen + 1;
5755 dwrq->flags = 1; /* active */
5760 /*------------------------------------------------------------------*/
5762 * Wireless Handler : set AP address
5764 static int airo_set_wap(struct net_device *dev,
5765 struct iw_request_info *info,
5766 struct sockaddr *awrq,
5769 struct airo_info *local = dev->priv;
5772 APListRid APList_rid;
5773 static const unsigned char bcast[ETH_ALEN] = { 255, 255, 255, 255, 255, 255 };
5775 if (awrq->sa_family != ARPHRD_ETHER)
5777 else if (!memcmp(bcast, awrq->sa_data, ETH_ALEN)) {
5778 memset(&cmd, 0, sizeof(cmd));
5779 cmd.cmd=CMD_LOSE_SYNC;
5780 if (down_interruptible(&local->sem))
5781 return -ERESTARTSYS;
5782 issuecommand(local, &cmd, &rsp);
5785 memset(&APList_rid, 0, sizeof(APList_rid));
5786 APList_rid.len = sizeof(APList_rid);
5787 memcpy(APList_rid.ap[0], awrq->sa_data, ETH_ALEN);
5788 disable_MAC(local, 1);
5789 writeAPListRid(local, &APList_rid, 1);
5790 enable_MAC(local, &rsp, 1);
5795 /*------------------------------------------------------------------*/
5797 * Wireless Handler : get AP address
5799 static int airo_get_wap(struct net_device *dev,
5800 struct iw_request_info *info,
5801 struct sockaddr *awrq,
5804 struct airo_info *local = dev->priv;
5805 StatusRid status_rid; /* Card status info */
5807 readStatusRid(local, &status_rid, 1);
5809 /* Tentative. This seems to work, wow, I'm lucky !!! */
5810 memcpy(awrq->sa_data, status_rid.bssid[0], ETH_ALEN);
5811 awrq->sa_family = ARPHRD_ETHER;
5816 /*------------------------------------------------------------------*/
5818 * Wireless Handler : set Nickname
5820 static int airo_set_nick(struct net_device *dev,
5821 struct iw_request_info *info,
5822 struct iw_point *dwrq,
5825 struct airo_info *local = dev->priv;
5827 /* Check the size of the string */
5828 if(dwrq->length > 16 + 1) {
5831 readConfigRid(local, 1);
5832 memset(local->config.nodeName, 0, sizeof(local->config.nodeName));
5833 memcpy(local->config.nodeName, extra, dwrq->length);
5834 set_bit (FLAG_COMMIT, &local->flags);
5836 return -EINPROGRESS; /* Call commit handler */
5839 /*------------------------------------------------------------------*/
5841 * Wireless Handler : get Nickname
5843 static int airo_get_nick(struct net_device *dev,
5844 struct iw_request_info *info,
5845 struct iw_point *dwrq,
5848 struct airo_info *local = dev->priv;
5850 readConfigRid(local, 1);
5851 strncpy(extra, local->config.nodeName, 16);
5853 dwrq->length = strlen(extra) + 1;
5858 /*------------------------------------------------------------------*/
5860 * Wireless Handler : set Bit-Rate
5862 static int airo_set_rate(struct net_device *dev,
5863 struct iw_request_info *info,
5864 struct iw_param *vwrq,
5867 struct airo_info *local = dev->priv;
5868 CapabilityRid cap_rid; /* Card capability info */
5872 /* First : get a valid bit rate value */
5873 readCapabilityRid(local, &cap_rid, 1);
5875 /* Which type of value ? */
5876 if((vwrq->value < 8) && (vwrq->value >= 0)) {
5877 /* Setting by rate index */
5878 /* Find value in the magic rate table */
5879 brate = cap_rid.supportedRates[vwrq->value];
5881 /* Setting by frequency value */
5882 u8 normvalue = (u8) (vwrq->value/500000);
5884 /* Check if rate is valid */
5885 for(i = 0 ; i < 8 ; i++) {
5886 if(normvalue == cap_rid.supportedRates[i]) {
5892 /* -1 designed the max rate (mostly auto mode) */
5893 if(vwrq->value == -1) {
5894 /* Get the highest available rate */
5895 for(i = 0 ; i < 8 ; i++) {
5896 if(cap_rid.supportedRates[i] == 0)
5900 brate = cap_rid.supportedRates[i - 1];
5902 /* Check that it is valid */
5907 readConfigRid(local, 1);
5908 /* Now, check if we want a fixed or auto value */
5909 if(vwrq->fixed == 0) {
5910 /* Fill all the rates up to this max rate */
5911 memset(local->config.rates, 0, 8);
5912 for(i = 0 ; i < 8 ; i++) {
5913 local->config.rates[i] = cap_rid.supportedRates[i];
5914 if(local->config.rates[i] == brate)
5919 /* One rate, fixed */
5920 memset(local->config.rates, 0, 8);
5921 local->config.rates[0] = brate;
5923 set_bit (FLAG_COMMIT, &local->flags);
5925 return -EINPROGRESS; /* Call commit handler */
5928 /*------------------------------------------------------------------*/
5930 * Wireless Handler : get Bit-Rate
5932 static int airo_get_rate(struct net_device *dev,
5933 struct iw_request_info *info,
5934 struct iw_param *vwrq,
5937 struct airo_info *local = dev->priv;
5938 StatusRid status_rid; /* Card status info */
5940 readStatusRid(local, &status_rid, 1);
5942 vwrq->value = status_rid.currentXmitRate * 500000;
5943 /* If more than one rate, set auto */
5944 readConfigRid(local, 1);
5945 vwrq->fixed = (local->config.rates[1] == 0);
5950 /*------------------------------------------------------------------*/
5952 * Wireless Handler : set RTS threshold
5954 static int airo_set_rts(struct net_device *dev,
5955 struct iw_request_info *info,
5956 struct iw_param *vwrq,
5959 struct airo_info *local = dev->priv;
5960 int rthr = vwrq->value;
5964 if((rthr < 0) || (rthr > 2312)) {
5967 readConfigRid(local, 1);
5968 local->config.rtsThres = rthr;
5969 set_bit (FLAG_COMMIT, &local->flags);
5971 return -EINPROGRESS; /* Call commit handler */
5974 /*------------------------------------------------------------------*/
5976 * Wireless Handler : get RTS threshold
5978 static int airo_get_rts(struct net_device *dev,
5979 struct iw_request_info *info,
5980 struct iw_param *vwrq,
5983 struct airo_info *local = dev->priv;
5985 readConfigRid(local, 1);
5986 vwrq->value = local->config.rtsThres;
5987 vwrq->disabled = (vwrq->value >= 2312);
5993 /*------------------------------------------------------------------*/
5995 * Wireless Handler : set Fragmentation threshold
5997 static int airo_set_frag(struct net_device *dev,
5998 struct iw_request_info *info,
5999 struct iw_param *vwrq,
6002 struct airo_info *local = dev->priv;
6003 int fthr = vwrq->value;
6007 if((fthr < 256) || (fthr > 2312)) {
6010 fthr &= ~0x1; /* Get an even value - is it really needed ??? */
6011 readConfigRid(local, 1);
6012 local->config.fragThresh = (u16)fthr;
6013 set_bit (FLAG_COMMIT, &local->flags);
6015 return -EINPROGRESS; /* Call commit handler */
6018 /*------------------------------------------------------------------*/
6020 * Wireless Handler : get Fragmentation threshold
6022 static int airo_get_frag(struct net_device *dev,
6023 struct iw_request_info *info,
6024 struct iw_param *vwrq,
6027 struct airo_info *local = dev->priv;
6029 readConfigRid(local, 1);
6030 vwrq->value = local->config.fragThresh;
6031 vwrq->disabled = (vwrq->value >= 2312);
6037 /*------------------------------------------------------------------*/
6039 * Wireless Handler : set Mode of Operation
6041 static int airo_set_mode(struct net_device *dev,
6042 struct iw_request_info *info,
6046 struct airo_info *local = dev->priv;
6049 readConfigRid(local, 1);
6050 if ((local->config.rmode & 0xff) >= RXMODE_RFMON)
6055 local->config.opmode &= 0xFF00;
6056 local->config.opmode |= MODE_STA_IBSS;
6057 local->config.rmode &= 0xfe00;
6058 local->config.scanMode = SCANMODE_ACTIVE;
6059 clear_bit (FLAG_802_11, &local->flags);
6062 local->config.opmode &= 0xFF00;
6063 local->config.opmode |= MODE_STA_ESS;
6064 local->config.rmode &= 0xfe00;
6065 local->config.scanMode = SCANMODE_ACTIVE;
6066 clear_bit (FLAG_802_11, &local->flags);
6068 case IW_MODE_MASTER:
6069 local->config.opmode &= 0xFF00;
6070 local->config.opmode |= MODE_AP;
6071 local->config.rmode &= 0xfe00;
6072 local->config.scanMode = SCANMODE_ACTIVE;
6073 clear_bit (FLAG_802_11, &local->flags);
6075 case IW_MODE_REPEAT:
6076 local->config.opmode &= 0xFF00;
6077 local->config.opmode |= MODE_AP_RPTR;
6078 local->config.rmode &= 0xfe00;
6079 local->config.scanMode = SCANMODE_ACTIVE;
6080 clear_bit (FLAG_802_11, &local->flags);
6082 case IW_MODE_MONITOR:
6083 local->config.opmode &= 0xFF00;
6084 local->config.opmode |= MODE_STA_ESS;
6085 local->config.rmode &= 0xfe00;
6086 local->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
6087 local->config.scanMode = SCANMODE_PASSIVE;
6088 set_bit (FLAG_802_11, &local->flags);
6094 set_bit (FLAG_RESET, &local->flags);
6095 set_bit (FLAG_COMMIT, &local->flags);
6097 return -EINPROGRESS; /* Call commit handler */
6100 /*------------------------------------------------------------------*/
6102 * Wireless Handler : get Mode of Operation
6104 static int airo_get_mode(struct net_device *dev,
6105 struct iw_request_info *info,
6109 struct airo_info *local = dev->priv;
6111 readConfigRid(local, 1);
6112 /* If not managed, assume it's ad-hoc */
6113 switch (local->config.opmode & 0xFF) {
6115 *uwrq = IW_MODE_INFRA;
6118 *uwrq = IW_MODE_MASTER;
6121 *uwrq = IW_MODE_REPEAT;
6124 *uwrq = IW_MODE_ADHOC;
6130 /*------------------------------------------------------------------*/
6132 * Wireless Handler : set Encryption Key
6134 static int airo_set_encode(struct net_device *dev,
6135 struct iw_request_info *info,
6136 struct iw_point *dwrq,
6139 struct airo_info *local = dev->priv;
6140 CapabilityRid cap_rid; /* Card capability info */
6142 /* Is WEP supported ? */
6143 readCapabilityRid(local, &cap_rid, 1);
6144 /* Older firmware doesn't support this...
6145 if(!(cap_rid.softCap & 2)) {
6148 readConfigRid(local, 1);
6150 /* Basic checking: do we have a key to set ?
6151 * Note : with the new API, it's impossible to get a NULL pointer.
6152 * Therefore, we need to check a key size == 0 instead.
6153 * New version of iwconfig properly set the IW_ENCODE_NOKEY flag
6154 * when no key is present (only change flags), but older versions
6155 * don't do it. - Jean II */
6156 if (dwrq->length > 0) {
6158 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6159 int current_index = get_wep_key(local, 0xffff);
6160 /* Check the size of the key */
6161 if (dwrq->length > MAX_KEY_SIZE) {
6164 /* Check the index (none -> use current) */
6165 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4:1)))
6166 index = current_index;
6167 /* Set the length */
6168 if (dwrq->length > MIN_KEY_SIZE)
6169 key.len = MAX_KEY_SIZE;
6171 if (dwrq->length > 0)
6172 key.len = MIN_KEY_SIZE;
6174 /* Disable the key */
6176 /* Check if the key is not marked as invalid */
6177 if(!(dwrq->flags & IW_ENCODE_NOKEY)) {
6179 memset(key.key, 0, MAX_KEY_SIZE);
6180 /* Copy the key in the driver */
6181 memcpy(key.key, extra, dwrq->length);
6182 /* Send the key to the card */
6183 set_wep_key(local, index, key.key, key.len, 1, 1);
6185 /* WE specify that if a valid key is set, encryption
6186 * should be enabled (user may turn it off later)
6187 * This is also how "iwconfig ethX key on" works */
6188 if((index == current_index) && (key.len > 0) &&
6189 (local->config.authType == AUTH_OPEN)) {
6190 local->config.authType = AUTH_ENCRYPT;
6191 set_bit (FLAG_COMMIT, &local->flags);
6194 /* Do we want to just set the transmit key index ? */
6195 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6196 if ((index >= 0) && (index < ((cap_rid.softCap & 0x80)?4:1))) {
6197 set_wep_key(local, index, 0, 0, 1, 1);
6199 /* Don't complain if only change the mode */
6200 if(!dwrq->flags & IW_ENCODE_MODE) {
6204 /* Read the flags */
6205 if(dwrq->flags & IW_ENCODE_DISABLED)
6206 local->config.authType = AUTH_OPEN; // disable encryption
6207 if(dwrq->flags & IW_ENCODE_RESTRICTED)
6208 local->config.authType = AUTH_SHAREDKEY; // Only Both
6209 if(dwrq->flags & IW_ENCODE_OPEN)
6210 local->config.authType = AUTH_ENCRYPT; // Only Wep
6211 /* Commit the changes to flags if needed */
6212 if(dwrq->flags & IW_ENCODE_MODE)
6213 set_bit (FLAG_COMMIT, &local->flags);
6214 return -EINPROGRESS; /* Call commit handler */
6217 /*------------------------------------------------------------------*/
6219 * Wireless Handler : get Encryption Key
6221 static int airo_get_encode(struct net_device *dev,
6222 struct iw_request_info *info,
6223 struct iw_point *dwrq,
6226 struct airo_info *local = dev->priv;
6227 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6228 CapabilityRid cap_rid; /* Card capability info */
6230 /* Is it supported ? */
6231 readCapabilityRid(local, &cap_rid, 1);
6232 if(!(cap_rid.softCap & 2)) {
6235 readConfigRid(local, 1);
6236 /* Check encryption mode */
6237 switch(local->config.authType) {
6239 dwrq->flags = IW_ENCODE_OPEN;
6241 case AUTH_SHAREDKEY:
6242 dwrq->flags = IW_ENCODE_RESTRICTED;
6246 dwrq->flags = IW_ENCODE_DISABLED;
6249 /* We can't return the key, so set the proper flag and return zero */
6250 dwrq->flags |= IW_ENCODE_NOKEY;
6251 memset(extra, 0, 16);
6253 /* Which key do we want ? -1 -> tx index */
6254 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4 : 1)))
6255 index = get_wep_key(local, 0xffff);
6256 dwrq->flags |= index + 1;
6257 /* Copy the key to the user buffer */
6258 dwrq->length = get_wep_key(local, index);
6259 if (dwrq->length > 16) {
6265 /*------------------------------------------------------------------*/
6267 * Wireless Handler : set Tx-Power
6269 static int airo_set_txpow(struct net_device *dev,
6270 struct iw_request_info *info,
6271 struct iw_param *vwrq,
6274 struct airo_info *local = dev->priv;
6275 CapabilityRid cap_rid; /* Card capability info */
6279 readCapabilityRid(local, &cap_rid, 1);
6281 if (vwrq->disabled) {
6282 set_bit (FLAG_RADIO_OFF | FLAG_COMMIT, &local->flags);
6283 return -EINPROGRESS; /* Call commit handler */
6285 if (vwrq->flags != IW_TXPOW_MWATT) {
6288 clear_bit (FLAG_RADIO_OFF, &local->flags);
6289 for (i = 0; cap_rid.txPowerLevels[i] && (i < 8); i++)
6290 if ((vwrq->value==cap_rid.txPowerLevels[i])) {
6291 readConfigRid(local, 1);
6292 local->config.txPower = vwrq->value;
6293 set_bit (FLAG_COMMIT, &local->flags);
6294 rc = -EINPROGRESS; /* Call commit handler */
6300 /*------------------------------------------------------------------*/
6302 * Wireless Handler : get Tx-Power
6304 static int airo_get_txpow(struct net_device *dev,
6305 struct iw_request_info *info,
6306 struct iw_param *vwrq,
6309 struct airo_info *local = dev->priv;
6311 readConfigRid(local, 1);
6312 vwrq->value = local->config.txPower;
6313 vwrq->fixed = 1; /* No power control */
6314 vwrq->disabled = test_bit(FLAG_RADIO_OFF, &local->flags);
6315 vwrq->flags = IW_TXPOW_MWATT;
6320 /*------------------------------------------------------------------*/
6322 * Wireless Handler : set Retry limits
6324 static int airo_set_retry(struct net_device *dev,
6325 struct iw_request_info *info,
6326 struct iw_param *vwrq,
6329 struct airo_info *local = dev->priv;
6332 if(vwrq->disabled) {
6335 readConfigRid(local, 1);
6336 if(vwrq->flags & IW_RETRY_LIMIT) {
6337 if(vwrq->flags & IW_RETRY_MAX)
6338 local->config.longRetryLimit = vwrq->value;
6339 else if (vwrq->flags & IW_RETRY_MIN)
6340 local->config.shortRetryLimit = vwrq->value;
6342 /* No modifier : set both */
6343 local->config.longRetryLimit = vwrq->value;
6344 local->config.shortRetryLimit = vwrq->value;
6346 set_bit (FLAG_COMMIT, &local->flags);
6347 rc = -EINPROGRESS; /* Call commit handler */
6349 if(vwrq->flags & IW_RETRY_LIFETIME) {
6350 local->config.txLifetime = vwrq->value / 1024;
6351 set_bit (FLAG_COMMIT, &local->flags);
6352 rc = -EINPROGRESS; /* Call commit handler */
6357 /*------------------------------------------------------------------*/
6359 * Wireless Handler : get Retry limits
6361 static int airo_get_retry(struct net_device *dev,
6362 struct iw_request_info *info,
6363 struct iw_param *vwrq,
6366 struct airo_info *local = dev->priv;
6368 vwrq->disabled = 0; /* Can't be disabled */
6370 readConfigRid(local, 1);
6371 /* Note : by default, display the min retry number */
6372 if((vwrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
6373 vwrq->flags = IW_RETRY_LIFETIME;
6374 vwrq->value = (int)local->config.txLifetime * 1024;
6375 } else if((vwrq->flags & IW_RETRY_MAX)) {
6376 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
6377 vwrq->value = (int)local->config.longRetryLimit;
6379 vwrq->flags = IW_RETRY_LIMIT;
6380 vwrq->value = (int)local->config.shortRetryLimit;
6381 if((int)local->config.shortRetryLimit != (int)local->config.longRetryLimit)
6382 vwrq->flags |= IW_RETRY_MIN;
6388 /*------------------------------------------------------------------*/
6390 * Wireless Handler : get range info
6392 static int airo_get_range(struct net_device *dev,
6393 struct iw_request_info *info,
6394 struct iw_point *dwrq,
6397 struct airo_info *local = dev->priv;
6398 struct iw_range *range = (struct iw_range *) extra;
6399 CapabilityRid cap_rid; /* Card capability info */
6403 readCapabilityRid(local, &cap_rid, 1);
6405 dwrq->length = sizeof(struct iw_range);
6406 memset(range, 0, sizeof(*range));
6407 range->min_nwid = 0x0000;
6408 range->max_nwid = 0x0000;
6409 range->num_channels = 14;
6410 /* Should be based on cap_rid.country to give only
6411 * what the current card support */
6413 for(i = 0; i < 14; i++) {
6414 range->freq[k].i = i + 1; /* List index */
6415 range->freq[k].m = frequency_list[i] * 100000;
6416 range->freq[k++].e = 1; /* Values in table in MHz -> * 10^5 * 10 */
6418 range->num_frequency = k;
6420 /* Hum... Should put the right values there */
6421 range->max_qual.qual = 10;
6422 range->max_qual.level = 0x100 - 120; /* -120 dBm */
6423 range->max_qual.noise = 0;
6424 range->sensitivity = 65535;
6426 for(i = 0 ; i < 8 ; i++) {
6427 range->bitrate[i] = cap_rid.supportedRates[i] * 500000;
6428 if(range->bitrate[i] == 0)
6431 range->num_bitrates = i;
6433 /* Set an indication of the max TCP throughput
6434 * in bit/s that we can expect using this interface.
6435 * May be use for QoS stuff... Jean II */
6437 range->throughput = 5000 * 1000;
6439 range->throughput = 1500 * 1000;
6442 range->max_rts = 2312;
6443 range->min_frag = 256;
6444 range->max_frag = 2312;
6446 if(cap_rid.softCap & 2) {
6448 range->encoding_size[0] = 5;
6450 if (cap_rid.softCap & 0x100) {
6451 range->encoding_size[1] = 13;
6452 range->num_encoding_sizes = 2;
6454 range->num_encoding_sizes = 1;
6455 range->max_encoding_tokens = (cap_rid.softCap & 0x80) ? 4 : 1;
6457 range->num_encoding_sizes = 0;
6458 range->max_encoding_tokens = 0;
6461 range->max_pmp = 5000000; /* 5 secs */
6463 range->max_pmt = 65535 * 1024; /* ??? */
6464 range->pmp_flags = IW_POWER_PERIOD;
6465 range->pmt_flags = IW_POWER_TIMEOUT;
6466 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
6468 /* Transmit Power - values are in mW */
6469 for(i = 0 ; i < 8 ; i++) {
6470 range->txpower[i] = cap_rid.txPowerLevels[i];
6471 if(range->txpower[i] == 0)
6474 range->num_txpower = i;
6475 range->txpower_capa = IW_TXPOW_MWATT;
6476 range->we_version_source = 12;
6477 range->we_version_compiled = WIRELESS_EXT;
6478 range->retry_capa = IW_RETRY_LIMIT | IW_RETRY_LIFETIME;
6479 range->retry_flags = IW_RETRY_LIMIT;
6480 range->r_time_flags = IW_RETRY_LIFETIME;
6481 range->min_retry = 1;
6482 range->max_retry = 65535;
6483 range->min_r_time = 1024;
6484 range->max_r_time = 65535 * 1024;
6485 /* Experimental measurements - boundary 11/5.5 Mb/s */
6486 /* Note : with or without the (local->rssi), results
6487 * are somewhat different. - Jean II */
6488 range->avg_qual.qual = 6;
6490 range->avg_qual.level = 186; /* -70 dBm */
6492 range->avg_qual.level = 176; /* -80 dBm */
6493 range->avg_qual.noise = 0;
6498 /*------------------------------------------------------------------*/
6500 * Wireless Handler : set Power Management
6502 static int airo_set_power(struct net_device *dev,
6503 struct iw_request_info *info,
6504 struct iw_param *vwrq,
6507 struct airo_info *local = dev->priv;
6509 readConfigRid(local, 1);
6510 if (vwrq->disabled) {
6511 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6514 local->config.powerSaveMode = POWERSAVE_CAM;
6515 local->config.rmode &= 0xFF00;
6516 local->config.rmode |= RXMODE_BC_MC_ADDR;
6517 set_bit (FLAG_COMMIT, &local->flags);
6518 return -EINPROGRESS; /* Call commit handler */
6520 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
6521 local->config.fastListenDelay = (vwrq->value + 500) / 1024;
6522 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6523 set_bit (FLAG_COMMIT, &local->flags);
6524 } else if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
6525 local->config.fastListenInterval = local->config.listenInterval = (vwrq->value + 500) / 1024;
6526 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6527 set_bit (FLAG_COMMIT, &local->flags);
6529 switch (vwrq->flags & IW_POWER_MODE) {
6530 case IW_POWER_UNICAST_R:
6531 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6534 local->config.rmode &= 0xFF00;
6535 local->config.rmode |= RXMODE_ADDR;
6536 set_bit (FLAG_COMMIT, &local->flags);
6538 case IW_POWER_ALL_R:
6539 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6542 local->config.rmode &= 0xFF00;
6543 local->config.rmode |= RXMODE_BC_MC_ADDR;
6544 set_bit (FLAG_COMMIT, &local->flags);
6550 // Note : we may want to factor local->need_commit here
6551 // Note2 : may also want to factor RXMODE_RFMON test
6552 return -EINPROGRESS; /* Call commit handler */
6555 /*------------------------------------------------------------------*/
6557 * Wireless Handler : get Power Management
6559 static int airo_get_power(struct net_device *dev,
6560 struct iw_request_info *info,
6561 struct iw_param *vwrq,
6564 struct airo_info *local = dev->priv;
6567 readConfigRid(local, 1);
6568 mode = local->config.powerSaveMode;
6569 if ((vwrq->disabled = (mode == POWERSAVE_CAM)))
6571 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
6572 vwrq->value = (int)local->config.fastListenDelay * 1024;
6573 vwrq->flags = IW_POWER_TIMEOUT;
6575 vwrq->value = (int)local->config.fastListenInterval * 1024;
6576 vwrq->flags = IW_POWER_PERIOD;
6578 if ((local->config.rmode & 0xFF) == RXMODE_ADDR)
6579 vwrq->flags |= IW_POWER_UNICAST_R;
6581 vwrq->flags |= IW_POWER_ALL_R;
6586 /*------------------------------------------------------------------*/
6588 * Wireless Handler : set Sensitivity
6590 static int airo_set_sens(struct net_device *dev,
6591 struct iw_request_info *info,
6592 struct iw_param *vwrq,
6595 struct airo_info *local = dev->priv;
6597 readConfigRid(local, 1);
6598 local->config.rssiThreshold = vwrq->disabled ? RSSI_DEFAULT : vwrq->value;
6599 set_bit (FLAG_COMMIT, &local->flags);
6601 return -EINPROGRESS; /* Call commit handler */
6604 /*------------------------------------------------------------------*/
6606 * Wireless Handler : get Sensitivity
6608 static int airo_get_sens(struct net_device *dev,
6609 struct iw_request_info *info,
6610 struct iw_param *vwrq,
6613 struct airo_info *local = dev->priv;
6615 readConfigRid(local, 1);
6616 vwrq->value = local->config.rssiThreshold;
6617 vwrq->disabled = (vwrq->value == 0);
6623 /*------------------------------------------------------------------*/
6625 * Wireless Handler : get AP List
6626 * Note : this is deprecated in favor of IWSCAN
6628 static int airo_get_aplist(struct net_device *dev,
6629 struct iw_request_info *info,
6630 struct iw_point *dwrq,
6633 struct airo_info *local = dev->priv;
6634 struct sockaddr *address = (struct sockaddr *) extra;
6635 struct iw_quality qual[IW_MAX_AP];
6638 int loseSync = capable(CAP_NET_ADMIN) ? 1: -1;
6640 for (i = 0; i < IW_MAX_AP; i++) {
6641 if (readBSSListRid(local, loseSync, &BSSList))
6644 memcpy(address[i].sa_data, BSSList.bssid, ETH_ALEN);
6645 address[i].sa_family = ARPHRD_ETHER;
6647 qual[i].level = 0x100 - local->rssi[BSSList.rssi].rssidBm;
6649 qual[i].level = (BSSList.rssi + 321) / 2;
6650 qual[i].qual = qual[i].noise = 0;
6651 qual[i].updated = 2;
6652 if (BSSList.index == 0xffff)
6656 StatusRid status_rid; /* Card status info */
6657 readStatusRid(local, &status_rid, 1);
6659 i < min(IW_MAX_AP, 4) &&
6660 (status_rid.bssid[i][0]
6661 & status_rid.bssid[i][1]
6662 & status_rid.bssid[i][2]
6663 & status_rid.bssid[i][3]
6664 & status_rid.bssid[i][4]
6665 & status_rid.bssid[i][5])!=0xff &&
6666 (status_rid.bssid[i][0]
6667 | status_rid.bssid[i][1]
6668 | status_rid.bssid[i][2]
6669 | status_rid.bssid[i][3]
6670 | status_rid.bssid[i][4]
6671 | status_rid.bssid[i][5]);
6673 memcpy(address[i].sa_data,
6674 status_rid.bssid[i], ETH_ALEN);
6675 address[i].sa_family = ARPHRD_ETHER;
6678 dwrq->flags = 1; /* Should be define'd */
6679 memcpy(extra + sizeof(struct sockaddr)*i,
6680 &qual, sizeof(struct iw_quality)*i);
6687 /*------------------------------------------------------------------*/
6689 * Wireless Handler : Initiate Scan
6691 static int airo_set_scan(struct net_device *dev,
6692 struct iw_request_info *info,
6693 struct iw_param *vwrq,
6696 struct airo_info *ai = dev->priv;
6700 /* Note : you may have realised that, as this is a SET operation,
6701 * this is privileged and therefore a normal user can't
6703 * This is not an error, while the device perform scanning,
6704 * traffic doesn't flow, so it's a perfect DoS...
6706 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
6708 /* Initiate a scan command */
6709 memset(&cmd, 0, sizeof(cmd));
6710 cmd.cmd=CMD_LISTBSS;
6711 if (down_interruptible(&ai->sem))
6712 return -ERESTARTSYS;
6713 issuecommand(ai, &cmd, &rsp);
6714 ai->scan_timestamp = jiffies;
6717 /* At this point, just return to the user. */
6722 /*------------------------------------------------------------------*/
6724 * Translate scan data returned from the card to a card independent
6725 * format that the Wireless Tools will understand - Jean II
6727 static inline char *airo_translate_scan(struct net_device *dev,
6732 struct airo_info *ai = dev->priv;
6733 struct iw_event iwe; /* Temporary buffer */
6735 char * current_val; /* For rates */
6738 /* First entry *MUST* be the AP MAC address */
6739 iwe.cmd = SIOCGIWAP;
6740 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
6741 memcpy(iwe.u.ap_addr.sa_data, list->bssid, ETH_ALEN);
6742 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_ADDR_LEN);
6744 /* Other entries will be displayed in the order we give them */
6747 iwe.u.data.length = list->ssidLen;
6748 if(iwe.u.data.length > 32)
6749 iwe.u.data.length = 32;
6750 iwe.cmd = SIOCGIWESSID;
6751 iwe.u.data.flags = 1;
6752 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, list->ssid);
6755 iwe.cmd = SIOCGIWMODE;
6756 capabilities = le16_to_cpu(list->cap);
6757 if(capabilities & (CAP_ESS | CAP_IBSS)) {
6758 if(capabilities & CAP_ESS)
6759 iwe.u.mode = IW_MODE_MASTER;
6761 iwe.u.mode = IW_MODE_ADHOC;
6762 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_UINT_LEN);
6766 iwe.cmd = SIOCGIWFREQ;
6767 iwe.u.freq.m = le16_to_cpu(list->dsChannel);
6768 iwe.u.freq.m = frequency_list[iwe.u.freq.m] * 100000;
6770 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_FREQ_LEN);
6772 /* Add quality statistics */
6775 iwe.u.qual.level = 0x100 - ai->rssi[list->rssi].rssidBm;
6777 iwe.u.qual.level = (list->rssi + 321) / 2;
6778 iwe.u.qual.noise = 0;
6779 iwe.u.qual.qual = 0;
6780 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
6782 /* Add encryption capability */
6783 iwe.cmd = SIOCGIWENCODE;
6784 if(capabilities & CAP_PRIVACY)
6785 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
6787 iwe.u.data.flags = IW_ENCODE_DISABLED;
6788 iwe.u.data.length = 0;
6789 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, list->ssid);
6791 /* Rate : stuffing multiple values in a single event require a bit
6792 * more of magic - Jean II */
6793 current_val = current_ev + IW_EV_LCP_LEN;
6795 iwe.cmd = SIOCGIWRATE;
6796 /* Those two flags are ignored... */
6797 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
6799 for(i = 0 ; i < 8 ; i++) {
6800 /* NULL terminated */
6801 if(list->rates[i] == 0)
6803 /* Bit rate given in 500 kb/s units (+ 0x80) */
6804 iwe.u.bitrate.value = ((list->rates[i] & 0x7f) * 500000);
6805 /* Add new value to event */
6806 current_val = iwe_stream_add_value(current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
6808 /* Check if we added any event */
6809 if((current_val - current_ev) > IW_EV_LCP_LEN)
6810 current_ev = current_val;
6812 /* The other data in the scan result are not really
6813 * interesting, so for now drop it - Jean II */
6817 /*------------------------------------------------------------------*/
6819 * Wireless Handler : Read Scan Results
6821 static int airo_get_scan(struct net_device *dev,
6822 struct iw_request_info *info,
6823 struct iw_point *dwrq,
6826 struct airo_info *ai = dev->priv;
6829 char *current_ev = extra;
6831 /* When we are associated again, the scan has surely finished.
6832 * Just in case, let's make sure enough time has elapsed since
6833 * we started the scan. - Javier */
6834 if(ai->scan_timestamp && time_before(jiffies,ai->scan_timestamp+3*HZ)) {
6835 /* Important note : we don't want to block the caller
6836 * until results are ready for various reasons.
6837 * First, managing wait queues is complex and racy
6838 * (there may be multiple simultaneous callers).
6839 * Second, we grab some rtnetlink lock before comming
6840 * here (in dev_ioctl()).
6841 * Third, the caller can wait on the Wireless Event
6845 ai->scan_timestamp = 0;
6847 /* There's only a race with proc_BSSList_open(), but its
6848 * consequences are begnign. So I don't bother fixing it - Javier */
6850 /* Try to read the first entry of the scan result */
6851 rc = PC4500_readrid(ai, RID_BSSLISTFIRST, &BSSList, sizeof(BSSList), 1);
6852 if((rc) || (BSSList.index == 0xffff)) {
6853 /* Client error, no scan results...
6854 * The caller need to restart the scan. */
6858 /* Read and parse all entries */
6859 while((!rc) && (BSSList.index != 0xffff)) {
6860 /* Translate to WE format this entry */
6861 current_ev = airo_translate_scan(dev, current_ev,
6862 extra + IW_SCAN_MAX_DATA,
6865 /* Read next entry */
6866 rc = PC4500_readrid(ai, RID_BSSLISTNEXT,
6867 &BSSList, sizeof(BSSList), 1);
6869 /* Length of data */
6870 dwrq->length = (current_ev - extra);
6871 dwrq->flags = 0; /* todo */
6876 /*------------------------------------------------------------------*/
6878 * Commit handler : called after a bunch of SET operations
6880 static int airo_config_commit(struct net_device *dev,
6881 struct iw_request_info *info, /* NULL */
6882 void *zwrq, /* NULL */
6883 char *extra) /* NULL */
6885 struct airo_info *local = dev->priv;
6888 if (!test_bit (FLAG_COMMIT, &local->flags))
6891 /* Some of the "SET" function may have modified some of the
6892 * parameters. It's now time to commit them in the card */
6893 disable_MAC(local, 1);
6894 if (test_bit (FLAG_RESET, &local->flags)) {
6895 APListRid APList_rid;
6898 readAPListRid(local, &APList_rid);
6899 readSsidRid(local, &SSID_rid);
6900 if (test_bit(FLAG_MPI,&local->flags))
6901 setup_card(local, dev->dev_addr, 1 );
6903 reset_airo_card(dev);
6904 disable_MAC(local, 1);
6905 writeSsidRid(local, &SSID_rid, 1);
6906 writeAPListRid(local, &APList_rid, 1);
6908 if (down_interruptible(&local->sem))
6909 return -ERESTARTSYS;
6910 writeConfigRid(local, 0);
6911 enable_MAC(local, &rsp, 0);
6912 if (test_bit (FLAG_RESET, &local->flags))
6913 airo_set_promisc(local);
6920 /*------------------------------------------------------------------*/
6922 * Structures to export the Wireless Handlers
6925 static const struct iw_priv_args airo_private_args[] = {
6926 /*{ cmd, set_args, get_args, name } */
6927 { AIROIOCTL, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
6928 IW_PRIV_TYPE_BYTE | 2047, "airoioctl" },
6929 { AIROIDIFC, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
6930 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "airoidifc" },
6933 static const iw_handler airo_handler[] =
6935 (iw_handler) airo_config_commit, /* SIOCSIWCOMMIT */
6936 (iw_handler) airo_get_name, /* SIOCGIWNAME */
6937 (iw_handler) NULL, /* SIOCSIWNWID */
6938 (iw_handler) NULL, /* SIOCGIWNWID */
6939 (iw_handler) airo_set_freq, /* SIOCSIWFREQ */
6940 (iw_handler) airo_get_freq, /* SIOCGIWFREQ */
6941 (iw_handler) airo_set_mode, /* SIOCSIWMODE */
6942 (iw_handler) airo_get_mode, /* SIOCGIWMODE */
6943 (iw_handler) airo_set_sens, /* SIOCSIWSENS */
6944 (iw_handler) airo_get_sens, /* SIOCGIWSENS */
6945 (iw_handler) NULL, /* SIOCSIWRANGE */
6946 (iw_handler) airo_get_range, /* SIOCGIWRANGE */
6947 (iw_handler) NULL, /* SIOCSIWPRIV */
6948 (iw_handler) NULL, /* SIOCGIWPRIV */
6949 (iw_handler) NULL, /* SIOCSIWSTATS */
6950 (iw_handler) NULL, /* SIOCGIWSTATS */
6951 iw_handler_set_spy, /* SIOCSIWSPY */
6952 iw_handler_get_spy, /* SIOCGIWSPY */
6953 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
6954 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
6955 (iw_handler) airo_set_wap, /* SIOCSIWAP */
6956 (iw_handler) airo_get_wap, /* SIOCGIWAP */
6957 (iw_handler) NULL, /* -- hole -- */
6958 (iw_handler) airo_get_aplist, /* SIOCGIWAPLIST */
6959 (iw_handler) airo_set_scan, /* SIOCSIWSCAN */
6960 (iw_handler) airo_get_scan, /* SIOCGIWSCAN */
6961 (iw_handler) airo_set_essid, /* SIOCSIWESSID */
6962 (iw_handler) airo_get_essid, /* SIOCGIWESSID */
6963 (iw_handler) airo_set_nick, /* SIOCSIWNICKN */
6964 (iw_handler) airo_get_nick, /* SIOCGIWNICKN */
6965 (iw_handler) NULL, /* -- hole -- */
6966 (iw_handler) NULL, /* -- hole -- */
6967 (iw_handler) airo_set_rate, /* SIOCSIWRATE */
6968 (iw_handler) airo_get_rate, /* SIOCGIWRATE */
6969 (iw_handler) airo_set_rts, /* SIOCSIWRTS */
6970 (iw_handler) airo_get_rts, /* SIOCGIWRTS */
6971 (iw_handler) airo_set_frag, /* SIOCSIWFRAG */
6972 (iw_handler) airo_get_frag, /* SIOCGIWFRAG */
6973 (iw_handler) airo_set_txpow, /* SIOCSIWTXPOW */
6974 (iw_handler) airo_get_txpow, /* SIOCGIWTXPOW */
6975 (iw_handler) airo_set_retry, /* SIOCSIWRETRY */
6976 (iw_handler) airo_get_retry, /* SIOCGIWRETRY */
6977 (iw_handler) airo_set_encode, /* SIOCSIWENCODE */
6978 (iw_handler) airo_get_encode, /* SIOCGIWENCODE */
6979 (iw_handler) airo_set_power, /* SIOCSIWPOWER */
6980 (iw_handler) airo_get_power, /* SIOCGIWPOWER */
6983 /* Note : don't describe AIROIDIFC and AIROOLDIDIFC in here.
6984 * We want to force the use of the ioctl code, because those can't be
6985 * won't work the iw_handler code (because they simultaneously read
6986 * and write data and iw_handler can't do that).
6987 * Note that it's perfectly legal to read/write on a single ioctl command,
6988 * you just can't use iwpriv and need to force it via the ioctl handler.
6990 static const iw_handler airo_private_handler[] =
6992 NULL, /* SIOCIWFIRSTPRIV */
6995 static const struct iw_handler_def airo_handler_def =
6997 .num_standard = sizeof(airo_handler)/sizeof(iw_handler),
6998 .num_private = sizeof(airo_private_handler)/sizeof(iw_handler),
6999 .num_private_args = sizeof(airo_private_args)/sizeof(struct iw_priv_args),
7000 .standard = (iw_handler *) airo_handler,
7001 .private = (iw_handler *) airo_private_handler,
7002 .private_args = (struct iw_priv_args *) airo_private_args,
7003 .spy_offset = ((void *) (&((struct airo_info *) NULL)->spy_data) -
7008 #endif /* WIRELESS_EXT */
7011 * This defines the configuration part of the Wireless Extensions
7012 * Note : irq and spinlock protection will occur in the subroutines
7015 * o Check input value more carefully and fill correct values in range
7016 * o Test and shakeout the bugs (if any)
7020 * Javier Achirica did a great job of merging code from the unnamed CISCO
7021 * developer that added support for flashing the card.
7023 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
7026 struct airo_info *ai = (struct airo_info *)dev->priv;
7038 int val = AIROMAGIC;
7040 if (copy_from_user(&com,rq->ifr_data,sizeof(com)))
7042 else if (copy_to_user(com.data,(char *)&val,sizeof(val)))
7051 /* Get the command struct and hand it off for evaluation by
7052 * the proper subfunction
7056 if (copy_from_user(&com,rq->ifr_data,sizeof(com))) {
7061 /* Separate R/W functions bracket legality here
7063 if ( com.command == AIRORSWVERSION ) {
7064 if (copy_to_user(com.data, swversion, sizeof(swversion)))
7069 else if ( com.command <= AIRORRID)
7070 rc = readrids(dev,&com);
7071 else if ( com.command >= AIROPCAP && com.command <= (AIROPLEAPUSR+2) )
7072 rc = writerids(dev,&com);
7073 else if ( com.command >= AIROFLSHRST && com.command <= AIRORESTART )
7074 rc = flashcard(dev,&com);
7076 rc = -EINVAL; /* Bad command in ioctl */
7079 #endif /* CISCO_EXT */
7081 // All other calls are currently unsupported
7090 * Get the Wireless stats out of the driver
7091 * Note : irq and spinlock protection will occur in the subroutines
7094 * o Check if work in Ad-Hoc mode (otherwise, use SPY, as in wvlan_cs)
7098 static void airo_read_wireless_stats(struct airo_info *local)
7100 StatusRid status_rid;
7102 u32 *vals = stats_rid.vals;
7104 /* Get stats out of the card */
7105 clear_bit(JOB_WSTATS, &local->flags);
7110 readStatusRid(local, &status_rid, 0);
7111 readStatsRid(local, &stats_rid, RID_STATS, 0);
7115 local->wstats.status = status_rid.mode;
7117 /* Signal quality and co. But where is the noise level ??? */
7118 local->wstats.qual.qual = status_rid.signalQuality;
7120 local->wstats.qual.level = 0x100 - local->rssi[status_rid.sigQuality].rssidBm;
7122 local->wstats.qual.level = (status_rid.normalizedSignalStrength + 321) / 2;
7123 if (status_rid.len >= 124) {
7124 local->wstats.qual.noise = 256 - status_rid.noisedBm;
7125 local->wstats.qual.updated = 7;
7127 local->wstats.qual.noise = 0;
7128 local->wstats.qual.updated = 3;
7131 /* Packets discarded in the wireless adapter due to wireless
7132 * specific problems */
7133 local->wstats.discard.nwid = vals[56] + vals[57] + vals[58];/* SSID Mismatch */
7134 local->wstats.discard.code = vals[6];/* RxWepErr */
7135 local->wstats.discard.fragment = vals[30];
7136 local->wstats.discard.retries = vals[10];
7137 local->wstats.discard.misc = vals[1] + vals[32];
7138 local->wstats.miss.beacon = vals[34];
7141 struct iw_statistics *airo_get_wireless_stats(struct net_device *dev)
7143 struct airo_info *local = dev->priv;
7145 /* Get stats out of the card if available */
7146 if (down_trylock(&local->sem) != 0) {
7147 set_bit(JOB_WSTATS, &local->flags);
7148 wake_up_interruptible(&local->thr_wait);
7150 airo_read_wireless_stats(local);
7152 return &local->wstats;
7154 #endif /* WIRELESS_EXT */
7158 * This just translates from driver IOCTL codes to the command codes to
7159 * feed to the radio's host interface. Things can be added/deleted
7160 * as needed. This represents the READ side of control I/O to
7163 static int readrids(struct net_device *dev, aironet_ioctl *comp) {
7164 unsigned short ridcode;
7165 unsigned char *iobuf;
7167 struct airo_info *ai = dev->priv;
7169 if (test_bit(FLAG_FLASHING, &ai->flags))
7172 switch(comp->command)
7174 case AIROGCAP: ridcode = RID_CAPABILITIES; break;
7175 case AIROGCFG: writeConfigRid (ai, 1);
7176 ridcode = RID_CONFIG; break;
7177 case AIROGSLIST: ridcode = RID_SSID; break;
7178 case AIROGVLIST: ridcode = RID_APLIST; break;
7179 case AIROGDRVNAM: ridcode = RID_DRVNAME; break;
7180 case AIROGEHTENC: ridcode = RID_ETHERENCAP; break;
7181 case AIROGWEPKTMP: ridcode = RID_WEP_TEMP;
7182 /* Only super-user can read WEP keys */
7183 if (!capable(CAP_NET_ADMIN))
7186 case AIROGWEPKNV: ridcode = RID_WEP_PERM;
7187 /* Only super-user can read WEP keys */
7188 if (!capable(CAP_NET_ADMIN))
7191 case AIROGSTAT: ridcode = RID_STATUS; break;
7192 case AIROGSTATSD32: ridcode = RID_STATSDELTA; break;
7193 case AIROGSTATSC32: ridcode = RID_STATS; break;
7196 if (copy_to_user(comp->data, &ai->micstats,
7197 min((int)comp->len,(int)sizeof(ai->micstats))))
7201 case AIRORRID: ridcode = comp->ridnum; break;
7207 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7210 PC4500_readrid(ai,ridcode,iobuf,RIDSIZE, 1);
7211 /* get the count of bytes in the rid docs say 1st 2 bytes is it.
7212 * then return it to the user
7213 * 9/22/2000 Honor user given length
7217 if (copy_to_user(comp->data, iobuf, min(len, (int)RIDSIZE))) {
7226 * Danger Will Robinson write the rids here
7229 static int writerids(struct net_device *dev, aironet_ioctl *comp) {
7230 struct airo_info *ai = dev->priv;
7236 static int (* writer)(struct airo_info *, u16 rid, const void *, int, int);
7237 unsigned char *iobuf;
7239 /* Only super-user can write RIDs */
7240 if (!capable(CAP_NET_ADMIN))
7243 if (test_bit(FLAG_FLASHING, &ai->flags))
7247 writer = do_writerid;
7249 switch(comp->command)
7251 case AIROPSIDS: ridcode = RID_SSID; break;
7252 case AIROPCAP: ridcode = RID_CAPABILITIES; break;
7253 case AIROPAPLIST: ridcode = RID_APLIST; break;
7254 case AIROPCFG: ai->config.len = 0;
7255 ridcode = RID_CONFIG; break;
7256 case AIROPWEPKEYNV: ridcode = RID_WEP_PERM; break;
7257 case AIROPLEAPUSR: ridcode = RID_LEAPUSERNAME; break;
7258 case AIROPLEAPPWD: ridcode = RID_LEAPPASSWORD; break;
7259 case AIROPWEPKEY: ridcode = RID_WEP_TEMP; writer = PC4500_writerid;
7261 case AIROPLEAPUSR+1: ridcode = 0xFF2A; break;
7262 case AIROPLEAPUSR+2: ridcode = 0xFF2B; break;
7264 /* this is not really a rid but a command given to the card
7268 if (enable_MAC(ai, &rsp, 1) != 0)
7273 * Evidently this code in the airo driver does not get a symbol
7274 * as disable_MAC. it's probably so short the compiler does not gen one.
7280 /* This command merely clears the counts does not actually store any data
7281 * only reads rid. But as it changes the cards state, I put it in the
7282 * writerid routines.
7285 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7288 PC4500_readrid(ai,RID_STATSDELTACLEAR,iobuf,RIDSIZE, 1);
7291 enabled = ai->micstats.enabled;
7292 memset(&ai->micstats,0,sizeof(ai->micstats));
7293 ai->micstats.enabled = enabled;
7296 if (copy_to_user(comp->data, iobuf,
7297 min((int)comp->len, (int)RIDSIZE))) {
7305 return -EOPNOTSUPP; /* Blarg! */
7307 if(comp->len > RIDSIZE)
7310 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7313 if (copy_from_user(iobuf,comp->data,comp->len)) {
7318 if (comp->command == AIROPCFG) {
7319 ConfigRid *cfg = (ConfigRid *)iobuf;
7321 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags))
7322 cfg->opmode |= MODE_MIC;
7324 if ((cfg->opmode & 0xFF) == MODE_STA_IBSS)
7325 set_bit (FLAG_ADHOC, &ai->flags);
7327 clear_bit (FLAG_ADHOC, &ai->flags);
7330 if((*writer)(ai, ridcode, iobuf,comp->len,1)) {
7338 /*****************************************************************************
7339 * Ancillary flash / mod functions much black magic lurkes here *
7340 *****************************************************************************
7344 * Flash command switch table
7347 int flashcard(struct net_device *dev, aironet_ioctl *comp) {
7349 int cmdreset(struct airo_info *);
7350 int setflashmode(struct airo_info *);
7351 int flashgchar(struct airo_info *,int,int);
7352 int flashpchar(struct airo_info *,int,int);
7353 int flashputbuf(struct airo_info *);
7354 int flashrestart(struct airo_info *,struct net_device *);
7356 /* Only super-user can modify flash */
7357 if (!capable(CAP_NET_ADMIN))
7360 switch(comp->command)
7363 return cmdreset((struct airo_info *)dev->priv);
7366 if (!((struct airo_info *)dev->priv)->flash &&
7367 (((struct airo_info *)dev->priv)->flash = kmalloc (FLASHSIZE, GFP_KERNEL)) == NULL)
7369 return setflashmode((struct airo_info *)dev->priv);
7371 case AIROFLSHGCHR: /* Get char from aux */
7372 if(comp->len != sizeof(int))
7374 if (copy_from_user(&z,comp->data,comp->len))
7376 return flashgchar((struct airo_info *)dev->priv,z,8000);
7378 case AIROFLSHPCHR: /* Send char to card. */
7379 if(comp->len != sizeof(int))
7381 if (copy_from_user(&z,comp->data,comp->len))
7383 return flashpchar((struct airo_info *)dev->priv,z,8000);
7385 case AIROFLPUTBUF: /* Send 32k to card */
7386 if (!((struct airo_info *)dev->priv)->flash)
7388 if(comp->len > FLASHSIZE)
7390 if(copy_from_user(((struct airo_info *)dev->priv)->flash,comp->data,comp->len))
7393 flashputbuf((struct airo_info *)dev->priv);
7397 if(flashrestart((struct airo_info *)dev->priv,dev))
7404 #define FLASH_COMMAND 0x7e7e
7408 * Disable MAC and do soft reset on
7412 int cmdreset(struct airo_info *ai) {
7416 printk(KERN_INFO "Waitbusy hang before RESET\n");
7420 OUT4500(ai,COMMAND,CMD_SOFTRESET);
7422 set_current_state (TASK_UNINTERRUPTIBLE);
7423 schedule_timeout (HZ); /* WAS 600 12/7/00 */
7426 printk(KERN_INFO "Waitbusy hang AFTER RESET\n");
7433 * Put the card in legendary flash
7437 int setflashmode (struct airo_info *ai) {
7438 set_bit (FLAG_FLASHING, &ai->flags);
7440 OUT4500(ai, SWS0, FLASH_COMMAND);
7441 OUT4500(ai, SWS1, FLASH_COMMAND);
7443 OUT4500(ai, SWS0, FLASH_COMMAND);
7444 OUT4500(ai, COMMAND,0x10);
7446 OUT4500(ai, SWS2, FLASH_COMMAND);
7447 OUT4500(ai, SWS3, FLASH_COMMAND);
7448 OUT4500(ai, COMMAND,0);
7450 set_current_state (TASK_UNINTERRUPTIBLE);
7451 schedule_timeout (HZ/2); /* 500ms delay */
7454 clear_bit (FLAG_FLASHING, &ai->flags);
7455 printk(KERN_INFO "Waitbusy hang after setflash mode\n");
7461 /* Put character to SWS0 wait for dwelltime
7465 int flashpchar(struct airo_info *ai,int byte,int dwelltime) {
7476 /* Wait for busy bit d15 to go false indicating buffer empty */
7477 while ((IN4500 (ai, SWS0) & 0x8000) && waittime > 0) {
7482 /* timeout for busy clear wait */
7484 printk(KERN_INFO "flash putchar busywait timeout! \n");
7488 /* Port is clear now write byte and wait for it to echo back */
7490 OUT4500(ai,SWS0,byte);
7493 echo = IN4500(ai,SWS1);
7494 } while (dwelltime >= 0 && echo != byte);
7498 return (echo == byte) ? 0 : -EIO;
7502 * Get a character from the card matching matchbyte
7505 int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime){
7507 unsigned char rbyte=0;
7510 rchar = IN4500(ai,SWS1);
7512 if(dwelltime && !(0x8000 & rchar)){
7517 rbyte = 0xff & rchar;
7519 if( (rbyte == matchbyte) && (0x8000 & rchar) ){
7523 if( rbyte == 0x81 || rbyte == 0x82 || rbyte == 0x83 || rbyte == 0x1a || 0xffff == rchar)
7527 }while(dwelltime > 0);
7532 * Transfer 32k of firmware data from user buffer to our buffer and
7536 int flashputbuf(struct airo_info *ai){
7540 if (test_bit(FLAG_MPI,&ai->flags))
7541 memcpy(ai->pciaux + 0x8000, ai->flash, FLASHSIZE);
7543 OUT4500(ai,AUXPAGE,0x100);
7544 OUT4500(ai,AUXOFF,0);
7546 for(nwords=0;nwords != FLASHSIZE / 2;nwords++){
7547 OUT4500(ai,AUXDATA,ai->flash[nwords] & 0xffff);
7550 OUT4500(ai,SWS0,0x8000);
7558 int flashrestart(struct airo_info *ai,struct net_device *dev){
7561 set_current_state (TASK_UNINTERRUPTIBLE);
7562 schedule_timeout (HZ); /* Added 12/7/00 */
7563 clear_bit (FLAG_FLASHING, &ai->flags);
7564 status = setup_card(ai, dev->dev_addr, 1);
7566 if (!test_bit(FLAG_MPI,&ai->flags))
7567 for( i = 0; i < MAX_FIDS; i++ ) {
7568 ai->fids[i] = transmit_allocate
7569 ( ai, 2312, i >= MAX_FIDS / 2 );
7572 set_current_state (TASK_UNINTERRUPTIBLE);
7573 schedule_timeout (HZ); /* Added 12/7/00 */
7576 #endif /* CISCO_EXT */
7579 This program is free software; you can redistribute it and/or
7580 modify it under the terms of the GNU General Public License
7581 as published by the Free Software Foundation; either version 2
7582 of the License, or (at your option) any later version.
7584 This program is distributed in the hope that it will be useful,
7585 but WITHOUT ANY WARRANTY; without even the implied warranty of
7586 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
7587 GNU General Public License for more details.
7591 Redistribution and use in source and binary forms, with or without
7592 modification, are permitted provided that the following conditions
7595 1. Redistributions of source code must retain the above copyright
7596 notice, this list of conditions and the following disclaimer.
7597 2. Redistributions in binary form must reproduce the above copyright
7598 notice, this list of conditions and the following disclaimer in the
7599 documentation and/or other materials provided with the distribution.
7600 3. The name of the author may not be used to endorse or promote
7601 products derived from this software without specific prior written
7604 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
7605 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
7606 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
7607 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
7608 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
7609 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
7610 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
7611 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
7612 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
7613 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
7614 POSSIBILITY OF SUCH DAMAGE.
7617 module_init(airo_init_module);
7618 module_exit(airo_cleanup_module);