1 /*======================================================================
3 Aironet driver for 4500 and 4800 series cards
5 This code is released under both the GPL version 2 and BSD licenses.
6 Either license may be used. The respective licenses are found at
9 This code was developed by Benjamin Reed <breed@users.sourceforge.net>
10 including portions of which come from the Aironet PC4500
11 Developer's Reference Manual and used with permission. Copyright
12 (C) 1999 Benjamin Reed. All Rights Reserved. Permission to use
13 code in the Developer's manual was granted for this driver by
14 Aironet. Major code contributions were received from Javier Achirica
15 <achirica@users.sourceforge.net> and Jean Tourrilhes <jt@hpl.hp.com>.
16 Code was also integrated from the Cisco Aironet driver for Linux.
17 Support for MPI350 cards was added by Fabrice Bellet
18 <fabrice@bellet.info>.
20 ======================================================================*/
22 #include <linux/config.h>
23 #include <linux/init.h>
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/proc_fs.h>
28 #include <linux/smp_lock.h>
30 #include <linux/sched.h>
31 #include <linux/ptrace.h>
32 #include <linux/slab.h>
33 #include <linux/string.h>
34 #include <linux/timer.h>
35 #include <linux/interrupt.h>
36 #include <linux/suspend.h>
39 #include <asm/system.h>
40 #include <asm/bitops.h>
42 #include <linux/netdevice.h>
43 #include <linux/etherdevice.h>
44 #include <linux/skbuff.h>
45 #include <linux/if_arp.h>
46 #include <linux/ioport.h>
47 #include <linux/pci.h>
48 #include <asm/uaccess.h>
51 static struct pci_device_id card_ids[] = {
52 { 0x14b9, 1, PCI_ANY_ID, PCI_ANY_ID, },
53 { 0x14b9, 0x4500, PCI_ANY_ID, PCI_ANY_ID },
54 { 0x14b9, 0x4800, PCI_ANY_ID, PCI_ANY_ID, },
55 { 0x14b9, 0x0340, PCI_ANY_ID, PCI_ANY_ID, },
56 { 0x14b9, 0x0350, PCI_ANY_ID, PCI_ANY_ID, },
57 { 0x14b9, 0x5000, PCI_ANY_ID, PCI_ANY_ID, },
58 { 0x14b9, 0xa504, PCI_ANY_ID, PCI_ANY_ID, },
61 MODULE_DEVICE_TABLE(pci, card_ids);
63 static int airo_pci_probe(struct pci_dev *, const struct pci_device_id *);
64 static void airo_pci_remove(struct pci_dev *);
65 static int airo_pci_suspend(struct pci_dev *pdev, u32 state);
66 static int airo_pci_resume(struct pci_dev *pdev);
68 static struct pci_driver airo_driver = {
71 .probe = airo_pci_probe,
72 .remove = __devexit_p(airo_pci_remove),
73 .suspend = airo_pci_suspend,
74 .resume = airo_pci_resume,
76 #endif /* CONFIG_PCI */
78 /* Include Wireless Extension definition and check version - Jean II */
79 #include <linux/wireless.h>
80 #define WIRELESS_SPY // enable iwspy support
81 #include <net/iw_handler.h> // New driver API
83 #define CISCO_EXT // enable Cisco extensions
85 #include <linux/delay.h>
88 /* Support Cisco MIC feature */
91 #if defined(MICSUPPORT) && !defined(CONFIG_CRYPTO)
92 #warning MIC support requires Crypto API
96 /* Hack to do some power saving */
99 /* As you can see this list is HUGH!
100 I really don't know what a lot of these counts are about, but they
101 are all here for completeness. If the IGNLABEL macro is put in
102 infront of the label, that statistic will not be included in the list
103 of statistics in the /proc filesystem */
105 #define IGNLABEL(comment) NULL
106 static char *statsLabels[] = {
108 IGNLABEL("RxPlcpCrcErr"),
109 IGNLABEL("RxPlcpFormatErr"),
110 IGNLABEL("RxPlcpLengthErr"),
141 "LostSync-MissedBeacons",
142 "LostSync-ArlExceeded",
144 "LostSync-Disassoced",
145 "LostSync-TsfTiming",
154 IGNLABEL("HmacTxMc"),
155 IGNLABEL("HmacTxBc"),
156 IGNLABEL("HmacTxUc"),
157 IGNLABEL("HmacTxFail"),
158 IGNLABEL("HmacRxMc"),
159 IGNLABEL("HmacRxBc"),
160 IGNLABEL("HmacRxUc"),
161 IGNLABEL("HmacRxDiscard"),
162 IGNLABEL("HmacRxAccepted"),
170 IGNLABEL("ReasonOutsideTable"),
171 IGNLABEL("ReasonStatus1"),
172 IGNLABEL("ReasonStatus2"),
173 IGNLABEL("ReasonStatus3"),
174 IGNLABEL("ReasonStatus4"),
175 IGNLABEL("ReasonStatus5"),
176 IGNLABEL("ReasonStatus6"),
177 IGNLABEL("ReasonStatus7"),
178 IGNLABEL("ReasonStatus8"),
179 IGNLABEL("ReasonStatus9"),
180 IGNLABEL("ReasonStatus10"),
181 IGNLABEL("ReasonStatus11"),
182 IGNLABEL("ReasonStatus12"),
183 IGNLABEL("ReasonStatus13"),
184 IGNLABEL("ReasonStatus14"),
185 IGNLABEL("ReasonStatus15"),
186 IGNLABEL("ReasonStatus16"),
187 IGNLABEL("ReasonStatus17"),
188 IGNLABEL("ReasonStatus18"),
189 IGNLABEL("ReasonStatus19"),
209 #define RUN_AT(x) (jiffies+(x))
213 /* These variables are for insmod, since it seems that the rates
214 can only be set in setup_card. Rates should be a comma separated
215 (no spaces) list of rates (up to 8). */
218 static int basic_rate;
219 static char *ssids[3];
225 int maxencrypt /* = 0 */; /* The highest rate that the card can encrypt at.
226 0 means no limit. For old cards this was 4 */
228 static int auto_wep /* = 0 */; /* If set, it tries to figure out the wep mode */
229 static int aux_bap /* = 0 */; /* Checks to see if the aux ports are needed to read
230 the bap, needed on some older cards and buses. */
233 static int probe = 1;
235 static int proc_uid /* = 0 */;
237 static int proc_gid /* = 0 */;
239 static int airo_perm = 0555;
241 static int proc_perm = 0644;
243 MODULE_AUTHOR("Benjamin Reed");
244 MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet \
245 cards. Direct support for ISA/PCI/MPI cards and support \
246 for PCMCIA when used with airo_cs.");
247 MODULE_LICENSE("Dual BSD/GPL");
248 MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340/350");
249 MODULE_PARM(io,"1-4i");
250 MODULE_PARM(irq,"1-4i");
251 MODULE_PARM(basic_rate,"i");
252 MODULE_PARM(rates,"1-8i");
253 MODULE_PARM(ssids,"1-3s");
254 MODULE_PARM(auto_wep,"i");
255 MODULE_PARM_DESC(auto_wep, "If non-zero, the driver will keep looping through \
256 the authentication options until an association is made. The value of \
257 auto_wep is number of the wep keys to check. A value of 2 will try using \
258 the key at index 0 and index 1.");
259 MODULE_PARM(aux_bap,"i");
260 MODULE_PARM_DESC(aux_bap, "If non-zero, the driver will switch into a mode \
261 than seems to work better for older cards with some older buses. Before \
262 switching it checks that the switch is needed.");
263 MODULE_PARM(maxencrypt, "i");
264 MODULE_PARM_DESC(maxencrypt, "The maximum speed that the card can do \
265 encryption. Units are in 512kbs. Zero (default) means there is no limit. \
266 Older cards used to be limited to 2mbs (4).");
267 MODULE_PARM(adhoc, "i");
268 MODULE_PARM_DESC(adhoc, "If non-zero, the card will start in adhoc mode.");
269 MODULE_PARM(probe, "i");
270 MODULE_PARM_DESC(probe, "If zero, the driver won't start the card.");
272 MODULE_PARM(proc_uid, "i");
273 MODULE_PARM_DESC(proc_uid, "The uid that the /proc files will belong to.");
274 MODULE_PARM(proc_gid, "i");
275 MODULE_PARM_DESC(proc_gid, "The gid that the /proc files will belong to.");
276 MODULE_PARM(airo_perm, "i");
277 MODULE_PARM_DESC(airo_perm, "The permission bits of /proc/[driver/]aironet.");
278 MODULE_PARM(proc_perm, "i");
279 MODULE_PARM_DESC(proc_perm, "The permission bits of the files in /proc");
281 /* This is a kind of sloppy hack to get this information to OUT4500 and
282 IN4500. I would be extremely interested in the situation where this
283 doesn't work though!!! */
284 static int do8bitIO = 0;
293 #define MAC_ENABLE 0x0001
294 #define MAC_DISABLE 0x0002
295 #define CMD_LOSE_SYNC 0x0003 /* Not sure what this does... */
296 #define CMD_SOFTRESET 0x0004
297 #define HOSTSLEEP 0x0005
298 #define CMD_MAGIC_PKT 0x0006
299 #define CMD_SETWAKEMASK 0x0007
300 #define CMD_READCFG 0x0008
301 #define CMD_SETMODE 0x0009
302 #define CMD_ALLOCATETX 0x000a
303 #define CMD_TRANSMIT 0x000b
304 #define CMD_DEALLOCATETX 0x000c
306 #define CMD_WORKAROUND 0x0011
307 #define CMD_ALLOCATEAUX 0x0020
308 #define CMD_ACCESS 0x0021
309 #define CMD_PCIBAP 0x0022
310 #define CMD_PCIAUX 0x0023
311 #define CMD_ALLOCBUF 0x0028
312 #define CMD_GETTLV 0x0029
313 #define CMD_PUTTLV 0x002a
314 #define CMD_DELTLV 0x002b
315 #define CMD_FINDNEXTTLV 0x002c
316 #define CMD_PSPNODES 0x0030
317 #define CMD_SETCW 0x0031
318 #define CMD_SETPCF 0x0032
319 #define CMD_SETPHYREG 0x003e
320 #define CMD_TXTEST 0x003f
321 #define MAC_ENABLETX 0x0101
322 #define CMD_LISTBSS 0x0103
323 #define CMD_SAVECFG 0x0108
324 #define CMD_ENABLEAUX 0x0111
325 #define CMD_WRITERID 0x0121
326 #define CMD_USEPSPNODES 0x0130
327 #define MAC_ENABLERX 0x0201
330 #define ERROR_QUALIF 0x00
331 #define ERROR_ILLCMD 0x01
332 #define ERROR_ILLFMT 0x02
333 #define ERROR_INVFID 0x03
334 #define ERROR_INVRID 0x04
335 #define ERROR_LARGE 0x05
336 #define ERROR_NDISABL 0x06
337 #define ERROR_ALLOCBSY 0x07
338 #define ERROR_NORD 0x0B
339 #define ERROR_NOWR 0x0C
340 #define ERROR_INVFIDTX 0x0D
341 #define ERROR_TESTACT 0x0E
342 #define ERROR_TAGNFND 0x12
343 #define ERROR_DECODE 0x20
344 #define ERROR_DESCUNAV 0x21
345 #define ERROR_BADLEN 0x22
346 #define ERROR_MODE 0x80
347 #define ERROR_HOP 0x81
348 #define ERROR_BINTER 0x82
349 #define ERROR_RXMODE 0x83
350 #define ERROR_MACADDR 0x84
351 #define ERROR_RATES 0x85
352 #define ERROR_ORDER 0x86
353 #define ERROR_SCAN 0x87
354 #define ERROR_AUTH 0x88
355 #define ERROR_PSMODE 0x89
356 #define ERROR_RTYPE 0x8A
357 #define ERROR_DIVER 0x8B
358 #define ERROR_SSID 0x8C
359 #define ERROR_APLIST 0x8D
360 #define ERROR_AUTOWAKE 0x8E
361 #define ERROR_LEAP 0x8F
372 #define LINKSTAT 0x10
376 #define TXALLOCFID 0x22
377 #define TXCOMPLFID 0x24
392 /* Offset into aux memory for descriptors */
393 #define AUX_OFFSET 0x800
394 /* Size of allocated packets */
397 /* Size of the transmit queue */
401 #define BAP0 0 // Used for receiving packets
402 #define BAP1 2 // Used for xmiting packets and working with RIDS
405 #define COMMAND_BUSY 0x8000
407 #define BAP_BUSY 0x8000
408 #define BAP_ERR 0x4000
409 #define BAP_DONE 0x2000
411 #define PROMISC 0xffff
412 #define NOPROMISC 0x0000
415 #define EV_CLEARCOMMANDBUSY 0x4000
418 #define EV_TXEXC 0x04
419 #define EV_ALLOC 0x08
421 #define EV_AWAKE 0x100
422 #define EV_TXCPY 0x400
423 #define EV_UNKNOWN 0x800
424 #define EV_MIC 0x1000 /* Message Integrity Check Interrupt */
425 #define EV_AWAKEN 0x2000
426 #define STATUS_INTS (EV_AWAKE|EV_LINK|EV_TXEXC|EV_TX|EV_TXCPY|EV_RX|EV_MIC)
428 #ifdef CHECK_UNKNOWN_INTS
429 #define IGNORE_INTS ( EV_CMD | EV_UNKNOWN)
431 #define IGNORE_INTS (~STATUS_INTS)
438 #define RID_CAPABILITIES 0xFF00
439 #define RID_APINFO 0xFF01
440 #define RID_RADIOINFO 0xFF02
441 #define RID_UNKNOWN3 0xFF03
442 #define RID_RSSI 0xFF04
443 #define RID_CONFIG 0xFF10
444 #define RID_SSID 0xFF11
445 #define RID_APLIST 0xFF12
446 #define RID_DRVNAME 0xFF13
447 #define RID_ETHERENCAP 0xFF14
448 #define RID_WEP_TEMP 0xFF15
449 #define RID_WEP_PERM 0xFF16
450 #define RID_MODULATION 0xFF17
451 #define RID_OPTIONS 0xFF18
452 #define RID_ACTUALCONFIG 0xFF20 /*readonly*/
453 #define RID_FACTORYCONFIG 0xFF21
454 #define RID_UNKNOWN22 0xFF22
455 #define RID_LEAPUSERNAME 0xFF23
456 #define RID_LEAPPASSWORD 0xFF24
457 #define RID_STATUS 0xFF50
458 #define RID_BEACON_HST 0xFF51
459 #define RID_BUSY_HST 0xFF52
460 #define RID_RETRIES_HST 0xFF53
461 #define RID_UNKNOWN54 0xFF54
462 #define RID_UNKNOWN55 0xFF55
463 #define RID_UNKNOWN56 0xFF56
464 #define RID_MIC 0xFF57
465 #define RID_STATS16 0xFF60
466 #define RID_STATS16DELTA 0xFF61
467 #define RID_STATS16DELTACLEAR 0xFF62
468 #define RID_STATS 0xFF68
469 #define RID_STATSDELTA 0xFF69
470 #define RID_STATSDELTACLEAR 0xFF6A
471 #define RID_ECHOTEST_RID 0xFF70
472 #define RID_ECHOTEST_RESULTS 0xFF71
473 #define RID_BSSLISTFIRST 0xFF72
474 #define RID_BSSLISTNEXT 0xFF73
491 * Rids and endian-ness: The Rids will always be in cpu endian, since
492 * this all the patches from the big-endian guys end up doing that.
493 * so all rid access should use the read/writeXXXRid routines.
496 /* This is redundant for x86 archs, but it seems necessary for ARM */
499 /* This structure came from an email sent to me from an engineer at
500 aironet for inclusion into this driver */
509 /* These structures are from the Aironet's PC4500 Developers Manual */
523 #define MOD_DEFAULT 0
529 u16 len; /* sizeof(ConfigRid) */
530 u16 opmode; /* operating mode */
531 #define MODE_STA_IBSS 0
532 #define MODE_STA_ESS 1
534 #define MODE_AP_RPTR 3
535 #define MODE_ETHERNET_HOST (0<<8) /* rx payloads converted */
536 #define MODE_LLC_HOST (1<<8) /* rx payloads left as is */
537 #define MODE_AIRONET_EXTEND (1<<9) /* enable Aironet extenstions */
538 #define MODE_AP_INTERFACE (1<<10) /* enable ap interface extensions */
539 #define MODE_ANTENNA_ALIGN (1<<11) /* enable antenna alignment */
540 #define MODE_ETHER_LLC (1<<12) /* enable ethernet LLC */
541 #define MODE_LEAF_NODE (1<<13) /* enable leaf node bridge */
542 #define MODE_CF_POLLABLE (1<<14) /* enable CF pollable */
543 #define MODE_MIC (1<<15) /* enable MIC */
544 u16 rmode; /* receive mode */
545 #define RXMODE_BC_MC_ADDR 0
546 #define RXMODE_BC_ADDR 1 /* ignore multicasts */
547 #define RXMODE_ADDR 2 /* ignore multicast and broadcast */
548 #define RXMODE_RFMON 3 /* wireless monitor mode */
549 #define RXMODE_RFMON_ANYBSS 4
550 #define RXMODE_LANMON 5 /* lan style monitor -- data packets only */
551 #define RXMODE_DISABLE_802_3_HEADER (1<<8) /* disables 802.3 header on rx */
552 #define RXMODE_NORMALIZED_RSSI (1<<9) /* return normalized RSSI */
555 u8 macAddr[ETH_ALEN];
559 u16 txLifetime; /* in kusec */
560 u16 rxLifetime; /* in kusec */
563 u16 u16deviceType; /* for overriding device type */
567 /*---------- Scanning/Associating ----------*/
569 #define SCANMODE_ACTIVE 0
570 #define SCANMODE_PASSIVE 1
571 #define SCANMODE_AIROSCAN 2
572 u16 probeDelay; /* in kusec */
573 u16 probeEnergyTimeout; /* in kusec */
574 u16 probeResponseTimeout;
575 u16 beaconListenTimeout;
579 #define AUTH_OPEN 0x1
580 #define AUTH_ENCRYPT 0x101
581 #define AUTH_SHAREDKEY 0x102
582 #define AUTH_ALLOW_UNENCRYPTED 0x200
583 u16 associationTimeout;
584 u16 specifiedApTimeout;
585 u16 offlineScanInterval;
586 u16 offlineScanDuration;
588 u16 maxBeaconLostTime;
590 #define DISABLE_REFRESH 0xFFFF
592 /*---------- Power save operation ----------*/
594 #define POWERSAVE_CAM 0
595 #define POWERSAVE_PSP 1
596 #define POWERSAVE_PSPCAM 2
599 u16 fastListenInterval;
603 /*---------- Ap/Ibss config items ----------*/
612 /*---------- Radio configuration ----------*/
614 #define RADIOTYPE_DEFAULT 0
615 #define RADIOTYPE_802_11 1
616 #define RADIOTYPE_LEGACY 2
620 #define TXPOWER_DEFAULT 0
622 #define RSSI_DEFAULT 0
624 #define PREAMBLE_AUTO 0
625 #define PREAMBLE_LONG 1
626 #define PREAMBLE_SHORT 2
630 /*---------- Aironet Extensions ----------*/
636 /*---------- Aironet Extensions ----------*/
638 #define MAGIC_ACTION_STSCHG 1
639 #define MAGIC_ACTION_RESUME 2
640 #define MAGIC_IGNORE_MCAST (1<<8)
641 #define MAGIC_IGNORE_BCAST (1<<9)
642 #define MAGIC_SWITCH_TO_PSP (0<<10)
643 #define MAGIC_STAY_IN_CAM (1<<10)
657 u8 bssid[4][ETH_ALEN];
671 u16 normalizedSignalStrength;
674 u8 noisePercent; /* Noise percent in last second */
675 u8 noisedBm; /* Noise dBm in last second */
676 u8 noiseAvePercent; /* Noise percent in last minute */
677 u8 noiseAvedBm; /* Noise dBm in last minute */
678 u8 noiseMaxPercent; /* Highest noise percent in last minute */
679 u8 noiseMaxdBm; /* Highest noise dbm in last minute */
683 #define STAT_NOPACKETS 0
684 #define STAT_NOCARRIERSET 10
685 #define STAT_GOTCARRIERSET 11
686 #define STAT_WRONGSSID 20
687 #define STAT_BADCHANNEL 25
688 #define STAT_BADBITRATES 30
689 #define STAT_BADPRIVACY 35
690 #define STAT_APFOUND 40
691 #define STAT_APREJECTED 50
692 #define STAT_AUTHENTICATING 60
693 #define STAT_DEAUTHENTICATED 61
694 #define STAT_AUTHTIMEOUT 62
695 #define STAT_ASSOCIATING 70
696 #define STAT_DEASSOCIATED 71
697 #define STAT_ASSOCTIMEOUT 72
698 #define STAT_NOTAIROAP 73
699 #define STAT_ASSOCIATED 80
700 #define STAT_LEAPING 90
701 #define STAT_LEAPFAILED 91
702 #define STAT_LEAPTIMEDOUT 92
703 #define STAT_LEAPCOMPLETE 93
726 char factoryAddr[ETH_ALEN];
727 char aironetAddr[ETH_ALEN];
730 char callid[ETH_ALEN];
731 char supportedRates[8];
734 u16 txPowerLevels[8];
749 u16 index; /* First is 0 and 0xffff means end of list */
750 #define RADIO_FH 1 /* Frequency hopping radio type */
751 #define RADIO_DS 2 /* Direct sequence radio type */
752 #define RADIO_TMA 4 /* Proprietary radio used in old cards (2500) */
754 u8 bssid[ETH_ALEN]; /* Mac address of the BSS */
759 #define CAP_ESS (1<<0)
760 #define CAP_IBSS (1<<1)
761 #define CAP_PRIVACY (1<<4)
762 #define CAP_SHORTHDR (1<<5)
765 u8 rates[8]; /* Same as rates for config rid */
766 struct { /* For frequency hopping only */
820 #define TXCTL_TXOK (1<<1) /* report if tx is ok */
821 #define TXCTL_TXEX (1<<2) /* report if tx fails */
822 #define TXCTL_802_3 (0<<3) /* 802.3 packet */
823 #define TXCTL_802_11 (1<<3) /* 802.11 mac packet */
824 #define TXCTL_ETHERNET (0<<4) /* payload has ethertype */
825 #define TXCTL_LLC (1<<4) /* payload is llc */
826 #define TXCTL_RELEASE (0<<5) /* release after completion */
827 #define TXCTL_NORELEASE (1<<5) /* on completion returns to host */
829 #define BUSY_FID 0x10000
832 #define AIROMAGIC 0xa55a
833 /* Warning : SIOCDEVPRIVATE may disapear during 2.5.X - Jean II */
834 #ifdef SIOCIWFIRSTPRIV
835 #ifdef SIOCDEVPRIVATE
836 #define AIROOLDIOCTL SIOCDEVPRIVATE
837 #define AIROOLDIDIFC AIROOLDIOCTL + 1
838 #endif /* SIOCDEVPRIVATE */
839 #else /* SIOCIWFIRSTPRIV */
840 #define SIOCIWFIRSTPRIV SIOCDEVPRIVATE
841 #endif /* SIOCIWFIRSTPRIV */
842 /* This may be wrong. When using the new SIOCIWFIRSTPRIV range, we probably
843 * should use only "GET" ioctls (last bit set to 1). "SET" ioctls are root
844 * only and don't return the modified struct ifreq to the application which
845 * is usually a problem. - Jean II */
846 #define AIROIOCTL SIOCIWFIRSTPRIV
847 #define AIROIDIFC AIROIOCTL + 1
849 /* Ioctl constants to be used in airo_ioctl.command */
851 #define AIROGCAP 0 // Capability rid
852 #define AIROGCFG 1 // USED A LOT
853 #define AIROGSLIST 2 // System ID list
854 #define AIROGVLIST 3 // List of specified AP's
855 #define AIROGDRVNAM 4 // NOTUSED
856 #define AIROGEHTENC 5 // NOTUSED
857 #define AIROGWEPKTMP 6
858 #define AIROGWEPKNV 7
860 #define AIROGSTATSC32 9
861 #define AIROGSTATSD32 10
862 #define AIROGMICRID 11
863 #define AIROGMICSTATS 12
864 #define AIROGFLAGS 13
867 #define AIRORSWVERSION 17
869 /* Leave gap of 40 commands after AIROGSTATSD32 for future */
871 #define AIROPCAP AIROGSTATSD32 + 40
872 #define AIROPVLIST AIROPCAP + 1
873 #define AIROPSLIST AIROPVLIST + 1
874 #define AIROPCFG AIROPSLIST + 1
875 #define AIROPSIDS AIROPCFG + 1
876 #define AIROPAPLIST AIROPSIDS + 1
877 #define AIROPMACON AIROPAPLIST + 1 /* Enable mac */
878 #define AIROPMACOFF AIROPMACON + 1 /* Disable mac */
879 #define AIROPSTCLR AIROPMACOFF + 1
880 #define AIROPWEPKEY AIROPSTCLR + 1
881 #define AIROPWEPKEYNV AIROPWEPKEY + 1
882 #define AIROPLEAPPWD AIROPWEPKEYNV + 1
883 #define AIROPLEAPUSR AIROPLEAPPWD + 1
887 #define AIROFLSHRST AIROPWEPKEYNV + 40
888 #define AIROFLSHGCHR AIROFLSHRST + 1
889 #define AIROFLSHSTFL AIROFLSHGCHR + 1
890 #define AIROFLSHPCHR AIROFLSHSTFL + 1
891 #define AIROFLPUTBUF AIROFLSHPCHR + 1
892 #define AIRORESTART AIROFLPUTBUF + 1
894 #define FLASHSIZE 32768
895 #define AUXMEMSIZE (256 * 1024)
897 typedef struct aironet_ioctl {
898 unsigned short command; // What to do
899 unsigned short len; // Len of data
900 unsigned short ridnum; // rid number
901 unsigned char __user *data; // d-data
904 static char *swversion = "2.1";
905 #endif /* CISCO_EXT */
907 #define NUM_MODULES 2
908 #define MIC_MSGLEN_MAX 2400
909 #define EMMH32_MSGLEN_MAX MIC_MSGLEN_MAX
913 u8 enabled; // MIC enabled or not
914 u32 rxSuccess; // successful packets received
915 u32 rxIncorrectMIC; // pkts dropped due to incorrect MIC comparison
916 u32 rxNotMICed; // pkts dropped due to not being MIC'd
917 u32 rxMICPlummed; // pkts dropped due to not having a MIC plummed
918 u32 rxWrongSequence; // pkts dropped due to sequence number violation
923 u32 coeff[((EMMH32_MSGLEN_MAX)+3)>>2];
924 u64 accum; // accumulated mic, reduced to u32 in final()
925 int position; // current position (byte offset) in message
929 } part; // saves partial message word across update() calls
933 emmh32_context seed; // Context - the seed
934 u32 rx; // Received sequence number
935 u32 tx; // Tx sequence number
936 u32 window; // Start of window
937 u8 valid; // Flag to say if context is valid or not
942 miccntx mCtx; // Multicast context
943 miccntx uCtx; // Unicast context
947 unsigned int rid: 16;
948 unsigned int len: 15;
949 unsigned int valid: 1;
950 dma_addr_t host_addr;
954 unsigned int offset: 15;
956 unsigned int len: 15;
957 unsigned int valid: 1;
958 dma_addr_t host_addr;
962 unsigned int ctl: 15;
964 unsigned int len: 15;
965 unsigned int valid: 1;
966 dma_addr_t host_addr;
970 * Host receive descriptor
973 unsigned char *card_ram_off; /* offset into card memory of the
975 RxFid rx_desc; /* card receive descriptor */
976 char *virtual_host_addr; /* virtual address of host receive
982 * Host transmit descriptor
985 unsigned char *card_ram_off; /* offset into card memory of the
987 TxFid tx_desc; /* card transmit descriptor */
988 char *virtual_host_addr; /* virtual address of host receive
994 * Host RID descriptor
997 unsigned char *card_ram_off; /* offset into card memory of the
999 Rid rid_desc; /* card RID descriptor */
1000 char *virtual_host_addr; /* virtual address of host receive
1009 #define HOST_SET (1 << 0)
1010 #define HOST_INT_TX (1 << 1) /* Interrupt on successful TX */
1011 #define HOST_INT_TXERR (1 << 2) /* Interrupt on unseccessful TX */
1012 #define HOST_LCC_PAYLOAD (1 << 4) /* LLC payload, 0 = Ethertype */
1013 #define HOST_DONT_RLSE (1 << 5) /* Don't release buffer when done */
1014 #define HOST_DONT_RETRY (1 << 6) /* Don't retry trasmit */
1015 #define HOST_CLR_AID (1 << 7) /* clear AID failure */
1016 #define HOST_RTS (1 << 9) /* Force RTS use */
1017 #define HOST_SHORT (1 << 10) /* Do short preamble */
1044 WifiCtlHdr wifictlhdr8023 = {
1046 .ctl = HOST_DONT_RLSE,
1051 // Frequency list (map channels to frequencies)
1052 static const long frequency_list[] = { 2412, 2417, 2422, 2427, 2432, 2437, 2442,
1053 2447, 2452, 2457, 2462, 2467, 2472, 2484 };
1055 // A few details needed for WEP (Wireless Equivalent Privacy)
1056 #define MAX_KEY_SIZE 13 // 128 (?) bits
1057 #define MIN_KEY_SIZE 5 // 40 bits RC4 - WEP
1058 typedef struct wep_key_t {
1060 u8 key[16]; /* 40-bit and 104-bit keys */
1063 /* Backward compatibility */
1064 #ifndef IW_ENCODE_NOKEY
1065 #define IW_ENCODE_NOKEY 0x0800 /* Key is write only, so not present */
1066 #define IW_ENCODE_MODE (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
1067 #endif /* IW_ENCODE_NOKEY */
1069 /* List of Wireless Handlers (new API) */
1070 static const struct iw_handler_def airo_handler_def;
1071 #endif /* WIRELESS_EXT */
1073 static const char version[] = "airo.c 0.6 (Ben Reed & Javier Achirica)";
1077 static int get_dec_u16( char *buffer, int *start, int limit );
1078 static void OUT4500( struct airo_info *, u16 register, u16 value );
1079 static unsigned short IN4500( struct airo_info *, u16 register );
1080 static u16 setup_card(struct airo_info*, u8 *mac, int lock);
1081 static int enable_MAC( struct airo_info *ai, Resp *rsp, int lock );
1082 static void disable_MAC(struct airo_info *ai, int lock);
1083 static void enable_interrupts(struct airo_info*);
1084 static void disable_interrupts(struct airo_info*);
1085 static u16 issuecommand(struct airo_info*, Cmd *pCmd, Resp *pRsp);
1086 static int bap_setup(struct airo_info*, u16 rid, u16 offset, int whichbap);
1087 static int aux_bap_read(struct airo_info*, u16 *pu16Dst, int bytelen,
1089 static int fast_bap_read(struct airo_info*, u16 *pu16Dst, int bytelen,
1091 static int bap_write(struct airo_info*, const u16 *pu16Src, int bytelen,
1093 static int PC4500_accessrid(struct airo_info*, u16 rid, u16 accmd);
1094 static int PC4500_readrid(struct airo_info*, u16 rid, void *pBuf, int len, int lock);
1095 static int PC4500_writerid(struct airo_info*, u16 rid, const void
1096 *pBuf, int len, int lock);
1097 static int do_writerid( struct airo_info*, u16 rid, const void *rid_data,
1098 int len, int dummy );
1099 static u16 transmit_allocate(struct airo_info*, int lenPayload, int raw);
1100 static int transmit_802_3_packet(struct airo_info*, int len, char *pPacket);
1101 static int transmit_802_11_packet(struct airo_info*, int len, char *pPacket);
1103 static int mpi_send_packet (struct net_device *dev);
1104 static void mpi_unmap_card(struct pci_dev *pci);
1105 static void mpi_receive_802_3(struct airo_info *ai);
1106 static void mpi_receive_802_11(struct airo_info *ai);
1107 static int waitbusy (struct airo_info *ai);
1109 static irqreturn_t airo_interrupt( int irq, void* dev_id, struct pt_regs
1111 static int airo_thread(void *data);
1112 static void timer_func( struct net_device *dev );
1113 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
1115 struct iw_statistics *airo_get_wireless_stats (struct net_device *dev);
1116 static void airo_read_wireless_stats (struct airo_info *local);
1117 #endif /* WIRELESS_EXT */
1119 static int readrids(struct net_device *dev, aironet_ioctl *comp);
1120 static int writerids(struct net_device *dev, aironet_ioctl *comp);
1121 int flashcard(struct net_device *dev, aironet_ioctl *comp);
1122 #endif /* CISCO_EXT */
1124 static void micinit(struct airo_info *ai);
1125 static int micsetup(struct airo_info *ai);
1126 static int encapsulate(struct airo_info *ai, etherHead *pPacket, MICBuffer *buffer, int len);
1127 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *pPacket, u16 payLen);
1129 #include <linux/crypto.h>
1133 struct net_device_stats stats;
1134 struct net_device *dev;
1135 /* Note, we can have MAX_FIDS outstanding. FIDs are 16-bits, so we
1136 use the high bit to mark whether it is in use. */
1138 #define MPI_MAX_FIDS 1
1141 char keyindex; // Used with auto wep
1142 char defindex; // Used with auto wep
1143 struct proc_dir_entry *proc_entry;
1144 spinlock_t aux_lock;
1145 unsigned long flags;
1146 #define FLAG_PROMISC 8 /* IFF_PROMISC 0x100 - include/linux/if.h */
1147 #define FLAG_RADIO_OFF 0 /* User disabling of MAC */
1148 #define FLAG_RADIO_DOWN 1 /* ifup/ifdown disabling of MAC */
1149 #define FLAG_RADIO_MASK 0x03
1150 #define FLAG_ENABLED 2
1151 #define FLAG_ADHOC 3 /* Needed by MIC */
1152 #define FLAG_MIC_CAPABLE 4
1153 #define FLAG_UPDATE_MULTI 5
1154 #define FLAG_UPDATE_UNI 6
1155 #define FLAG_802_11 7
1156 #define FLAG_PENDING_XMIT 9
1157 #define FLAG_PENDING_XMIT11 10
1159 #define FLAG_REGISTERED 12
1160 #define FLAG_COMMIT 13
1161 #define FLAG_RESET 14
1162 #define FLAG_FLASHING 15
1163 #define JOB_MASK 0x1ff0000
1166 #define JOB_XMIT11 18
1167 #define JOB_STATS 19
1168 #define JOB_PROMISC 20
1170 #define JOB_EVENT 22
1171 #define JOB_AUTOWEP 23
1172 #define JOB_WSTATS 24
1173 int (*bap_read)(struct airo_info*, u16 *pu16Dst, int bytelen,
1175 unsigned short *flash;
1177 struct task_struct *task;
1178 struct semaphore sem;
1180 wait_queue_head_t thr_wait;
1181 struct completion thr_exited;
1182 unsigned long expires;
1184 struct sk_buff *skb;
1187 struct net_device *wifidev;
1189 struct iw_statistics wstats; // wireless stats
1190 unsigned long scan_timestamp; /* Time started to scan */
1191 struct iw_spy_data spy_data;
1192 #endif /* WIRELESS_EXT */
1195 struct crypto_tfm *tfm;
1197 mic_statistics micstats;
1199 HostRxDesc rxfids[MPI_MAX_FIDS]; // rx/tx/config MPI350 descriptors
1200 HostTxDesc txfids[MPI_MAX_FIDS];
1201 HostRidDesc config_desc;
1202 unsigned long ridbus; // phys addr of config_desc
1203 struct sk_buff_head txq;// tx queue used by mpi350 code
1204 struct pci_dev *pci;
1205 unsigned char *pcimem;
1206 unsigned char *pciaux;
1207 unsigned char *shared;
1208 dma_addr_t shared_dma;
1212 #define PCI_SHARED_LEN 2*MPI_MAX_FIDS*PKTSIZE+RIDSIZE
1214 char proc_name[IFNAMSIZ];
1217 static inline int bap_read(struct airo_info *ai, u16 *pu16Dst, int bytelen,
1219 return ai->bap_read(ai, pu16Dst, bytelen, whichbap);
1222 static int setup_proc_entry( struct net_device *dev,
1223 struct airo_info *apriv );
1224 static int takedown_proc_entry( struct net_device *dev,
1225 struct airo_info *apriv );
1228 /***********************************************************************
1230 ***********************************************************************
1233 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq);
1234 static void MoveWindow(miccntx *context, u32 micSeq);
1235 void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct crypto_tfm *);
1236 void emmh32_init(emmh32_context *context);
1237 void emmh32_update(emmh32_context *context, u8 *pOctets, int len);
1238 void emmh32_final(emmh32_context *context, u8 digest[4]);
1240 /* micinit - Initialize mic seed */
1242 static void micinit(struct airo_info *ai)
1246 clear_bit(JOB_MIC, &ai->flags);
1247 PC4500_readrid(ai, RID_MIC, &mic_rid, sizeof(mic_rid), 0);
1250 ai->micstats.enabled = (mic_rid.state & 0x00FF) ? 1 : 0;
1252 if (ai->micstats.enabled) {
1253 /* Key must be valid and different */
1254 if (mic_rid.multicastValid && (!ai->mod[0].mCtx.valid ||
1255 (memcmp (ai->mod[0].mCtx.key, mic_rid.multicast,
1256 sizeof(ai->mod[0].mCtx.key)) != 0))) {
1257 /* Age current mic Context */
1258 memcpy(&ai->mod[1].mCtx,&ai->mod[0].mCtx,sizeof(miccntx));
1259 /* Initialize new context */
1260 memcpy(&ai->mod[0].mCtx.key,mic_rid.multicast,sizeof(mic_rid.multicast));
1261 ai->mod[0].mCtx.window = 33; //Window always points to the middle
1262 ai->mod[0].mCtx.rx = 0; //Rx Sequence numbers
1263 ai->mod[0].mCtx.tx = 0; //Tx sequence numbers
1264 ai->mod[0].mCtx.valid = 1; //Key is now valid
1266 /* Give key to mic seed */
1267 emmh32_setseed(&ai->mod[0].mCtx.seed,mic_rid.multicast,sizeof(mic_rid.multicast), ai->tfm);
1270 /* Key must be valid and different */
1271 if (mic_rid.unicastValid && (!ai->mod[0].uCtx.valid ||
1272 (memcmp(ai->mod[0].uCtx.key, mic_rid.unicast,
1273 sizeof(ai->mod[0].uCtx.key)) != 0))) {
1274 /* Age current mic Context */
1275 memcpy(&ai->mod[1].uCtx,&ai->mod[0].uCtx,sizeof(miccntx));
1276 /* Initialize new context */
1277 memcpy(&ai->mod[0].uCtx.key,mic_rid.unicast,sizeof(mic_rid.unicast));
1279 ai->mod[0].uCtx.window = 33; //Window always points to the middle
1280 ai->mod[0].uCtx.rx = 0; //Rx Sequence numbers
1281 ai->mod[0].uCtx.tx = 0; //Tx sequence numbers
1282 ai->mod[0].uCtx.valid = 1; //Key is now valid
1284 //Give key to mic seed
1285 emmh32_setseed(&ai->mod[0].uCtx.seed, mic_rid.unicast, sizeof(mic_rid.unicast), ai->tfm);
1288 /* So next time we have a valid key and mic is enabled, we will update
1289 * the sequence number if the key is the same as before.
1291 ai->mod[0].uCtx.valid = 0;
1292 ai->mod[0].mCtx.valid = 0;
1296 /* micsetup - Get ready for business */
1298 static int micsetup(struct airo_info *ai) {
1301 if (ai->tfm == NULL)
1302 ai->tfm = crypto_alloc_tfm("aes", 0);
1304 if (ai->tfm == NULL) {
1305 printk(KERN_ERR "airo: failed to load transform for AES\n");
1309 for (i=0; i < NUM_MODULES; i++) {
1310 memset(&ai->mod[i].mCtx,0,sizeof(miccntx));
1311 memset(&ai->mod[i].uCtx,0,sizeof(miccntx));
1316 char micsnap[]= {0xAA,0xAA,0x03,0x00,0x40,0x96,0x00,0x02};
1318 /*===========================================================================
1319 * Description: Mic a packet
1321 * Inputs: etherHead * pointer to an 802.3 frame
1323 * Returns: BOOLEAN if successful, otherwise false.
1324 * PacketTxLen will be updated with the mic'd packets size.
1326 * Caveats: It is assumed that the frame buffer will already
1327 * be big enough to hold the largets mic message possible.
1328 * (No memory allocation is done here).
1330 * Author: sbraneky (10/15/01)
1331 * Merciless hacks by rwilcher (1/14/02)
1334 static int encapsulate(struct airo_info *ai ,etherHead *frame, MICBuffer *mic, int payLen)
1338 // Determine correct context
1339 // If not adhoc, always use unicast key
1341 if (test_bit(FLAG_ADHOC, &ai->flags) && (frame->da[0] & 0x1))
1342 context = &ai->mod[0].mCtx;
1344 context = &ai->mod[0].uCtx;
1346 if (!context->valid)
1349 mic->typelen = htons(payLen + 16); //Length of Mic'd packet
1351 memcpy(&mic->u.snap, micsnap, sizeof(micsnap)); // Add Snap
1354 mic->seq = htonl(context->tx);
1357 emmh32_init(&context->seed); // Mic the packet
1358 emmh32_update(&context->seed,frame->da,ETH_ALEN * 2); // DA,SA
1359 emmh32_update(&context->seed,(u8*)&mic->typelen,10); // Type/Length and Snap
1360 emmh32_update(&context->seed,(u8*)&mic->seq,sizeof(mic->seq)); //SEQ
1361 emmh32_update(&context->seed,frame->da + ETH_ALEN * 2,payLen); //payload
1362 emmh32_final(&context->seed, (u8*)&mic->mic);
1364 /* New Type/length ?????????? */
1365 mic->typelen = 0; //Let NIC know it could be an oversized packet
1377 /*===========================================================================
1378 * Description: Decapsulates a MIC'd packet and returns the 802.3 packet
1379 * (removes the MIC stuff) if packet is a valid packet.
1381 * Inputs: etherHead pointer to the 802.3 packet
1383 * Returns: BOOLEAN - TRUE if packet should be dropped otherwise FALSE
1385 * Author: sbraneky (10/15/01)
1386 * Merciless hacks by rwilcher (1/14/02)
1387 *---------------------------------------------------------------------------
1390 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *eth, u16 payLen)
1396 mic_error micError = NONE;
1398 // Check if the packet is a Mic'd packet
1400 if (!ai->micstats.enabled) {
1401 //No Mic set or Mic OFF but we received a MIC'd packet.
1402 if (memcmp ((u8*)eth + 14, micsnap, sizeof(micsnap)) == 0) {
1403 ai->micstats.rxMICPlummed++;
1409 if (ntohs(mic->typelen) == 0x888E)
1412 if (memcmp (mic->u.snap, micsnap, sizeof(micsnap)) != 0) {
1413 // Mic enabled but packet isn't Mic'd
1414 ai->micstats.rxMICPlummed++;
1418 micSEQ = ntohl(mic->seq); //store SEQ as CPU order
1420 //At this point we a have a mic'd packet and mic is enabled
1421 //Now do the mic error checking.
1423 //Receive seq must be odd
1424 if ( (micSEQ & 1) == 0 ) {
1425 ai->micstats.rxWrongSequence++;
1429 for (i = 0; i < NUM_MODULES; i++) {
1430 int mcast = eth->da[0] & 1;
1431 //Determine proper context
1432 context = mcast ? &ai->mod[i].mCtx : &ai->mod[i].uCtx;
1434 //Make sure context is valid
1435 if (!context->valid) {
1437 micError = NOMICPLUMMED;
1443 mic->typelen = htons(payLen + sizeof(MICBuffer) - 2);
1445 emmh32_init(&context->seed);
1446 emmh32_update(&context->seed, eth->da, ETH_ALEN*2);
1447 emmh32_update(&context->seed, (u8 *)&mic->typelen, sizeof(mic->typelen)+sizeof(mic->u.snap));
1448 emmh32_update(&context->seed, (u8 *)&mic->seq,sizeof(mic->seq));
1449 emmh32_update(&context->seed, eth->da + ETH_ALEN*2,payLen);
1451 emmh32_final(&context->seed, digest);
1453 if (memcmp(digest, &mic->mic, 4)) { //Make sure the mics match
1456 micError = INCORRECTMIC;
1460 //Check Sequence number if mics pass
1461 if (RxSeqValid(ai, context, mcast, micSEQ) == SUCCESS) {
1462 ai->micstats.rxSuccess++;
1466 micError = SEQUENCE;
1469 // Update statistics
1471 case NOMICPLUMMED: ai->micstats.rxMICPlummed++; break;
1472 case SEQUENCE: ai->micstats.rxWrongSequence++; break;
1473 case INCORRECTMIC: ai->micstats.rxIncorrectMIC++; break;
1480 /*===========================================================================
1481 * Description: Checks the Rx Seq number to make sure it is valid
1482 * and hasn't already been received
1484 * Inputs: miccntx - mic context to check seq against
1485 * micSeq - the Mic seq number
1487 * Returns: TRUE if valid otherwise FALSE.
1489 * Author: sbraneky (10/15/01)
1490 * Merciless hacks by rwilcher (1/14/02)
1491 *---------------------------------------------------------------------------
1494 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq)
1498 //Allow for the ap being rebooted - if it is then use the next
1499 //sequence number of the current sequence number - might go backwards
1502 if (test_bit(FLAG_UPDATE_MULTI, &ai->flags)) {
1503 clear_bit (FLAG_UPDATE_MULTI, &ai->flags);
1504 context->window = (micSeq > 33) ? micSeq : 33;
1505 context->rx = 0; // Reset rx
1507 } else if (test_bit(FLAG_UPDATE_UNI, &ai->flags)) {
1508 clear_bit (FLAG_UPDATE_UNI, &ai->flags);
1509 context->window = (micSeq > 33) ? micSeq : 33; // Move window
1510 context->rx = 0; // Reset rx
1513 //Make sequence number relative to START of window
1514 seq = micSeq - (context->window - 33);
1516 //Too old of a SEQ number to check.
1521 //Window is infinite forward
1522 MoveWindow(context,micSeq);
1526 // We are in the window. Now check the context rx bit to see if it was already sent
1527 seq >>= 1; //divide by 2 because we only have odd numbers
1528 index = 1 << seq; //Get an index number
1530 if (!(context->rx & index)) {
1531 //micSEQ falls inside the window.
1532 //Add seqence number to the list of received numbers.
1533 context->rx |= index;
1535 MoveWindow(context,micSeq);
1542 static void MoveWindow(miccntx *context, u32 micSeq)
1546 //Move window if seq greater than the middle of the window
1547 if (micSeq > context->window) {
1548 shift = (micSeq - context->window) >> 1;
1552 context->rx >>= shift;
1556 context->window = micSeq; //Move window
1560 /*==============================================*/
1561 /*========== EMMH ROUTINES ====================*/
1562 /*==============================================*/
1564 /* mic accumulate */
1565 #define MIC_ACCUM(val) \
1566 context->accum += (u64)(val) * context->coeff[coeff_position++];
1568 static unsigned char aes_counter[16];
1570 /* expand the key to fill the MMH coefficient array */
1571 void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct crypto_tfm *tfm)
1573 /* take the keying material, expand if necessary, truncate at 16-bytes */
1574 /* run through AES counter mode to generate context->coeff[] */
1578 u8 *cipher, plain[16];
1579 struct scatterlist sg[1];
1581 crypto_cipher_setkey(tfm, pkey, 16);
1583 for (i = 0; i < (sizeof(context->coeff)/sizeof(context->coeff[0])); ) {
1584 aes_counter[15] = (u8)(counter >> 0);
1585 aes_counter[14] = (u8)(counter >> 8);
1586 aes_counter[13] = (u8)(counter >> 16);
1587 aes_counter[12] = (u8)(counter >> 24);
1589 memcpy (plain, aes_counter, 16);
1590 sg[0].page = virt_to_page(plain);
1591 sg[0].offset = ((long) plain & ~PAGE_MASK);
1593 crypto_cipher_encrypt(tfm, sg, sg, 16);
1594 cipher = kmap(sg[0].page) + sg[0].offset;
1595 for (j=0; (j<16) && (i< (sizeof(context->coeff)/sizeof(context->coeff[0]))); ) {
1596 context->coeff[i++] = ntohl(*(u32 *)&cipher[j]);
1602 /* prepare for calculation of a new mic */
1603 void emmh32_init(emmh32_context *context)
1605 /* prepare for new mic calculation */
1607 context->position = 0;
1610 /* add some bytes to the mic calculation */
1611 void emmh32_update(emmh32_context *context, u8 *pOctets, int len)
1613 int coeff_position, byte_position;
1615 if (len == 0) return;
1617 coeff_position = context->position >> 2;
1619 /* deal with partial 32-bit word left over from last update */
1620 byte_position = context->position & 3;
1621 if (byte_position) {
1622 /* have a partial word in part to deal with */
1624 if (len == 0) return;
1625 context->part.d8[byte_position++] = *pOctets++;
1626 context->position++;
1628 } while (byte_position < 4);
1629 MIC_ACCUM(htonl(context->part.d32));
1632 /* deal with full 32-bit words */
1634 MIC_ACCUM(htonl(*(u32 *)pOctets));
1635 context->position += 4;
1640 /* deal with partial 32-bit word that will be left over from this update */
1643 context->part.d8[byte_position++] = *pOctets++;
1644 context->position++;
1649 /* mask used to zero empty bytes for final partial word */
1650 static u32 mask32[4] = { 0x00000000L, 0xFF000000L, 0xFFFF0000L, 0xFFFFFF00L };
1652 /* calculate the mic */
1653 void emmh32_final(emmh32_context *context, u8 digest[4])
1655 int coeff_position, byte_position;
1661 coeff_position = context->position >> 2;
1663 /* deal with partial 32-bit word left over from last update */
1664 byte_position = context->position & 3;
1665 if (byte_position) {
1666 /* have a partial word in part to deal with */
1667 val = htonl(context->part.d32);
1668 MIC_ACCUM(val & mask32[byte_position]); /* zero empty bytes */
1671 /* reduce the accumulated u64 to a 32-bit MIC */
1672 sum = context->accum;
1673 stmp = (sum & 0xffffffffLL) - ((sum >> 32) * 15);
1674 utmp = (stmp & 0xffffffffLL) - ((stmp >> 32) * 15);
1675 sum = utmp & 0xffffffffLL;
1676 if (utmp > 0x10000000fLL)
1680 digest[0] = (val>>24) & 0xFF;
1681 digest[1] = (val>>16) & 0xFF;
1682 digest[2] = (val>>8) & 0xFF;
1683 digest[3] = val & 0xFF;
1687 static int readBSSListRid(struct airo_info *ai, int first,
1694 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
1695 memset(&cmd, 0, sizeof(cmd));
1696 cmd.cmd=CMD_LISTBSS;
1697 if (down_interruptible(&ai->sem))
1698 return -ERESTARTSYS;
1699 issuecommand(ai, &cmd, &rsp);
1701 /* Let the command take effect */
1702 set_current_state (TASK_INTERRUPTIBLE);
1704 schedule_timeout (3*HZ);
1707 rc = PC4500_readrid(ai, first ? RID_BSSLISTFIRST : RID_BSSLISTNEXT,
1708 list, sizeof(*list), 1);
1710 list->len = le16_to_cpu(list->len);
1711 list->index = le16_to_cpu(list->index);
1712 list->radioType = le16_to_cpu(list->radioType);
1713 list->cap = le16_to_cpu(list->cap);
1714 list->beaconInterval = le16_to_cpu(list->beaconInterval);
1715 list->fh.dwell = le16_to_cpu(list->fh.dwell);
1716 list->dsChannel = le16_to_cpu(list->dsChannel);
1717 list->atimWindow = le16_to_cpu(list->atimWindow);
1721 static int readWepKeyRid(struct airo_info*ai, WepKeyRid *wkr, int temp, int lock) {
1722 int rc = PC4500_readrid(ai, temp ? RID_WEP_TEMP : RID_WEP_PERM,
1723 wkr, sizeof(*wkr), lock);
1725 wkr->len = le16_to_cpu(wkr->len);
1726 wkr->kindex = le16_to_cpu(wkr->kindex);
1727 wkr->klen = le16_to_cpu(wkr->klen);
1730 /* In the writeXXXRid routines we copy the rids so that we don't screwup
1731 * the originals when we endian them... */
1732 static int writeWepKeyRid(struct airo_info*ai, WepKeyRid *pwkr, int perm, int lock) {
1734 WepKeyRid wkr = *pwkr;
1736 wkr.len = cpu_to_le16(wkr.len);
1737 wkr.kindex = cpu_to_le16(wkr.kindex);
1738 wkr.klen = cpu_to_le16(wkr.klen);
1739 rc = PC4500_writerid(ai, RID_WEP_TEMP, &wkr, sizeof(wkr), lock);
1740 if (rc!=SUCCESS) printk(KERN_ERR "airo: WEP_TEMP set %x\n", rc);
1742 rc = PC4500_writerid(ai, RID_WEP_PERM, &wkr, sizeof(wkr), lock);
1744 printk(KERN_ERR "airo: WEP_PERM set %x\n", rc);
1750 static int readSsidRid(struct airo_info*ai, SsidRid *ssidr) {
1752 int rc = PC4500_readrid(ai, RID_SSID, ssidr, sizeof(*ssidr), 1);
1754 ssidr->len = le16_to_cpu(ssidr->len);
1755 for(i = 0; i < 3; i++) {
1756 ssidr->ssids[i].len = le16_to_cpu(ssidr->ssids[i].len);
1760 static int writeSsidRid(struct airo_info*ai, SsidRid *pssidr, int lock) {
1763 SsidRid ssidr = *pssidr;
1765 ssidr.len = cpu_to_le16(ssidr.len);
1766 for(i = 0; i < 3; i++) {
1767 ssidr.ssids[i].len = cpu_to_le16(ssidr.ssids[i].len);
1769 rc = PC4500_writerid(ai, RID_SSID, &ssidr, sizeof(ssidr), lock);
1772 static int readConfigRid(struct airo_info*ai, int lock) {
1780 rc = PC4500_readrid(ai, RID_ACTUALCONFIG, &cfg, sizeof(cfg), lock);
1784 for(s = &cfg.len; s <= &cfg.rtsThres; s++) *s = le16_to_cpu(*s);
1786 for(s = &cfg.shortRetryLimit; s <= &cfg.radioType; s++)
1787 *s = le16_to_cpu(*s);
1789 for(s = &cfg.txPower; s <= &cfg.radioSpecific; s++)
1790 *s = le16_to_cpu(*s);
1792 for(s = &cfg.arlThreshold; s <= &cfg._reserved4[0]; s++)
1793 *s = cpu_to_le16(*s);
1795 for(s = &cfg.autoWake; s <= &cfg.autoWake; s++)
1796 *s = cpu_to_le16(*s);
1801 static inline void checkThrottle(struct airo_info *ai) {
1803 /* Old hardware had a limit on encryption speed */
1804 if (ai->config.authType != AUTH_OPEN && maxencrypt) {
1805 for(i=0; i<8; i++) {
1806 if (ai->config.rates[i] > maxencrypt) {
1807 ai->config.rates[i] = 0;
1812 static int writeConfigRid(struct airo_info*ai, int lock) {
1816 if (!test_bit (FLAG_COMMIT, &ai->flags))
1819 clear_bit (FLAG_COMMIT, &ai->flags);
1820 clear_bit (FLAG_RESET, &ai->flags);
1824 if ((cfgr.opmode & 0xFF) == MODE_STA_IBSS)
1825 set_bit(FLAG_ADHOC, &ai->flags);
1827 clear_bit(FLAG_ADHOC, &ai->flags);
1829 for(s = &cfgr.len; s <= &cfgr.rtsThres; s++) *s = cpu_to_le16(*s);
1831 for(s = &cfgr.shortRetryLimit; s <= &cfgr.radioType; s++)
1832 *s = cpu_to_le16(*s);
1834 for(s = &cfgr.txPower; s <= &cfgr.radioSpecific; s++)
1835 *s = cpu_to_le16(*s);
1837 for(s = &cfgr.arlThreshold; s <= &cfgr._reserved4[0]; s++)
1838 *s = cpu_to_le16(*s);
1840 for(s = &cfgr.autoWake; s <= &cfgr.autoWake; s++)
1841 *s = cpu_to_le16(*s);
1843 return PC4500_writerid( ai, RID_CONFIG, &cfgr, sizeof(cfgr), lock);
1845 static int readStatusRid(struct airo_info*ai, StatusRid *statr, int lock) {
1846 int rc = PC4500_readrid(ai, RID_STATUS, statr, sizeof(*statr), lock);
1849 statr->len = le16_to_cpu(statr->len);
1850 for(s = &statr->mode; s <= &statr->SSIDlen; s++) *s = le16_to_cpu(*s);
1852 for(s = &statr->beaconPeriod; s <= &statr->shortPreamble; s++)
1853 *s = le16_to_cpu(*s);
1854 statr->load = le16_to_cpu(statr->load);
1855 statr->assocStatus = le16_to_cpu(statr->assocStatus);
1858 static int readAPListRid(struct airo_info*ai, APListRid *aplr) {
1859 int rc = PC4500_readrid(ai, RID_APLIST, aplr, sizeof(*aplr), 1);
1860 aplr->len = le16_to_cpu(aplr->len);
1863 static int writeAPListRid(struct airo_info*ai, APListRid *aplr, int lock) {
1865 aplr->len = cpu_to_le16(aplr->len);
1866 rc = PC4500_writerid(ai, RID_APLIST, aplr, sizeof(*aplr), lock);
1869 static int readCapabilityRid(struct airo_info*ai, CapabilityRid *capr, int lock) {
1870 int rc = PC4500_readrid(ai, RID_CAPABILITIES, capr, sizeof(*capr), lock);
1873 capr->len = le16_to_cpu(capr->len);
1874 capr->prodNum = le16_to_cpu(capr->prodNum);
1875 capr->radioType = le16_to_cpu(capr->radioType);
1876 capr->country = le16_to_cpu(capr->country);
1877 for(s = &capr->txPowerLevels[0]; s <= &capr->requiredHard; s++)
1878 *s = le16_to_cpu(*s);
1881 static int readStatsRid(struct airo_info*ai, StatsRid *sr, int rid, int lock) {
1882 int rc = PC4500_readrid(ai, rid, sr, sizeof(*sr), lock);
1885 sr->len = le16_to_cpu(sr->len);
1886 for(i = &sr->vals[0]; i <= &sr->vals[99]; i++) *i = le32_to_cpu(*i);
1890 static int airo_open(struct net_device *dev) {
1891 struct airo_info *info = dev->priv;
1894 if (test_bit(FLAG_FLASHING, &info->flags))
1897 /* Make sure the card is configured.
1898 * Wireless Extensions may postpone config changes until the card
1899 * is open (to pipeline changes and speed-up card setup). If
1900 * those changes are not yet commited, do it now - Jean II */
1901 if (test_bit (FLAG_COMMIT, &info->flags)) {
1902 disable_MAC(info, 1);
1903 writeConfigRid(info, 1);
1906 if (info->wifidev != dev) {
1907 /* Power on the MAC controller (which may have been disabled) */
1908 clear_bit(FLAG_RADIO_DOWN, &info->flags);
1909 enable_interrupts(info);
1911 enable_MAC(info, &rsp, 1);
1913 netif_start_queue(dev);
1917 static int mpi_start_xmit(struct sk_buff *skb, struct net_device *dev) {
1918 int npacks, pending;
1919 unsigned long flags;
1920 struct airo_info *ai = dev->priv;
1923 printk(KERN_ERR "airo: %s: skb==NULL\n",__FUNCTION__);
1926 npacks = skb_queue_len (&ai->txq);
1928 if (npacks >= MAXTXQ - 1) {
1929 netif_stop_queue (dev);
1930 if (npacks > MAXTXQ) {
1931 ai->stats.tx_fifo_errors++;
1934 skb_queue_tail (&ai->txq, skb);
1938 spin_lock_irqsave(&ai->aux_lock, flags);
1939 skb_queue_tail (&ai->txq, skb);
1940 pending = test_bit(FLAG_PENDING_XMIT, &ai->flags);
1941 spin_unlock_irqrestore(&ai->aux_lock,flags);
1942 netif_wake_queue (dev);
1945 set_bit(FLAG_PENDING_XMIT, &ai->flags);
1946 mpi_send_packet (dev);
1954 * Attempt to transmit a packet. Can be called from interrupt
1955 * or transmit . return number of packets we tried to send
1958 static int mpi_send_packet (struct net_device *dev)
1960 struct sk_buff *skb;
1961 unsigned char *buffer;
1962 s16 len, *payloadLen;
1963 struct airo_info *ai = dev->priv;
1966 /* get a packet to send */
1968 if ((skb = skb_dequeue(&ai->txq)) == 0) {
1970 "airo: %s: Dequeue'd zero in send_packet()\n",
1975 /* check min length*/
1976 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1979 ai->txfids[0].tx_desc.offset = 0;
1980 ai->txfids[0].tx_desc.valid = 1;
1981 ai->txfids[0].tx_desc.eoc = 1;
1982 ai->txfids[0].tx_desc.len =len+sizeof(WifiHdr);
1985 * Magic, the cards firmware needs a length count (2 bytes) in the host buffer
1986 * right after TXFID_HDR.The TXFID_HDR contains the status short so payloadlen
1987 * is immediatly after it. ------------------------------------------------
1988 * |TXFIDHDR+STATUS|PAYLOADLEN|802.3HDR|PACKETDATA|
1989 * ------------------------------------------------
1992 memcpy((char *)ai->txfids[0].virtual_host_addr,
1993 (char *)&wifictlhdr8023, sizeof(wifictlhdr8023));
1995 payloadLen = (s16 *)(ai->txfids[0].virtual_host_addr +
1996 sizeof(wifictlhdr8023));
1997 sendbuf = ai->txfids[0].virtual_host_addr +
1998 sizeof(wifictlhdr8023) + 2 ;
2001 * Firmware automaticly puts 802 header on so
2002 * we don't need to account for it in the length
2005 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
2006 (ntohs(((u16 *)buffer)[6]) != 0x888E)) {
2009 if (encapsulate(ai, (etherHead *)buffer, &pMic, len - sizeof(etherHead)) != SUCCESS)
2012 *payloadLen = cpu_to_le16(len-sizeof(etherHead)+sizeof(pMic));
2013 ai->txfids[0].tx_desc.len += sizeof(pMic);
2014 /* copy data into airo dma buffer */
2015 memcpy (sendbuf, buffer, sizeof(etherHead));
2016 buffer += sizeof(etherHead);
2017 sendbuf += sizeof(etherHead);
2018 memcpy (sendbuf, &pMic, sizeof(pMic));
2019 sendbuf += sizeof(pMic);
2020 memcpy (sendbuf, buffer, len - sizeof(etherHead));
2024 *payloadLen = cpu_to_le16(len - sizeof(etherHead));
2026 dev->trans_start = jiffies;
2028 /* copy data into airo dma buffer */
2029 memcpy(sendbuf, buffer, len);
2032 memcpy((char *)ai->txfids[0].card_ram_off,
2033 (char *)&ai->txfids[0].tx_desc, sizeof(TxFid));
2035 OUT4500(ai, EVACK, 8);
2037 dev_kfree_skb_any(skb);
2041 static void get_tx_error(struct airo_info *ai, u32 fid)
2046 status = ((WifiCtlHdr *)ai->txfids[0].virtual_host_addr)->ctlhdr.status;
2048 if (bap_setup(ai, ai->fids[fid] & 0xffff, 4, BAP0) != SUCCESS)
2050 bap_read(ai, &status, 2, BAP0);
2052 if (le16_to_cpu(status) & 2) /* Too many retries */
2053 ai->stats.tx_aborted_errors++;
2054 if (le16_to_cpu(status) & 4) /* Transmit lifetime exceeded */
2055 ai->stats.tx_heartbeat_errors++;
2056 if (le16_to_cpu(status) & 8) /* Aid fail */
2058 if (le16_to_cpu(status) & 0x10) /* MAC disabled */
2059 ai->stats.tx_carrier_errors++;
2060 if (le16_to_cpu(status) & 0x20) /* Association lost */
2062 /* We produce a TXDROP event only for retry or lifetime
2063 * exceeded, because that's the only status that really mean
2064 * that this particular node went away.
2065 * Other errors means that *we* screwed up. - Jean II */
2066 if ((le16_to_cpu(status) & 2) ||
2067 (le16_to_cpu(status) & 4)) {
2068 union iwreq_data wrqu;
2071 /* Faster to skip over useless data than to do
2072 * another bap_setup(). We are at offset 0x6 and
2073 * need to go to 0x18 and read 6 bytes - Jean II */
2074 bap_read(ai, (u16 *) junk, 0x18, BAP0);
2076 /* Copy 802.11 dest address.
2077 * We use the 802.11 header because the frame may
2078 * not be 802.3 or may be mangled...
2079 * In Ad-Hoc mode, it will be the node address.
2080 * In managed mode, it will be most likely the AP addr
2081 * User space will figure out how to convert it to
2082 * whatever it needs (IP address or else).
2084 memcpy(wrqu.addr.sa_data, junk + 0x12, ETH_ALEN);
2085 wrqu.addr.sa_family = ARPHRD_ETHER;
2087 /* Send event to user space */
2088 wireless_send_event(ai->dev, IWEVTXDROP, &wrqu, NULL);
2092 static void airo_end_xmit(struct net_device *dev) {
2095 struct airo_info *priv = dev->priv;
2096 struct sk_buff *skb = priv->xmit.skb;
2097 int fid = priv->xmit.fid;
2098 u32 *fids = priv->fids;
2100 clear_bit(JOB_XMIT, &priv->flags);
2101 clear_bit(FLAG_PENDING_XMIT, &priv->flags);
2102 status = transmit_802_3_packet (priv, fids[fid], skb->data);
2106 if ( status == SUCCESS ) {
2107 dev->trans_start = jiffies;
2108 for (; i < MAX_FIDS / 2 && (priv->fids[i] & 0xffff0000); i++);
2110 priv->fids[fid] &= 0xffff;
2111 priv->stats.tx_window_errors++;
2113 if (i < MAX_FIDS / 2)
2114 netif_wake_queue(dev);
2118 static int airo_start_xmit(struct sk_buff *skb, struct net_device *dev) {
2121 struct airo_info *priv = dev->priv;
2122 u32 *fids = priv->fids;
2124 if ( skb == NULL ) {
2125 printk( KERN_ERR "airo: skb == NULL!!!\n" );
2129 /* Find a vacant FID */
2130 for( i = 0; i < MAX_FIDS / 2 && (fids[i] & 0xffff0000); i++ );
2131 for( j = i + 1; j < MAX_FIDS / 2 && (fids[j] & 0xffff0000); j++ );
2133 if ( j >= MAX_FIDS / 2 ) {
2134 netif_stop_queue(dev);
2136 if (i == MAX_FIDS / 2) {
2137 priv->stats.tx_fifo_errors++;
2141 /* check min length*/
2142 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2143 /* Mark fid as used & save length for later */
2144 fids[i] |= (len << 16);
2145 priv->xmit.skb = skb;
2147 if (down_trylock(&priv->sem) != 0) {
2148 set_bit(FLAG_PENDING_XMIT, &priv->flags);
2149 netif_stop_queue(dev);
2150 set_bit(JOB_XMIT, &priv->flags);
2151 wake_up_interruptible(&priv->thr_wait);
2157 static void airo_end_xmit11(struct net_device *dev) {
2160 struct airo_info *priv = dev->priv;
2161 struct sk_buff *skb = priv->xmit11.skb;
2162 int fid = priv->xmit11.fid;
2163 u32 *fids = priv->fids;
2165 clear_bit(JOB_XMIT11, &priv->flags);
2166 clear_bit(FLAG_PENDING_XMIT11, &priv->flags);
2167 status = transmit_802_11_packet (priv, fids[fid], skb->data);
2171 if ( status == SUCCESS ) {
2172 dev->trans_start = jiffies;
2173 for (; i < MAX_FIDS && (priv->fids[i] & 0xffff0000); i++);
2175 priv->fids[fid] &= 0xffff;
2176 priv->stats.tx_window_errors++;
2179 netif_wake_queue(dev);
2183 static int airo_start_xmit11(struct sk_buff *skb, struct net_device *dev) {
2186 struct airo_info *priv = dev->priv;
2187 u32 *fids = priv->fids;
2189 if (test_bit(FLAG_MPI, &priv->flags)) {
2190 /* Not implemented yet for MPI350 */
2191 netif_stop_queue(dev);
2195 if ( skb == NULL ) {
2196 printk( KERN_ERR "airo: skb == NULL!!!\n" );
2200 /* Find a vacant FID */
2201 for( i = MAX_FIDS / 2; i < MAX_FIDS && (fids[i] & 0xffff0000); i++ );
2202 for( j = i + 1; j < MAX_FIDS && (fids[j] & 0xffff0000); j++ );
2204 if ( j >= MAX_FIDS ) {
2205 netif_stop_queue(dev);
2207 if (i == MAX_FIDS) {
2208 priv->stats.tx_fifo_errors++;
2212 /* check min length*/
2213 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2214 /* Mark fid as used & save length for later */
2215 fids[i] |= (len << 16);
2216 priv->xmit11.skb = skb;
2217 priv->xmit11.fid = i;
2218 if (down_trylock(&priv->sem) != 0) {
2219 set_bit(FLAG_PENDING_XMIT11, &priv->flags);
2220 netif_stop_queue(dev);
2221 set_bit(JOB_XMIT11, &priv->flags);
2222 wake_up_interruptible(&priv->thr_wait);
2224 airo_end_xmit11(dev);
2228 static void airo_read_stats(struct airo_info *ai) {
2230 u32 *vals = stats_rid.vals;
2232 clear_bit(JOB_STATS, &ai->flags);
2237 readStatsRid(ai, &stats_rid, RID_STATS, 0);
2240 ai->stats.rx_packets = vals[43] + vals[44] + vals[45];
2241 ai->stats.tx_packets = vals[39] + vals[40] + vals[41];
2242 ai->stats.rx_bytes = vals[92];
2243 ai->stats.tx_bytes = vals[91];
2244 ai->stats.rx_errors = vals[0] + vals[2] + vals[3] + vals[4];
2245 ai->stats.tx_errors = vals[42] + ai->stats.tx_fifo_errors;
2246 ai->stats.multicast = vals[43];
2247 ai->stats.collisions = vals[89];
2249 /* detailed rx_errors: */
2250 ai->stats.rx_length_errors = vals[3];
2251 ai->stats.rx_crc_errors = vals[4];
2252 ai->stats.rx_frame_errors = vals[2];
2253 ai->stats.rx_fifo_errors = vals[0];
2256 struct net_device_stats *airo_get_stats(struct net_device *dev)
2258 struct airo_info *local = dev->priv;
2260 if (!test_bit(JOB_STATS, &local->flags)) {
2261 /* Get stats out of the card if available */
2262 if (down_trylock(&local->sem) != 0) {
2263 set_bit(JOB_STATS, &local->flags);
2264 wake_up_interruptible(&local->thr_wait);
2266 airo_read_stats(local);
2269 return &local->stats;
2272 static void airo_set_promisc(struct airo_info *ai) {
2276 memset(&cmd, 0, sizeof(cmd));
2277 cmd.cmd=CMD_SETMODE;
2278 clear_bit(JOB_PROMISC, &ai->flags);
2279 cmd.parm0=(ai->flags&IFF_PROMISC) ? PROMISC : NOPROMISC;
2280 issuecommand(ai, &cmd, &rsp);
2284 static void airo_set_multicast_list(struct net_device *dev) {
2285 struct airo_info *ai = dev->priv;
2287 if ((dev->flags ^ ai->flags) & IFF_PROMISC) {
2288 change_bit(FLAG_PROMISC, &ai->flags);
2289 if (down_trylock(&ai->sem) != 0) {
2290 set_bit(JOB_PROMISC, &ai->flags);
2291 wake_up_interruptible(&ai->thr_wait);
2293 airo_set_promisc(ai);
2296 if ((dev->flags&IFF_ALLMULTI)||dev->mc_count>0) {
2297 /* Turn on multicast. (Should be already setup...) */
2301 static int airo_set_mac_address(struct net_device *dev, void *p)
2303 struct airo_info *ai = dev->priv;
2304 struct sockaddr *addr = p;
2307 readConfigRid(ai, 1);
2308 memcpy (ai->config.macAddr, addr->sa_data, dev->addr_len);
2309 set_bit (FLAG_COMMIT, &ai->flags);
2311 writeConfigRid (ai, 1);
2312 enable_MAC(ai, &rsp, 1);
2313 memcpy (ai->dev->dev_addr, addr->sa_data, dev->addr_len);
2315 memcpy (ai->wifidev->dev_addr, addr->sa_data, dev->addr_len);
2319 static int airo_change_mtu(struct net_device *dev, int new_mtu)
2321 if ((new_mtu < 68) || (new_mtu > 2400))
2328 static int airo_close(struct net_device *dev) {
2329 struct airo_info *ai = dev->priv;
2331 netif_stop_queue(dev);
2333 if (ai->wifidev != dev) {
2334 #ifdef POWER_ON_DOWN
2335 /* Shut power to the card. The idea is that the user can save
2336 * power when he doesn't need the card with "ifconfig down".
2337 * That's the method that is most friendly towards the network
2338 * stack (i.e. the network stack won't try to broadcast
2339 * anything on the interface and routes are gone. Jean II */
2340 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2343 disable_interrupts( ai );
2348 static void del_airo_dev( struct net_device *dev );
2350 void stop_airo_card( struct net_device *dev, int freeres )
2352 struct airo_info *ai = dev->priv;
2354 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2356 disable_interrupts(ai);
2357 free_irq( dev->irq, dev );
2358 takedown_proc_entry( dev, ai );
2359 if (test_bit(FLAG_REGISTERED, &ai->flags)) {
2360 unregister_netdev( dev );
2362 unregister_netdev(ai->wifidev);
2363 free_netdev(ai->wifidev);
2366 clear_bit(FLAG_REGISTERED, &ai->flags);
2368 set_bit(JOB_DIE, &ai->flags);
2369 kill_proc(ai->thr_pid, SIGTERM, 1);
2370 wait_for_completion(&ai->thr_exited);
2373 * Clean out tx queue
2375 if (test_bit(FLAG_MPI, &ai->flags) && skb_queue_len (&ai->txq) > 0) {
2376 struct sk_buff *skb = NULL;
2377 for (;(skb = skb_dequeue(&ai->txq));)
2390 /* PCMCIA frees this stuff, so only for PCI and ISA */
2391 release_region( dev->base_addr, 64 );
2392 if (test_bit(FLAG_MPI, &ai->flags)) {
2394 mpi_unmap_card(ai->pci);
2396 iounmap(ai->pcimem);
2398 iounmap(ai->pciaux);
2399 pci_free_consistent(ai->pci, PCI_SHARED_LEN,
2400 ai->shared, ai->shared_dma);
2405 crypto_free_tfm(ai->tfm);
2407 del_airo_dev( dev );
2411 EXPORT_SYMBOL(stop_airo_card);
2413 static int add_airo_dev( struct net_device *dev );
2415 int wll_header_parse(struct sk_buff *skb, unsigned char *haddr)
2417 memcpy(haddr, skb->mac.raw + 10, ETH_ALEN);
2421 static void mpi_unmap_card(struct pci_dev *pci)
2423 unsigned long mem_start = pci_resource_start(pci, 1);
2424 unsigned long mem_len = pci_resource_len(pci, 1);
2425 unsigned long aux_start = pci_resource_start(pci, 2);
2426 unsigned long aux_len = AUXMEMSIZE;
2428 release_mem_region(aux_start, aux_len);
2429 release_mem_region(mem_start, mem_len);
2432 /*************************************************************
2433 * This routine assumes that descriptors have been setup .
2434 * Run at insmod time or after reset when the decriptors
2435 * have been initialized . Returns 0 if all is well nz
2436 * otherwise . Does not allocate memory but sets up card
2437 * using previously allocated descriptors.
2439 static int mpi_init_descriptors (struct airo_info *ai)
2446 /* Alloc card RX descriptors */
2447 netif_stop_queue(ai->dev);
2449 memset(&rsp,0,sizeof(rsp));
2450 memset(&cmd,0,sizeof(cmd));
2452 cmd.cmd = CMD_ALLOCATEAUX;
2454 cmd.parm1 = (ai->rxfids[0].card_ram_off - ai->pciaux);
2455 cmd.parm2 = MPI_MAX_FIDS;
2456 rc=issuecommand(ai, &cmd, &rsp);
2457 if (rc != SUCCESS) {
2458 printk(KERN_ERR "airo: Couldn't allocate RX FID\n");
2462 for (i=0; i<MPI_MAX_FIDS; i++) {
2463 memcpy(ai->rxfids[i].card_ram_off,
2464 &ai->rxfids[i].rx_desc, sizeof(RxFid));
2467 /* Alloc card TX descriptors */
2469 memset(&rsp,0,sizeof(rsp));
2470 memset(&cmd,0,sizeof(cmd));
2472 cmd.cmd = CMD_ALLOCATEAUX;
2474 cmd.parm1 = (ai->txfids[0].card_ram_off - ai->pciaux);
2475 cmd.parm2 = MPI_MAX_FIDS;
2477 for (i=0; i<MPI_MAX_FIDS; i++) {
2478 ai->txfids[i].tx_desc.valid = 1;
2479 memcpy((char *)ai->txfids[i].card_ram_off,
2480 &ai->txfids[i].tx_desc, sizeof(TxFid));
2482 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2484 rc=issuecommand(ai, &cmd, &rsp);
2485 if (rc != SUCCESS) {
2486 printk(KERN_ERR "airo: Couldn't allocate TX FID\n");
2490 /* Alloc card Rid descriptor */
2491 memset(&rsp,0,sizeof(rsp));
2492 memset(&cmd,0,sizeof(cmd));
2494 cmd.cmd = CMD_ALLOCATEAUX;
2496 cmd.parm1 = (ai->config_desc.card_ram_off - ai->pciaux);
2497 cmd.parm2 = 1; /* Magic number... */
2498 rc=issuecommand(ai, &cmd, &rsp);
2499 if (rc != SUCCESS) {
2500 printk(KERN_ERR "airo: Couldn't allocate RID\n");
2504 memcpy((char *)ai->config_desc.card_ram_off,
2505 (char *)&ai->config_desc.rid_desc, sizeof(Rid));
2511 * We are setting up three things here:
2512 * 1) Map AUX memory for descriptors: Rid, TxFid, or RxFid.
2513 * 2) Map PCI memory for issueing commands.
2514 * 3) Allocate memory (shared) to send and receive ethernet frames.
2516 static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci,
2519 unsigned long mem_start, mem_len, aux_start, aux_len;
2522 unsigned char *busaddroff,*vpackoff;
2523 unsigned char *pciaddroff;
2525 mem_start = pci_resource_start(pci, 1);
2526 mem_len = pci_resource_len(pci, 1);
2527 aux_start = pci_resource_start(pci, 2);
2528 aux_len = AUXMEMSIZE;
2530 if (!request_mem_region(mem_start, mem_len, name)) {
2531 printk(KERN_ERR "airo: Couldn't get region %x[%x] for %s\n",
2532 (int)mem_start, (int)mem_len, name);
2535 if (!request_mem_region(aux_start, aux_len, name)) {
2536 printk(KERN_ERR "airo: Couldn't get region %x[%x] for %s\n",
2537 (int)aux_start, (int)aux_len, name);
2541 ai->pcimem = ioremap(mem_start, mem_len);
2543 printk(KERN_ERR "airo: Couldn't map region %x[%x] for %s\n",
2544 (int)mem_start, (int)mem_len, name);
2547 ai->pciaux = ioremap(aux_start, aux_len);
2549 printk(KERN_ERR "airo: Couldn't map region %x[%x] for %s\n",
2550 (int)aux_start, (int)aux_len, name);
2554 /* Reserve PKTSIZE for each fid and 2K for the Rids */
2555 ai->shared = pci_alloc_consistent(pci, PCI_SHARED_LEN, &ai->shared_dma);
2557 printk(KERN_ERR "airo: Couldn't alloc_consistent %d\n",
2563 * Setup descriptor RX, TX, CONFIG
2565 busaddroff = (unsigned char *)ai->shared_dma;
2566 pciaddroff = ai->pciaux + AUX_OFFSET;
2567 vpackoff = ai->shared;
2569 /* RX descriptor setup */
2570 for(i = 0; i < MPI_MAX_FIDS; i++) {
2571 ai->rxfids[i].pending = 0;
2572 ai->rxfids[i].card_ram_off = pciaddroff;
2573 ai->rxfids[i].virtual_host_addr = vpackoff;
2574 ai->rxfids[i].rx_desc.host_addr = (dma_addr_t) busaddroff;
2575 ai->rxfids[i].rx_desc.valid = 1;
2576 ai->rxfids[i].rx_desc.len = PKTSIZE;
2577 ai->rxfids[i].rx_desc.rdy = 0;
2579 pciaddroff += sizeof(RxFid);
2580 busaddroff += PKTSIZE;
2581 vpackoff += PKTSIZE;
2584 /* TX descriptor setup */
2585 for(i = 0; i < MPI_MAX_FIDS; i++) {
2586 ai->txfids[i].card_ram_off = pciaddroff;
2587 ai->txfids[i].virtual_host_addr = vpackoff;
2588 ai->txfids[i].tx_desc.valid = 1;
2589 ai->txfids[i].tx_desc.host_addr = (dma_addr_t) busaddroff;
2590 memcpy(ai->txfids[i].virtual_host_addr,
2591 &wifictlhdr8023, sizeof(wifictlhdr8023));
2593 pciaddroff += sizeof(TxFid);
2594 busaddroff += PKTSIZE;
2595 vpackoff += PKTSIZE;
2597 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2599 /* Rid descriptor setup */
2600 ai->config_desc.card_ram_off = pciaddroff;
2601 ai->config_desc.virtual_host_addr = vpackoff;
2602 ai->config_desc.rid_desc.host_addr = (dma_addr_t) busaddroff;
2603 ai->ridbus = (dma_addr_t)busaddroff;
2604 ai->config_desc.rid_desc.rid = 0;
2605 ai->config_desc.rid_desc.len = RIDSIZE;
2606 ai->config_desc.rid_desc.valid = 1;
2607 pciaddroff += sizeof(Rid);
2608 busaddroff += RIDSIZE;
2609 vpackoff += RIDSIZE;
2611 /* Tell card about descriptors */
2612 if (mpi_init_descriptors (ai) != SUCCESS)
2617 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2619 iounmap(ai->pciaux);
2621 iounmap(ai->pcimem);
2623 release_mem_region(aux_start, aux_len);
2625 release_mem_region(mem_start, mem_len);
2630 static void wifi_setup(struct net_device *dev)
2632 dev->hard_header = NULL;
2633 dev->rebuild_header = NULL;
2634 dev->hard_header_cache = NULL;
2635 dev->header_cache_update= NULL;
2637 dev->hard_header_parse = wll_header_parse;
2638 dev->hard_start_xmit = &airo_start_xmit11;
2639 dev->get_stats = &airo_get_stats;
2640 dev->set_mac_address = &airo_set_mac_address;
2641 dev->do_ioctl = &airo_ioctl;
2643 dev->get_wireless_stats = airo_get_wireless_stats;
2644 dev->wireless_handlers = (struct iw_handler_def *)&airo_handler_def;
2645 #endif /* WIRELESS_EXT */
2646 dev->change_mtu = &airo_change_mtu;
2647 dev->open = &airo_open;
2648 dev->stop = &airo_close;
2650 dev->type = ARPHRD_IEEE80211;
2651 dev->hard_header_len = ETH_HLEN;
2653 dev->addr_len = ETH_ALEN;
2654 dev->tx_queue_len = 100;
2656 memset(dev->broadcast,0xFF, ETH_ALEN);
2658 dev->flags = IFF_BROADCAST|IFF_MULTICAST;
2661 static struct net_device *init_wifidev(struct airo_info *ai,
2662 struct net_device *ethdev)
2665 struct net_device *dev = alloc_netdev(0, "wifi%d", wifi_setup);
2668 dev->priv = ethdev->priv;
2669 dev->irq = ethdev->irq;
2670 dev->base_addr = ethdev->base_addr;
2671 memcpy(dev->dev_addr, ethdev->dev_addr, dev->addr_len);
2672 err = register_netdev(dev);
2680 int reset_card( struct net_device *dev , int lock) {
2681 struct airo_info *ai = dev->priv;
2683 if (lock && down_interruptible(&ai->sem))
2686 OUT4500(ai,COMMAND,CMD_SOFTRESET);
2687 set_current_state (TASK_UNINTERRUPTIBLE);
2688 schedule_timeout (HZ/5);
2690 set_current_state (TASK_UNINTERRUPTIBLE);
2691 schedule_timeout (HZ/5);
2697 struct net_device *_init_airo_card( unsigned short irq, int port,
2698 int is_pcmcia, struct pci_dev *pci )
2700 struct net_device *dev;
2701 struct airo_info *ai;
2704 /* Create the network device object. */
2705 dev = alloc_etherdev(sizeof(*ai));
2707 printk(KERN_ERR "airo: Couldn't alloc_etherdev\n");
2710 if (dev_alloc_name(dev, dev->name) < 0) {
2711 printk(KERN_ERR "airo: Couldn't get name!\n");
2718 if (pci && (pci->device == 0x5000 || pci->device == 0xa504)) {
2719 printk(KERN_DEBUG "airo: Found an MPI350 card\n");
2720 set_bit(FLAG_MPI, &ai->flags);
2723 ai->aux_lock = SPIN_LOCK_UNLOCKED;
2724 sema_init(&ai->sem, 1);
2727 init_waitqueue_head (&ai->thr_wait);
2728 init_completion (&ai->thr_exited);
2729 ai->thr_pid = kernel_thread(airo_thread, dev, CLONE_FS | CLONE_FILES);
2730 if (ai->thr_pid < 0)
2735 rc = add_airo_dev( dev );
2739 /* The Airo-specific entries in the device structure. */
2740 if (test_bit(FLAG_MPI,&ai->flags)) {
2741 skb_queue_head_init (&ai->txq);
2742 dev->hard_start_xmit = &mpi_start_xmit;
2744 dev->hard_start_xmit = &airo_start_xmit;
2745 dev->get_stats = &airo_get_stats;
2746 dev->set_multicast_list = &airo_set_multicast_list;
2747 dev->set_mac_address = &airo_set_mac_address;
2748 dev->do_ioctl = &airo_ioctl;
2750 dev->get_wireless_stats = airo_get_wireless_stats;
2751 dev->wireless_handlers = (struct iw_handler_def *)&airo_handler_def;
2752 #endif /* WIRELESS_EXT */
2753 dev->change_mtu = &airo_change_mtu;
2754 dev->open = &airo_open;
2755 dev->stop = &airo_close;
2757 dev->base_addr = port;
2759 /* what is with PCMCIA ??? */
2761 SET_NETDEV_DEV(dev, &pci->dev);
2764 if (test_bit(FLAG_MPI,&ai->flags))
2765 reset_card (dev, 1);
2767 rc = request_irq( dev->irq, airo_interrupt, SA_SHIRQ, dev->name, dev );
2769 printk(KERN_ERR "airo: register interrupt %d failed, rc %d\n", irq, rc );
2770 goto err_out_unlink;
2773 if (!request_region( dev->base_addr, 64, dev->name )) {
2775 printk(KERN_ERR "airo: Couldn't request region\n");
2780 if (test_bit(FLAG_MPI,&ai->flags)) {
2781 if (mpi_map_card(ai, pci, dev->name)) {
2782 printk(KERN_ERR "airo: Could not map memory\n");
2788 if ( setup_card( ai, dev->dev_addr, 1 ) != SUCCESS ) {
2789 printk( KERN_ERR "airo: MAC could not be enabled\n" );
2793 } else if (!test_bit(FLAG_MPI,&ai->flags)) {
2794 ai->bap_read = fast_bap_read;
2795 set_bit(FLAG_FLASHING, &ai->flags);
2798 rc = register_netdev(dev);
2800 printk(KERN_ERR "airo: Couldn't register_netdev\n");
2803 ai->wifidev = init_wifidev(ai, dev);
2805 set_bit(FLAG_REGISTERED,&ai->flags);
2806 printk( KERN_INFO "airo: MAC enabled %s %x:%x:%x:%x:%x:%x\n",
2808 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
2809 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5] );
2811 /* Allocate the transmit buffers */
2812 if (probe && !test_bit(FLAG_MPI,&ai->flags))
2813 for( i = 0; i < MAX_FIDS; i++ )
2814 ai->fids[i] = transmit_allocate(ai,2312,i>=MAX_FIDS/2);
2816 setup_proc_entry( dev, dev->priv ); /* XXX check for failure */
2817 netif_start_queue(dev);
2818 SET_MODULE_OWNER(dev);
2822 if (test_bit(FLAG_MPI,&ai->flags) && pci) {
2823 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2824 iounmap(ai->pciaux);
2825 iounmap(ai->pcimem);
2826 mpi_unmap_card(ai->pci);
2830 release_region( dev->base_addr, 64 );
2832 free_irq(dev->irq, dev);
2836 set_bit(JOB_DIE, &ai->flags);
2837 kill_proc(ai->thr_pid, SIGTERM, 1);
2838 wait_for_completion(&ai->thr_exited);
2844 struct net_device *init_airo_card( unsigned short irq, int port, int is_pcmcia )
2846 return _init_airo_card ( irq, port, is_pcmcia, NULL);
2849 EXPORT_SYMBOL(init_airo_card);
2851 static int waitbusy (struct airo_info *ai) {
2853 while ((IN4500 (ai, COMMAND) & COMMAND_BUSY) & (delay < 10000)) {
2855 if ((++delay % 20) == 0)
2856 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
2858 return delay < 10000;
2861 int reset_airo_card( struct net_device *dev )
2864 struct airo_info *ai = dev->priv;
2866 if (reset_card (dev, 1))
2869 if ( setup_card(ai, dev->dev_addr, 1 ) != SUCCESS ) {
2870 printk( KERN_ERR "airo: MAC could not be enabled\n" );
2873 printk( KERN_INFO "airo: MAC enabled %s %x:%x:%x:%x:%x:%x\n", dev->name,
2874 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
2875 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
2876 /* Allocate the transmit buffers if needed */
2877 if (!test_bit(FLAG_MPI,&ai->flags))
2878 for( i = 0; i < MAX_FIDS; i++ )
2879 ai->fids[i] = transmit_allocate (ai,2312,i>=MAX_FIDS/2);
2881 enable_interrupts( ai );
2882 netif_wake_queue(dev);
2886 EXPORT_SYMBOL(reset_airo_card);
2888 static void airo_send_event(struct net_device *dev) {
2889 struct airo_info *ai = dev->priv;
2890 union iwreq_data wrqu;
2891 StatusRid status_rid;
2893 clear_bit(JOB_EVENT, &ai->flags);
2894 PC4500_readrid(ai, RID_STATUS, &status_rid, sizeof(status_rid), 0);
2896 wrqu.data.length = 0;
2897 wrqu.data.flags = 0;
2898 memcpy(wrqu.ap_addr.sa_data, status_rid.bssid[0], ETH_ALEN);
2899 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
2901 /* Send event to user space */
2902 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
2905 static int airo_thread(void *data) {
2906 struct net_device *dev = data;
2907 struct airo_info *ai = dev->priv;
2910 daemonize("%s", dev->name);
2911 allow_signal(SIGTERM);
2914 if (signal_pending(current))
2915 flush_signals(current);
2917 /* make swsusp happy with our thread */
2918 if (current->flags & PF_FREEZE)
2919 refrigerator(PF_FREEZE);
2921 if (test_bit(JOB_DIE, &ai->flags))
2924 if (ai->flags & JOB_MASK) {
2925 locked = down_interruptible(&ai->sem);
2929 init_waitqueue_entry(&wait, current);
2930 add_wait_queue(&ai->thr_wait, &wait);
2932 set_current_state(TASK_INTERRUPTIBLE);
2933 if (ai->flags & JOB_MASK)
2936 if (time_after_eq(jiffies,ai->expires)){
2937 set_bit(JOB_AUTOWEP,&ai->flags);
2940 if (!signal_pending(current)) {
2941 schedule_timeout(ai->expires - jiffies);
2944 } else if (!signal_pending(current)) {
2950 current->state = TASK_RUNNING;
2951 remove_wait_queue(&ai->thr_wait, &wait);
2958 if (test_bit(JOB_DIE, &ai->flags)) {
2963 if (ai->power || test_bit(FLAG_FLASHING, &ai->flags)) {
2968 if (test_bit(JOB_XMIT, &ai->flags))
2970 else if (test_bit(JOB_XMIT11, &ai->flags))
2971 airo_end_xmit11(dev);
2972 else if (test_bit(JOB_STATS, &ai->flags))
2973 airo_read_stats(ai);
2974 else if (test_bit(JOB_WSTATS, &ai->flags))
2975 airo_read_wireless_stats(ai);
2976 else if (test_bit(JOB_PROMISC, &ai->flags))
2977 airo_set_promisc(ai);
2979 else if (test_bit(JOB_MIC, &ai->flags))
2982 else if (test_bit(JOB_EVENT, &ai->flags))
2983 airo_send_event(dev);
2984 else if (test_bit(JOB_AUTOWEP, &ai->flags))
2987 complete_and_exit (&ai->thr_exited, 0);
2990 static irqreturn_t airo_interrupt ( int irq, void* dev_id, struct pt_regs *regs) {
2991 struct net_device *dev = (struct net_device *)dev_id;
2994 struct airo_info *apriv = dev->priv;
2995 u16 savedInterrupts = 0;
2998 if (!netif_device_present(dev))
3002 status = IN4500( apriv, EVSTAT );
3003 if ( !(status & STATUS_INTS) || status == 0xffff ) break;
3007 if ( status & EV_AWAKE ) {
3008 OUT4500( apriv, EVACK, EV_AWAKE );
3009 OUT4500( apriv, EVACK, EV_AWAKE );
3012 if (!savedInterrupts) {
3013 savedInterrupts = IN4500( apriv, EVINTEN );
3014 OUT4500( apriv, EVINTEN, 0 );
3017 if ( status & EV_MIC ) {
3018 OUT4500( apriv, EVACK, EV_MIC );
3020 if (test_bit(FLAG_MIC_CAPABLE, &apriv->flags)) {
3021 set_bit(JOB_MIC, &apriv->flags);
3022 wake_up_interruptible(&apriv->thr_wait);
3026 if ( status & EV_LINK ) {
3027 union iwreq_data wrqu;
3028 /* The link status has changed, if you want to put a
3029 monitor hook in, do it here. (Remember that
3030 interrupts are still disabled!)
3032 u16 newStatus = IN4500(apriv, LINKSTAT);
3033 OUT4500( apriv, EVACK, EV_LINK);
3034 /* Here is what newStatus means: */
3035 #define NOBEACON 0x8000 /* Loss of sync - missed beacons */
3036 #define MAXRETRIES 0x8001 /* Loss of sync - max retries */
3037 #define MAXARL 0x8002 /* Loss of sync - average retry level exceeded*/
3038 #define FORCELOSS 0x8003 /* Loss of sync - host request */
3039 #define TSFSYNC 0x8004 /* Loss of sync - TSF synchronization */
3040 #define DEAUTH 0x8100 /* Deauthentication (low byte is reason code) */
3041 #define DISASS 0x8200 /* Disassociation (low byte is reason code) */
3042 #define ASSFAIL 0x8400 /* Association failure (low byte is reason
3044 #define AUTHFAIL 0x0300 /* Authentication failure (low byte is reason
3046 #define ASSOCIATED 0x0400 /* Assocatied */
3047 #define RC_RESERVED 0 /* Reserved return code */
3048 #define RC_NOREASON 1 /* Unspecified reason */
3049 #define RC_AUTHINV 2 /* Previous authentication invalid */
3050 #define RC_DEAUTH 3 /* Deauthenticated because sending station is
3052 #define RC_NOACT 4 /* Disassociated due to inactivity */
3053 #define RC_MAXLOAD 5 /* Disassociated because AP is unable to handle
3054 all currently associated stations */
3055 #define RC_BADCLASS2 6 /* Class 2 frame received from
3056 non-Authenticated station */
3057 #define RC_BADCLASS3 7 /* Class 3 frame received from
3058 non-Associated station */
3059 #define RC_STATLEAVE 8 /* Disassociated because sending station is
3061 #define RC_NOAUTH 9 /* Station requesting (Re)Association is not
3062 Authenticated with the responding station */
3063 if (newStatus != ASSOCIATED) {
3064 if (auto_wep && !apriv->expires) {
3065 apriv->expires = RUN_AT(3*HZ);
3066 wake_up_interruptible(&apriv->thr_wait);
3069 struct task_struct *task = apriv->task;
3073 wake_up_process (task);
3074 set_bit(FLAG_UPDATE_UNI, &apriv->flags);
3075 set_bit(FLAG_UPDATE_MULTI, &apriv->flags);
3077 /* Question : is ASSOCIATED the only status
3078 * that is valid ? We want to catch handover
3079 * and reassociations as valid status
3081 if(newStatus == ASSOCIATED) {
3082 if (apriv->scan_timestamp) {
3083 /* Send an empty event to user space.
3084 * We don't send the received data on
3085 * the event because it would require
3086 * us to do complex transcoding, and
3087 * we want to minimise the work done in
3088 * the irq handler. Use a request to
3089 * extract the data - Jean II */
3090 wrqu.data.length = 0;
3091 wrqu.data.flags = 0;
3092 wireless_send_event(dev, SIOCGIWSCAN, &wrqu, NULL);
3093 apriv->scan_timestamp = 0;
3095 if (down_trylock(&apriv->sem) != 0) {
3096 set_bit(JOB_EVENT, &apriv->flags);
3097 wake_up_interruptible(&apriv->thr_wait);
3099 airo_send_event(dev);
3101 memset(wrqu.ap_addr.sa_data, '\0', ETH_ALEN);
3102 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
3104 /* Send event to user space */
3105 wireless_send_event(dev, SIOCGIWAP, &wrqu,NULL);
3109 /* Check to see if there is something to receive */
3110 if ( status & EV_RX ) {
3111 struct sk_buff *skb = NULL;
3112 u16 fc, len, hdrlen = 0;
3126 if (test_bit(FLAG_MPI,&apriv->flags)) {
3127 if (test_bit(FLAG_802_11, &apriv->flags))
3128 mpi_receive_802_11(apriv);
3130 mpi_receive_802_3(apriv);
3131 OUT4500(apriv, EVACK, EV_RX);
3135 fid = IN4500( apriv, RXFID );
3137 /* Get the packet length */
3138 if (test_bit(FLAG_802_11, &apriv->flags)) {
3139 bap_setup (apriv, fid, 4, BAP0);
3140 bap_read (apriv, (u16*)&hdr, sizeof(hdr), BAP0);
3141 /* Bad CRC. Ignore packet */
3142 if (le16_to_cpu(hdr.status) & 2)
3144 if (apriv->wifidev == NULL)
3147 bap_setup (apriv, fid, 0x36, BAP0);
3148 bap_read (apriv, (u16*)&hdr.len, 2, BAP0);
3150 len = le16_to_cpu(hdr.len);
3153 printk( KERN_ERR "airo: Bad size %d\n", len );
3159 if (test_bit(FLAG_802_11, &apriv->flags)) {
3160 bap_read (apriv, (u16*)&fc, sizeof(fc), BAP0);
3161 fc = le16_to_cpu(fc);
3164 if ((fc & 0xe0) == 0xc0)
3170 if ((fc&0x300)==0x300){
3178 hdrlen = ETH_ALEN * 2;
3180 skb = dev_alloc_skb( len + hdrlen + 2 + 2 );
3182 apriv->stats.rx_dropped++;
3185 skb_reserve(skb, 2); /* This way the IP header is aligned */
3186 buffer = (u16*)skb_put (skb, len + hdrlen);
3187 if (test_bit(FLAG_802_11, &apriv->flags)) {
3189 bap_read (apriv, buffer + 1, hdrlen - 2, BAP0);
3191 bap_read (apriv, tmpbuf, 6, BAP0);
3193 bap_read (apriv, &gap, sizeof(gap), BAP0);
3194 gap = le16_to_cpu(gap);
3197 bap_read (apriv, tmpbuf, gap, BAP0);
3199 printk(KERN_ERR "airo: gaplen too big. Problems will follow...\n");
3201 bap_read (apriv, buffer + hdrlen/2, len, BAP0);
3206 bap_read (apriv, buffer, ETH_ALEN*2, BAP0);
3208 if (apriv->micstats.enabled) {
3209 bap_read (apriv,(u16*)&micbuf,sizeof(micbuf),BAP0);
3210 if (ntohs(micbuf.typelen) > 0x05DC)
3211 bap_setup (apriv, fid, 0x44, BAP0);
3213 if (len <= sizeof(micbuf))
3216 len -= sizeof(micbuf);
3217 skb_trim (skb, len + hdrlen);
3221 bap_read(apriv,buffer+ETH_ALEN,len,BAP0);
3223 if (decapsulate(apriv,&micbuf,(etherHead*)buffer,len)) {
3225 dev_kfree_skb_irq (skb);
3230 OUT4500( apriv, EVACK, EV_RX);
3234 #ifdef IW_WIRELESS_SPY /* defined in iw_handler.h */
3235 if (apriv->spy_data.spy_number > 0) {
3237 struct iw_quality wstats;
3238 /* Prepare spy data : addr + qual */
3239 if (!test_bit(FLAG_802_11, &apriv->flags)) {
3240 sa = (char*)buffer + 6;
3241 bap_setup (apriv, fid, 8, BAP0);
3242 bap_read (apriv, (u16*)hdr.rssi, 2, BAP0);
3244 sa = (char*)buffer + 10;
3245 wstats.qual = hdr.rssi[0];
3247 wstats.level = 0x100 - apriv->rssi[hdr.rssi[1]].rssidBm;
3249 wstats.level = (hdr.rssi[1] + 321) / 2;
3251 /* Update spy records */
3252 wireless_spy_update(dev, sa, &wstats);
3254 #endif /* IW_WIRELESS_SPY */
3255 OUT4500( apriv, EVACK, EV_RX);
3257 if (test_bit(FLAG_802_11, &apriv->flags)) {
3258 skb->mac.raw = skb->data;
3259 skb->pkt_type = PACKET_OTHERHOST;
3260 skb->dev = apriv->wifidev;
3261 skb->protocol = htons(ETH_P_802_2);
3264 skb->protocol = eth_type_trans(skb,dev);
3266 skb->dev->last_rx = jiffies;
3267 skb->ip_summed = CHECKSUM_NONE;
3273 /* Check to see if a packet has been transmitted */
3274 if ( status & ( EV_TX|EV_TXCPY|EV_TXEXC ) ) {
3279 if (test_bit(FLAG_MPI,&apriv->flags)) {
3280 unsigned long flags;
3282 if (status & EV_TXEXC)
3283 get_tx_error(apriv, -1);
3284 spin_lock_irqsave(&apriv->aux_lock, flags);
3285 if (skb_queue_len (&apriv->txq)) {
3286 spin_unlock_irqrestore(&apriv->aux_lock,flags);
3287 mpi_send_packet (dev);
3289 clear_bit(FLAG_PENDING_XMIT, &apriv->flags);
3290 spin_unlock_irqrestore(&apriv->aux_lock,flags);
3291 netif_wake_queue (dev);
3293 OUT4500( apriv, EVACK,
3294 status & (EV_TX|EV_TXCPY|EV_TXEXC));
3298 fid = IN4500(apriv, TXCOMPLFID);
3300 for( i = 0; i < MAX_FIDS; i++ ) {
3301 if ( ( apriv->fids[i] & 0xffff ) == fid ) {
3302 len = apriv->fids[i] >> 16;
3307 if (status & EV_TXEXC)
3308 get_tx_error(apriv, index);
3309 OUT4500( apriv, EVACK, status & (EV_TX | EV_TXEXC));
3310 /* Set up to be used again */
3311 apriv->fids[index] &= 0xffff;
3312 if (index < MAX_FIDS / 2) {
3313 if (!test_bit(FLAG_PENDING_XMIT, &apriv->flags))
3314 netif_wake_queue(dev);
3316 if (!test_bit(FLAG_PENDING_XMIT11, &apriv->flags))
3317 netif_wake_queue(apriv->wifidev);
3320 OUT4500( apriv, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3321 printk( KERN_ERR "airo: Unallocated FID was used to xmit\n" );
3325 if ( status & ~STATUS_INTS & ~IGNORE_INTS )
3326 printk( KERN_WARNING "airo: Got weird status %x\n",
3327 status & ~STATUS_INTS & ~IGNORE_INTS );
3330 if (savedInterrupts)
3331 OUT4500( apriv, EVINTEN, savedInterrupts );
3334 return IRQ_RETVAL(handled);
3338 * Routines to talk to the card
3342 * This was originally written for the 4500, hence the name
3343 * NOTE: If use with 8bit mode and SMP bad things will happen!
3344 * Why would some one do 8 bit IO in an SMP machine?!?
3346 static void OUT4500( struct airo_info *ai, u16 reg, u16 val ) {
3347 if (test_bit(FLAG_MPI,&ai->flags))
3350 outw( val, ai->dev->base_addr + reg );
3352 outb( val & 0xff, ai->dev->base_addr + reg );
3353 outb( val >> 8, ai->dev->base_addr + reg + 1 );
3357 static u16 IN4500( struct airo_info *ai, u16 reg ) {
3360 if (test_bit(FLAG_MPI,&ai->flags))
3363 rc = inw( ai->dev->base_addr + reg );
3365 rc = inb( ai->dev->base_addr + reg );
3366 rc += ((int)inb( ai->dev->base_addr + reg + 1 )) << 8;
3371 static int enable_MAC( struct airo_info *ai, Resp *rsp, int lock ) {
3375 /* FLAG_RADIO_OFF : Radio disabled via /proc or Wireless Extensions
3376 * FLAG_RADIO_DOWN : Radio disabled via "ifconfig ethX down"
3377 * Note : we could try to use !netif_running(dev) in enable_MAC()
3378 * instead of this flag, but I don't trust it *within* the
3379 * open/close functions, and testing both flags together is
3380 * "cheaper" - Jean II */
3381 if (ai->flags & FLAG_RADIO_MASK) return SUCCESS;
3383 if (lock && down_interruptible(&ai->sem))
3384 return -ERESTARTSYS;
3386 if (!test_bit(FLAG_ENABLED, &ai->flags)) {
3387 memset(&cmd, 0, sizeof(cmd));
3388 cmd.cmd = MAC_ENABLE;
3389 rc = issuecommand(ai, &cmd, rsp);
3391 set_bit(FLAG_ENABLED, &ai->flags);
3399 printk(KERN_ERR "%s: Cannot enable MAC, err=%d\n",
3404 static void disable_MAC( struct airo_info *ai, int lock ) {
3408 if (lock && down_interruptible(&ai->sem))
3411 if (test_bit(FLAG_ENABLED, &ai->flags)) {
3412 memset(&cmd, 0, sizeof(cmd));
3413 cmd.cmd = MAC_DISABLE; // disable in case already enabled
3414 issuecommand(ai, &cmd, &rsp);
3415 clear_bit(FLAG_ENABLED, &ai->flags);
3421 static void enable_interrupts( struct airo_info *ai ) {
3422 /* Enable the interrupts */
3423 OUT4500( ai, EVINTEN, STATUS_INTS );
3426 static void disable_interrupts( struct airo_info *ai ) {
3427 OUT4500( ai, EVINTEN, 0 );
3430 static void mpi_receive_802_3(struct airo_info *ai)
3434 struct sk_buff *skb;
3441 memcpy ((char *)&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3442 /* Make sure we got something */
3443 if (rxd.rdy && rxd.valid == 0) {
3445 if (len < 12 && len > 2048)
3448 skb = dev_alloc_skb(len);
3450 ai->stats.rx_dropped++;
3453 buffer = skb_put(skb,len);
3455 memcpy(buffer, ai->rxfids[0].virtual_host_addr, ETH_ALEN * 2);
3456 if (ai->micstats.enabled) {
3458 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2,
3460 if (ntohs(micbuf.typelen) <= 0x05DC) {
3461 if (len <= sizeof(micbuf) + ETH_ALEN * 2)
3464 off = sizeof(micbuf);
3465 skb_trim (skb, len - off);
3468 memcpy(buffer + ETH_ALEN * 2,
3469 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2 + off,
3470 len - ETH_ALEN * 2 - off);
3471 if (decapsulate (ai, &micbuf, (etherHead*)buffer, len - off - ETH_ALEN * 2)) {
3473 dev_kfree_skb_irq (skb);
3477 memcpy(buffer, ai->rxfids[0].virtual_host_addr, len);
3479 #ifdef IW_WIRELESS_SPY /* defined in iw_handler.h */
3480 if (ai->spy_data.spy_number > 0) {
3482 struct iw_quality wstats;
3483 /* Prepare spy data : addr + qual */
3484 sa = buffer + ETH_ALEN;
3485 wstats.qual = 0; /* XXX Where do I get that info from ??? */
3488 /* Update spy records */
3489 wireless_spy_update(ai->dev, sa, &wstats);
3491 #endif /* IW_WIRELESS_SPY */
3494 skb->ip_summed = CHECKSUM_NONE;
3495 skb->protocol = eth_type_trans(skb, ai->dev);
3496 skb->dev->last_rx = jiffies;
3500 if (rxd.valid == 0) {
3504 memcpy (ai->rxfids[0].card_ram_off, (char *)&rxd, sizeof(rxd));
3508 void mpi_receive_802_11 (struct airo_info *ai)
3511 struct sk_buff *skb = NULL;
3512 u16 fc, len, hdrlen = 0;
3524 char *ptr = ai->rxfids[0].virtual_host_addr+4;
3526 memcpy ((char *)&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3527 memcpy ((char *)&hdr, ptr, sizeof(hdr));
3529 /* Bad CRC. Ignore packet */
3530 if (le16_to_cpu(hdr.status) & 2)
3532 if (ai->wifidev == NULL)
3534 len = le16_to_cpu(hdr.len);
3536 printk( KERN_ERR "airo: Bad size %d\n", len );
3542 memcpy ((char *)&fc, ptr, sizeof(fc));
3543 fc = le16_to_cpu(fc);
3546 if ((fc & 0xe0) == 0xc0)
3552 if ((fc&0x300)==0x300){
3560 skb = dev_alloc_skb( len + hdrlen + 2 );
3562 ai->stats.rx_dropped++;
3565 buffer = (u16*)skb_put (skb, len + hdrlen);
3566 memcpy ((char *)buffer, ptr, hdrlen);
3570 memcpy ((char *)&gap, ptr, sizeof(gap));
3572 gap = le16_to_cpu(gap);
3578 "airo: gaplen too big. Problems will follow...\n");
3580 memcpy ((char *)buffer + hdrlen, ptr, len);
3582 #ifdef IW_WIRELESS_SPY /* defined in iw_handler.h */
3583 if (ai->spy_data.spy_number > 0) {
3585 struct iw_quality wstats;
3586 /* Prepare spy data : addr + qual */
3587 sa = (char*)buffer + 10;
3588 wstats.qual = hdr.rssi[0];
3590 wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3592 wstats.level = (hdr.rssi[1] + 321) / 2;
3594 /* Update spy records */
3595 wireless_spy_update(ai->dev, sa, &wstats);
3597 #endif /* IW_WIRELESS_SPY */
3598 skb->mac.raw = skb->data;
3599 skb->pkt_type = PACKET_OTHERHOST;
3600 skb->dev = ai->wifidev;
3601 skb->protocol = htons(ETH_P_802_2);
3602 skb->dev->last_rx = jiffies;
3603 skb->ip_summed = CHECKSUM_NONE;
3606 if (rxd.valid == 0) {
3610 memcpy (ai->rxfids[0].card_ram_off, (char *)&rxd, sizeof(rxd));
3614 static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
3625 memset( &mySsid, 0, sizeof( mySsid ) );
3631 /* The NOP is the first step in getting the card going */
3633 cmd.parm0 = cmd.parm1 = cmd.parm2 = 0;
3634 if (lock && down_interruptible(&ai->sem))
3636 if ( issuecommand( ai, &cmd, &rsp ) != SUCCESS ) {
3641 disable_MAC( ai, 0);
3643 // Let's figure out if we need to use the AUX port
3644 if (!test_bit(FLAG_MPI,&ai->flags)) {
3645 cmd.cmd = CMD_ENABLEAUX;
3646 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
3649 printk(KERN_ERR "airo: Error checking for AUX port\n");
3652 if (!aux_bap || rsp.status & 0xff00) {
3653 ai->bap_read = fast_bap_read;
3654 printk(KERN_DEBUG "airo: Doing fast bap_reads\n");
3656 ai->bap_read = aux_bap_read;
3657 printk(KERN_DEBUG "airo: Doing AUX bap_reads\n");
3662 if (ai->config.len == 0) {
3663 tdsRssiRid rssi_rid;
3664 CapabilityRid cap_rid;
3674 // general configuration (read/modify/write)
3675 status = readConfigRid(ai, lock);
3676 if ( status != SUCCESS ) return ERROR;
3678 status = readCapabilityRid(ai, &cap_rid, lock);
3679 if ( status != SUCCESS ) return ERROR;
3681 status = PC4500_readrid(ai,RID_RSSI,&rssi_rid,sizeof(rssi_rid),lock);
3682 if ( status == SUCCESS ) {
3683 if (ai->rssi || (ai->rssi = kmalloc(512, GFP_KERNEL)) != NULL)
3684 memcpy(ai->rssi, (u8*)&rssi_rid + 2, 512);
3691 if (cap_rid.softCap & 8)
3692 ai->config.rmode |= RXMODE_NORMALIZED_RSSI;
3694 printk(KERN_WARNING "airo: unknown received signal level scale\n");
3696 ai->config.opmode = adhoc ? MODE_STA_IBSS : MODE_STA_ESS;
3697 ai->config.authType = AUTH_OPEN;
3698 ai->config.modulation = MOD_CCK;
3701 if ((cap_rid.len>=sizeof(cap_rid)) && (cap_rid.extSoftCap&1) &&
3702 (micsetup(ai) == SUCCESS)) {
3703 ai->config.opmode |= MODE_MIC;
3704 set_bit(FLAG_MIC_CAPABLE, &ai->flags);
3708 /* Save off the MAC */
3709 for( i = 0; i < ETH_ALEN; i++ ) {
3710 mac[i] = ai->config.macAddr[i];
3713 /* Check to see if there are any insmod configured
3717 memset(ai->config.rates,0,sizeof(ai->config.rates));
3718 for( i = 0; i < 8 && rates[i]; i++ ) {
3719 ai->config.rates[i] = rates[i];
3722 if ( basic_rate > 0 ) {
3724 for( i = 0; i < 8; i++ ) {
3725 if ( ai->config.rates[i] == basic_rate ||
3726 !ai->config.rates ) {
3727 ai->config.rates[i] = basic_rate | 0x80;
3732 set_bit (FLAG_COMMIT, &ai->flags);
3735 /* Setup the SSIDs if present */
3738 for( i = 0; i < 3 && ssids[i]; i++ ) {
3739 mySsid.ssids[i].len = strlen(ssids[i]);
3740 if ( mySsid.ssids[i].len > 32 )
3741 mySsid.ssids[i].len = 32;
3742 memcpy(mySsid.ssids[i].ssid, ssids[i],
3743 mySsid.ssids[i].len);
3745 mySsid.len = sizeof(mySsid);
3748 status = writeConfigRid(ai, lock);
3749 if ( status != SUCCESS ) return ERROR;
3751 /* Set up the SSID list */
3753 status = writeSsidRid(ai, &mySsid, lock);
3754 if ( status != SUCCESS ) return ERROR;
3757 status = enable_MAC(ai, &rsp, lock);
3758 if ( status != SUCCESS || (rsp.status & 0xFF00) != 0) {
3759 printk( KERN_ERR "airo: Bad MAC enable reason = %x, rid = %x, offset = %d\n", rsp.rsp0, rsp.rsp1, rsp.rsp2 );
3763 /* Grab the initial wep key, we gotta save it for auto_wep */
3764 rc = readWepKeyRid(ai, &wkr, 1, lock);
3765 if (rc == SUCCESS) do {
3766 lastindex = wkr.kindex;
3767 if (wkr.kindex == 0xffff) {
3768 ai->defindex = wkr.mac[0];
3770 rc = readWepKeyRid(ai, &wkr, 0, lock);
3771 } while(lastindex != wkr.kindex);
3774 ai->expires = RUN_AT(3*HZ);
3775 wake_up_interruptible(&ai->thr_wait);
3781 static u16 issuecommand(struct airo_info *ai, Cmd *pCmd, Resp *pRsp) {
3782 // Im really paranoid about letting it run forever!
3783 int max_tries = 600000;
3785 if (IN4500(ai, EVSTAT) & EV_CMD)
3786 OUT4500(ai, EVACK, EV_CMD);
3788 OUT4500(ai, PARAM0, pCmd->parm0);
3789 OUT4500(ai, PARAM1, pCmd->parm1);
3790 OUT4500(ai, PARAM2, pCmd->parm2);
3791 OUT4500(ai, COMMAND, pCmd->cmd);
3793 while (max_tries-- && (IN4500(ai, EVSTAT) & EV_CMD) == 0) {
3794 if ((IN4500(ai, COMMAND)) == pCmd->cmd)
3795 // PC4500 didn't notice command, try again
3796 OUT4500(ai, COMMAND, pCmd->cmd);
3797 if (!in_atomic() && (max_tries & 255) == 0)
3801 if ( max_tries == -1 ) {
3803 "airo: Max tries exceeded when issueing command\n" );
3804 if (IN4500(ai, COMMAND) & COMMAND_BUSY)
3805 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3809 // command completed
3810 pRsp->status = IN4500(ai, STATUS);
3811 pRsp->rsp0 = IN4500(ai, RESP0);
3812 pRsp->rsp1 = IN4500(ai, RESP1);
3813 pRsp->rsp2 = IN4500(ai, RESP2);
3814 if ((pRsp->status & 0xff00)!=0 && pCmd->cmd != CMD_SOFTRESET) {
3815 printk (KERN_ERR "airo: cmd= %x\n", pCmd->cmd);
3816 printk (KERN_ERR "airo: status= %x\n", pRsp->status);
3817 printk (KERN_ERR "airo: Rsp0= %x\n", pRsp->rsp0);
3818 printk (KERN_ERR "airo: Rsp1= %x\n", pRsp->rsp1);
3819 printk (KERN_ERR "airo: Rsp2= %x\n", pRsp->rsp2);
3822 // clear stuck command busy if necessary
3823 if (IN4500(ai, COMMAND) & COMMAND_BUSY) {
3824 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3826 // acknowledge processing the status/response
3827 OUT4500(ai, EVACK, EV_CMD);
3832 /* Sets up the bap to start exchange data. whichbap should
3833 * be one of the BAP0 or BAP1 defines. Locks should be held before
3835 static int bap_setup(struct airo_info *ai, u16 rid, u16 offset, int whichbap )
3840 OUT4500(ai, SELECT0+whichbap, rid);
3841 OUT4500(ai, OFFSET0+whichbap, offset);
3843 int status = IN4500(ai, OFFSET0+whichbap);
3844 if (status & BAP_BUSY) {
3845 /* This isn't really a timeout, but its kinda
3850 } else if ( status & BAP_ERR ) {
3851 /* invalid rid or offset */
3852 printk( KERN_ERR "airo: BAP error %x %d\n",
3855 } else if (status & BAP_DONE) { // success
3858 if ( !(max_tries--) ) {
3860 "airo: BAP setup error too many retries\n" );
3863 // -- PC4500 missed it, try again
3864 OUT4500(ai, SELECT0+whichbap, rid);
3865 OUT4500(ai, OFFSET0+whichbap, offset);
3870 /* should only be called by aux_bap_read. This aux function and the
3871 following use concepts not documented in the developers guide. I
3872 got them from a patch given to my by Aironet */
3873 static u16 aux_setup(struct airo_info *ai, u16 page,
3874 u16 offset, u16 *len)
3878 OUT4500(ai, AUXPAGE, page);
3879 OUT4500(ai, AUXOFF, 0);
3880 next = IN4500(ai, AUXDATA);
3881 *len = IN4500(ai, AUXDATA)&0xff;
3882 if (offset != 4) OUT4500(ai, AUXOFF, offset);
3886 /* requires call to bap_setup() first */
3887 static int aux_bap_read(struct airo_info *ai, u16 *pu16Dst,
3888 int bytelen, int whichbap)
3896 unsigned long flags;
3898 spin_lock_irqsave(&ai->aux_lock, flags);
3899 page = IN4500(ai, SWS0+whichbap);
3900 offset = IN4500(ai, SWS2+whichbap);
3901 next = aux_setup(ai, page, offset, &len);
3902 words = (bytelen+1)>>1;
3904 for (i=0; i<words;) {
3906 count = (len>>1) < (words-i) ? (len>>1) : (words-i);
3908 insw( ai->dev->base_addr+DATA0+whichbap,
3911 insb( ai->dev->base_addr+DATA0+whichbap,
3912 pu16Dst+i, count << 1 );
3915 next = aux_setup(ai, next, 4, &len);
3918 spin_unlock_irqrestore(&ai->aux_lock, flags);
3923 /* requires call to bap_setup() first */
3924 static int fast_bap_read(struct airo_info *ai, u16 *pu16Dst,
3925 int bytelen, int whichbap)
3927 bytelen = (bytelen + 1) & (~1); // round up to even value
3929 insw( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen>>1 );
3931 insb( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen );
3935 /* requires call to bap_setup() first */
3936 static int bap_write(struct airo_info *ai, const u16 *pu16Src,
3937 int bytelen, int whichbap)
3939 bytelen = (bytelen + 1) & (~1); // round up to even value
3941 outsw( ai->dev->base_addr+DATA0+whichbap,
3942 pu16Src, bytelen>>1 );
3944 outsb( ai->dev->base_addr+DATA0+whichbap, pu16Src, bytelen );
3948 static int PC4500_accessrid(struct airo_info *ai, u16 rid, u16 accmd)
3950 Cmd cmd; /* for issuing commands */
3951 Resp rsp; /* response from commands */
3954 memset(&cmd, 0, sizeof(cmd));
3957 status = issuecommand(ai, &cmd, &rsp);
3958 if (status != 0) return status;
3959 if ( (rsp.status & 0x7F00) != 0) {
3960 return (accmd << 8) + (rsp.rsp0 & 0xFF);
3965 /* Note, that we are using BAP1 which is also used by transmit, so
3966 * we must get a lock. */
3967 static int PC4500_readrid(struct airo_info *ai, u16 rid, void *pBuf, int len, int lock)
3973 if (down_interruptible(&ai->sem))
3976 if (test_bit(FLAG_MPI,&ai->flags)) {
3980 memset(&cmd, 0, sizeof(cmd));
3981 memset(&rsp, 0, sizeof(rsp));
3982 ai->config_desc.rid_desc.valid = 1;
3983 ai->config_desc.rid_desc.len = RIDSIZE;
3984 ai->config_desc.rid_desc.rid = 0;
3985 ai->config_desc.rid_desc.host_addr = ai->ridbus;
3987 cmd.cmd = CMD_ACCESS;
3990 memcpy((char *)ai->config_desc.card_ram_off,
3991 (char *)&ai->config_desc.rid_desc, sizeof(Rid));
3993 rc = issuecommand(ai, &cmd, &rsp);
3995 if (rsp.status & 0x7f00)
3998 memcpy(pBuf, ai->config_desc.virtual_host_addr, len);
4001 if ((status = PC4500_accessrid(ai, rid, CMD_ACCESS))!=SUCCESS) {
4005 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4009 // read the rid length field
4010 bap_read(ai, pBuf, 2, BAP1);
4011 // length for remaining part of rid
4012 len = min(len, (int)le16_to_cpu(*(u16*)pBuf)) - 2;
4016 "airo: Rid %x has a length of %d which is too short\n",
4017 (int)rid, (int)len );
4021 // read remainder of the rid
4022 rc = bap_read(ai, ((u16*)pBuf)+1, len, BAP1);
4030 /* Note, that we are using BAP1 which is also used by transmit, so
4031 * make sure this isnt called when a transmit is happening */
4032 static int PC4500_writerid(struct airo_info *ai, u16 rid,
4033 const void *pBuf, int len, int lock)
4038 *(u16*)pBuf = cpu_to_le16((u16)len);
4041 if (down_interruptible(&ai->sem))
4044 if (test_bit(FLAG_MPI,&ai->flags)) {
4048 if (test_bit(FLAG_ENABLED, &ai->flags))
4050 "%s: MAC should be disabled (rid=%04x)\n",
4052 memset(&cmd, 0, sizeof(cmd));
4053 memset(&rsp, 0, sizeof(rsp));
4055 ai->config_desc.rid_desc.valid = 1;
4056 ai->config_desc.rid_desc.len = *((u16 *)pBuf);
4057 ai->config_desc.rid_desc.rid = 0;
4059 cmd.cmd = CMD_WRITERID;
4062 memcpy((char *)ai->config_desc.card_ram_off,
4063 (char *)&ai->config_desc.rid_desc, sizeof(Rid));
4065 if (len < 4 || len > 2047) {
4066 printk(KERN_ERR "%s: len=%d\n",__FUNCTION__,len);
4069 memcpy((char *)ai->config_desc.virtual_host_addr,
4072 rc = issuecommand(ai, &cmd, &rsp);
4073 if ((rc & 0xff00) != 0) {
4074 printk(KERN_ERR "%s: Write rid Error %d\n",
4076 printk(KERN_ERR "%s: Cmd=%04x\n",
4077 __FUNCTION__,cmd.cmd);
4080 if ((rsp.status & 0x7f00))
4084 // --- first access so that we can write the rid data
4085 if ( (status = PC4500_accessrid(ai, rid, CMD_ACCESS)) != 0) {
4089 // --- now write the rid data
4090 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4094 bap_write(ai, pBuf, len, BAP1);
4095 // ---now commit the rid data
4096 rc = PC4500_accessrid(ai, rid, 0x100|CMD_ACCESS);
4104 /* Allocates a FID to be used for transmitting packets. We only use
4106 static u16 transmit_allocate(struct airo_info *ai, int lenPayload, int raw)
4108 unsigned int loop = 3000;
4114 cmd.cmd = CMD_ALLOCATETX;
4115 cmd.parm0 = lenPayload;
4116 if (down_interruptible(&ai->sem))
4118 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
4122 if ( (rsp.status & 0xFF00) != 0) {
4126 /* wait for the allocate event/indication
4127 * It makes me kind of nervous that this can just sit here and spin,
4128 * but in practice it only loops like four times. */
4129 while (((IN4500(ai, EVSTAT) & EV_ALLOC) == 0) && --loop);
4135 // get the allocated fid and acknowledge
4136 txFid = IN4500(ai, TXALLOCFID);
4137 OUT4500(ai, EVACK, EV_ALLOC);
4139 /* The CARD is pretty cool since it converts the ethernet packet
4140 * into 802.11. Also note that we don't release the FID since we
4141 * will be using the same one over and over again. */
4142 /* We only have to setup the control once since we are not
4143 * releasing the fid. */
4145 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_11
4146 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4148 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_3
4149 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4150 if (bap_setup(ai, txFid, 0x0008, BAP1) != SUCCESS)
4153 bap_write(ai, &txControl, sizeof(txControl), BAP1);
4161 /* In general BAP1 is dedicated to transmiting packets. However,
4162 since we need a BAP when accessing RIDs, we also use BAP1 for that.
4163 Make sure the BAP1 spinlock is held when this is called. */
4164 static int transmit_802_3_packet(struct airo_info *ai, int len, char *pPacket)
4175 if (len <= ETH_ALEN * 2) {
4176 printk( KERN_WARNING "Short packet %d\n", len );
4179 len -= ETH_ALEN * 2;
4182 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
4183 (ntohs(((u16 *)pPacket)[6]) != 0x888E)) {
4184 if (encapsulate(ai,(etherHead *)pPacket,&pMic,len) != SUCCESS)
4186 miclen = sizeof(pMic);
4190 // packet is destination[6], source[6], payload[len-12]
4191 // write the payload length and dst/src/payload
4192 if (bap_setup(ai, txFid, 0x0036, BAP1) != SUCCESS) return ERROR;
4193 /* The hardware addresses aren't counted as part of the payload, so
4194 * we have to subtract the 12 bytes for the addresses off */
4195 payloadLen = cpu_to_le16(len + miclen);
4196 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4197 bap_write(ai, (const u16*)pPacket, sizeof(etherHead), BAP1);
4199 bap_write(ai, (const u16*)&pMic, miclen, BAP1);
4200 bap_write(ai, (const u16*)(pPacket + sizeof(etherHead)), len, BAP1);
4201 // issue the transmit command
4202 memset( &cmd, 0, sizeof( cmd ) );
4203 cmd.cmd = CMD_TRANSMIT;
4205 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4206 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4210 static int transmit_802_11_packet(struct airo_info *ai, int len, char *pPacket)
4225 fc = le16_to_cpu(*(const u16*)pPacket);
4228 if ((fc & 0xe0) == 0xc0)
4234 if ((fc&0x300)==0x300){
4243 printk( KERN_WARNING "Short packet %d\n", len );
4247 /* packet is 802.11 header + payload
4248 * write the payload length and dst/src/payload */
4249 if (bap_setup(ai, txFid, 6, BAP1) != SUCCESS) return ERROR;
4250 /* The 802.11 header aren't counted as part of the payload, so
4251 * we have to subtract the header bytes off */
4252 payloadLen = cpu_to_le16(len-hdrlen);
4253 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4254 if (bap_setup(ai, txFid, 0x0014, BAP1) != SUCCESS) return ERROR;
4255 bap_write(ai, (const u16*)pPacket, hdrlen, BAP1);
4256 bap_write(ai, hdrlen == 30 ?
4257 (const u16*)&gap.gaplen : (const u16*)&gap, 38 - hdrlen, BAP1);
4259 bap_write(ai, (const u16*)(pPacket + hdrlen), len - hdrlen, BAP1);
4260 // issue the transmit command
4261 memset( &cmd, 0, sizeof( cmd ) );
4262 cmd.cmd = CMD_TRANSMIT;
4264 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4265 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4270 * This is the proc_fs routines. It is a bit messier than I would
4271 * like! Feel free to clean it up!
4274 static ssize_t proc_read( struct file *file,
4275 char __user *buffer,
4279 static ssize_t proc_write( struct file *file,
4280 const char __user *buffer,
4283 static int proc_close( struct inode *inode, struct file *file );
4285 static int proc_stats_open( struct inode *inode, struct file *file );
4286 static int proc_statsdelta_open( struct inode *inode, struct file *file );
4287 static int proc_status_open( struct inode *inode, struct file *file );
4288 static int proc_SSID_open( struct inode *inode, struct file *file );
4289 static int proc_APList_open( struct inode *inode, struct file *file );
4290 static int proc_BSSList_open( struct inode *inode, struct file *file );
4291 static int proc_config_open( struct inode *inode, struct file *file );
4292 static int proc_wepkey_open( struct inode *inode, struct file *file );
4294 static struct file_operations proc_statsdelta_ops = {
4296 .open = proc_statsdelta_open,
4297 .release = proc_close
4300 static struct file_operations proc_stats_ops = {
4302 .open = proc_stats_open,
4303 .release = proc_close
4306 static struct file_operations proc_status_ops = {
4308 .open = proc_status_open,
4309 .release = proc_close
4312 static struct file_operations proc_SSID_ops = {
4314 .write = proc_write,
4315 .open = proc_SSID_open,
4316 .release = proc_close
4319 static struct file_operations proc_BSSList_ops = {
4321 .write = proc_write,
4322 .open = proc_BSSList_open,
4323 .release = proc_close
4326 static struct file_operations proc_APList_ops = {
4328 .write = proc_write,
4329 .open = proc_APList_open,
4330 .release = proc_close
4333 static struct file_operations proc_config_ops = {
4335 .write = proc_write,
4336 .open = proc_config_open,
4337 .release = proc_close
4340 static struct file_operations proc_wepkey_ops = {
4342 .write = proc_write,
4343 .open = proc_wepkey_open,
4344 .release = proc_close
4347 static struct proc_dir_entry *airo_entry;
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 strcpy(apriv->proc_name,dev->name);
4368 apriv->proc_entry = create_proc_entry(apriv->proc_name,
4371 apriv->proc_entry->uid = proc_uid;
4372 apriv->proc_entry->gid = proc_gid;
4373 apriv->proc_entry->owner = THIS_MODULE;
4375 /* Setup the StatsDelta */
4376 entry = create_proc_entry("StatsDelta",
4377 S_IFREG | (S_IRUGO&proc_perm),
4379 entry->uid = proc_uid;
4380 entry->gid = proc_gid;
4382 entry->owner = THIS_MODULE;
4383 SETPROC_OPS(entry, proc_statsdelta_ops);
4385 /* Setup the Stats */
4386 entry = create_proc_entry("Stats",
4387 S_IFREG | (S_IRUGO&proc_perm),
4389 entry->uid = proc_uid;
4390 entry->gid = proc_gid;
4392 entry->owner = THIS_MODULE;
4393 SETPROC_OPS(entry, proc_stats_ops);
4395 /* Setup the Status */
4396 entry = create_proc_entry("Status",
4397 S_IFREG | (S_IRUGO&proc_perm),
4399 entry->uid = proc_uid;
4400 entry->gid = proc_gid;
4402 entry->owner = THIS_MODULE;
4403 SETPROC_OPS(entry, proc_status_ops);
4405 /* Setup the Config */
4406 entry = create_proc_entry("Config",
4407 S_IFREG | proc_perm,
4409 entry->uid = proc_uid;
4410 entry->gid = proc_gid;
4412 entry->owner = THIS_MODULE;
4413 SETPROC_OPS(entry, proc_config_ops);
4415 /* Setup the SSID */
4416 entry = create_proc_entry("SSID",
4417 S_IFREG | proc_perm,
4419 entry->uid = proc_uid;
4420 entry->gid = proc_gid;
4422 entry->owner = THIS_MODULE;
4423 SETPROC_OPS(entry, proc_SSID_ops);
4425 /* Setup the APList */
4426 entry = create_proc_entry("APList",
4427 S_IFREG | proc_perm,
4429 entry->uid = proc_uid;
4430 entry->gid = proc_gid;
4432 entry->owner = THIS_MODULE;
4433 SETPROC_OPS(entry, proc_APList_ops);
4435 /* Setup the BSSList */
4436 entry = create_proc_entry("BSSList",
4437 S_IFREG | proc_perm,
4439 entry->uid = proc_uid;
4440 entry->gid = proc_gid;
4442 entry->owner = THIS_MODULE;
4443 SETPROC_OPS(entry, proc_BSSList_ops);
4445 /* Setup the WepKey */
4446 entry = create_proc_entry("WepKey",
4447 S_IFREG | proc_perm,
4449 entry->uid = proc_uid;
4450 entry->gid = proc_gid;
4452 entry->owner = THIS_MODULE;
4453 SETPROC_OPS(entry, proc_wepkey_ops);
4458 static int takedown_proc_entry( struct net_device *dev,
4459 struct airo_info *apriv ) {
4460 if ( !apriv->proc_entry->namelen ) return 0;
4461 remove_proc_entry("Stats",apriv->proc_entry);
4462 remove_proc_entry("StatsDelta",apriv->proc_entry);
4463 remove_proc_entry("Status",apriv->proc_entry);
4464 remove_proc_entry("Config",apriv->proc_entry);
4465 remove_proc_entry("SSID",apriv->proc_entry);
4466 remove_proc_entry("APList",apriv->proc_entry);
4467 remove_proc_entry("BSSList",apriv->proc_entry);
4468 remove_proc_entry("WepKey",apriv->proc_entry);
4469 remove_proc_entry(apriv->proc_name,airo_entry);
4474 * What we want from the proc_fs is to be able to efficiently read
4475 * and write the configuration. To do this, we want to read the
4476 * configuration when the file is opened and write it when the file is
4477 * closed. So basically we allocate a read buffer at open and fill it
4478 * with data, and allocate a write buffer and read it at close.
4482 * The read routine is generic, it relies on the preallocated rbuffer
4483 * to supply the data.
4485 static ssize_t proc_read( struct file *file,
4486 char __user *buffer,
4490 loff_t pos = *offset;
4491 struct proc_data *priv = (struct proc_data*)file->private_data;
4498 if (pos >= priv->readlen)
4500 if (len > priv->readlen - pos)
4501 len = priv->readlen - pos;
4502 if (copy_to_user(buffer, priv->rbuffer + pos, len))
4504 *offset = pos + len;
4509 * The write routine is generic, it fills in a preallocated rbuffer
4510 * to supply the data.
4512 static ssize_t proc_write( struct file *file,
4513 const char __user *buffer,
4517 loff_t pos = *offset;
4518 struct proc_data *priv = (struct proc_data*)file->private_data;
4525 if (pos >= priv->maxwritelen)
4527 if (len > priv->maxwritelen - pos)
4528 len = priv->maxwritelen - pos;
4529 if (copy_from_user(priv->wbuffer + pos, buffer, len))
4531 if ( pos + len > priv->writelen )
4532 priv->writelen = len + file->f_pos;
4533 *offset = pos + len;
4537 static int proc_status_open( struct inode *inode, struct file *file ) {
4538 struct proc_data *data;
4539 struct proc_dir_entry *dp = PDE(inode);
4540 struct net_device *dev = dp->data;
4541 struct airo_info *apriv = dev->priv;
4542 CapabilityRid cap_rid;
4543 StatusRid status_rid;
4546 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4548 memset(file->private_data, 0, sizeof(struct proc_data));
4549 data = (struct proc_data *)file->private_data;
4550 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4551 kfree (file->private_data);
4555 readStatusRid(apriv, &status_rid, 1);
4556 readCapabilityRid(apriv, &cap_rid, 1);
4558 i = sprintf(data->rbuffer, "Status: %s%s%s%s%s%s%s%s%s\n",
4559 status_rid.mode & 1 ? "CFG ": "",
4560 status_rid.mode & 2 ? "ACT ": "",
4561 status_rid.mode & 0x10 ? "SYN ": "",
4562 status_rid.mode & 0x20 ? "LNK ": "",
4563 status_rid.mode & 0x40 ? "LEAP ": "",
4564 status_rid.mode & 0x80 ? "PRIV ": "",
4565 status_rid.mode & 0x100 ? "KEY ": "",
4566 status_rid.mode & 0x200 ? "WEP ": "",
4567 status_rid.mode & 0x8000 ? "ERR ": "");
4568 sprintf( data->rbuffer+i, "Mode: %x\n"
4569 "Signal Strength: %d\n"
4570 "Signal Quality: %d\n"
4575 "Driver Version: %s\n"
4576 "Device: %s\nManufacturer: %s\nFirmware Version: %s\n"
4577 "Radio type: %x\nCountry: %x\nHardware Version: %x\n"
4578 "Software Version: %x\nSoftware Subversion: %x\n"
4579 "Boot block version: %x\n",
4580 (int)status_rid.mode,
4581 (int)status_rid.normalizedSignalStrength,
4582 (int)status_rid.signalQuality,
4583 (int)status_rid.SSIDlen,
4586 (int)status_rid.channel,
4587 (int)status_rid.currentXmitRate/2,
4595 (int)cap_rid.softVer,
4596 (int)cap_rid.softSubVer,
4597 (int)cap_rid.bootBlockVer );
4598 data->readlen = strlen( data->rbuffer );
4602 static int proc_stats_rid_open(struct inode*, struct file*, u16);
4603 static int proc_statsdelta_open( struct inode *inode,
4604 struct file *file ) {
4605 if (file->f_mode&FMODE_WRITE) {
4606 return proc_stats_rid_open(inode, file, RID_STATSDELTACLEAR);
4608 return proc_stats_rid_open(inode, file, RID_STATSDELTA);
4611 static int proc_stats_open( struct inode *inode, struct file *file ) {
4612 return proc_stats_rid_open(inode, file, RID_STATS);
4615 static int proc_stats_rid_open( struct inode *inode,
4618 struct proc_data *data;
4619 struct proc_dir_entry *dp = PDE(inode);
4620 struct net_device *dev = dp->data;
4621 struct airo_info *apriv = dev->priv;
4624 u32 *vals = stats.vals;
4626 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4628 memset(file->private_data, 0, sizeof(struct proc_data));
4629 data = (struct proc_data *)file->private_data;
4630 if ((data->rbuffer = kmalloc( 4096, GFP_KERNEL )) == NULL) {
4631 kfree (file->private_data);
4635 readStatsRid(apriv, &stats, rid, 1);
4638 for(i=0; statsLabels[i]!=(char *)-1 &&
4639 i*4<stats.len; i++){
4640 if (!statsLabels[i]) continue;
4641 if (j+strlen(statsLabels[i])+16>4096) {
4643 "airo: Potentially disasterous buffer overflow averted!\n");
4646 j+=sprintf(data->rbuffer+j, "%s: %u\n", statsLabels[i], vals[i]);
4648 if (i*4>=stats.len){
4650 "airo: Got a short rid\n");
4656 static int get_dec_u16( char *buffer, int *start, int limit ) {
4659 for( value = 0; buffer[*start] >= '0' &&
4660 buffer[*start] <= '9' &&
4661 *start < limit; (*start)++ ) {
4664 value += buffer[*start] - '0';
4666 if ( !valid ) return -1;
4670 static int airo_config_commit(struct net_device *dev,
4671 struct iw_request_info *info, void *zwrq,
4674 static void proc_config_on_close( struct inode *inode, struct file *file ) {
4675 struct proc_data *data = file->private_data;
4676 struct proc_dir_entry *dp = PDE(inode);
4677 struct net_device *dev = dp->data;
4678 struct airo_info *ai = dev->priv;
4681 if ( !data->writelen ) return;
4683 readConfigRid(ai, 1);
4684 set_bit (FLAG_COMMIT, &ai->flags);
4686 line = data->wbuffer;
4688 /*** Mode processing */
4689 if ( !strncmp( line, "Mode: ", 6 ) ) {
4691 if ((ai->config.rmode & 0xff) >= RXMODE_RFMON)
4692 set_bit (FLAG_RESET, &ai->flags);
4693 ai->config.rmode &= 0xfe00;
4694 clear_bit (FLAG_802_11, &ai->flags);
4695 ai->config.opmode &= 0xFF00;
4696 ai->config.scanMode = SCANMODE_ACTIVE;
4697 if ( line[0] == 'a' ) {
4698 ai->config.opmode |= 0;
4700 ai->config.opmode |= 1;
4701 if ( line[0] == 'r' ) {
4702 ai->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
4703 ai->config.scanMode = SCANMODE_PASSIVE;
4704 set_bit (FLAG_802_11, &ai->flags);
4705 } else if ( line[0] == 'y' ) {
4706 ai->config.rmode |= RXMODE_RFMON_ANYBSS | RXMODE_DISABLE_802_3_HEADER;
4707 ai->config.scanMode = SCANMODE_PASSIVE;
4708 set_bit (FLAG_802_11, &ai->flags);
4709 } else if ( line[0] == 'l' )
4710 ai->config.rmode |= RXMODE_LANMON;
4712 set_bit (FLAG_COMMIT, &ai->flags);
4715 /*** Radio status */
4716 else if (!strncmp(line,"Radio: ", 7)) {
4718 if (!strncmp(line,"off",3)) {
4719 set_bit (FLAG_RADIO_OFF, &ai->flags);
4721 clear_bit (FLAG_RADIO_OFF, &ai->flags);
4724 /*** NodeName processing */
4725 else if ( !strncmp( line, "NodeName: ", 10 ) ) {
4729 memset( ai->config.nodeName, 0, 16 );
4730 /* Do the name, assume a space between the mode and node name */
4731 for( j = 0; j < 16 && line[j] != '\n'; j++ ) {
4732 ai->config.nodeName[j] = line[j];
4734 set_bit (FLAG_COMMIT, &ai->flags);
4737 /*** PowerMode processing */
4738 else if ( !strncmp( line, "PowerMode: ", 11 ) ) {
4740 if ( !strncmp( line, "PSPCAM", 6 ) ) {
4741 ai->config.powerSaveMode = POWERSAVE_PSPCAM;
4742 set_bit (FLAG_COMMIT, &ai->flags);
4743 } else if ( !strncmp( line, "PSP", 3 ) ) {
4744 ai->config.powerSaveMode = POWERSAVE_PSP;
4745 set_bit (FLAG_COMMIT, &ai->flags);
4747 ai->config.powerSaveMode = POWERSAVE_CAM;
4748 set_bit (FLAG_COMMIT, &ai->flags);
4750 } else if ( !strncmp( line, "DataRates: ", 11 ) ) {
4751 int v, i = 0, k = 0; /* i is index into line,
4752 k is index to rates */
4755 while((v = get_dec_u16(line, &i, 3))!=-1) {
4756 ai->config.rates[k++] = (u8)v;
4760 set_bit (FLAG_COMMIT, &ai->flags);
4761 } else if ( !strncmp( line, "Channel: ", 9 ) ) {
4764 v = get_dec_u16(line, &i, i+3);
4766 ai->config.channelSet = (u16)v;
4767 set_bit (FLAG_COMMIT, &ai->flags);
4769 } else if ( !strncmp( line, "XmitPower: ", 11 ) ) {
4772 v = get_dec_u16(line, &i, i+3);
4774 ai->config.txPower = (u16)v;
4775 set_bit (FLAG_COMMIT, &ai->flags);
4777 } else if ( !strncmp( line, "WEP: ", 5 ) ) {
4781 ai->config.authType = (u16)AUTH_SHAREDKEY;
4784 ai->config.authType = (u16)AUTH_ENCRYPT;
4787 ai->config.authType = (u16)AUTH_OPEN;
4790 set_bit (FLAG_COMMIT, &ai->flags);
4791 } else if ( !strncmp( line, "LongRetryLimit: ", 16 ) ) {
4795 v = get_dec_u16(line, &i, 3);
4796 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4797 ai->config.longRetryLimit = (u16)v;
4798 set_bit (FLAG_COMMIT, &ai->flags);
4799 } else if ( !strncmp( line, "ShortRetryLimit: ", 17 ) ) {
4803 v = get_dec_u16(line, &i, 3);
4804 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4805 ai->config.shortRetryLimit = (u16)v;
4806 set_bit (FLAG_COMMIT, &ai->flags);
4807 } else if ( !strncmp( line, "RTSThreshold: ", 14 ) ) {
4811 v = get_dec_u16(line, &i, 4);
4812 v = (v<0) ? 0 : ((v>2312) ? 2312 : v);
4813 ai->config.rtsThres = (u16)v;
4814 set_bit (FLAG_COMMIT, &ai->flags);
4815 } else if ( !strncmp( line, "TXMSDULifetime: ", 16 ) ) {
4819 v = get_dec_u16(line, &i, 5);
4821 ai->config.txLifetime = (u16)v;
4822 set_bit (FLAG_COMMIT, &ai->flags);
4823 } else if ( !strncmp( line, "RXMSDULifetime: ", 16 ) ) {
4827 v = get_dec_u16(line, &i, 5);
4829 ai->config.rxLifetime = (u16)v;
4830 set_bit (FLAG_COMMIT, &ai->flags);
4831 } else if ( !strncmp( line, "TXDiversity: ", 13 ) ) {
4832 ai->config.txDiversity =
4833 (line[13]=='l') ? 1 :
4834 ((line[13]=='r')? 2: 3);
4835 set_bit (FLAG_COMMIT, &ai->flags);
4836 } else if ( !strncmp( line, "RXDiversity: ", 13 ) ) {
4837 ai->config.rxDiversity =
4838 (line[13]=='l') ? 1 :
4839 ((line[13]=='r')? 2: 3);
4840 set_bit (FLAG_COMMIT, &ai->flags);
4841 } else if ( !strncmp( line, "FragThreshold: ", 15 ) ) {
4845 v = get_dec_u16(line, &i, 4);
4846 v = (v<256) ? 256 : ((v>2312) ? 2312 : v);
4847 v = v & 0xfffe; /* Make sure its even */
4848 ai->config.fragThresh = (u16)v;
4849 set_bit (FLAG_COMMIT, &ai->flags);
4850 } else if (!strncmp(line, "Modulation: ", 12)) {
4853 case 'd': ai->config.modulation=MOD_DEFAULT; set_bit(FLAG_COMMIT, &ai->flags); break;
4854 case 'c': ai->config.modulation=MOD_CCK; set_bit(FLAG_COMMIT, &ai->flags); break;
4855 case 'm': ai->config.modulation=MOD_MOK; set_bit(FLAG_COMMIT, &ai->flags); break;
4857 printk( KERN_WARNING "airo: Unknown modulation\n" );
4859 } else if (!strncmp(line, "Preamble: ", 10)) {
4862 case 'a': ai->config.preamble=PREAMBLE_AUTO; set_bit(FLAG_COMMIT, &ai->flags); break;
4863 case 'l': ai->config.preamble=PREAMBLE_LONG; set_bit(FLAG_COMMIT, &ai->flags); break;
4864 case 's': ai->config.preamble=PREAMBLE_SHORT; set_bit(FLAG_COMMIT, &ai->flags); break;
4865 default: printk(KERN_WARNING "airo: Unknown preamble\n");
4868 printk( KERN_WARNING "Couldn't figure out %s\n", line );
4870 while( line[0] && line[0] != '\n' ) line++;
4871 if ( line[0] ) line++;
4873 airo_config_commit(dev, NULL, NULL, NULL);
4876 static char *get_rmode(u16 mode) {
4878 case RXMODE_RFMON: return "rfmon";
4879 case RXMODE_RFMON_ANYBSS: return "yna (any) bss rfmon";
4880 case RXMODE_LANMON: return "lanmon";
4885 static int proc_config_open( struct inode *inode, struct file *file ) {
4886 struct proc_data *data;
4887 struct proc_dir_entry *dp = PDE(inode);
4888 struct net_device *dev = dp->data;
4889 struct airo_info *ai = dev->priv;
4892 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4894 memset(file->private_data, 0, sizeof(struct proc_data));
4895 data = (struct proc_data *)file->private_data;
4896 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4897 kfree (file->private_data);
4900 if ((data->wbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4901 kfree (data->rbuffer);
4902 kfree (file->private_data);
4905 memset( data->wbuffer, 0, 2048 );
4906 data->maxwritelen = 2048;
4907 data->on_close = proc_config_on_close;
4909 readConfigRid(ai, 1);
4911 i = sprintf( data->rbuffer,
4916 "DataRates: %d %d %d %d %d %d %d %d\n"
4919 (ai->config.opmode & 0xFF) == 0 ? "adhoc" :
4920 (ai->config.opmode & 0xFF) == 1 ? get_rmode(ai->config.rmode):
4921 (ai->config.opmode & 0xFF) == 2 ? "AP" :
4922 (ai->config.opmode & 0xFF) == 3 ? "AP RPTR" : "Error",
4923 test_bit(FLAG_RADIO_OFF, &ai->flags) ? "off" : "on",
4924 ai->config.nodeName,
4925 ai->config.powerSaveMode == 0 ? "CAM" :
4926 ai->config.powerSaveMode == 1 ? "PSP" :
4927 ai->config.powerSaveMode == 2 ? "PSPCAM" : "Error",
4928 (int)ai->config.rates[0],
4929 (int)ai->config.rates[1],
4930 (int)ai->config.rates[2],
4931 (int)ai->config.rates[3],
4932 (int)ai->config.rates[4],
4933 (int)ai->config.rates[5],
4934 (int)ai->config.rates[6],
4935 (int)ai->config.rates[7],
4936 (int)ai->config.channelSet,
4937 (int)ai->config.txPower
4939 sprintf( data->rbuffer + i,
4940 "LongRetryLimit: %d\n"
4941 "ShortRetryLimit: %d\n"
4942 "RTSThreshold: %d\n"
4943 "TXMSDULifetime: %d\n"
4944 "RXMSDULifetime: %d\n"
4947 "FragThreshold: %d\n"
4951 (int)ai->config.longRetryLimit,
4952 (int)ai->config.shortRetryLimit,
4953 (int)ai->config.rtsThres,
4954 (int)ai->config.txLifetime,
4955 (int)ai->config.rxLifetime,
4956 ai->config.txDiversity == 1 ? "left" :
4957 ai->config.txDiversity == 2 ? "right" : "both",
4958 ai->config.rxDiversity == 1 ? "left" :
4959 ai->config.rxDiversity == 2 ? "right" : "both",
4960 (int)ai->config.fragThresh,
4961 ai->config.authType == AUTH_ENCRYPT ? "encrypt" :
4962 ai->config.authType == AUTH_SHAREDKEY ? "shared" : "open",
4963 ai->config.modulation == 0 ? "default" :
4964 ai->config.modulation == MOD_CCK ? "cck" :
4965 ai->config.modulation == MOD_MOK ? "mok" : "error",
4966 ai->config.preamble == PREAMBLE_AUTO ? "auto" :
4967 ai->config.preamble == PREAMBLE_LONG ? "long" :
4968 ai->config.preamble == PREAMBLE_SHORT ? "short" : "error"
4970 data->readlen = strlen( data->rbuffer );
4974 static void proc_SSID_on_close( struct inode *inode, struct file *file ) {
4975 struct proc_data *data = (struct proc_data *)file->private_data;
4976 struct proc_dir_entry *dp = PDE(inode);
4977 struct net_device *dev = dp->data;
4978 struct airo_info *ai = dev->priv;
4984 if ( !data->writelen ) return;
4986 memset( &SSID_rid, 0, sizeof( SSID_rid ) );
4988 for( i = 0; i < 3; i++ ) {
4990 for( j = 0; j+offset < data->writelen && j < 32 &&
4991 data->wbuffer[offset+j] != '\n'; j++ ) {
4992 SSID_rid.ssids[i].ssid[j] = data->wbuffer[offset+j];
4994 if ( j == 0 ) break;
4995 SSID_rid.ssids[i].len = j;
4997 while( data->wbuffer[offset] != '\n' &&
4998 offset < data->writelen ) offset++;
5002 SSID_rid.len = sizeof(SSID_rid);
5004 writeSsidRid(ai, &SSID_rid, 1);
5005 enable_MAC(ai, &rsp, 1);
5008 inline static u8 hexVal(char c) {
5009 if (c>='0' && c<='9') return c -= '0';
5010 if (c>='a' && c<='f') return c -= 'a'-10;
5011 if (c>='A' && c<='F') return c -= 'A'-10;
5015 static void proc_APList_on_close( struct inode *inode, struct file *file ) {
5016 struct proc_data *data = (struct proc_data *)file->private_data;
5017 struct proc_dir_entry *dp = PDE(inode);
5018 struct net_device *dev = dp->data;
5019 struct airo_info *ai = dev->priv;
5020 APListRid APList_rid;
5024 if ( !data->writelen ) return;
5026 memset( &APList_rid, 0, sizeof(APList_rid) );
5027 APList_rid.len = sizeof(APList_rid);
5029 for( i = 0; i < 4 && data->writelen >= (i+1)*6*3; i++ ) {
5031 for( j = 0; j < 6*3 && data->wbuffer[j+i*6*3]; j++ ) {
5034 APList_rid.ap[i][j/3]=
5035 hexVal(data->wbuffer[j+i*6*3])<<4;
5038 APList_rid.ap[i][j/3]|=
5039 hexVal(data->wbuffer[j+i*6*3]);
5045 writeAPListRid(ai, &APList_rid, 1);
5046 enable_MAC(ai, &rsp, 1);
5049 /* This function wraps PC4500_writerid with a MAC disable */
5050 static int do_writerid( struct airo_info *ai, u16 rid, const void *rid_data,
5051 int len, int dummy ) {
5056 rc = PC4500_writerid(ai, rid, rid_data, len, 1);
5057 enable_MAC(ai, &rsp, 1);
5061 /* Returns the length of the key at the index. If index == 0xffff
5062 * the index of the transmit key is returned. If the key doesn't exist,
5063 * -1 will be returned.
5065 static int get_wep_key(struct airo_info *ai, u16 index) {
5070 rc = readWepKeyRid(ai, &wkr, 1, 1);
5071 if (rc == SUCCESS) do {
5072 lastindex = wkr.kindex;
5073 if (wkr.kindex == index) {
5074 if (index == 0xffff) {
5079 readWepKeyRid(ai, &wkr, 0, 1);
5080 } while(lastindex != wkr.kindex);
5084 static int set_wep_key(struct airo_info *ai, u16 index,
5085 const char *key, u16 keylen, int perm, int lock ) {
5086 static const unsigned char macaddr[ETH_ALEN] = { 0x01, 0, 0, 0, 0, 0 };
5090 memset(&wkr, 0, sizeof(wkr));
5092 // We are selecting which key to use
5093 wkr.len = sizeof(wkr);
5094 wkr.kindex = 0xffff;
5095 wkr.mac[0] = (char)index;
5096 if (perm) printk(KERN_INFO "Setting transmit key to %d\n", index);
5097 if (perm) ai->defindex = (char)index;
5099 // We are actually setting the key
5100 wkr.len = sizeof(wkr);
5103 memcpy( wkr.key, key, keylen );
5104 memcpy( wkr.mac, macaddr, ETH_ALEN );
5105 printk(KERN_INFO "Setting key %d\n", index);
5108 disable_MAC(ai, lock);
5109 writeWepKeyRid(ai, &wkr, perm, lock);
5110 enable_MAC(ai, &rsp, lock);
5114 static void proc_wepkey_on_close( struct inode *inode, struct file *file ) {
5115 struct proc_data *data;
5116 struct proc_dir_entry *dp = PDE(inode);
5117 struct net_device *dev = dp->data;
5118 struct airo_info *ai = dev->priv;
5124 memset(key, 0, sizeof(key));
5126 data = (struct proc_data *)file->private_data;
5127 if ( !data->writelen ) return;
5129 if (data->wbuffer[0] >= '0' && data->wbuffer[0] <= '3' &&
5130 (data->wbuffer[1] == ' ' || data->wbuffer[1] == '\n')) {
5131 index = data->wbuffer[0] - '0';
5132 if (data->wbuffer[1] == '\n') {
5133 set_wep_key(ai, index, NULL, 0, 1, 1);
5138 printk(KERN_ERR "airo: WepKey passed invalid key index\n");
5142 for( i = 0; i < 16*3 && data->wbuffer[i+j]; i++ ) {
5145 key[i/3] = hexVal(data->wbuffer[i+j])<<4;
5148 key[i/3] |= hexVal(data->wbuffer[i+j]);
5152 set_wep_key(ai, index, key, i/3, 1, 1);
5155 static int proc_wepkey_open( struct inode *inode, struct file *file ) {
5156 struct proc_data *data;
5157 struct proc_dir_entry *dp = PDE(inode);
5158 struct net_device *dev = dp->data;
5159 struct airo_info *ai = dev->priv;
5166 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5168 memset(file->private_data, 0, sizeof(struct proc_data));
5169 memset(&wkr, 0, sizeof(wkr));
5170 data = (struct proc_data *)file->private_data;
5171 if ((data->rbuffer = kmalloc( 180, GFP_KERNEL )) == NULL) {
5172 kfree (file->private_data);
5175 memset(data->rbuffer, 0, 180);
5177 data->maxwritelen = 80;
5178 if ((data->wbuffer = kmalloc( 80, GFP_KERNEL )) == NULL) {
5179 kfree (data->rbuffer);
5180 kfree (file->private_data);
5183 memset( data->wbuffer, 0, 80 );
5184 data->on_close = proc_wepkey_on_close;
5186 ptr = data->rbuffer;
5187 strcpy(ptr, "No wep keys\n");
5188 rc = readWepKeyRid(ai, &wkr, 1, 1);
5189 if (rc == SUCCESS) do {
5190 lastindex = wkr.kindex;
5191 if (wkr.kindex == 0xffff) {
5192 j += sprintf(ptr+j, "Tx key = %d\n",
5195 j += sprintf(ptr+j, "Key %d set with length = %d\n",
5196 (int)wkr.kindex, (int)wkr.klen);
5198 readWepKeyRid(ai, &wkr, 0, 1);
5199 } while((lastindex != wkr.kindex) && (j < 180-30));
5201 data->readlen = strlen( data->rbuffer );
5205 static int proc_SSID_open( struct inode *inode, struct file *file ) {
5206 struct proc_data *data;
5207 struct proc_dir_entry *dp = PDE(inode);
5208 struct net_device *dev = dp->data;
5209 struct airo_info *ai = dev->priv;
5214 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5216 memset(file->private_data, 0, sizeof(struct proc_data));
5217 data = (struct proc_data *)file->private_data;
5218 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5219 kfree (file->private_data);
5223 data->maxwritelen = 33*3;
5224 if ((data->wbuffer = kmalloc( 33*3, GFP_KERNEL )) == NULL) {
5225 kfree (data->rbuffer);
5226 kfree (file->private_data);
5229 memset( data->wbuffer, 0, 33*3 );
5230 data->on_close = proc_SSID_on_close;
5232 readSsidRid(ai, &SSID_rid);
5233 ptr = data->rbuffer;
5234 for( i = 0; i < 3; i++ ) {
5236 if ( !SSID_rid.ssids[i].len ) break;
5237 for( j = 0; j < 32 &&
5238 j < SSID_rid.ssids[i].len &&
5239 SSID_rid.ssids[i].ssid[j]; j++ ) {
5240 *ptr++ = SSID_rid.ssids[i].ssid[j];
5245 data->readlen = strlen( data->rbuffer );
5249 static int proc_APList_open( struct inode *inode, struct file *file ) {
5250 struct proc_data *data;
5251 struct proc_dir_entry *dp = PDE(inode);
5252 struct net_device *dev = dp->data;
5253 struct airo_info *ai = dev->priv;
5256 APListRid APList_rid;
5258 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5260 memset(file->private_data, 0, sizeof(struct proc_data));
5261 data = (struct proc_data *)file->private_data;
5262 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5263 kfree (file->private_data);
5267 data->maxwritelen = 4*6*3;
5268 if ((data->wbuffer = kmalloc( data->maxwritelen, GFP_KERNEL )) == NULL) {
5269 kfree (data->rbuffer);
5270 kfree (file->private_data);
5273 memset( data->wbuffer, 0, data->maxwritelen );
5274 data->on_close = proc_APList_on_close;
5276 readAPListRid(ai, &APList_rid);
5277 ptr = data->rbuffer;
5278 for( i = 0; i < 4; i++ ) {
5279 // We end when we find a zero MAC
5280 if ( !*(int*)APList_rid.ap[i] &&
5281 !*(int*)&APList_rid.ap[i][2]) break;
5282 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x\n",
5283 (int)APList_rid.ap[i][0],
5284 (int)APList_rid.ap[i][1],
5285 (int)APList_rid.ap[i][2],
5286 (int)APList_rid.ap[i][3],
5287 (int)APList_rid.ap[i][4],
5288 (int)APList_rid.ap[i][5]);
5290 if (i==0) ptr += sprintf(ptr, "Not using specific APs\n");
5293 data->readlen = strlen( data->rbuffer );
5297 static int proc_BSSList_open( struct inode *inode, struct file *file ) {
5298 struct proc_data *data;
5299 struct proc_dir_entry *dp = PDE(inode);
5300 struct net_device *dev = dp->data;
5301 struct airo_info *ai = dev->priv;
5303 BSSListRid BSSList_rid;
5305 /* If doLoseSync is not 1, we won't do a Lose Sync */
5306 int doLoseSync = -1;
5308 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5310 memset(file->private_data, 0, sizeof(struct proc_data));
5311 data = (struct proc_data *)file->private_data;
5312 if ((data->rbuffer = kmalloc( 1024, GFP_KERNEL )) == NULL) {
5313 kfree (file->private_data);
5317 data->maxwritelen = 0;
5318 data->wbuffer = NULL;
5319 data->on_close = NULL;
5321 if (file->f_mode & FMODE_WRITE) {
5322 if (!(file->f_mode & FMODE_READ)) {
5326 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
5327 memset(&cmd, 0, sizeof(cmd));
5328 cmd.cmd=CMD_LISTBSS;
5329 if (down_interruptible(&ai->sem))
5330 return -ERESTARTSYS;
5331 issuecommand(ai, &cmd, &rsp);
5338 ptr = data->rbuffer;
5339 /* There is a race condition here if there are concurrent opens.
5340 Since it is a rare condition, we'll just live with it, otherwise
5341 we have to add a spin lock... */
5342 rc = readBSSListRid(ai, doLoseSync, &BSSList_rid);
5343 while(rc == 0 && BSSList_rid.index != 0xffff) {
5344 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x %*s rssi = %d",
5345 (int)BSSList_rid.bssid[0],
5346 (int)BSSList_rid.bssid[1],
5347 (int)BSSList_rid.bssid[2],
5348 (int)BSSList_rid.bssid[3],
5349 (int)BSSList_rid.bssid[4],
5350 (int)BSSList_rid.bssid[5],
5351 (int)BSSList_rid.ssidLen,
5353 (int)BSSList_rid.rssi);
5354 ptr += sprintf(ptr, " channel = %d %s %s %s %s\n",
5355 (int)BSSList_rid.dsChannel,
5356 BSSList_rid.cap & CAP_ESS ? "ESS" : "",
5357 BSSList_rid.cap & CAP_IBSS ? "adhoc" : "",
5358 BSSList_rid.cap & CAP_PRIVACY ? "wep" : "",
5359 BSSList_rid.cap & CAP_SHORTHDR ? "shorthdr" : "");
5360 rc = readBSSListRid(ai, 0, &BSSList_rid);
5363 data->readlen = strlen( data->rbuffer );
5367 static int proc_close( struct inode *inode, struct file *file )
5369 struct proc_data *data = (struct proc_data *)file->private_data;
5370 if ( data->on_close != NULL ) data->on_close( inode, file );
5371 if ( data->rbuffer ) kfree( data->rbuffer );
5372 if ( data->wbuffer ) kfree( data->wbuffer );
5377 static struct net_device_list {
5378 struct net_device *dev;
5379 struct net_device_list *next;
5382 /* Since the card doesn't automatically switch to the right WEP mode,
5383 we will make it do it. If the card isn't associated, every secs we
5384 will switch WEP modes to see if that will help. If the card is
5385 associated we will check every minute to see if anything has
5387 static void timer_func( struct net_device *dev ) {
5388 struct airo_info *apriv = dev->priv;
5391 /* We don't have a link so try changing the authtype */
5392 readConfigRid(apriv, 0);
5393 disable_MAC(apriv, 0);
5394 switch(apriv->config.authType) {
5396 /* So drop to OPEN */
5397 apriv->config.authType = AUTH_OPEN;
5399 case AUTH_SHAREDKEY:
5400 if (apriv->keyindex < auto_wep) {
5401 set_wep_key(apriv, apriv->keyindex, NULL, 0, 0, 0);
5402 apriv->config.authType = AUTH_SHAREDKEY;
5405 /* Drop to ENCRYPT */
5406 apriv->keyindex = 0;
5407 set_wep_key(apriv, apriv->defindex, NULL, 0, 0, 0);
5408 apriv->config.authType = AUTH_ENCRYPT;
5411 default: /* We'll escalate to SHAREDKEY */
5412 apriv->config.authType = AUTH_SHAREDKEY;
5414 set_bit (FLAG_COMMIT, &apriv->flags);
5415 writeConfigRid(apriv, 0);
5416 enable_MAC(apriv, &rsp, 0);
5419 /* Schedule check to see if the change worked */
5420 clear_bit(JOB_AUTOWEP, &apriv->flags);
5421 apriv->expires = RUN_AT(HZ*3);
5424 static int add_airo_dev( struct net_device *dev ) {
5425 struct net_device_list *node = kmalloc( sizeof( *node ), GFP_KERNEL );
5430 node->next = airo_devices;
5431 airo_devices = node;
5436 static void del_airo_dev( struct net_device *dev ) {
5437 struct net_device_list **p = &airo_devices;
5438 while( *p && ( (*p)->dev != dev ) )
5440 if ( *p && (*p)->dev == dev )
5445 static int __devinit airo_pci_probe(struct pci_dev *pdev,
5446 const struct pci_device_id *pent)
5448 struct net_device *dev;
5450 if (pci_enable_device(pdev))
5452 pci_set_master(pdev);
5454 if (pdev->device == 0x5000 || pdev->device == 0xa504)
5455 dev = _init_airo_card(pdev->irq, pdev->resource[0].start, 0, pdev);
5457 dev = _init_airo_card(pdev->irq, pdev->resource[2].start, 0, pdev);
5461 pci_set_drvdata(pdev, dev);
5465 static void __devexit airo_pci_remove(struct pci_dev *pdev)
5469 static int airo_pci_suspend(struct pci_dev *pdev, u32 state)
5471 struct net_device *dev = pci_get_drvdata(pdev);
5472 struct airo_info *ai = dev->priv;
5476 if ((ai->APList == NULL) &&
5477 (ai->APList = kmalloc(sizeof(APListRid), GFP_KERNEL)) == NULL)
5479 if ((ai->SSID == NULL) &&
5480 (ai->SSID = kmalloc(sizeof(SsidRid), GFP_KERNEL)) == NULL)
5482 readAPListRid(ai, ai->APList);
5483 readSsidRid(ai, ai->SSID);
5484 memset(&cmd, 0, sizeof(cmd));
5485 /* the lock will be released at the end of the resume callback */
5486 if (down_interruptible(&ai->sem))
5489 netif_device_detach(dev);
5492 issuecommand(ai, &cmd, &rsp);
5494 pci_enable_wake(pdev, state, 1);
5495 pci_save_state(pdev, ai->pci_state);
5496 return pci_set_power_state(pdev, state);
5499 static int airo_pci_resume(struct pci_dev *pdev)
5501 struct net_device *dev = pci_get_drvdata(pdev);
5502 struct airo_info *ai = dev->priv;
5505 pci_set_power_state(pdev, 0);
5506 pci_restore_state(pdev, ai->pci_state);
5507 pci_enable_wake(pdev, ai->power, 0);
5509 if (ai->power > 1) {
5511 mpi_init_descriptors(ai);
5512 setup_card(ai, dev->dev_addr, 0);
5513 clear_bit(FLAG_RADIO_OFF, &ai->flags);
5514 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
5516 OUT4500(ai, EVACK, EV_AWAKEN);
5517 OUT4500(ai, EVACK, EV_AWAKEN);
5518 schedule_timeout(HZ/10);
5521 set_bit (FLAG_COMMIT, &ai->flags);
5523 schedule_timeout (HZ/5);
5525 writeSsidRid(ai, ai->SSID, 0);
5530 writeAPListRid(ai, ai->APList, 0);
5534 writeConfigRid(ai, 0);
5535 enable_MAC(ai, &rsp, 0);
5537 netif_device_attach(dev);
5538 netif_wake_queue(dev);
5539 enable_interrupts(ai);
5545 static int __init airo_init_module( void )
5547 int i, have_isa_dev = 0;
5549 airo_entry = create_proc_entry("aironet",
5550 S_IFDIR | airo_perm,
5552 airo_entry->uid = proc_uid;
5553 airo_entry->gid = proc_gid;
5555 for( i = 0; i < 4 && io[i] && irq[i]; i++ ) {
5557 "airo: Trying to configure ISA adapter at irq=%d io=0x%x\n",
5559 if (init_airo_card( irq[i], io[i], 0 ))
5564 printk( KERN_INFO "airo: Probing for PCI adapters\n" );
5565 pci_register_driver(&airo_driver);
5566 printk( KERN_INFO "airo: Finished probing for PCI adapters\n" );
5569 /* Always exit with success, as we are a library module
5570 * as well as a driver module
5575 static void __exit airo_cleanup_module( void )
5577 while( airo_devices ) {
5578 printk( KERN_INFO "airo: Unregistering %s\n", airo_devices->dev->name );
5579 stop_airo_card( airo_devices->dev, 1 );
5582 pci_unregister_driver(&airo_driver);
5584 remove_proc_entry("aironet", proc_root_driver);
5589 * Initial Wireless Extension code for Aironet driver by :
5590 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 17 November 00
5591 * Conversion to new driver API by :
5592 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 26 March 02
5593 * Javier also did a good amount of work here, adding some new extensions
5594 * and fixing my code. Let's just say that without him this code just
5595 * would not work at all... - Jean II
5598 static int airo_get_quality (StatusRid *status_rid, CapabilityRid *cap_rid)
5602 if ((status_rid->mode & 0x3f) == 0x3f && (cap_rid->hardCap & 8)) {
5603 if (memcmp(cap_rid->prodName, "350", 3))
5604 if (status_rid->signalQuality > 0x20)
5607 quality = 0x20 - status_rid->signalQuality;
5609 if (status_rid->signalQuality > 0xb0)
5611 else if (status_rid->signalQuality < 0x10)
5614 quality = 0xb0 - status_rid->signalQuality;
5619 #define airo_get_max_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x20 : 0xa0)
5620 #define airo_get_avg_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x10 : 0x50);
5622 /*------------------------------------------------------------------*/
5624 * Wireless Handler : get protocol name
5626 static int airo_get_name(struct net_device *dev,
5627 struct iw_request_info *info,
5631 strcpy(cwrq, "IEEE 802.11-DS");
5635 /*------------------------------------------------------------------*/
5637 * Wireless Handler : set frequency
5639 static int airo_set_freq(struct net_device *dev,
5640 struct iw_request_info *info,
5641 struct iw_freq *fwrq,
5644 struct airo_info *local = dev->priv;
5645 int rc = -EINPROGRESS; /* Call commit handler */
5647 /* If setting by frequency, convert to a channel */
5648 if((fwrq->e == 1) &&
5649 (fwrq->m >= (int) 2.412e8) &&
5650 (fwrq->m <= (int) 2.487e8)) {
5651 int f = fwrq->m / 100000;
5653 while((c < 14) && (f != frequency_list[c]))
5655 /* Hack to fall through... */
5659 /* Setting by channel number */
5660 if((fwrq->m > 1000) || (fwrq->e > 0))
5663 int channel = fwrq->m;
5664 /* We should do a better check than that,
5665 * based on the card capability !!! */
5666 if((channel < 1) || (channel > 16)) {
5667 printk(KERN_DEBUG "%s: New channel value of %d is invalid!\n", dev->name, fwrq->m);
5670 readConfigRid(local, 1);
5671 /* Yes ! We can set it !!! */
5672 local->config.channelSet = (u16)(channel - 1);
5673 set_bit (FLAG_COMMIT, &local->flags);
5679 /*------------------------------------------------------------------*/
5681 * Wireless Handler : get frequency
5683 static int airo_get_freq(struct net_device *dev,
5684 struct iw_request_info *info,
5685 struct iw_freq *fwrq,
5688 struct airo_info *local = dev->priv;
5689 StatusRid status_rid; /* Card status info */
5691 readConfigRid(local, 1);
5692 if ((local->config.opmode & 0xFF) == MODE_STA_ESS)
5693 status_rid.channel = local->config.channelSet;
5695 readStatusRid(local, &status_rid, 1);
5697 #ifdef WEXT_USECHANNELS
5698 fwrq->m = ((int)status_rid.channel) + 1;
5702 int f = (int)status_rid.channel;
5703 fwrq->m = frequency_list[f] * 100000;
5711 /*------------------------------------------------------------------*/
5713 * Wireless Handler : set ESSID
5715 static int airo_set_essid(struct net_device *dev,
5716 struct iw_request_info *info,
5717 struct iw_point *dwrq,
5720 struct airo_info *local = dev->priv;
5722 SsidRid SSID_rid; /* SSIDs */
5724 /* Reload the list of current SSID */
5725 readSsidRid(local, &SSID_rid);
5727 /* Check if we asked for `any' */
5728 if(dwrq->flags == 0) {
5729 /* Just send an empty SSID list */
5730 memset(&SSID_rid, 0, sizeof(SSID_rid));
5732 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
5734 /* Check the size of the string */
5735 if(dwrq->length > IW_ESSID_MAX_SIZE+1) {
5738 /* Check if index is valid */
5739 if((index < 0) || (index >= 4)) {
5744 memset(SSID_rid.ssids[index].ssid, 0,
5745 sizeof(SSID_rid.ssids[index].ssid));
5746 memcpy(SSID_rid.ssids[index].ssid, extra, dwrq->length);
5747 SSID_rid.ssids[index].len = dwrq->length - 1;
5749 SSID_rid.len = sizeof(SSID_rid);
5750 /* Write it to the card */
5751 disable_MAC(local, 1);
5752 writeSsidRid(local, &SSID_rid, 1);
5753 enable_MAC(local, &rsp, 1);
5758 /*------------------------------------------------------------------*/
5760 * Wireless Handler : get ESSID
5762 static int airo_get_essid(struct net_device *dev,
5763 struct iw_request_info *info,
5764 struct iw_point *dwrq,
5767 struct airo_info *local = dev->priv;
5768 StatusRid status_rid; /* Card status info */
5770 readStatusRid(local, &status_rid, 1);
5772 /* Note : if dwrq->flags != 0, we should
5773 * get the relevant SSID from the SSID list... */
5775 /* Get the current SSID */
5776 memcpy(extra, status_rid.SSID, status_rid.SSIDlen);
5777 extra[status_rid.SSIDlen] = '\0';
5778 /* If none, we may want to get the one that was set */
5781 dwrq->length = status_rid.SSIDlen + 1;
5782 dwrq->flags = 1; /* active */
5787 /*------------------------------------------------------------------*/
5789 * Wireless Handler : set AP address
5791 static int airo_set_wap(struct net_device *dev,
5792 struct iw_request_info *info,
5793 struct sockaddr *awrq,
5796 struct airo_info *local = dev->priv;
5799 APListRid APList_rid;
5800 static const unsigned char bcast[ETH_ALEN] = { 255, 255, 255, 255, 255, 255 };
5802 if (awrq->sa_family != ARPHRD_ETHER)
5804 else if (!memcmp(bcast, awrq->sa_data, ETH_ALEN)) {
5805 memset(&cmd, 0, sizeof(cmd));
5806 cmd.cmd=CMD_LOSE_SYNC;
5807 if (down_interruptible(&local->sem))
5808 return -ERESTARTSYS;
5809 issuecommand(local, &cmd, &rsp);
5812 memset(&APList_rid, 0, sizeof(APList_rid));
5813 APList_rid.len = sizeof(APList_rid);
5814 memcpy(APList_rid.ap[0], awrq->sa_data, ETH_ALEN);
5815 disable_MAC(local, 1);
5816 writeAPListRid(local, &APList_rid, 1);
5817 enable_MAC(local, &rsp, 1);
5822 /*------------------------------------------------------------------*/
5824 * Wireless Handler : get AP address
5826 static int airo_get_wap(struct net_device *dev,
5827 struct iw_request_info *info,
5828 struct sockaddr *awrq,
5831 struct airo_info *local = dev->priv;
5832 StatusRid status_rid; /* Card status info */
5834 readStatusRid(local, &status_rid, 1);
5836 /* Tentative. This seems to work, wow, I'm lucky !!! */
5837 memcpy(awrq->sa_data, status_rid.bssid[0], ETH_ALEN);
5838 awrq->sa_family = ARPHRD_ETHER;
5843 /*------------------------------------------------------------------*/
5845 * Wireless Handler : set Nickname
5847 static int airo_set_nick(struct net_device *dev,
5848 struct iw_request_info *info,
5849 struct iw_point *dwrq,
5852 struct airo_info *local = dev->priv;
5854 /* Check the size of the string */
5855 if(dwrq->length > 16 + 1) {
5858 readConfigRid(local, 1);
5859 memset(local->config.nodeName, 0, sizeof(local->config.nodeName));
5860 memcpy(local->config.nodeName, extra, dwrq->length);
5861 set_bit (FLAG_COMMIT, &local->flags);
5863 return -EINPROGRESS; /* Call commit handler */
5866 /*------------------------------------------------------------------*/
5868 * Wireless Handler : get Nickname
5870 static int airo_get_nick(struct net_device *dev,
5871 struct iw_request_info *info,
5872 struct iw_point *dwrq,
5875 struct airo_info *local = dev->priv;
5877 readConfigRid(local, 1);
5878 strncpy(extra, local->config.nodeName, 16);
5880 dwrq->length = strlen(extra) + 1;
5885 /*------------------------------------------------------------------*/
5887 * Wireless Handler : set Bit-Rate
5889 static int airo_set_rate(struct net_device *dev,
5890 struct iw_request_info *info,
5891 struct iw_param *vwrq,
5894 struct airo_info *local = dev->priv;
5895 CapabilityRid cap_rid; /* Card capability info */
5899 /* First : get a valid bit rate value */
5900 readCapabilityRid(local, &cap_rid, 1);
5902 /* Which type of value ? */
5903 if((vwrq->value < 8) && (vwrq->value >= 0)) {
5904 /* Setting by rate index */
5905 /* Find value in the magic rate table */
5906 brate = cap_rid.supportedRates[vwrq->value];
5908 /* Setting by frequency value */
5909 u8 normvalue = (u8) (vwrq->value/500000);
5911 /* Check if rate is valid */
5912 for(i = 0 ; i < 8 ; i++) {
5913 if(normvalue == cap_rid.supportedRates[i]) {
5919 /* -1 designed the max rate (mostly auto mode) */
5920 if(vwrq->value == -1) {
5921 /* Get the highest available rate */
5922 for(i = 0 ; i < 8 ; i++) {
5923 if(cap_rid.supportedRates[i] == 0)
5927 brate = cap_rid.supportedRates[i - 1];
5929 /* Check that it is valid */
5934 readConfigRid(local, 1);
5935 /* Now, check if we want a fixed or auto value */
5936 if(vwrq->fixed == 0) {
5937 /* Fill all the rates up to this max rate */
5938 memset(local->config.rates, 0, 8);
5939 for(i = 0 ; i < 8 ; i++) {
5940 local->config.rates[i] = cap_rid.supportedRates[i];
5941 if(local->config.rates[i] == brate)
5946 /* One rate, fixed */
5947 memset(local->config.rates, 0, 8);
5948 local->config.rates[0] = brate;
5950 set_bit (FLAG_COMMIT, &local->flags);
5952 return -EINPROGRESS; /* Call commit handler */
5955 /*------------------------------------------------------------------*/
5957 * Wireless Handler : get Bit-Rate
5959 static int airo_get_rate(struct net_device *dev,
5960 struct iw_request_info *info,
5961 struct iw_param *vwrq,
5964 struct airo_info *local = dev->priv;
5965 StatusRid status_rid; /* Card status info */
5967 readStatusRid(local, &status_rid, 1);
5969 vwrq->value = status_rid.currentXmitRate * 500000;
5970 /* If more than one rate, set auto */
5971 readConfigRid(local, 1);
5972 vwrq->fixed = (local->config.rates[1] == 0);
5977 /*------------------------------------------------------------------*/
5979 * Wireless Handler : set RTS threshold
5981 static int airo_set_rts(struct net_device *dev,
5982 struct iw_request_info *info,
5983 struct iw_param *vwrq,
5986 struct airo_info *local = dev->priv;
5987 int rthr = vwrq->value;
5991 if((rthr < 0) || (rthr > 2312)) {
5994 readConfigRid(local, 1);
5995 local->config.rtsThres = rthr;
5996 set_bit (FLAG_COMMIT, &local->flags);
5998 return -EINPROGRESS; /* Call commit handler */
6001 /*------------------------------------------------------------------*/
6003 * Wireless Handler : get RTS threshold
6005 static int airo_get_rts(struct net_device *dev,
6006 struct iw_request_info *info,
6007 struct iw_param *vwrq,
6010 struct airo_info *local = dev->priv;
6012 readConfigRid(local, 1);
6013 vwrq->value = local->config.rtsThres;
6014 vwrq->disabled = (vwrq->value >= 2312);
6020 /*------------------------------------------------------------------*/
6022 * Wireless Handler : set Fragmentation threshold
6024 static int airo_set_frag(struct net_device *dev,
6025 struct iw_request_info *info,
6026 struct iw_param *vwrq,
6029 struct airo_info *local = dev->priv;
6030 int fthr = vwrq->value;
6034 if((fthr < 256) || (fthr > 2312)) {
6037 fthr &= ~0x1; /* Get an even value - is it really needed ??? */
6038 readConfigRid(local, 1);
6039 local->config.fragThresh = (u16)fthr;
6040 set_bit (FLAG_COMMIT, &local->flags);
6042 return -EINPROGRESS; /* Call commit handler */
6045 /*------------------------------------------------------------------*/
6047 * Wireless Handler : get Fragmentation threshold
6049 static int airo_get_frag(struct net_device *dev,
6050 struct iw_request_info *info,
6051 struct iw_param *vwrq,
6054 struct airo_info *local = dev->priv;
6056 readConfigRid(local, 1);
6057 vwrq->value = local->config.fragThresh;
6058 vwrq->disabled = (vwrq->value >= 2312);
6064 /*------------------------------------------------------------------*/
6066 * Wireless Handler : set Mode of Operation
6068 static int airo_set_mode(struct net_device *dev,
6069 struct iw_request_info *info,
6073 struct airo_info *local = dev->priv;
6076 readConfigRid(local, 1);
6077 if ((local->config.rmode & 0xff) >= RXMODE_RFMON)
6082 local->config.opmode &= 0xFF00;
6083 local->config.opmode |= MODE_STA_IBSS;
6084 local->config.rmode &= 0xfe00;
6085 local->config.scanMode = SCANMODE_ACTIVE;
6086 clear_bit (FLAG_802_11, &local->flags);
6089 local->config.opmode &= 0xFF00;
6090 local->config.opmode |= MODE_STA_ESS;
6091 local->config.rmode &= 0xfe00;
6092 local->config.scanMode = SCANMODE_ACTIVE;
6093 clear_bit (FLAG_802_11, &local->flags);
6095 case IW_MODE_MASTER:
6096 local->config.opmode &= 0xFF00;
6097 local->config.opmode |= MODE_AP;
6098 local->config.rmode &= 0xfe00;
6099 local->config.scanMode = SCANMODE_ACTIVE;
6100 clear_bit (FLAG_802_11, &local->flags);
6102 case IW_MODE_REPEAT:
6103 local->config.opmode &= 0xFF00;
6104 local->config.opmode |= MODE_AP_RPTR;
6105 local->config.rmode &= 0xfe00;
6106 local->config.scanMode = SCANMODE_ACTIVE;
6107 clear_bit (FLAG_802_11, &local->flags);
6109 case IW_MODE_MONITOR:
6110 local->config.opmode &= 0xFF00;
6111 local->config.opmode |= MODE_STA_ESS;
6112 local->config.rmode &= 0xfe00;
6113 local->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
6114 local->config.scanMode = SCANMODE_PASSIVE;
6115 set_bit (FLAG_802_11, &local->flags);
6121 set_bit (FLAG_RESET, &local->flags);
6122 set_bit (FLAG_COMMIT, &local->flags);
6124 return -EINPROGRESS; /* Call commit handler */
6127 /*------------------------------------------------------------------*/
6129 * Wireless Handler : get Mode of Operation
6131 static int airo_get_mode(struct net_device *dev,
6132 struct iw_request_info *info,
6136 struct airo_info *local = dev->priv;
6138 readConfigRid(local, 1);
6139 /* If not managed, assume it's ad-hoc */
6140 switch (local->config.opmode & 0xFF) {
6142 *uwrq = IW_MODE_INFRA;
6145 *uwrq = IW_MODE_MASTER;
6148 *uwrq = IW_MODE_REPEAT;
6151 *uwrq = IW_MODE_ADHOC;
6157 /*------------------------------------------------------------------*/
6159 * Wireless Handler : set Encryption Key
6161 static int airo_set_encode(struct net_device *dev,
6162 struct iw_request_info *info,
6163 struct iw_point *dwrq,
6166 struct airo_info *local = dev->priv;
6167 CapabilityRid cap_rid; /* Card capability info */
6169 /* Is WEP supported ? */
6170 readCapabilityRid(local, &cap_rid, 1);
6171 /* Older firmware doesn't support this...
6172 if(!(cap_rid.softCap & 2)) {
6175 readConfigRid(local, 1);
6177 /* Basic checking: do we have a key to set ?
6178 * Note : with the new API, it's impossible to get a NULL pointer.
6179 * Therefore, we need to check a key size == 0 instead.
6180 * New version of iwconfig properly set the IW_ENCODE_NOKEY flag
6181 * when no key is present (only change flags), but older versions
6182 * don't do it. - Jean II */
6183 if (dwrq->length > 0) {
6185 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6186 int current_index = get_wep_key(local, 0xffff);
6187 /* Check the size of the key */
6188 if (dwrq->length > MAX_KEY_SIZE) {
6191 /* Check the index (none -> use current) */
6192 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4:1)))
6193 index = current_index;
6194 /* Set the length */
6195 if (dwrq->length > MIN_KEY_SIZE)
6196 key.len = MAX_KEY_SIZE;
6198 if (dwrq->length > 0)
6199 key.len = MIN_KEY_SIZE;
6201 /* Disable the key */
6203 /* Check if the key is not marked as invalid */
6204 if(!(dwrq->flags & IW_ENCODE_NOKEY)) {
6206 memset(key.key, 0, MAX_KEY_SIZE);
6207 /* Copy the key in the driver */
6208 memcpy(key.key, extra, dwrq->length);
6209 /* Send the key to the card */
6210 set_wep_key(local, index, key.key, key.len, 1, 1);
6212 /* WE specify that if a valid key is set, encryption
6213 * should be enabled (user may turn it off later)
6214 * This is also how "iwconfig ethX key on" works */
6215 if((index == current_index) && (key.len > 0) &&
6216 (local->config.authType == AUTH_OPEN)) {
6217 local->config.authType = AUTH_ENCRYPT;
6218 set_bit (FLAG_COMMIT, &local->flags);
6221 /* Do we want to just set the transmit key index ? */
6222 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6223 if ((index >= 0) && (index < ((cap_rid.softCap & 0x80)?4:1))) {
6224 set_wep_key(local, index, NULL, 0, 1, 1);
6226 /* Don't complain if only change the mode */
6227 if(!dwrq->flags & IW_ENCODE_MODE) {
6231 /* Read the flags */
6232 if(dwrq->flags & IW_ENCODE_DISABLED)
6233 local->config.authType = AUTH_OPEN; // disable encryption
6234 if(dwrq->flags & IW_ENCODE_RESTRICTED)
6235 local->config.authType = AUTH_SHAREDKEY; // Only Both
6236 if(dwrq->flags & IW_ENCODE_OPEN)
6237 local->config.authType = AUTH_ENCRYPT; // Only Wep
6238 /* Commit the changes to flags if needed */
6239 if(dwrq->flags & IW_ENCODE_MODE)
6240 set_bit (FLAG_COMMIT, &local->flags);
6241 return -EINPROGRESS; /* Call commit handler */
6244 /*------------------------------------------------------------------*/
6246 * Wireless Handler : get Encryption Key
6248 static int airo_get_encode(struct net_device *dev,
6249 struct iw_request_info *info,
6250 struct iw_point *dwrq,
6253 struct airo_info *local = dev->priv;
6254 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6255 CapabilityRid cap_rid; /* Card capability info */
6257 /* Is it supported ? */
6258 readCapabilityRid(local, &cap_rid, 1);
6259 if(!(cap_rid.softCap & 2)) {
6262 readConfigRid(local, 1);
6263 /* Check encryption mode */
6264 switch(local->config.authType) {
6266 dwrq->flags = IW_ENCODE_OPEN;
6268 case AUTH_SHAREDKEY:
6269 dwrq->flags = IW_ENCODE_RESTRICTED;
6273 dwrq->flags = IW_ENCODE_DISABLED;
6276 /* We can't return the key, so set the proper flag and return zero */
6277 dwrq->flags |= IW_ENCODE_NOKEY;
6278 memset(extra, 0, 16);
6280 /* Which key do we want ? -1 -> tx index */
6281 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4 : 1)))
6282 index = get_wep_key(local, 0xffff);
6283 dwrq->flags |= index + 1;
6284 /* Copy the key to the user buffer */
6285 dwrq->length = get_wep_key(local, index);
6286 if (dwrq->length > 16) {
6292 /*------------------------------------------------------------------*/
6294 * Wireless Handler : set Tx-Power
6296 static int airo_set_txpow(struct net_device *dev,
6297 struct iw_request_info *info,
6298 struct iw_param *vwrq,
6301 struct airo_info *local = dev->priv;
6302 CapabilityRid cap_rid; /* Card capability info */
6306 readCapabilityRid(local, &cap_rid, 1);
6308 if (vwrq->disabled) {
6309 set_bit (FLAG_RADIO_OFF, &local->flags);
6310 set_bit (FLAG_COMMIT, &local->flags);
6311 return -EINPROGRESS; /* Call commit handler */
6313 if (vwrq->flags != IW_TXPOW_MWATT) {
6316 clear_bit (FLAG_RADIO_OFF, &local->flags);
6317 for (i = 0; cap_rid.txPowerLevels[i] && (i < 8); i++)
6318 if ((vwrq->value==cap_rid.txPowerLevels[i])) {
6319 readConfigRid(local, 1);
6320 local->config.txPower = vwrq->value;
6321 set_bit (FLAG_COMMIT, &local->flags);
6322 rc = -EINPROGRESS; /* Call commit handler */
6328 /*------------------------------------------------------------------*/
6330 * Wireless Handler : get Tx-Power
6332 static int airo_get_txpow(struct net_device *dev,
6333 struct iw_request_info *info,
6334 struct iw_param *vwrq,
6337 struct airo_info *local = dev->priv;
6339 readConfigRid(local, 1);
6340 vwrq->value = local->config.txPower;
6341 vwrq->fixed = 1; /* No power control */
6342 vwrq->disabled = test_bit(FLAG_RADIO_OFF, &local->flags);
6343 vwrq->flags = IW_TXPOW_MWATT;
6348 /*------------------------------------------------------------------*/
6350 * Wireless Handler : set Retry limits
6352 static int airo_set_retry(struct net_device *dev,
6353 struct iw_request_info *info,
6354 struct iw_param *vwrq,
6357 struct airo_info *local = dev->priv;
6360 if(vwrq->disabled) {
6363 readConfigRid(local, 1);
6364 if(vwrq->flags & IW_RETRY_LIMIT) {
6365 if(vwrq->flags & IW_RETRY_MAX)
6366 local->config.longRetryLimit = vwrq->value;
6367 else if (vwrq->flags & IW_RETRY_MIN)
6368 local->config.shortRetryLimit = vwrq->value;
6370 /* No modifier : set both */
6371 local->config.longRetryLimit = vwrq->value;
6372 local->config.shortRetryLimit = vwrq->value;
6374 set_bit (FLAG_COMMIT, &local->flags);
6375 rc = -EINPROGRESS; /* Call commit handler */
6377 if(vwrq->flags & IW_RETRY_LIFETIME) {
6378 local->config.txLifetime = vwrq->value / 1024;
6379 set_bit (FLAG_COMMIT, &local->flags);
6380 rc = -EINPROGRESS; /* Call commit handler */
6385 /*------------------------------------------------------------------*/
6387 * Wireless Handler : get Retry limits
6389 static int airo_get_retry(struct net_device *dev,
6390 struct iw_request_info *info,
6391 struct iw_param *vwrq,
6394 struct airo_info *local = dev->priv;
6396 vwrq->disabled = 0; /* Can't be disabled */
6398 readConfigRid(local, 1);
6399 /* Note : by default, display the min retry number */
6400 if((vwrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
6401 vwrq->flags = IW_RETRY_LIFETIME;
6402 vwrq->value = (int)local->config.txLifetime * 1024;
6403 } else if((vwrq->flags & IW_RETRY_MAX)) {
6404 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
6405 vwrq->value = (int)local->config.longRetryLimit;
6407 vwrq->flags = IW_RETRY_LIMIT;
6408 vwrq->value = (int)local->config.shortRetryLimit;
6409 if((int)local->config.shortRetryLimit != (int)local->config.longRetryLimit)
6410 vwrq->flags |= IW_RETRY_MIN;
6416 /*------------------------------------------------------------------*/
6418 * Wireless Handler : get range info
6420 static int airo_get_range(struct net_device *dev,
6421 struct iw_request_info *info,
6422 struct iw_point *dwrq,
6425 struct airo_info *local = dev->priv;
6426 struct iw_range *range = (struct iw_range *) extra;
6427 CapabilityRid cap_rid; /* Card capability info */
6431 readCapabilityRid(local, &cap_rid, 1);
6433 dwrq->length = sizeof(struct iw_range);
6434 memset(range, 0, sizeof(*range));
6435 range->min_nwid = 0x0000;
6436 range->max_nwid = 0x0000;
6437 range->num_channels = 14;
6438 /* Should be based on cap_rid.country to give only
6439 * what the current card support */
6441 for(i = 0; i < 14; i++) {
6442 range->freq[k].i = i + 1; /* List index */
6443 range->freq[k].m = frequency_list[i] * 100000;
6444 range->freq[k++].e = 1; /* Values in table in MHz -> * 10^5 * 10 */
6446 range->num_frequency = k;
6448 /* Hum... Should put the right values there */
6449 range->max_qual.qual = airo_get_max_quality(&cap_rid);
6450 range->max_qual.level = 0x100 - 120; /* -120 dBm */
6451 range->max_qual.noise = 0;
6452 range->sensitivity = 65535;
6454 for(i = 0 ; i < 8 ; i++) {
6455 range->bitrate[i] = cap_rid.supportedRates[i] * 500000;
6456 if(range->bitrate[i] == 0)
6459 range->num_bitrates = i;
6461 /* Set an indication of the max TCP throughput
6462 * in bit/s that we can expect using this interface.
6463 * May be use for QoS stuff... Jean II */
6465 range->throughput = 5000 * 1000;
6467 range->throughput = 1500 * 1000;
6470 range->max_rts = 2312;
6471 range->min_frag = 256;
6472 range->max_frag = 2312;
6474 if(cap_rid.softCap & 2) {
6476 range->encoding_size[0] = 5;
6478 if (cap_rid.softCap & 0x100) {
6479 range->encoding_size[1] = 13;
6480 range->num_encoding_sizes = 2;
6482 range->num_encoding_sizes = 1;
6483 range->max_encoding_tokens = (cap_rid.softCap & 0x80) ? 4 : 1;
6485 range->num_encoding_sizes = 0;
6486 range->max_encoding_tokens = 0;
6489 range->max_pmp = 5000000; /* 5 secs */
6491 range->max_pmt = 65535 * 1024; /* ??? */
6492 range->pmp_flags = IW_POWER_PERIOD;
6493 range->pmt_flags = IW_POWER_TIMEOUT;
6494 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
6496 /* Transmit Power - values are in mW */
6497 for(i = 0 ; i < 8 ; i++) {
6498 range->txpower[i] = cap_rid.txPowerLevels[i];
6499 if(range->txpower[i] == 0)
6502 range->num_txpower = i;
6503 range->txpower_capa = IW_TXPOW_MWATT;
6504 range->we_version_source = 12;
6505 range->we_version_compiled = WIRELESS_EXT;
6506 range->retry_capa = IW_RETRY_LIMIT | IW_RETRY_LIFETIME;
6507 range->retry_flags = IW_RETRY_LIMIT;
6508 range->r_time_flags = IW_RETRY_LIFETIME;
6509 range->min_retry = 1;
6510 range->max_retry = 65535;
6511 range->min_r_time = 1024;
6512 range->max_r_time = 65535 * 1024;
6513 /* Experimental measurements - boundary 11/5.5 Mb/s */
6514 /* Note : with or without the (local->rssi), results
6515 * are somewhat different. - Jean II */
6516 range->avg_qual.qual = airo_get_avg_quality(&cap_rid);
6518 range->avg_qual.level = 186; /* -70 dBm */
6520 range->avg_qual.level = 176; /* -80 dBm */
6521 range->avg_qual.noise = 0;
6526 /*------------------------------------------------------------------*/
6528 * Wireless Handler : set Power Management
6530 static int airo_set_power(struct net_device *dev,
6531 struct iw_request_info *info,
6532 struct iw_param *vwrq,
6535 struct airo_info *local = dev->priv;
6537 readConfigRid(local, 1);
6538 if (vwrq->disabled) {
6539 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6542 local->config.powerSaveMode = POWERSAVE_CAM;
6543 local->config.rmode &= 0xFF00;
6544 local->config.rmode |= RXMODE_BC_MC_ADDR;
6545 set_bit (FLAG_COMMIT, &local->flags);
6546 return -EINPROGRESS; /* Call commit handler */
6548 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
6549 local->config.fastListenDelay = (vwrq->value + 500) / 1024;
6550 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6551 set_bit (FLAG_COMMIT, &local->flags);
6552 } else if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
6553 local->config.fastListenInterval = local->config.listenInterval = (vwrq->value + 500) / 1024;
6554 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6555 set_bit (FLAG_COMMIT, &local->flags);
6557 switch (vwrq->flags & IW_POWER_MODE) {
6558 case IW_POWER_UNICAST_R:
6559 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6562 local->config.rmode &= 0xFF00;
6563 local->config.rmode |= RXMODE_ADDR;
6564 set_bit (FLAG_COMMIT, &local->flags);
6566 case IW_POWER_ALL_R:
6567 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6570 local->config.rmode &= 0xFF00;
6571 local->config.rmode |= RXMODE_BC_MC_ADDR;
6572 set_bit (FLAG_COMMIT, &local->flags);
6578 // Note : we may want to factor local->need_commit here
6579 // Note2 : may also want to factor RXMODE_RFMON test
6580 return -EINPROGRESS; /* Call commit handler */
6583 /*------------------------------------------------------------------*/
6585 * Wireless Handler : get Power Management
6587 static int airo_get_power(struct net_device *dev,
6588 struct iw_request_info *info,
6589 struct iw_param *vwrq,
6592 struct airo_info *local = dev->priv;
6595 readConfigRid(local, 1);
6596 mode = local->config.powerSaveMode;
6597 if ((vwrq->disabled = (mode == POWERSAVE_CAM)))
6599 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
6600 vwrq->value = (int)local->config.fastListenDelay * 1024;
6601 vwrq->flags = IW_POWER_TIMEOUT;
6603 vwrq->value = (int)local->config.fastListenInterval * 1024;
6604 vwrq->flags = IW_POWER_PERIOD;
6606 if ((local->config.rmode & 0xFF) == RXMODE_ADDR)
6607 vwrq->flags |= IW_POWER_UNICAST_R;
6609 vwrq->flags |= IW_POWER_ALL_R;
6614 /*------------------------------------------------------------------*/
6616 * Wireless Handler : set Sensitivity
6618 static int airo_set_sens(struct net_device *dev,
6619 struct iw_request_info *info,
6620 struct iw_param *vwrq,
6623 struct airo_info *local = dev->priv;
6625 readConfigRid(local, 1);
6626 local->config.rssiThreshold = vwrq->disabled ? RSSI_DEFAULT : vwrq->value;
6627 set_bit (FLAG_COMMIT, &local->flags);
6629 return -EINPROGRESS; /* Call commit handler */
6632 /*------------------------------------------------------------------*/
6634 * Wireless Handler : get Sensitivity
6636 static int airo_get_sens(struct net_device *dev,
6637 struct iw_request_info *info,
6638 struct iw_param *vwrq,
6641 struct airo_info *local = dev->priv;
6643 readConfigRid(local, 1);
6644 vwrq->value = local->config.rssiThreshold;
6645 vwrq->disabled = (vwrq->value == 0);
6651 /*------------------------------------------------------------------*/
6653 * Wireless Handler : get AP List
6654 * Note : this is deprecated in favor of IWSCAN
6656 static int airo_get_aplist(struct net_device *dev,
6657 struct iw_request_info *info,
6658 struct iw_point *dwrq,
6661 struct airo_info *local = dev->priv;
6662 struct sockaddr *address = (struct sockaddr *) extra;
6663 struct iw_quality qual[IW_MAX_AP];
6666 int loseSync = capable(CAP_NET_ADMIN) ? 1: -1;
6668 for (i = 0; i < IW_MAX_AP; i++) {
6669 if (readBSSListRid(local, loseSync, &BSSList))
6672 memcpy(address[i].sa_data, BSSList.bssid, ETH_ALEN);
6673 address[i].sa_family = ARPHRD_ETHER;
6675 qual[i].level = 0x100 - local->rssi[BSSList.rssi].rssidBm;
6677 qual[i].level = (BSSList.rssi + 321) / 2;
6678 qual[i].qual = qual[i].noise = 0;
6679 qual[i].updated = 2;
6680 if (BSSList.index == 0xffff)
6684 StatusRid status_rid; /* Card status info */
6685 readStatusRid(local, &status_rid, 1);
6687 i < min(IW_MAX_AP, 4) &&
6688 (status_rid.bssid[i][0]
6689 & status_rid.bssid[i][1]
6690 & status_rid.bssid[i][2]
6691 & status_rid.bssid[i][3]
6692 & status_rid.bssid[i][4]
6693 & status_rid.bssid[i][5])!=0xff &&
6694 (status_rid.bssid[i][0]
6695 | status_rid.bssid[i][1]
6696 | status_rid.bssid[i][2]
6697 | status_rid.bssid[i][3]
6698 | status_rid.bssid[i][4]
6699 | status_rid.bssid[i][5]);
6701 memcpy(address[i].sa_data,
6702 status_rid.bssid[i], ETH_ALEN);
6703 address[i].sa_family = ARPHRD_ETHER;
6706 dwrq->flags = 1; /* Should be define'd */
6707 memcpy(extra + sizeof(struct sockaddr)*i,
6708 &qual, sizeof(struct iw_quality)*i);
6715 /*------------------------------------------------------------------*/
6717 * Wireless Handler : Initiate Scan
6719 static int airo_set_scan(struct net_device *dev,
6720 struct iw_request_info *info,
6721 struct iw_param *vwrq,
6724 struct airo_info *ai = dev->priv;
6728 /* Note : you may have realised that, as this is a SET operation,
6729 * this is privileged and therefore a normal user can't
6731 * This is not an error, while the device perform scanning,
6732 * traffic doesn't flow, so it's a perfect DoS...
6734 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
6736 /* Initiate a scan command */
6737 memset(&cmd, 0, sizeof(cmd));
6738 cmd.cmd=CMD_LISTBSS;
6739 if (down_interruptible(&ai->sem))
6740 return -ERESTARTSYS;
6741 issuecommand(ai, &cmd, &rsp);
6742 ai->scan_timestamp = jiffies;
6745 /* At this point, just return to the user. */
6750 /*------------------------------------------------------------------*/
6752 * Translate scan data returned from the card to a card independent
6753 * format that the Wireless Tools will understand - Jean II
6755 static inline char *airo_translate_scan(struct net_device *dev,
6760 struct airo_info *ai = dev->priv;
6761 struct iw_event iwe; /* Temporary buffer */
6763 char * current_val; /* For rates */
6766 /* First entry *MUST* be the AP MAC address */
6767 iwe.cmd = SIOCGIWAP;
6768 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
6769 memcpy(iwe.u.ap_addr.sa_data, list->bssid, ETH_ALEN);
6770 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_ADDR_LEN);
6772 /* Other entries will be displayed in the order we give them */
6775 iwe.u.data.length = list->ssidLen;
6776 if(iwe.u.data.length > 32)
6777 iwe.u.data.length = 32;
6778 iwe.cmd = SIOCGIWESSID;
6779 iwe.u.data.flags = 1;
6780 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, list->ssid);
6783 iwe.cmd = SIOCGIWMODE;
6784 capabilities = le16_to_cpu(list->cap);
6785 if(capabilities & (CAP_ESS | CAP_IBSS)) {
6786 if(capabilities & CAP_ESS)
6787 iwe.u.mode = IW_MODE_MASTER;
6789 iwe.u.mode = IW_MODE_ADHOC;
6790 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_UINT_LEN);
6794 iwe.cmd = SIOCGIWFREQ;
6795 iwe.u.freq.m = le16_to_cpu(list->dsChannel);
6796 iwe.u.freq.m = frequency_list[iwe.u.freq.m] * 100000;
6798 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_FREQ_LEN);
6800 /* Add quality statistics */
6803 iwe.u.qual.level = 0x100 - ai->rssi[list->rssi].rssidBm;
6805 iwe.u.qual.level = (list->rssi + 321) / 2;
6806 iwe.u.qual.noise = 0;
6807 iwe.u.qual.qual = 0;
6808 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
6810 /* Add encryption capability */
6811 iwe.cmd = SIOCGIWENCODE;
6812 if(capabilities & CAP_PRIVACY)
6813 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
6815 iwe.u.data.flags = IW_ENCODE_DISABLED;
6816 iwe.u.data.length = 0;
6817 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, list->ssid);
6819 /* Rate : stuffing multiple values in a single event require a bit
6820 * more of magic - Jean II */
6821 current_val = current_ev + IW_EV_LCP_LEN;
6823 iwe.cmd = SIOCGIWRATE;
6824 /* Those two flags are ignored... */
6825 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
6827 for(i = 0 ; i < 8 ; i++) {
6828 /* NULL terminated */
6829 if(list->rates[i] == 0)
6831 /* Bit rate given in 500 kb/s units (+ 0x80) */
6832 iwe.u.bitrate.value = ((list->rates[i] & 0x7f) * 500000);
6833 /* Add new value to event */
6834 current_val = iwe_stream_add_value(current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
6836 /* Check if we added any event */
6837 if((current_val - current_ev) > IW_EV_LCP_LEN)
6838 current_ev = current_val;
6840 /* The other data in the scan result are not really
6841 * interesting, so for now drop it - Jean II */
6845 /*------------------------------------------------------------------*/
6847 * Wireless Handler : Read Scan Results
6849 static int airo_get_scan(struct net_device *dev,
6850 struct iw_request_info *info,
6851 struct iw_point *dwrq,
6854 struct airo_info *ai = dev->priv;
6857 char *current_ev = extra;
6859 /* When we are associated again, the scan has surely finished.
6860 * Just in case, let's make sure enough time has elapsed since
6861 * we started the scan. - Javier */
6862 if(ai->scan_timestamp && time_before(jiffies,ai->scan_timestamp+3*HZ)) {
6863 /* Important note : we don't want to block the caller
6864 * until results are ready for various reasons.
6865 * First, managing wait queues is complex and racy
6866 * (there may be multiple simultaneous callers).
6867 * Second, we grab some rtnetlink lock before comming
6868 * here (in dev_ioctl()).
6869 * Third, the caller can wait on the Wireless Event
6873 ai->scan_timestamp = 0;
6875 /* There's only a race with proc_BSSList_open(), but its
6876 * consequences are begnign. So I don't bother fixing it - Javier */
6878 /* Try to read the first entry of the scan result */
6879 rc = PC4500_readrid(ai, RID_BSSLISTFIRST, &BSSList, sizeof(BSSList), 1);
6880 if((rc) || (BSSList.index == 0xffff)) {
6881 /* Client error, no scan results...
6882 * The caller need to restart the scan. */
6886 /* Read and parse all entries */
6887 while((!rc) && (BSSList.index != 0xffff)) {
6888 /* Translate to WE format this entry */
6889 current_ev = airo_translate_scan(dev, current_ev,
6890 extra + IW_SCAN_MAX_DATA,
6893 /* Read next entry */
6894 rc = PC4500_readrid(ai, RID_BSSLISTNEXT,
6895 &BSSList, sizeof(BSSList), 1);
6897 /* Length of data */
6898 dwrq->length = (current_ev - extra);
6899 dwrq->flags = 0; /* todo */
6904 /*------------------------------------------------------------------*/
6906 * Commit handler : called after a bunch of SET operations
6908 static int airo_config_commit(struct net_device *dev,
6909 struct iw_request_info *info, /* NULL */
6910 void *zwrq, /* NULL */
6911 char *extra) /* NULL */
6913 struct airo_info *local = dev->priv;
6916 if (!test_bit (FLAG_COMMIT, &local->flags))
6919 /* Some of the "SET" function may have modified some of the
6920 * parameters. It's now time to commit them in the card */
6921 disable_MAC(local, 1);
6922 if (test_bit (FLAG_RESET, &local->flags)) {
6923 APListRid APList_rid;
6926 readAPListRid(local, &APList_rid);
6927 readSsidRid(local, &SSID_rid);
6928 if (test_bit(FLAG_MPI,&local->flags))
6929 setup_card(local, dev->dev_addr, 1 );
6931 reset_airo_card(dev);
6932 disable_MAC(local, 1);
6933 writeSsidRid(local, &SSID_rid, 1);
6934 writeAPListRid(local, &APList_rid, 1);
6936 if (down_interruptible(&local->sem))
6937 return -ERESTARTSYS;
6938 writeConfigRid(local, 0);
6939 enable_MAC(local, &rsp, 0);
6940 if (test_bit (FLAG_RESET, &local->flags))
6941 airo_set_promisc(local);
6948 /*------------------------------------------------------------------*/
6950 * Structures to export the Wireless Handlers
6953 static const struct iw_priv_args airo_private_args[] = {
6954 /*{ cmd, set_args, get_args, name } */
6955 { AIROIOCTL, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
6956 IW_PRIV_TYPE_BYTE | 2047, "airoioctl" },
6957 { AIROIDIFC, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
6958 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "airoidifc" },
6961 static const iw_handler airo_handler[] =
6963 (iw_handler) airo_config_commit, /* SIOCSIWCOMMIT */
6964 (iw_handler) airo_get_name, /* SIOCGIWNAME */
6965 (iw_handler) NULL, /* SIOCSIWNWID */
6966 (iw_handler) NULL, /* SIOCGIWNWID */
6967 (iw_handler) airo_set_freq, /* SIOCSIWFREQ */
6968 (iw_handler) airo_get_freq, /* SIOCGIWFREQ */
6969 (iw_handler) airo_set_mode, /* SIOCSIWMODE */
6970 (iw_handler) airo_get_mode, /* SIOCGIWMODE */
6971 (iw_handler) airo_set_sens, /* SIOCSIWSENS */
6972 (iw_handler) airo_get_sens, /* SIOCGIWSENS */
6973 (iw_handler) NULL, /* SIOCSIWRANGE */
6974 (iw_handler) airo_get_range, /* SIOCGIWRANGE */
6975 (iw_handler) NULL, /* SIOCSIWPRIV */
6976 (iw_handler) NULL, /* SIOCGIWPRIV */
6977 (iw_handler) NULL, /* SIOCSIWSTATS */
6978 (iw_handler) NULL, /* SIOCGIWSTATS */
6979 iw_handler_set_spy, /* SIOCSIWSPY */
6980 iw_handler_get_spy, /* SIOCGIWSPY */
6981 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
6982 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
6983 (iw_handler) airo_set_wap, /* SIOCSIWAP */
6984 (iw_handler) airo_get_wap, /* SIOCGIWAP */
6985 (iw_handler) NULL, /* -- hole -- */
6986 (iw_handler) airo_get_aplist, /* SIOCGIWAPLIST */
6987 (iw_handler) airo_set_scan, /* SIOCSIWSCAN */
6988 (iw_handler) airo_get_scan, /* SIOCGIWSCAN */
6989 (iw_handler) airo_set_essid, /* SIOCSIWESSID */
6990 (iw_handler) airo_get_essid, /* SIOCGIWESSID */
6991 (iw_handler) airo_set_nick, /* SIOCSIWNICKN */
6992 (iw_handler) airo_get_nick, /* SIOCGIWNICKN */
6993 (iw_handler) NULL, /* -- hole -- */
6994 (iw_handler) NULL, /* -- hole -- */
6995 (iw_handler) airo_set_rate, /* SIOCSIWRATE */
6996 (iw_handler) airo_get_rate, /* SIOCGIWRATE */
6997 (iw_handler) airo_set_rts, /* SIOCSIWRTS */
6998 (iw_handler) airo_get_rts, /* SIOCGIWRTS */
6999 (iw_handler) airo_set_frag, /* SIOCSIWFRAG */
7000 (iw_handler) airo_get_frag, /* SIOCGIWFRAG */
7001 (iw_handler) airo_set_txpow, /* SIOCSIWTXPOW */
7002 (iw_handler) airo_get_txpow, /* SIOCGIWTXPOW */
7003 (iw_handler) airo_set_retry, /* SIOCSIWRETRY */
7004 (iw_handler) airo_get_retry, /* SIOCGIWRETRY */
7005 (iw_handler) airo_set_encode, /* SIOCSIWENCODE */
7006 (iw_handler) airo_get_encode, /* SIOCGIWENCODE */
7007 (iw_handler) airo_set_power, /* SIOCSIWPOWER */
7008 (iw_handler) airo_get_power, /* SIOCGIWPOWER */
7011 /* Note : don't describe AIROIDIFC and AIROOLDIDIFC in here.
7012 * We want to force the use of the ioctl code, because those can't be
7013 * won't work the iw_handler code (because they simultaneously read
7014 * and write data and iw_handler can't do that).
7015 * Note that it's perfectly legal to read/write on a single ioctl command,
7016 * you just can't use iwpriv and need to force it via the ioctl handler.
7018 static const iw_handler airo_private_handler[] =
7020 NULL, /* SIOCIWFIRSTPRIV */
7023 static const struct iw_handler_def airo_handler_def =
7025 .num_standard = sizeof(airo_handler)/sizeof(iw_handler),
7026 .num_private = sizeof(airo_private_handler)/sizeof(iw_handler),
7027 .num_private_args = sizeof(airo_private_args)/sizeof(struct iw_priv_args),
7028 .standard = (iw_handler *) airo_handler,
7029 .private = (iw_handler *) airo_private_handler,
7030 .private_args = (struct iw_priv_args *) airo_private_args,
7031 .spy_offset = ((void *) (&((struct airo_info *) NULL)->spy_data) -
7036 #endif /* WIRELESS_EXT */
7039 * This defines the configuration part of the Wireless Extensions
7040 * Note : irq and spinlock protection will occur in the subroutines
7043 * o Check input value more carefully and fill correct values in range
7044 * o Test and shakeout the bugs (if any)
7048 * Javier Achirica did a great job of merging code from the unnamed CISCO
7049 * developer that added support for flashing the card.
7051 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
7054 struct airo_info *ai = (struct airo_info *)dev->priv;
7066 int val = AIROMAGIC;
7068 if (copy_from_user(&com,rq->ifr_data,sizeof(com)))
7070 else if (copy_to_user(com.data,(char *)&val,sizeof(val)))
7079 /* Get the command struct and hand it off for evaluation by
7080 * the proper subfunction
7084 if (copy_from_user(&com,rq->ifr_data,sizeof(com))) {
7089 /* Separate R/W functions bracket legality here
7091 if ( com.command == AIRORSWVERSION ) {
7092 if (copy_to_user(com.data, swversion, sizeof(swversion)))
7097 else if ( com.command <= AIRORRID)
7098 rc = readrids(dev,&com);
7099 else if ( com.command >= AIROPCAP && com.command <= (AIROPLEAPUSR+2) )
7100 rc = writerids(dev,&com);
7101 else if ( com.command >= AIROFLSHRST && com.command <= AIRORESTART )
7102 rc = flashcard(dev,&com);
7104 rc = -EINVAL; /* Bad command in ioctl */
7107 #endif /* CISCO_EXT */
7109 // All other calls are currently unsupported
7118 * Get the Wireless stats out of the driver
7119 * Note : irq and spinlock protection will occur in the subroutines
7122 * o Check if work in Ad-Hoc mode (otherwise, use SPY, as in wvlan_cs)
7126 static void airo_read_wireless_stats(struct airo_info *local)
7128 StatusRid status_rid;
7130 CapabilityRid cap_rid;
7131 u32 *vals = stats_rid.vals;
7133 /* Get stats out of the card */
7134 clear_bit(JOB_WSTATS, &local->flags);
7139 readCapabilityRid(local, &cap_rid, 0);
7140 readStatusRid(local, &status_rid, 0);
7141 readStatsRid(local, &stats_rid, RID_STATS, 0);
7145 local->wstats.status = status_rid.mode;
7147 /* Signal quality and co. But where is the noise level ??? */
7148 local->wstats.qual.qual = airo_get_quality(&status_rid, &cap_rid);
7150 local->wstats.qual.level = 0x100 - local->rssi[status_rid.sigQuality].rssidBm;
7152 local->wstats.qual.level = (status_rid.normalizedSignalStrength + 321) / 2;
7153 if (status_rid.len >= 124) {
7154 local->wstats.qual.noise = 256 - status_rid.noisedBm;
7155 local->wstats.qual.updated = 7;
7157 local->wstats.qual.noise = 0;
7158 local->wstats.qual.updated = 3;
7161 /* Packets discarded in the wireless adapter due to wireless
7162 * specific problems */
7163 local->wstats.discard.nwid = vals[56] + vals[57] + vals[58];/* SSID Mismatch */
7164 local->wstats.discard.code = vals[6];/* RxWepErr */
7165 local->wstats.discard.fragment = vals[30];
7166 local->wstats.discard.retries = vals[10];
7167 local->wstats.discard.misc = vals[1] + vals[32];
7168 local->wstats.miss.beacon = vals[34];
7171 struct iw_statistics *airo_get_wireless_stats(struct net_device *dev)
7173 struct airo_info *local = dev->priv;
7175 if (!test_bit(JOB_WSTATS, &local->flags)) {
7176 /* Get stats out of the card if available */
7177 if (down_trylock(&local->sem) != 0) {
7178 set_bit(JOB_WSTATS, &local->flags);
7179 wake_up_interruptible(&local->thr_wait);
7181 airo_read_wireless_stats(local);
7184 return &local->wstats;
7186 #endif /* WIRELESS_EXT */
7190 * This just translates from driver IOCTL codes to the command codes to
7191 * feed to the radio's host interface. Things can be added/deleted
7192 * as needed. This represents the READ side of control I/O to
7195 static int readrids(struct net_device *dev, aironet_ioctl *comp) {
7196 unsigned short ridcode;
7197 unsigned char *iobuf;
7199 struct airo_info *ai = dev->priv;
7202 if (test_bit(FLAG_FLASHING, &ai->flags))
7205 switch(comp->command)
7207 case AIROGCAP: ridcode = RID_CAPABILITIES; break;
7208 case AIROGCFG: ridcode = RID_CONFIG;
7209 if (test_bit(FLAG_COMMIT, &ai->flags)) {
7210 disable_MAC (ai, 1);
7211 writeConfigRid (ai, 1);
7212 enable_MAC (ai, &rsp, 1);
7215 case AIROGSLIST: ridcode = RID_SSID; break;
7216 case AIROGVLIST: ridcode = RID_APLIST; break;
7217 case AIROGDRVNAM: ridcode = RID_DRVNAME; break;
7218 case AIROGEHTENC: ridcode = RID_ETHERENCAP; break;
7219 case AIROGWEPKTMP: ridcode = RID_WEP_TEMP;
7220 /* Only super-user can read WEP keys */
7221 if (!capable(CAP_NET_ADMIN))
7224 case AIROGWEPKNV: ridcode = RID_WEP_PERM;
7225 /* Only super-user can read WEP keys */
7226 if (!capable(CAP_NET_ADMIN))
7229 case AIROGSTAT: ridcode = RID_STATUS; break;
7230 case AIROGSTATSD32: ridcode = RID_STATSDELTA; break;
7231 case AIROGSTATSC32: ridcode = RID_STATS; break;
7234 if (copy_to_user(comp->data, &ai->micstats,
7235 min((int)comp->len,(int)sizeof(ai->micstats))))
7239 case AIRORRID: ridcode = comp->ridnum; break;
7245 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7248 PC4500_readrid(ai,ridcode,iobuf,RIDSIZE, 1);
7249 /* get the count of bytes in the rid docs say 1st 2 bytes is it.
7250 * then return it to the user
7251 * 9/22/2000 Honor user given length
7255 if (copy_to_user(comp->data, iobuf, min(len, (int)RIDSIZE))) {
7264 * Danger Will Robinson write the rids here
7267 static int writerids(struct net_device *dev, aironet_ioctl *comp) {
7268 struct airo_info *ai = dev->priv;
7274 static int (* writer)(struct airo_info *, u16 rid, const void *, int, int);
7275 unsigned char *iobuf;
7277 /* Only super-user can write RIDs */
7278 if (!capable(CAP_NET_ADMIN))
7281 if (test_bit(FLAG_FLASHING, &ai->flags))
7285 writer = do_writerid;
7287 switch(comp->command)
7289 case AIROPSIDS: ridcode = RID_SSID; break;
7290 case AIROPCAP: ridcode = RID_CAPABILITIES; break;
7291 case AIROPAPLIST: ridcode = RID_APLIST; break;
7292 case AIROPCFG: ai->config.len = 0;
7293 clear_bit(FLAG_COMMIT, &ai->flags);
7294 ridcode = RID_CONFIG; break;
7295 case AIROPWEPKEYNV: ridcode = RID_WEP_PERM; break;
7296 case AIROPLEAPUSR: ridcode = RID_LEAPUSERNAME; break;
7297 case AIROPLEAPPWD: ridcode = RID_LEAPPASSWORD; break;
7298 case AIROPWEPKEY: ridcode = RID_WEP_TEMP; writer = PC4500_writerid;
7300 case AIROPLEAPUSR+1: ridcode = 0xFF2A; break;
7301 case AIROPLEAPUSR+2: ridcode = 0xFF2B; break;
7303 /* this is not really a rid but a command given to the card
7307 if (enable_MAC(ai, &rsp, 1) != 0)
7312 * Evidently this code in the airo driver does not get a symbol
7313 * as disable_MAC. it's probably so short the compiler does not gen one.
7319 /* This command merely clears the counts does not actually store any data
7320 * only reads rid. But as it changes the cards state, I put it in the
7321 * writerid routines.
7324 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7327 PC4500_readrid(ai,RID_STATSDELTACLEAR,iobuf,RIDSIZE, 1);
7330 enabled = ai->micstats.enabled;
7331 memset(&ai->micstats,0,sizeof(ai->micstats));
7332 ai->micstats.enabled = enabled;
7335 if (copy_to_user(comp->data, iobuf,
7336 min((int)comp->len, (int)RIDSIZE))) {
7344 return -EOPNOTSUPP; /* Blarg! */
7346 if(comp->len > RIDSIZE)
7349 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7352 if (copy_from_user(iobuf,comp->data,comp->len)) {
7357 if (comp->command == AIROPCFG) {
7358 ConfigRid *cfg = (ConfigRid *)iobuf;
7360 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags))
7361 cfg->opmode |= MODE_MIC;
7363 if ((cfg->opmode & 0xFF) == MODE_STA_IBSS)
7364 set_bit (FLAG_ADHOC, &ai->flags);
7366 clear_bit (FLAG_ADHOC, &ai->flags);
7369 if((*writer)(ai, ridcode, iobuf,comp->len,1)) {
7377 /*****************************************************************************
7378 * Ancillary flash / mod functions much black magic lurkes here *
7379 *****************************************************************************
7383 * Flash command switch table
7386 int flashcard(struct net_device *dev, aironet_ioctl *comp) {
7388 int cmdreset(struct airo_info *);
7389 int setflashmode(struct airo_info *);
7390 int flashgchar(struct airo_info *,int,int);
7391 int flashpchar(struct airo_info *,int,int);
7392 int flashputbuf(struct airo_info *);
7393 int flashrestart(struct airo_info *,struct net_device *);
7395 /* Only super-user can modify flash */
7396 if (!capable(CAP_NET_ADMIN))
7399 switch(comp->command)
7402 return cmdreset((struct airo_info *)dev->priv);
7405 if (!((struct airo_info *)dev->priv)->flash &&
7406 (((struct airo_info *)dev->priv)->flash = kmalloc (FLASHSIZE, GFP_KERNEL)) == NULL)
7408 return setflashmode((struct airo_info *)dev->priv);
7410 case AIROFLSHGCHR: /* Get char from aux */
7411 if(comp->len != sizeof(int))
7413 if (copy_from_user(&z,comp->data,comp->len))
7415 return flashgchar((struct airo_info *)dev->priv,z,8000);
7417 case AIROFLSHPCHR: /* Send char to card. */
7418 if(comp->len != sizeof(int))
7420 if (copy_from_user(&z,comp->data,comp->len))
7422 return flashpchar((struct airo_info *)dev->priv,z,8000);
7424 case AIROFLPUTBUF: /* Send 32k to card */
7425 if (!((struct airo_info *)dev->priv)->flash)
7427 if(comp->len > FLASHSIZE)
7429 if(copy_from_user(((struct airo_info *)dev->priv)->flash,comp->data,comp->len))
7432 flashputbuf((struct airo_info *)dev->priv);
7436 if(flashrestart((struct airo_info *)dev->priv,dev))
7443 #define FLASH_COMMAND 0x7e7e
7447 * Disable MAC and do soft reset on
7451 int cmdreset(struct airo_info *ai) {
7455 printk(KERN_INFO "Waitbusy hang before RESET\n");
7459 OUT4500(ai,COMMAND,CMD_SOFTRESET);
7461 set_current_state (TASK_UNINTERRUPTIBLE);
7462 schedule_timeout (HZ); /* WAS 600 12/7/00 */
7465 printk(KERN_INFO "Waitbusy hang AFTER RESET\n");
7472 * Put the card in legendary flash
7476 int setflashmode (struct airo_info *ai) {
7477 set_bit (FLAG_FLASHING, &ai->flags);
7479 OUT4500(ai, SWS0, FLASH_COMMAND);
7480 OUT4500(ai, SWS1, FLASH_COMMAND);
7482 OUT4500(ai, SWS0, FLASH_COMMAND);
7483 OUT4500(ai, COMMAND,0x10);
7485 OUT4500(ai, SWS2, FLASH_COMMAND);
7486 OUT4500(ai, SWS3, FLASH_COMMAND);
7487 OUT4500(ai, COMMAND,0);
7489 set_current_state (TASK_UNINTERRUPTIBLE);
7490 schedule_timeout (HZ/2); /* 500ms delay */
7493 clear_bit (FLAG_FLASHING, &ai->flags);
7494 printk(KERN_INFO "Waitbusy hang after setflash mode\n");
7500 /* Put character to SWS0 wait for dwelltime
7504 int flashpchar(struct airo_info *ai,int byte,int dwelltime) {
7515 /* Wait for busy bit d15 to go false indicating buffer empty */
7516 while ((IN4500 (ai, SWS0) & 0x8000) && waittime > 0) {
7521 /* timeout for busy clear wait */
7523 printk(KERN_INFO "flash putchar busywait timeout! \n");
7527 /* Port is clear now write byte and wait for it to echo back */
7529 OUT4500(ai,SWS0,byte);
7532 echo = IN4500(ai,SWS1);
7533 } while (dwelltime >= 0 && echo != byte);
7537 return (echo == byte) ? 0 : -EIO;
7541 * Get a character from the card matching matchbyte
7544 int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime){
7546 unsigned char rbyte=0;
7549 rchar = IN4500(ai,SWS1);
7551 if(dwelltime && !(0x8000 & rchar)){
7556 rbyte = 0xff & rchar;
7558 if( (rbyte == matchbyte) && (0x8000 & rchar) ){
7562 if( rbyte == 0x81 || rbyte == 0x82 || rbyte == 0x83 || rbyte == 0x1a || 0xffff == rchar)
7566 }while(dwelltime > 0);
7571 * Transfer 32k of firmware data from user buffer to our buffer and
7575 int flashputbuf(struct airo_info *ai){
7579 if (test_bit(FLAG_MPI,&ai->flags))
7580 memcpy(ai->pciaux + 0x8000, ai->flash, FLASHSIZE);
7582 OUT4500(ai,AUXPAGE,0x100);
7583 OUT4500(ai,AUXOFF,0);
7585 for(nwords=0;nwords != FLASHSIZE / 2;nwords++){
7586 OUT4500(ai,AUXDATA,ai->flash[nwords] & 0xffff);
7589 OUT4500(ai,SWS0,0x8000);
7597 int flashrestart(struct airo_info *ai,struct net_device *dev){
7600 set_current_state (TASK_UNINTERRUPTIBLE);
7601 schedule_timeout (HZ); /* Added 12/7/00 */
7602 clear_bit (FLAG_FLASHING, &ai->flags);
7603 if (test_bit(FLAG_MPI, &ai->flags)) {
7604 status = mpi_init_descriptors(ai);
7605 if (status != SUCCESS)
7608 status = setup_card(ai, dev->dev_addr, 1);
7610 if (!test_bit(FLAG_MPI,&ai->flags))
7611 for( i = 0; i < MAX_FIDS; i++ ) {
7612 ai->fids[i] = transmit_allocate
7613 ( ai, 2312, i >= MAX_FIDS / 2 );
7616 set_current_state (TASK_UNINTERRUPTIBLE);
7617 schedule_timeout (HZ); /* Added 12/7/00 */
7620 #endif /* CISCO_EXT */
7623 This program is free software; you can redistribute it and/or
7624 modify it under the terms of the GNU General Public License
7625 as published by the Free Software Foundation; either version 2
7626 of the License, or (at your option) any later version.
7628 This program is distributed in the hope that it will be useful,
7629 but WITHOUT ANY WARRANTY; without even the implied warranty of
7630 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
7631 GNU General Public License for more details.
7635 Redistribution and use in source and binary forms, with or without
7636 modification, are permitted provided that the following conditions
7639 1. Redistributions of source code must retain the above copyright
7640 notice, this list of conditions and the following disclaimer.
7641 2. Redistributions in binary form must reproduce the above copyright
7642 notice, this list of conditions and the following disclaimer in the
7643 documentation and/or other materials provided with the distribution.
7644 3. The name of the author may not be used to endorse or promote
7645 products derived from this software without specific prior written
7648 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
7649 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
7650 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
7651 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
7652 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
7653 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
7654 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
7655 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
7656 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
7657 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
7658 POSSIBILITY OF SUCH DAMAGE.
7661 module_init(airo_init_module);
7662 module_exit(airo_cleanup_module);