1 /*======================================================================
3 Aironet driver for 4500 and 4800 series cards
5 This code is released under both the GPL version 2 and BSD licenses.
6 Either license may be used. The respective licenses are found at
9 This code was developed by Benjamin Reed <breed@users.sourceforge.net>
10 including portions of which come from the Aironet PC4500
11 Developer's Reference Manual and used with permission. Copyright
12 (C) 1999 Benjamin Reed. All Rights Reserved. Permission to use
13 code in the Developer's manual was granted for this driver by
14 Aironet. Major code contributions were received from Javier Achirica
15 <achirica@users.sourceforge.net> and Jean Tourrilhes <jt@hpl.hp.com>.
16 Code was also integrated from the Cisco Aironet driver for Linux.
17 Support for MPI350 cards was added by Fabrice Bellet
18 <fabrice@bellet.info>.
20 ======================================================================*/
22 #include <linux/config.h>
23 #include <linux/init.h>
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/proc_fs.h>
28 #include <linux/smp_lock.h>
30 #include <linux/sched.h>
31 #include <linux/ptrace.h>
32 #include <linux/slab.h>
33 #include <linux/string.h>
34 #include <linux/timer.h>
35 #include <linux/interrupt.h>
37 #include <linux/bitops.h>
38 #include <linux/scatterlist.h>
40 #include <asm/system.h>
42 #include <linux/netdevice.h>
43 #include <linux/etherdevice.h>
44 #include <linux/skbuff.h>
45 #include <linux/if_arp.h>
46 #include <linux/ioport.h>
47 #include <linux/pci.h>
48 #include <asm/uaccess.h>
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, pm_message_t 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_param_array(io, int, NULL, 0);
250 module_param_array(irq, int, NULL, 0);
251 module_param(basic_rate, int, 0);
252 module_param_array(rates, int, NULL, 0);
253 module_param_array(ssids, charp, NULL, 0);
254 module_param(auto_wep, int, 0);
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_param(aux_bap, int, 0);
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_param(maxencrypt, int, 0);
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_param(adhoc, int, 0);
268 MODULE_PARM_DESC(adhoc, "If non-zero, the card will start in adhoc mode.");
269 module_param(probe, int, 0);
270 MODULE_PARM_DESC(probe, "If zero, the driver won't start the card.");
272 module_param(proc_uid, int, 0);
273 MODULE_PARM_DESC(proc_uid, "The uid that the /proc files will belong to.");
274 module_param(proc_gid, int, 0);
275 MODULE_PARM_DESC(proc_gid, "The gid that the /proc files will belong to.");
276 module_param(airo_perm, int, 0);
277 MODULE_PARM_DESC(airo_perm, "The permission bits of /proc/[driver/]aironet.");
278 module_param(proc_perm, int, 0);
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 __iomem *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 __iomem *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 __iomem *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 static WifiCtlHdr wifictlhdr8023 = {
1046 .ctl = HOST_DONT_RLSE,
1050 // Frequency list (map channels to frequencies)
1051 static const long frequency_list[] = { 2412, 2417, 2422, 2427, 2432, 2437, 2442,
1052 2447, 2452, 2457, 2462, 2467, 2472, 2484 };
1054 // A few details needed for WEP (Wireless Equivalent Privacy)
1055 #define MAX_KEY_SIZE 13 // 128 (?) bits
1056 #define MIN_KEY_SIZE 5 // 40 bits RC4 - WEP
1057 typedef struct wep_key_t {
1059 u8 key[16]; /* 40-bit and 104-bit keys */
1062 /* Backward compatibility */
1063 #ifndef IW_ENCODE_NOKEY
1064 #define IW_ENCODE_NOKEY 0x0800 /* Key is write only, so not present */
1065 #define IW_ENCODE_MODE (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
1066 #endif /* IW_ENCODE_NOKEY */
1068 /* List of Wireless Handlers (new API) */
1069 static const struct iw_handler_def airo_handler_def;
1071 static const char version[] = "airo.c 0.6 (Ben Reed & Javier Achirica)";
1075 static int get_dec_u16( char *buffer, int *start, int limit );
1076 static void OUT4500( struct airo_info *, u16 register, u16 value );
1077 static unsigned short IN4500( struct airo_info *, u16 register );
1078 static u16 setup_card(struct airo_info*, u8 *mac, int lock);
1079 static int enable_MAC( struct airo_info *ai, Resp *rsp, int lock );
1080 static void disable_MAC(struct airo_info *ai, int lock);
1081 static void enable_interrupts(struct airo_info*);
1082 static void disable_interrupts(struct airo_info*);
1083 static u16 issuecommand(struct airo_info*, Cmd *pCmd, Resp *pRsp);
1084 static int bap_setup(struct airo_info*, u16 rid, u16 offset, int whichbap);
1085 static int aux_bap_read(struct airo_info*, u16 *pu16Dst, int bytelen,
1087 static int fast_bap_read(struct airo_info*, u16 *pu16Dst, int bytelen,
1089 static int bap_write(struct airo_info*, const u16 *pu16Src, int bytelen,
1091 static int PC4500_accessrid(struct airo_info*, u16 rid, u16 accmd);
1092 static int PC4500_readrid(struct airo_info*, u16 rid, void *pBuf, int len, int lock);
1093 static int PC4500_writerid(struct airo_info*, u16 rid, const void
1094 *pBuf, int len, int lock);
1095 static int do_writerid( struct airo_info*, u16 rid, const void *rid_data,
1096 int len, int dummy );
1097 static u16 transmit_allocate(struct airo_info*, int lenPayload, int raw);
1098 static int transmit_802_3_packet(struct airo_info*, int len, char *pPacket);
1099 static int transmit_802_11_packet(struct airo_info*, int len, char *pPacket);
1101 static int mpi_send_packet (struct net_device *dev);
1102 static void mpi_unmap_card(struct pci_dev *pci);
1103 static void mpi_receive_802_3(struct airo_info *ai);
1104 static void mpi_receive_802_11(struct airo_info *ai);
1105 static int waitbusy (struct airo_info *ai);
1107 static irqreturn_t airo_interrupt( int irq, void* dev_id, struct pt_regs
1109 static int airo_thread(void *data);
1110 static void timer_func( struct net_device *dev );
1111 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
1112 static struct iw_statistics *airo_get_wireless_stats (struct net_device *dev);
1113 static void airo_read_wireless_stats (struct airo_info *local);
1115 static int readrids(struct net_device *dev, aironet_ioctl *comp);
1116 static int writerids(struct net_device *dev, aironet_ioctl *comp);
1117 static int flashcard(struct net_device *dev, aironet_ioctl *comp);
1118 #endif /* CISCO_EXT */
1120 static void micinit(struct airo_info *ai);
1121 static int micsetup(struct airo_info *ai);
1122 static int encapsulate(struct airo_info *ai, etherHead *pPacket, MICBuffer *buffer, int len);
1123 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *pPacket, u16 payLen);
1125 static u8 airo_rssi_to_dbm (tdsRssiEntry *rssi_rid, u8 rssi);
1126 static u8 airo_dbm_to_pct (tdsRssiEntry *rssi_rid, u8 dbm);
1128 #include <linux/crypto.h>
1132 struct net_device_stats stats;
1133 struct net_device *dev;
1134 /* Note, we can have MAX_FIDS outstanding. FIDs are 16-bits, so we
1135 use the high bit to mark whether it is in use. */
1137 #define MPI_MAX_FIDS 1
1140 char keyindex; // Used with auto wep
1141 char defindex; // Used with auto wep
1142 struct proc_dir_entry *proc_entry;
1143 spinlock_t aux_lock;
1144 unsigned long flags;
1145 #define FLAG_PROMISC 8 /* IFF_PROMISC 0x100 - include/linux/if.h */
1146 #define FLAG_RADIO_OFF 0 /* User disabling of MAC */
1147 #define FLAG_RADIO_DOWN 1 /* ifup/ifdown disabling of MAC */
1148 #define FLAG_RADIO_MASK 0x03
1149 #define FLAG_ENABLED 2
1150 #define FLAG_ADHOC 3 /* Needed by MIC */
1151 #define FLAG_MIC_CAPABLE 4
1152 #define FLAG_UPDATE_MULTI 5
1153 #define FLAG_UPDATE_UNI 6
1154 #define FLAG_802_11 7
1155 #define FLAG_PENDING_XMIT 9
1156 #define FLAG_PENDING_XMIT11 10
1158 #define FLAG_REGISTERED 12
1159 #define FLAG_COMMIT 13
1160 #define FLAG_RESET 14
1161 #define FLAG_FLASHING 15
1162 #define JOB_MASK 0x1ff0000
1165 #define JOB_XMIT11 18
1166 #define JOB_STATS 19
1167 #define JOB_PROMISC 20
1169 #define JOB_EVENT 22
1170 #define JOB_AUTOWEP 23
1171 #define JOB_WSTATS 24
1172 int (*bap_read)(struct airo_info*, u16 *pu16Dst, int bytelen,
1174 unsigned short *flash;
1176 struct task_struct *task;
1177 struct semaphore sem;
1179 wait_queue_head_t thr_wait;
1180 struct completion thr_exited;
1181 unsigned long expires;
1183 struct sk_buff *skb;
1186 struct net_device *wifidev;
1187 struct iw_statistics wstats; // wireless stats
1188 unsigned long scan_timestamp; /* Time started to scan */
1189 struct iw_spy_data spy_data;
1190 struct iw_public_data wireless_data;
1193 struct crypto_tfm *tfm;
1195 mic_statistics micstats;
1197 HostRxDesc rxfids[MPI_MAX_FIDS]; // rx/tx/config MPI350 descriptors
1198 HostTxDesc txfids[MPI_MAX_FIDS];
1199 HostRidDesc config_desc;
1200 unsigned long ridbus; // phys addr of config_desc
1201 struct sk_buff_head txq;// tx queue used by mpi350 code
1202 struct pci_dev *pci;
1203 unsigned char __iomem *pcimem;
1204 unsigned char __iomem *pciaux;
1205 unsigned char *shared;
1206 dma_addr_t shared_dma;
1210 #define PCI_SHARED_LEN 2*MPI_MAX_FIDS*PKTSIZE+RIDSIZE
1211 char proc_name[IFNAMSIZ];
1214 static inline int bap_read(struct airo_info *ai, u16 *pu16Dst, int bytelen,
1216 return ai->bap_read(ai, pu16Dst, bytelen, whichbap);
1219 static int setup_proc_entry( struct net_device *dev,
1220 struct airo_info *apriv );
1221 static int takedown_proc_entry( struct net_device *dev,
1222 struct airo_info *apriv );
1224 static int cmdreset(struct airo_info *ai);
1225 static int setflashmode (struct airo_info *ai);
1226 static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime);
1227 static int flashputbuf(struct airo_info *ai);
1228 static int flashrestart(struct airo_info *ai,struct net_device *dev);
1231 /***********************************************************************
1233 ***********************************************************************
1236 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq);
1237 static void MoveWindow(miccntx *context, u32 micSeq);
1238 static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct crypto_tfm *);
1239 static void emmh32_init(emmh32_context *context);
1240 static void emmh32_update(emmh32_context *context, u8 *pOctets, int len);
1241 static void emmh32_final(emmh32_context *context, u8 digest[4]);
1242 static int flashpchar(struct airo_info *ai,int byte,int dwelltime);
1244 /* micinit - Initialize mic seed */
1246 static void micinit(struct airo_info *ai)
1250 clear_bit(JOB_MIC, &ai->flags);
1251 PC4500_readrid(ai, RID_MIC, &mic_rid, sizeof(mic_rid), 0);
1254 ai->micstats.enabled = (mic_rid.state & 0x00FF) ? 1 : 0;
1256 if (ai->micstats.enabled) {
1257 /* Key must be valid and different */
1258 if (mic_rid.multicastValid && (!ai->mod[0].mCtx.valid ||
1259 (memcmp (ai->mod[0].mCtx.key, mic_rid.multicast,
1260 sizeof(ai->mod[0].mCtx.key)) != 0))) {
1261 /* Age current mic Context */
1262 memcpy(&ai->mod[1].mCtx,&ai->mod[0].mCtx,sizeof(miccntx));
1263 /* Initialize new context */
1264 memcpy(&ai->mod[0].mCtx.key,mic_rid.multicast,sizeof(mic_rid.multicast));
1265 ai->mod[0].mCtx.window = 33; //Window always points to the middle
1266 ai->mod[0].mCtx.rx = 0; //Rx Sequence numbers
1267 ai->mod[0].mCtx.tx = 0; //Tx sequence numbers
1268 ai->mod[0].mCtx.valid = 1; //Key is now valid
1270 /* Give key to mic seed */
1271 emmh32_setseed(&ai->mod[0].mCtx.seed,mic_rid.multicast,sizeof(mic_rid.multicast), ai->tfm);
1274 /* Key must be valid and different */
1275 if (mic_rid.unicastValid && (!ai->mod[0].uCtx.valid ||
1276 (memcmp(ai->mod[0].uCtx.key, mic_rid.unicast,
1277 sizeof(ai->mod[0].uCtx.key)) != 0))) {
1278 /* Age current mic Context */
1279 memcpy(&ai->mod[1].uCtx,&ai->mod[0].uCtx,sizeof(miccntx));
1280 /* Initialize new context */
1281 memcpy(&ai->mod[0].uCtx.key,mic_rid.unicast,sizeof(mic_rid.unicast));
1283 ai->mod[0].uCtx.window = 33; //Window always points to the middle
1284 ai->mod[0].uCtx.rx = 0; //Rx Sequence numbers
1285 ai->mod[0].uCtx.tx = 0; //Tx sequence numbers
1286 ai->mod[0].uCtx.valid = 1; //Key is now valid
1288 //Give key to mic seed
1289 emmh32_setseed(&ai->mod[0].uCtx.seed, mic_rid.unicast, sizeof(mic_rid.unicast), ai->tfm);
1292 /* So next time we have a valid key and mic is enabled, we will update
1293 * the sequence number if the key is the same as before.
1295 ai->mod[0].uCtx.valid = 0;
1296 ai->mod[0].mCtx.valid = 0;
1300 /* micsetup - Get ready for business */
1302 static int micsetup(struct airo_info *ai) {
1305 if (ai->tfm == NULL)
1306 ai->tfm = crypto_alloc_tfm("aes", CRYPTO_TFM_REQ_MAY_SLEEP);
1308 if (ai->tfm == NULL) {
1309 printk(KERN_ERR "airo: failed to load transform for AES\n");
1313 for (i=0; i < NUM_MODULES; i++) {
1314 memset(&ai->mod[i].mCtx,0,sizeof(miccntx));
1315 memset(&ai->mod[i].uCtx,0,sizeof(miccntx));
1320 static char micsnap[] = {0xAA,0xAA,0x03,0x00,0x40,0x96,0x00,0x02};
1322 /*===========================================================================
1323 * Description: Mic a packet
1325 * Inputs: etherHead * pointer to an 802.3 frame
1327 * Returns: BOOLEAN if successful, otherwise false.
1328 * PacketTxLen will be updated with the mic'd packets size.
1330 * Caveats: It is assumed that the frame buffer will already
1331 * be big enough to hold the largets mic message possible.
1332 * (No memory allocation is done here).
1334 * Author: sbraneky (10/15/01)
1335 * Merciless hacks by rwilcher (1/14/02)
1338 static int encapsulate(struct airo_info *ai ,etherHead *frame, MICBuffer *mic, int payLen)
1342 // Determine correct context
1343 // If not adhoc, always use unicast key
1345 if (test_bit(FLAG_ADHOC, &ai->flags) && (frame->da[0] & 0x1))
1346 context = &ai->mod[0].mCtx;
1348 context = &ai->mod[0].uCtx;
1350 if (!context->valid)
1353 mic->typelen = htons(payLen + 16); //Length of Mic'd packet
1355 memcpy(&mic->u.snap, micsnap, sizeof(micsnap)); // Add Snap
1358 mic->seq = htonl(context->tx);
1361 emmh32_init(&context->seed); // Mic the packet
1362 emmh32_update(&context->seed,frame->da,ETH_ALEN * 2); // DA,SA
1363 emmh32_update(&context->seed,(u8*)&mic->typelen,10); // Type/Length and Snap
1364 emmh32_update(&context->seed,(u8*)&mic->seq,sizeof(mic->seq)); //SEQ
1365 emmh32_update(&context->seed,frame->da + ETH_ALEN * 2,payLen); //payload
1366 emmh32_final(&context->seed, (u8*)&mic->mic);
1368 /* New Type/length ?????????? */
1369 mic->typelen = 0; //Let NIC know it could be an oversized packet
1381 /*===========================================================================
1382 * Description: Decapsulates a MIC'd packet and returns the 802.3 packet
1383 * (removes the MIC stuff) if packet is a valid packet.
1385 * Inputs: etherHead pointer to the 802.3 packet
1387 * Returns: BOOLEAN - TRUE if packet should be dropped otherwise FALSE
1389 * Author: sbraneky (10/15/01)
1390 * Merciless hacks by rwilcher (1/14/02)
1391 *---------------------------------------------------------------------------
1394 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *eth, u16 payLen)
1400 mic_error micError = NONE;
1402 // Check if the packet is a Mic'd packet
1404 if (!ai->micstats.enabled) {
1405 //No Mic set or Mic OFF but we received a MIC'd packet.
1406 if (memcmp ((u8*)eth + 14, micsnap, sizeof(micsnap)) == 0) {
1407 ai->micstats.rxMICPlummed++;
1413 if (ntohs(mic->typelen) == 0x888E)
1416 if (memcmp (mic->u.snap, micsnap, sizeof(micsnap)) != 0) {
1417 // Mic enabled but packet isn't Mic'd
1418 ai->micstats.rxMICPlummed++;
1422 micSEQ = ntohl(mic->seq); //store SEQ as CPU order
1424 //At this point we a have a mic'd packet and mic is enabled
1425 //Now do the mic error checking.
1427 //Receive seq must be odd
1428 if ( (micSEQ & 1) == 0 ) {
1429 ai->micstats.rxWrongSequence++;
1433 for (i = 0; i < NUM_MODULES; i++) {
1434 int mcast = eth->da[0] & 1;
1435 //Determine proper context
1436 context = mcast ? &ai->mod[i].mCtx : &ai->mod[i].uCtx;
1438 //Make sure context is valid
1439 if (!context->valid) {
1441 micError = NOMICPLUMMED;
1447 mic->typelen = htons(payLen + sizeof(MICBuffer) - 2);
1449 emmh32_init(&context->seed);
1450 emmh32_update(&context->seed, eth->da, ETH_ALEN*2);
1451 emmh32_update(&context->seed, (u8 *)&mic->typelen, sizeof(mic->typelen)+sizeof(mic->u.snap));
1452 emmh32_update(&context->seed, (u8 *)&mic->seq,sizeof(mic->seq));
1453 emmh32_update(&context->seed, eth->da + ETH_ALEN*2,payLen);
1455 emmh32_final(&context->seed, digest);
1457 if (memcmp(digest, &mic->mic, 4)) { //Make sure the mics match
1460 micError = INCORRECTMIC;
1464 //Check Sequence number if mics pass
1465 if (RxSeqValid(ai, context, mcast, micSEQ) == SUCCESS) {
1466 ai->micstats.rxSuccess++;
1470 micError = SEQUENCE;
1473 // Update statistics
1475 case NOMICPLUMMED: ai->micstats.rxMICPlummed++; break;
1476 case SEQUENCE: ai->micstats.rxWrongSequence++; break;
1477 case INCORRECTMIC: ai->micstats.rxIncorrectMIC++; break;
1484 /*===========================================================================
1485 * Description: Checks the Rx Seq number to make sure it is valid
1486 * and hasn't already been received
1488 * Inputs: miccntx - mic context to check seq against
1489 * micSeq - the Mic seq number
1491 * Returns: TRUE if valid otherwise FALSE.
1493 * Author: sbraneky (10/15/01)
1494 * Merciless hacks by rwilcher (1/14/02)
1495 *---------------------------------------------------------------------------
1498 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq)
1502 //Allow for the ap being rebooted - if it is then use the next
1503 //sequence number of the current sequence number - might go backwards
1506 if (test_bit(FLAG_UPDATE_MULTI, &ai->flags)) {
1507 clear_bit (FLAG_UPDATE_MULTI, &ai->flags);
1508 context->window = (micSeq > 33) ? micSeq : 33;
1509 context->rx = 0; // Reset rx
1511 } else if (test_bit(FLAG_UPDATE_UNI, &ai->flags)) {
1512 clear_bit (FLAG_UPDATE_UNI, &ai->flags);
1513 context->window = (micSeq > 33) ? micSeq : 33; // Move window
1514 context->rx = 0; // Reset rx
1517 //Make sequence number relative to START of window
1518 seq = micSeq - (context->window - 33);
1520 //Too old of a SEQ number to check.
1525 //Window is infinite forward
1526 MoveWindow(context,micSeq);
1530 // We are in the window. Now check the context rx bit to see if it was already sent
1531 seq >>= 1; //divide by 2 because we only have odd numbers
1532 index = 1 << seq; //Get an index number
1534 if (!(context->rx & index)) {
1535 //micSEQ falls inside the window.
1536 //Add seqence number to the list of received numbers.
1537 context->rx |= index;
1539 MoveWindow(context,micSeq);
1546 static void MoveWindow(miccntx *context, u32 micSeq)
1550 //Move window if seq greater than the middle of the window
1551 if (micSeq > context->window) {
1552 shift = (micSeq - context->window) >> 1;
1556 context->rx >>= shift;
1560 context->window = micSeq; //Move window
1564 /*==============================================*/
1565 /*========== EMMH ROUTINES ====================*/
1566 /*==============================================*/
1568 /* mic accumulate */
1569 #define MIC_ACCUM(val) \
1570 context->accum += (u64)(val) * context->coeff[coeff_position++];
1572 static unsigned char aes_counter[16];
1574 /* expand the key to fill the MMH coefficient array */
1575 static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct crypto_tfm *tfm)
1577 /* take the keying material, expand if necessary, truncate at 16-bytes */
1578 /* run through AES counter mode to generate context->coeff[] */
1582 u8 *cipher, plain[16];
1583 struct scatterlist sg[1];
1585 crypto_cipher_setkey(tfm, pkey, 16);
1587 for (i = 0; i < (sizeof(context->coeff)/sizeof(context->coeff[0])); ) {
1588 aes_counter[15] = (u8)(counter >> 0);
1589 aes_counter[14] = (u8)(counter >> 8);
1590 aes_counter[13] = (u8)(counter >> 16);
1591 aes_counter[12] = (u8)(counter >> 24);
1593 memcpy (plain, aes_counter, 16);
1594 sg_set_buf(sg, plain, 16);
1595 crypto_cipher_encrypt(tfm, sg, sg, 16);
1596 cipher = kmap(sg->page) + sg->offset;
1597 for (j=0; (j<16) && (i< (sizeof(context->coeff)/sizeof(context->coeff[0]))); ) {
1598 context->coeff[i++] = ntohl(*(u32 *)&cipher[j]);
1604 /* prepare for calculation of a new mic */
1605 static void emmh32_init(emmh32_context *context)
1607 /* prepare for new mic calculation */
1609 context->position = 0;
1612 /* add some bytes to the mic calculation */
1613 static void emmh32_update(emmh32_context *context, u8 *pOctets, int len)
1615 int coeff_position, byte_position;
1617 if (len == 0) return;
1619 coeff_position = context->position >> 2;
1621 /* deal with partial 32-bit word left over from last update */
1622 byte_position = context->position & 3;
1623 if (byte_position) {
1624 /* have a partial word in part to deal with */
1626 if (len == 0) return;
1627 context->part.d8[byte_position++] = *pOctets++;
1628 context->position++;
1630 } while (byte_position < 4);
1631 MIC_ACCUM(htonl(context->part.d32));
1634 /* deal with full 32-bit words */
1636 MIC_ACCUM(htonl(*(u32 *)pOctets));
1637 context->position += 4;
1642 /* deal with partial 32-bit word that will be left over from this update */
1645 context->part.d8[byte_position++] = *pOctets++;
1646 context->position++;
1651 /* mask used to zero empty bytes for final partial word */
1652 static u32 mask32[4] = { 0x00000000L, 0xFF000000L, 0xFFFF0000L, 0xFFFFFF00L };
1654 /* calculate the mic */
1655 static void emmh32_final(emmh32_context *context, u8 digest[4])
1657 int coeff_position, byte_position;
1663 coeff_position = context->position >> 2;
1665 /* deal with partial 32-bit word left over from last update */
1666 byte_position = context->position & 3;
1667 if (byte_position) {
1668 /* have a partial word in part to deal with */
1669 val = htonl(context->part.d32);
1670 MIC_ACCUM(val & mask32[byte_position]); /* zero empty bytes */
1673 /* reduce the accumulated u64 to a 32-bit MIC */
1674 sum = context->accum;
1675 stmp = (sum & 0xffffffffLL) - ((sum >> 32) * 15);
1676 utmp = (stmp & 0xffffffffLL) - ((stmp >> 32) * 15);
1677 sum = utmp & 0xffffffffLL;
1678 if (utmp > 0x10000000fLL)
1682 digest[0] = (val>>24) & 0xFF;
1683 digest[1] = (val>>16) & 0xFF;
1684 digest[2] = (val>>8) & 0xFF;
1685 digest[3] = val & 0xFF;
1689 static int readBSSListRid(struct airo_info *ai, int first,
1696 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
1697 memset(&cmd, 0, sizeof(cmd));
1698 cmd.cmd=CMD_LISTBSS;
1699 if (down_interruptible(&ai->sem))
1700 return -ERESTARTSYS;
1701 issuecommand(ai, &cmd, &rsp);
1703 /* Let the command take effect */
1708 rc = PC4500_readrid(ai, first ? RID_BSSLISTFIRST : RID_BSSLISTNEXT,
1709 list, sizeof(*list), 1);
1711 list->len = le16_to_cpu(list->len);
1712 list->index = le16_to_cpu(list->index);
1713 list->radioType = le16_to_cpu(list->radioType);
1714 list->cap = le16_to_cpu(list->cap);
1715 list->beaconInterval = le16_to_cpu(list->beaconInterval);
1716 list->fh.dwell = le16_to_cpu(list->fh.dwell);
1717 list->dsChannel = le16_to_cpu(list->dsChannel);
1718 list->atimWindow = le16_to_cpu(list->atimWindow);
1719 list->dBm = le16_to_cpu(list->dBm);
1723 static int readWepKeyRid(struct airo_info*ai, WepKeyRid *wkr, int temp, int lock) {
1724 int rc = PC4500_readrid(ai, temp ? RID_WEP_TEMP : RID_WEP_PERM,
1725 wkr, sizeof(*wkr), lock);
1727 wkr->len = le16_to_cpu(wkr->len);
1728 wkr->kindex = le16_to_cpu(wkr->kindex);
1729 wkr->klen = le16_to_cpu(wkr->klen);
1732 /* In the writeXXXRid routines we copy the rids so that we don't screwup
1733 * the originals when we endian them... */
1734 static int writeWepKeyRid(struct airo_info*ai, WepKeyRid *pwkr, int perm, int lock) {
1736 WepKeyRid wkr = *pwkr;
1738 wkr.len = cpu_to_le16(wkr.len);
1739 wkr.kindex = cpu_to_le16(wkr.kindex);
1740 wkr.klen = cpu_to_le16(wkr.klen);
1741 rc = PC4500_writerid(ai, RID_WEP_TEMP, &wkr, sizeof(wkr), lock);
1742 if (rc!=SUCCESS) printk(KERN_ERR "airo: WEP_TEMP set %x\n", rc);
1744 rc = PC4500_writerid(ai, RID_WEP_PERM, &wkr, sizeof(wkr), lock);
1746 printk(KERN_ERR "airo: WEP_PERM set %x\n", rc);
1752 static int readSsidRid(struct airo_info*ai, SsidRid *ssidr) {
1754 int rc = PC4500_readrid(ai, RID_SSID, ssidr, sizeof(*ssidr), 1);
1756 ssidr->len = le16_to_cpu(ssidr->len);
1757 for(i = 0; i < 3; i++) {
1758 ssidr->ssids[i].len = le16_to_cpu(ssidr->ssids[i].len);
1762 static int writeSsidRid(struct airo_info*ai, SsidRid *pssidr, int lock) {
1765 SsidRid ssidr = *pssidr;
1767 ssidr.len = cpu_to_le16(ssidr.len);
1768 for(i = 0; i < 3; i++) {
1769 ssidr.ssids[i].len = cpu_to_le16(ssidr.ssids[i].len);
1771 rc = PC4500_writerid(ai, RID_SSID, &ssidr, sizeof(ssidr), lock);
1774 static int readConfigRid(struct airo_info*ai, int lock) {
1782 rc = PC4500_readrid(ai, RID_ACTUALCONFIG, &cfg, sizeof(cfg), lock);
1786 for(s = &cfg.len; s <= &cfg.rtsThres; s++) *s = le16_to_cpu(*s);
1788 for(s = &cfg.shortRetryLimit; s <= &cfg.radioType; s++)
1789 *s = le16_to_cpu(*s);
1791 for(s = &cfg.txPower; s <= &cfg.radioSpecific; s++)
1792 *s = le16_to_cpu(*s);
1794 for(s = &cfg.arlThreshold; s <= &cfg._reserved4[0]; s++)
1795 *s = cpu_to_le16(*s);
1797 for(s = &cfg.autoWake; s <= &cfg.autoWake; s++)
1798 *s = cpu_to_le16(*s);
1803 static inline void checkThrottle(struct airo_info *ai) {
1805 /* Old hardware had a limit on encryption speed */
1806 if (ai->config.authType != AUTH_OPEN && maxencrypt) {
1807 for(i=0; i<8; i++) {
1808 if (ai->config.rates[i] > maxencrypt) {
1809 ai->config.rates[i] = 0;
1814 static int writeConfigRid(struct airo_info*ai, int lock) {
1818 if (!test_bit (FLAG_COMMIT, &ai->flags))
1821 clear_bit (FLAG_COMMIT, &ai->flags);
1822 clear_bit (FLAG_RESET, &ai->flags);
1826 if ((cfgr.opmode & 0xFF) == MODE_STA_IBSS)
1827 set_bit(FLAG_ADHOC, &ai->flags);
1829 clear_bit(FLAG_ADHOC, &ai->flags);
1831 for(s = &cfgr.len; s <= &cfgr.rtsThres; s++) *s = cpu_to_le16(*s);
1833 for(s = &cfgr.shortRetryLimit; s <= &cfgr.radioType; s++)
1834 *s = cpu_to_le16(*s);
1836 for(s = &cfgr.txPower; s <= &cfgr.radioSpecific; s++)
1837 *s = cpu_to_le16(*s);
1839 for(s = &cfgr.arlThreshold; s <= &cfgr._reserved4[0]; s++)
1840 *s = cpu_to_le16(*s);
1842 for(s = &cfgr.autoWake; s <= &cfgr.autoWake; s++)
1843 *s = cpu_to_le16(*s);
1845 return PC4500_writerid( ai, RID_CONFIG, &cfgr, sizeof(cfgr), lock);
1847 static int readStatusRid(struct airo_info*ai, StatusRid *statr, int lock) {
1848 int rc = PC4500_readrid(ai, RID_STATUS, statr, sizeof(*statr), lock);
1851 statr->len = le16_to_cpu(statr->len);
1852 for(s = &statr->mode; s <= &statr->SSIDlen; s++) *s = le16_to_cpu(*s);
1854 for(s = &statr->beaconPeriod; s <= &statr->shortPreamble; s++)
1855 *s = le16_to_cpu(*s);
1856 statr->load = le16_to_cpu(statr->load);
1857 statr->assocStatus = le16_to_cpu(statr->assocStatus);
1860 static int readAPListRid(struct airo_info*ai, APListRid *aplr) {
1861 int rc = PC4500_readrid(ai, RID_APLIST, aplr, sizeof(*aplr), 1);
1862 aplr->len = le16_to_cpu(aplr->len);
1865 static int writeAPListRid(struct airo_info*ai, APListRid *aplr, int lock) {
1867 aplr->len = cpu_to_le16(aplr->len);
1868 rc = PC4500_writerid(ai, RID_APLIST, aplr, sizeof(*aplr), lock);
1871 static int readCapabilityRid(struct airo_info*ai, CapabilityRid *capr, int lock) {
1872 int rc = PC4500_readrid(ai, RID_CAPABILITIES, capr, sizeof(*capr), lock);
1875 capr->len = le16_to_cpu(capr->len);
1876 capr->prodNum = le16_to_cpu(capr->prodNum);
1877 capr->radioType = le16_to_cpu(capr->radioType);
1878 capr->country = le16_to_cpu(capr->country);
1879 for(s = &capr->txPowerLevels[0]; s <= &capr->requiredHard; s++)
1880 *s = le16_to_cpu(*s);
1883 static int readStatsRid(struct airo_info*ai, StatsRid *sr, int rid, int lock) {
1884 int rc = PC4500_readrid(ai, rid, sr, sizeof(*sr), lock);
1887 sr->len = le16_to_cpu(sr->len);
1888 for(i = &sr->vals[0]; i <= &sr->vals[99]; i++) *i = le32_to_cpu(*i);
1892 static int airo_open(struct net_device *dev) {
1893 struct airo_info *info = dev->priv;
1896 if (test_bit(FLAG_FLASHING, &info->flags))
1899 /* Make sure the card is configured.
1900 * Wireless Extensions may postpone config changes until the card
1901 * is open (to pipeline changes and speed-up card setup). If
1902 * those changes are not yet commited, do it now - Jean II */
1903 if (test_bit (FLAG_COMMIT, &info->flags)) {
1904 disable_MAC(info, 1);
1905 writeConfigRid(info, 1);
1908 if (info->wifidev != dev) {
1909 /* Power on the MAC controller (which may have been disabled) */
1910 clear_bit(FLAG_RADIO_DOWN, &info->flags);
1911 enable_interrupts(info);
1913 enable_MAC(info, &rsp, 1);
1915 netif_start_queue(dev);
1919 static int mpi_start_xmit(struct sk_buff *skb, struct net_device *dev) {
1920 int npacks, pending;
1921 unsigned long flags;
1922 struct airo_info *ai = dev->priv;
1925 printk(KERN_ERR "airo: %s: skb==NULL\n",__FUNCTION__);
1928 npacks = skb_queue_len (&ai->txq);
1930 if (npacks >= MAXTXQ - 1) {
1931 netif_stop_queue (dev);
1932 if (npacks > MAXTXQ) {
1933 ai->stats.tx_fifo_errors++;
1936 skb_queue_tail (&ai->txq, skb);
1940 spin_lock_irqsave(&ai->aux_lock, flags);
1941 skb_queue_tail (&ai->txq, skb);
1942 pending = test_bit(FLAG_PENDING_XMIT, &ai->flags);
1943 spin_unlock_irqrestore(&ai->aux_lock,flags);
1944 netif_wake_queue (dev);
1947 set_bit(FLAG_PENDING_XMIT, &ai->flags);
1948 mpi_send_packet (dev);
1956 * Attempt to transmit a packet. Can be called from interrupt
1957 * or transmit . return number of packets we tried to send
1960 static int mpi_send_packet (struct net_device *dev)
1962 struct sk_buff *skb;
1963 unsigned char *buffer;
1964 s16 len, *payloadLen;
1965 struct airo_info *ai = dev->priv;
1968 /* get a packet to send */
1970 if ((skb = skb_dequeue(&ai->txq)) == 0) {
1972 "airo: %s: Dequeue'd zero in send_packet()\n",
1977 /* check min length*/
1978 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1981 ai->txfids[0].tx_desc.offset = 0;
1982 ai->txfids[0].tx_desc.valid = 1;
1983 ai->txfids[0].tx_desc.eoc = 1;
1984 ai->txfids[0].tx_desc.len =len+sizeof(WifiHdr);
1987 * Magic, the cards firmware needs a length count (2 bytes) in the host buffer
1988 * right after TXFID_HDR.The TXFID_HDR contains the status short so payloadlen
1989 * is immediatly after it. ------------------------------------------------
1990 * |TXFIDHDR+STATUS|PAYLOADLEN|802.3HDR|PACKETDATA|
1991 * ------------------------------------------------
1994 memcpy((char *)ai->txfids[0].virtual_host_addr,
1995 (char *)&wifictlhdr8023, sizeof(wifictlhdr8023));
1997 payloadLen = (s16 *)(ai->txfids[0].virtual_host_addr +
1998 sizeof(wifictlhdr8023));
1999 sendbuf = ai->txfids[0].virtual_host_addr +
2000 sizeof(wifictlhdr8023) + 2 ;
2003 * Firmware automaticly puts 802 header on so
2004 * we don't need to account for it in the length
2007 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
2008 (ntohs(((u16 *)buffer)[6]) != 0x888E)) {
2011 if (encapsulate(ai, (etherHead *)buffer, &pMic, len - sizeof(etherHead)) != SUCCESS)
2014 *payloadLen = cpu_to_le16(len-sizeof(etherHead)+sizeof(pMic));
2015 ai->txfids[0].tx_desc.len += sizeof(pMic);
2016 /* copy data into airo dma buffer */
2017 memcpy (sendbuf, buffer, sizeof(etherHead));
2018 buffer += sizeof(etherHead);
2019 sendbuf += sizeof(etherHead);
2020 memcpy (sendbuf, &pMic, sizeof(pMic));
2021 sendbuf += sizeof(pMic);
2022 memcpy (sendbuf, buffer, len - sizeof(etherHead));
2026 *payloadLen = cpu_to_le16(len - sizeof(etherHead));
2028 dev->trans_start = jiffies;
2030 /* copy data into airo dma buffer */
2031 memcpy(sendbuf, buffer, len);
2034 memcpy_toio(ai->txfids[0].card_ram_off,
2035 &ai->txfids[0].tx_desc, sizeof(TxFid));
2037 OUT4500(ai, EVACK, 8);
2039 dev_kfree_skb_any(skb);
2043 static void get_tx_error(struct airo_info *ai, s32 fid)
2048 status = ((WifiCtlHdr *)ai->txfids[0].virtual_host_addr)->ctlhdr.status;
2050 if (bap_setup(ai, ai->fids[fid] & 0xffff, 4, BAP0) != SUCCESS)
2052 bap_read(ai, &status, 2, BAP0);
2054 if (le16_to_cpu(status) & 2) /* Too many retries */
2055 ai->stats.tx_aborted_errors++;
2056 if (le16_to_cpu(status) & 4) /* Transmit lifetime exceeded */
2057 ai->stats.tx_heartbeat_errors++;
2058 if (le16_to_cpu(status) & 8) /* Aid fail */
2060 if (le16_to_cpu(status) & 0x10) /* MAC disabled */
2061 ai->stats.tx_carrier_errors++;
2062 if (le16_to_cpu(status) & 0x20) /* Association lost */
2064 /* We produce a TXDROP event only for retry or lifetime
2065 * exceeded, because that's the only status that really mean
2066 * that this particular node went away.
2067 * Other errors means that *we* screwed up. - Jean II */
2068 if ((le16_to_cpu(status) & 2) ||
2069 (le16_to_cpu(status) & 4)) {
2070 union iwreq_data wrqu;
2073 /* Faster to skip over useless data than to do
2074 * another bap_setup(). We are at offset 0x6 and
2075 * need to go to 0x18 and read 6 bytes - Jean II */
2076 bap_read(ai, (u16 *) junk, 0x18, BAP0);
2078 /* Copy 802.11 dest address.
2079 * We use the 802.11 header because the frame may
2080 * not be 802.3 or may be mangled...
2081 * In Ad-Hoc mode, it will be the node address.
2082 * In managed mode, it will be most likely the AP addr
2083 * User space will figure out how to convert it to
2084 * whatever it needs (IP address or else).
2086 memcpy(wrqu.addr.sa_data, junk + 0x12, ETH_ALEN);
2087 wrqu.addr.sa_family = ARPHRD_ETHER;
2089 /* Send event to user space */
2090 wireless_send_event(ai->dev, IWEVTXDROP, &wrqu, NULL);
2094 static void airo_end_xmit(struct net_device *dev) {
2097 struct airo_info *priv = dev->priv;
2098 struct sk_buff *skb = priv->xmit.skb;
2099 int fid = priv->xmit.fid;
2100 u32 *fids = priv->fids;
2102 clear_bit(JOB_XMIT, &priv->flags);
2103 clear_bit(FLAG_PENDING_XMIT, &priv->flags);
2104 status = transmit_802_3_packet (priv, fids[fid], skb->data);
2108 if ( status == SUCCESS ) {
2109 dev->trans_start = jiffies;
2110 for (; i < MAX_FIDS / 2 && (priv->fids[i] & 0xffff0000); i++);
2112 priv->fids[fid] &= 0xffff;
2113 priv->stats.tx_window_errors++;
2115 if (i < MAX_FIDS / 2)
2116 netif_wake_queue(dev);
2120 static int airo_start_xmit(struct sk_buff *skb, struct net_device *dev) {
2123 struct airo_info *priv = dev->priv;
2124 u32 *fids = priv->fids;
2126 if ( skb == NULL ) {
2127 printk( KERN_ERR "airo: skb == NULL!!!\n" );
2131 /* Find a vacant FID */
2132 for( i = 0; i < MAX_FIDS / 2 && (fids[i] & 0xffff0000); i++ );
2133 for( j = i + 1; j < MAX_FIDS / 2 && (fids[j] & 0xffff0000); j++ );
2135 if ( j >= MAX_FIDS / 2 ) {
2136 netif_stop_queue(dev);
2138 if (i == MAX_FIDS / 2) {
2139 priv->stats.tx_fifo_errors++;
2143 /* check min length*/
2144 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2145 /* Mark fid as used & save length for later */
2146 fids[i] |= (len << 16);
2147 priv->xmit.skb = skb;
2149 if (down_trylock(&priv->sem) != 0) {
2150 set_bit(FLAG_PENDING_XMIT, &priv->flags);
2151 netif_stop_queue(dev);
2152 set_bit(JOB_XMIT, &priv->flags);
2153 wake_up_interruptible(&priv->thr_wait);
2159 static void airo_end_xmit11(struct net_device *dev) {
2162 struct airo_info *priv = dev->priv;
2163 struct sk_buff *skb = priv->xmit11.skb;
2164 int fid = priv->xmit11.fid;
2165 u32 *fids = priv->fids;
2167 clear_bit(JOB_XMIT11, &priv->flags);
2168 clear_bit(FLAG_PENDING_XMIT11, &priv->flags);
2169 status = transmit_802_11_packet (priv, fids[fid], skb->data);
2173 if ( status == SUCCESS ) {
2174 dev->trans_start = jiffies;
2175 for (; i < MAX_FIDS && (priv->fids[i] & 0xffff0000); i++);
2177 priv->fids[fid] &= 0xffff;
2178 priv->stats.tx_window_errors++;
2181 netif_wake_queue(dev);
2185 static int airo_start_xmit11(struct sk_buff *skb, struct net_device *dev) {
2188 struct airo_info *priv = dev->priv;
2189 u32 *fids = priv->fids;
2191 if (test_bit(FLAG_MPI, &priv->flags)) {
2192 /* Not implemented yet for MPI350 */
2193 netif_stop_queue(dev);
2197 if ( skb == NULL ) {
2198 printk( KERN_ERR "airo: skb == NULL!!!\n" );
2202 /* Find a vacant FID */
2203 for( i = MAX_FIDS / 2; i < MAX_FIDS && (fids[i] & 0xffff0000); i++ );
2204 for( j = i + 1; j < MAX_FIDS && (fids[j] & 0xffff0000); j++ );
2206 if ( j >= MAX_FIDS ) {
2207 netif_stop_queue(dev);
2209 if (i == MAX_FIDS) {
2210 priv->stats.tx_fifo_errors++;
2214 /* check min length*/
2215 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2216 /* Mark fid as used & save length for later */
2217 fids[i] |= (len << 16);
2218 priv->xmit11.skb = skb;
2219 priv->xmit11.fid = i;
2220 if (down_trylock(&priv->sem) != 0) {
2221 set_bit(FLAG_PENDING_XMIT11, &priv->flags);
2222 netif_stop_queue(dev);
2223 set_bit(JOB_XMIT11, &priv->flags);
2224 wake_up_interruptible(&priv->thr_wait);
2226 airo_end_xmit11(dev);
2230 static void airo_read_stats(struct airo_info *ai) {
2232 u32 *vals = stats_rid.vals;
2234 clear_bit(JOB_STATS, &ai->flags);
2235 if (ai->power.event) {
2239 readStatsRid(ai, &stats_rid, RID_STATS, 0);
2242 ai->stats.rx_packets = vals[43] + vals[44] + vals[45];
2243 ai->stats.tx_packets = vals[39] + vals[40] + vals[41];
2244 ai->stats.rx_bytes = vals[92];
2245 ai->stats.tx_bytes = vals[91];
2246 ai->stats.rx_errors = vals[0] + vals[2] + vals[3] + vals[4];
2247 ai->stats.tx_errors = vals[42] + ai->stats.tx_fifo_errors;
2248 ai->stats.multicast = vals[43];
2249 ai->stats.collisions = vals[89];
2251 /* detailed rx_errors: */
2252 ai->stats.rx_length_errors = vals[3];
2253 ai->stats.rx_crc_errors = vals[4];
2254 ai->stats.rx_frame_errors = vals[2];
2255 ai->stats.rx_fifo_errors = vals[0];
2258 static struct net_device_stats *airo_get_stats(struct net_device *dev)
2260 struct airo_info *local = dev->priv;
2262 if (!test_bit(JOB_STATS, &local->flags)) {
2263 /* Get stats out of the card if available */
2264 if (down_trylock(&local->sem) != 0) {
2265 set_bit(JOB_STATS, &local->flags);
2266 wake_up_interruptible(&local->thr_wait);
2268 airo_read_stats(local);
2271 return &local->stats;
2274 static void airo_set_promisc(struct airo_info *ai) {
2278 memset(&cmd, 0, sizeof(cmd));
2279 cmd.cmd=CMD_SETMODE;
2280 clear_bit(JOB_PROMISC, &ai->flags);
2281 cmd.parm0=(ai->flags&IFF_PROMISC) ? PROMISC : NOPROMISC;
2282 issuecommand(ai, &cmd, &rsp);
2286 static void airo_set_multicast_list(struct net_device *dev) {
2287 struct airo_info *ai = dev->priv;
2289 if ((dev->flags ^ ai->flags) & IFF_PROMISC) {
2290 change_bit(FLAG_PROMISC, &ai->flags);
2291 if (down_trylock(&ai->sem) != 0) {
2292 set_bit(JOB_PROMISC, &ai->flags);
2293 wake_up_interruptible(&ai->thr_wait);
2295 airo_set_promisc(ai);
2298 if ((dev->flags&IFF_ALLMULTI)||dev->mc_count>0) {
2299 /* Turn on multicast. (Should be already setup...) */
2303 static int airo_set_mac_address(struct net_device *dev, void *p)
2305 struct airo_info *ai = dev->priv;
2306 struct sockaddr *addr = p;
2309 readConfigRid(ai, 1);
2310 memcpy (ai->config.macAddr, addr->sa_data, dev->addr_len);
2311 set_bit (FLAG_COMMIT, &ai->flags);
2313 writeConfigRid (ai, 1);
2314 enable_MAC(ai, &rsp, 1);
2315 memcpy (ai->dev->dev_addr, addr->sa_data, dev->addr_len);
2317 memcpy (ai->wifidev->dev_addr, addr->sa_data, dev->addr_len);
2321 static int airo_change_mtu(struct net_device *dev, int new_mtu)
2323 if ((new_mtu < 68) || (new_mtu > 2400))
2330 static int airo_close(struct net_device *dev) {
2331 struct airo_info *ai = dev->priv;
2333 netif_stop_queue(dev);
2335 if (ai->wifidev != dev) {
2336 #ifdef POWER_ON_DOWN
2337 /* Shut power to the card. The idea is that the user can save
2338 * power when he doesn't need the card with "ifconfig down".
2339 * That's the method that is most friendly towards the network
2340 * stack (i.e. the network stack won't try to broadcast
2341 * anything on the interface and routes are gone. Jean II */
2342 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2345 disable_interrupts( ai );
2350 static void del_airo_dev( struct net_device *dev );
2352 void stop_airo_card( struct net_device *dev, int freeres )
2354 struct airo_info *ai = dev->priv;
2356 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2358 disable_interrupts(ai);
2359 free_irq( dev->irq, dev );
2360 takedown_proc_entry( dev, ai );
2361 if (test_bit(FLAG_REGISTERED, &ai->flags)) {
2362 unregister_netdev( dev );
2364 unregister_netdev(ai->wifidev);
2365 free_netdev(ai->wifidev);
2368 clear_bit(FLAG_REGISTERED, &ai->flags);
2370 set_bit(JOB_DIE, &ai->flags);
2371 kill_proc(ai->thr_pid, SIGTERM, 1);
2372 wait_for_completion(&ai->thr_exited);
2375 * Clean out tx queue
2377 if (test_bit(FLAG_MPI, &ai->flags) && !skb_queue_empty(&ai->txq)) {
2378 struct sk_buff *skb = NULL;
2379 for (;(skb = skb_dequeue(&ai->txq));)
2388 /* PCMCIA frees this stuff, so only for PCI and ISA */
2389 release_region( dev->base_addr, 64 );
2390 if (test_bit(FLAG_MPI, &ai->flags)) {
2392 mpi_unmap_card(ai->pci);
2394 iounmap(ai->pcimem);
2396 iounmap(ai->pciaux);
2397 pci_free_consistent(ai->pci, PCI_SHARED_LEN,
2398 ai->shared, ai->shared_dma);
2402 crypto_free_tfm(ai->tfm);
2404 del_airo_dev( dev );
2408 EXPORT_SYMBOL(stop_airo_card);
2410 static int add_airo_dev( struct net_device *dev );
2412 static int wll_header_parse(struct sk_buff *skb, unsigned char *haddr)
2414 memcpy(haddr, skb->mac.raw + 10, ETH_ALEN);
2418 static void mpi_unmap_card(struct pci_dev *pci)
2420 unsigned long mem_start = pci_resource_start(pci, 1);
2421 unsigned long mem_len = pci_resource_len(pci, 1);
2422 unsigned long aux_start = pci_resource_start(pci, 2);
2423 unsigned long aux_len = AUXMEMSIZE;
2425 release_mem_region(aux_start, aux_len);
2426 release_mem_region(mem_start, mem_len);
2429 /*************************************************************
2430 * This routine assumes that descriptors have been setup .
2431 * Run at insmod time or after reset when the decriptors
2432 * have been initialized . Returns 0 if all is well nz
2433 * otherwise . Does not allocate memory but sets up card
2434 * using previously allocated descriptors.
2436 static int mpi_init_descriptors (struct airo_info *ai)
2443 /* Alloc card RX descriptors */
2444 netif_stop_queue(ai->dev);
2446 memset(&rsp,0,sizeof(rsp));
2447 memset(&cmd,0,sizeof(cmd));
2449 cmd.cmd = CMD_ALLOCATEAUX;
2451 cmd.parm1 = (ai->rxfids[0].card_ram_off - ai->pciaux);
2452 cmd.parm2 = MPI_MAX_FIDS;
2453 rc=issuecommand(ai, &cmd, &rsp);
2454 if (rc != SUCCESS) {
2455 printk(KERN_ERR "airo: Couldn't allocate RX FID\n");
2459 for (i=0; i<MPI_MAX_FIDS; i++) {
2460 memcpy_toio(ai->rxfids[i].card_ram_off,
2461 &ai->rxfids[i].rx_desc, sizeof(RxFid));
2464 /* Alloc card TX descriptors */
2466 memset(&rsp,0,sizeof(rsp));
2467 memset(&cmd,0,sizeof(cmd));
2469 cmd.cmd = CMD_ALLOCATEAUX;
2471 cmd.parm1 = (ai->txfids[0].card_ram_off - ai->pciaux);
2472 cmd.parm2 = MPI_MAX_FIDS;
2474 for (i=0; i<MPI_MAX_FIDS; i++) {
2475 ai->txfids[i].tx_desc.valid = 1;
2476 memcpy_toio(ai->txfids[i].card_ram_off,
2477 &ai->txfids[i].tx_desc, sizeof(TxFid));
2479 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2481 rc=issuecommand(ai, &cmd, &rsp);
2482 if (rc != SUCCESS) {
2483 printk(KERN_ERR "airo: Couldn't allocate TX FID\n");
2487 /* Alloc card Rid descriptor */
2488 memset(&rsp,0,sizeof(rsp));
2489 memset(&cmd,0,sizeof(cmd));
2491 cmd.cmd = CMD_ALLOCATEAUX;
2493 cmd.parm1 = (ai->config_desc.card_ram_off - ai->pciaux);
2494 cmd.parm2 = 1; /* Magic number... */
2495 rc=issuecommand(ai, &cmd, &rsp);
2496 if (rc != SUCCESS) {
2497 printk(KERN_ERR "airo: Couldn't allocate RID\n");
2501 memcpy_toio(ai->config_desc.card_ram_off,
2502 &ai->config_desc.rid_desc, sizeof(Rid));
2508 * We are setting up three things here:
2509 * 1) Map AUX memory for descriptors: Rid, TxFid, or RxFid.
2510 * 2) Map PCI memory for issueing commands.
2511 * 3) Allocate memory (shared) to send and receive ethernet frames.
2513 static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci,
2516 unsigned long mem_start, mem_len, aux_start, aux_len;
2519 dma_addr_t busaddroff;
2520 unsigned char *vpackoff;
2521 unsigned char __iomem *pciaddroff;
2523 mem_start = pci_resource_start(pci, 1);
2524 mem_len = pci_resource_len(pci, 1);
2525 aux_start = pci_resource_start(pci, 2);
2526 aux_len = AUXMEMSIZE;
2528 if (!request_mem_region(mem_start, mem_len, name)) {
2529 printk(KERN_ERR "airo: Couldn't get region %x[%x] for %s\n",
2530 (int)mem_start, (int)mem_len, name);
2533 if (!request_mem_region(aux_start, aux_len, name)) {
2534 printk(KERN_ERR "airo: Couldn't get region %x[%x] for %s\n",
2535 (int)aux_start, (int)aux_len, name);
2539 ai->pcimem = ioremap(mem_start, mem_len);
2541 printk(KERN_ERR "airo: Couldn't map region %x[%x] for %s\n",
2542 (int)mem_start, (int)mem_len, name);
2545 ai->pciaux = ioremap(aux_start, aux_len);
2547 printk(KERN_ERR "airo: Couldn't map region %x[%x] for %s\n",
2548 (int)aux_start, (int)aux_len, name);
2552 /* Reserve PKTSIZE for each fid and 2K for the Rids */
2553 ai->shared = pci_alloc_consistent(pci, PCI_SHARED_LEN, &ai->shared_dma);
2555 printk(KERN_ERR "airo: Couldn't alloc_consistent %d\n",
2561 * Setup descriptor RX, TX, CONFIG
2563 busaddroff = ai->shared_dma;
2564 pciaddroff = ai->pciaux + AUX_OFFSET;
2565 vpackoff = ai->shared;
2567 /* RX descriptor setup */
2568 for(i = 0; i < MPI_MAX_FIDS; i++) {
2569 ai->rxfids[i].pending = 0;
2570 ai->rxfids[i].card_ram_off = pciaddroff;
2571 ai->rxfids[i].virtual_host_addr = vpackoff;
2572 ai->rxfids[i].rx_desc.host_addr = busaddroff;
2573 ai->rxfids[i].rx_desc.valid = 1;
2574 ai->rxfids[i].rx_desc.len = PKTSIZE;
2575 ai->rxfids[i].rx_desc.rdy = 0;
2577 pciaddroff += sizeof(RxFid);
2578 busaddroff += PKTSIZE;
2579 vpackoff += PKTSIZE;
2582 /* TX descriptor setup */
2583 for(i = 0; i < MPI_MAX_FIDS; i++) {
2584 ai->txfids[i].card_ram_off = pciaddroff;
2585 ai->txfids[i].virtual_host_addr = vpackoff;
2586 ai->txfids[i].tx_desc.valid = 1;
2587 ai->txfids[i].tx_desc.host_addr = busaddroff;
2588 memcpy(ai->txfids[i].virtual_host_addr,
2589 &wifictlhdr8023, sizeof(wifictlhdr8023));
2591 pciaddroff += sizeof(TxFid);
2592 busaddroff += PKTSIZE;
2593 vpackoff += PKTSIZE;
2595 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2597 /* Rid descriptor setup */
2598 ai->config_desc.card_ram_off = pciaddroff;
2599 ai->config_desc.virtual_host_addr = vpackoff;
2600 ai->config_desc.rid_desc.host_addr = busaddroff;
2601 ai->ridbus = busaddroff;
2602 ai->config_desc.rid_desc.rid = 0;
2603 ai->config_desc.rid_desc.len = RIDSIZE;
2604 ai->config_desc.rid_desc.valid = 1;
2605 pciaddroff += sizeof(Rid);
2606 busaddroff += RIDSIZE;
2607 vpackoff += RIDSIZE;
2609 /* Tell card about descriptors */
2610 if (mpi_init_descriptors (ai) != SUCCESS)
2615 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2617 iounmap(ai->pciaux);
2619 iounmap(ai->pcimem);
2621 release_mem_region(aux_start, aux_len);
2623 release_mem_region(mem_start, mem_len);
2628 static void wifi_setup(struct net_device *dev)
2630 dev->hard_header = NULL;
2631 dev->rebuild_header = NULL;
2632 dev->hard_header_cache = NULL;
2633 dev->header_cache_update= NULL;
2635 dev->hard_header_parse = wll_header_parse;
2636 dev->hard_start_xmit = &airo_start_xmit11;
2637 dev->get_stats = &airo_get_stats;
2638 dev->set_mac_address = &airo_set_mac_address;
2639 dev->do_ioctl = &airo_ioctl;
2640 dev->wireless_handlers = &airo_handler_def;
2641 dev->change_mtu = &airo_change_mtu;
2642 dev->open = &airo_open;
2643 dev->stop = &airo_close;
2645 dev->type = ARPHRD_IEEE80211;
2646 dev->hard_header_len = ETH_HLEN;
2648 dev->addr_len = ETH_ALEN;
2649 dev->tx_queue_len = 100;
2651 memset(dev->broadcast,0xFF, ETH_ALEN);
2653 dev->flags = IFF_BROADCAST|IFF_MULTICAST;
2656 static struct net_device *init_wifidev(struct airo_info *ai,
2657 struct net_device *ethdev)
2660 struct net_device *dev = alloc_netdev(0, "wifi%d", wifi_setup);
2663 dev->priv = ethdev->priv;
2664 dev->irq = ethdev->irq;
2665 dev->base_addr = ethdev->base_addr;
2666 dev->wireless_data = ethdev->wireless_data;
2667 memcpy(dev->dev_addr, ethdev->dev_addr, dev->addr_len);
2668 err = register_netdev(dev);
2676 static int reset_card( struct net_device *dev , int lock) {
2677 struct airo_info *ai = dev->priv;
2679 if (lock && down_interruptible(&ai->sem))
2682 OUT4500(ai,COMMAND,CMD_SOFTRESET);
2691 static struct net_device *_init_airo_card( unsigned short irq, int port,
2692 int is_pcmcia, struct pci_dev *pci,
2693 struct device *dmdev )
2695 struct net_device *dev;
2696 struct airo_info *ai;
2699 /* Create the network device object. */
2700 dev = alloc_etherdev(sizeof(*ai));
2702 printk(KERN_ERR "airo: Couldn't alloc_etherdev\n");
2705 if (dev_alloc_name(dev, dev->name) < 0) {
2706 printk(KERN_ERR "airo: Couldn't get name!\n");
2713 if (pci && (pci->device == 0x5000 || pci->device == 0xa504)) {
2714 printk(KERN_DEBUG "airo: Found an MPI350 card\n");
2715 set_bit(FLAG_MPI, &ai->flags);
2718 spin_lock_init(&ai->aux_lock);
2719 sema_init(&ai->sem, 1);
2722 init_waitqueue_head (&ai->thr_wait);
2723 init_completion (&ai->thr_exited);
2724 ai->thr_pid = kernel_thread(airo_thread, dev, CLONE_FS | CLONE_FILES);
2725 if (ai->thr_pid < 0)
2730 rc = add_airo_dev( dev );
2734 /* The Airo-specific entries in the device structure. */
2735 if (test_bit(FLAG_MPI,&ai->flags)) {
2736 skb_queue_head_init (&ai->txq);
2737 dev->hard_start_xmit = &mpi_start_xmit;
2739 dev->hard_start_xmit = &airo_start_xmit;
2740 dev->get_stats = &airo_get_stats;
2741 dev->set_multicast_list = &airo_set_multicast_list;
2742 dev->set_mac_address = &airo_set_mac_address;
2743 dev->do_ioctl = &airo_ioctl;
2744 dev->wireless_handlers = &airo_handler_def;
2745 ai->wireless_data.spy_data = &ai->spy_data;
2746 dev->wireless_data = &ai->wireless_data;
2747 dev->change_mtu = &airo_change_mtu;
2748 dev->open = &airo_open;
2749 dev->stop = &airo_close;
2751 dev->base_addr = port;
2753 SET_NETDEV_DEV(dev, dmdev);
2756 if (test_bit(FLAG_MPI,&ai->flags))
2757 reset_card (dev, 1);
2759 rc = request_irq( dev->irq, airo_interrupt, SA_SHIRQ, dev->name, dev );
2761 printk(KERN_ERR "airo: register interrupt %d failed, rc %d\n", irq, rc );
2762 goto err_out_unlink;
2765 if (!request_region( dev->base_addr, 64, dev->name )) {
2767 printk(KERN_ERR "airo: Couldn't request region\n");
2772 if (test_bit(FLAG_MPI,&ai->flags)) {
2773 if (mpi_map_card(ai, pci, dev->name)) {
2774 printk(KERN_ERR "airo: Could not map memory\n");
2780 if ( setup_card( ai, dev->dev_addr, 1 ) != SUCCESS ) {
2781 printk( KERN_ERR "airo: MAC could not be enabled\n" );
2785 } else if (!test_bit(FLAG_MPI,&ai->flags)) {
2786 ai->bap_read = fast_bap_read;
2787 set_bit(FLAG_FLASHING, &ai->flags);
2790 rc = register_netdev(dev);
2792 printk(KERN_ERR "airo: Couldn't register_netdev\n");
2795 ai->wifidev = init_wifidev(ai, dev);
2797 set_bit(FLAG_REGISTERED,&ai->flags);
2798 printk( KERN_INFO "airo: MAC enabled %s %x:%x:%x:%x:%x:%x\n",
2800 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
2801 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5] );
2803 /* Allocate the transmit buffers */
2804 if (probe && !test_bit(FLAG_MPI,&ai->flags))
2805 for( i = 0; i < MAX_FIDS; i++ )
2806 ai->fids[i] = transmit_allocate(ai,2312,i>=MAX_FIDS/2);
2808 setup_proc_entry( dev, dev->priv ); /* XXX check for failure */
2809 netif_start_queue(dev);
2810 SET_MODULE_OWNER(dev);
2814 if (test_bit(FLAG_MPI,&ai->flags) && pci) {
2815 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2816 iounmap(ai->pciaux);
2817 iounmap(ai->pcimem);
2818 mpi_unmap_card(ai->pci);
2822 release_region( dev->base_addr, 64 );
2824 free_irq(dev->irq, dev);
2828 set_bit(JOB_DIE, &ai->flags);
2829 kill_proc(ai->thr_pid, SIGTERM, 1);
2830 wait_for_completion(&ai->thr_exited);
2836 struct net_device *init_airo_card( unsigned short irq, int port, int is_pcmcia,
2837 struct device *dmdev)
2839 return _init_airo_card ( irq, port, is_pcmcia, NULL, dmdev);
2842 EXPORT_SYMBOL(init_airo_card);
2844 static int waitbusy (struct airo_info *ai) {
2846 while ((IN4500 (ai, COMMAND) & COMMAND_BUSY) & (delay < 10000)) {
2848 if ((++delay % 20) == 0)
2849 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
2851 return delay < 10000;
2854 int reset_airo_card( struct net_device *dev )
2857 struct airo_info *ai = dev->priv;
2859 if (reset_card (dev, 1))
2862 if ( setup_card(ai, dev->dev_addr, 1 ) != SUCCESS ) {
2863 printk( KERN_ERR "airo: MAC could not be enabled\n" );
2866 printk( KERN_INFO "airo: MAC enabled %s %x:%x:%x:%x:%x:%x\n", dev->name,
2867 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
2868 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
2869 /* Allocate the transmit buffers if needed */
2870 if (!test_bit(FLAG_MPI,&ai->flags))
2871 for( i = 0; i < MAX_FIDS; i++ )
2872 ai->fids[i] = transmit_allocate (ai,2312,i>=MAX_FIDS/2);
2874 enable_interrupts( ai );
2875 netif_wake_queue(dev);
2879 EXPORT_SYMBOL(reset_airo_card);
2881 static void airo_send_event(struct net_device *dev) {
2882 struct airo_info *ai = dev->priv;
2883 union iwreq_data wrqu;
2884 StatusRid status_rid;
2886 clear_bit(JOB_EVENT, &ai->flags);
2887 PC4500_readrid(ai, RID_STATUS, &status_rid, sizeof(status_rid), 0);
2889 wrqu.data.length = 0;
2890 wrqu.data.flags = 0;
2891 memcpy(wrqu.ap_addr.sa_data, status_rid.bssid[0], ETH_ALEN);
2892 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
2894 /* Send event to user space */
2895 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
2898 static int airo_thread(void *data) {
2899 struct net_device *dev = data;
2900 struct airo_info *ai = dev->priv;
2903 daemonize("%s", dev->name);
2904 allow_signal(SIGTERM);
2907 if (signal_pending(current))
2908 flush_signals(current);
2910 /* make swsusp happy with our thread */
2913 if (test_bit(JOB_DIE, &ai->flags))
2916 if (ai->flags & JOB_MASK) {
2917 locked = down_interruptible(&ai->sem);
2921 init_waitqueue_entry(&wait, current);
2922 add_wait_queue(&ai->thr_wait, &wait);
2924 set_current_state(TASK_INTERRUPTIBLE);
2925 if (ai->flags & JOB_MASK)
2928 if (time_after_eq(jiffies,ai->expires)){
2929 set_bit(JOB_AUTOWEP,&ai->flags);
2932 if (!signal_pending(current)) {
2933 schedule_timeout(ai->expires - jiffies);
2936 } else if (!signal_pending(current)) {
2942 current->state = TASK_RUNNING;
2943 remove_wait_queue(&ai->thr_wait, &wait);
2950 if (test_bit(JOB_DIE, &ai->flags)) {
2955 if (ai->power.event || test_bit(FLAG_FLASHING, &ai->flags)) {
2960 if (test_bit(JOB_XMIT, &ai->flags))
2962 else if (test_bit(JOB_XMIT11, &ai->flags))
2963 airo_end_xmit11(dev);
2964 else if (test_bit(JOB_STATS, &ai->flags))
2965 airo_read_stats(ai);
2966 else if (test_bit(JOB_WSTATS, &ai->flags))
2967 airo_read_wireless_stats(ai);
2968 else if (test_bit(JOB_PROMISC, &ai->flags))
2969 airo_set_promisc(ai);
2971 else if (test_bit(JOB_MIC, &ai->flags))
2974 else if (test_bit(JOB_EVENT, &ai->flags))
2975 airo_send_event(dev);
2976 else if (test_bit(JOB_AUTOWEP, &ai->flags))
2979 complete_and_exit (&ai->thr_exited, 0);
2982 static irqreturn_t airo_interrupt ( int irq, void* dev_id, struct pt_regs *regs) {
2983 struct net_device *dev = (struct net_device *)dev_id;
2986 struct airo_info *apriv = dev->priv;
2987 u16 savedInterrupts = 0;
2990 if (!netif_device_present(dev))
2994 status = IN4500( apriv, EVSTAT );
2995 if ( !(status & STATUS_INTS) || status == 0xffff ) break;
2999 if ( status & EV_AWAKE ) {
3000 OUT4500( apriv, EVACK, EV_AWAKE );
3001 OUT4500( apriv, EVACK, EV_AWAKE );
3004 if (!savedInterrupts) {
3005 savedInterrupts = IN4500( apriv, EVINTEN );
3006 OUT4500( apriv, EVINTEN, 0 );
3009 if ( status & EV_MIC ) {
3010 OUT4500( apriv, EVACK, EV_MIC );
3012 if (test_bit(FLAG_MIC_CAPABLE, &apriv->flags)) {
3013 set_bit(JOB_MIC, &apriv->flags);
3014 wake_up_interruptible(&apriv->thr_wait);
3018 if ( status & EV_LINK ) {
3019 union iwreq_data wrqu;
3020 /* The link status has changed, if you want to put a
3021 monitor hook in, do it here. (Remember that
3022 interrupts are still disabled!)
3024 u16 newStatus = IN4500(apriv, LINKSTAT);
3025 OUT4500( apriv, EVACK, EV_LINK);
3026 /* Here is what newStatus means: */
3027 #define NOBEACON 0x8000 /* Loss of sync - missed beacons */
3028 #define MAXRETRIES 0x8001 /* Loss of sync - max retries */
3029 #define MAXARL 0x8002 /* Loss of sync - average retry level exceeded*/
3030 #define FORCELOSS 0x8003 /* Loss of sync - host request */
3031 #define TSFSYNC 0x8004 /* Loss of sync - TSF synchronization */
3032 #define DEAUTH 0x8100 /* Deauthentication (low byte is reason code) */
3033 #define DISASS 0x8200 /* Disassociation (low byte is reason code) */
3034 #define ASSFAIL 0x8400 /* Association failure (low byte is reason
3036 #define AUTHFAIL 0x0300 /* Authentication failure (low byte is reason
3038 #define ASSOCIATED 0x0400 /* Assocatied */
3039 #define RC_RESERVED 0 /* Reserved return code */
3040 #define RC_NOREASON 1 /* Unspecified reason */
3041 #define RC_AUTHINV 2 /* Previous authentication invalid */
3042 #define RC_DEAUTH 3 /* Deauthenticated because sending station is
3044 #define RC_NOACT 4 /* Disassociated due to inactivity */
3045 #define RC_MAXLOAD 5 /* Disassociated because AP is unable to handle
3046 all currently associated stations */
3047 #define RC_BADCLASS2 6 /* Class 2 frame received from
3048 non-Authenticated station */
3049 #define RC_BADCLASS3 7 /* Class 3 frame received from
3050 non-Associated station */
3051 #define RC_STATLEAVE 8 /* Disassociated because sending station is
3053 #define RC_NOAUTH 9 /* Station requesting (Re)Association is not
3054 Authenticated with the responding station */
3055 if (newStatus != ASSOCIATED) {
3056 if (auto_wep && !apriv->expires) {
3057 apriv->expires = RUN_AT(3*HZ);
3058 wake_up_interruptible(&apriv->thr_wait);
3061 struct task_struct *task = apriv->task;
3065 wake_up_process (task);
3066 set_bit(FLAG_UPDATE_UNI, &apriv->flags);
3067 set_bit(FLAG_UPDATE_MULTI, &apriv->flags);
3069 /* Question : is ASSOCIATED the only status
3070 * that is valid ? We want to catch handover
3071 * and reassociations as valid status
3073 if(newStatus == ASSOCIATED) {
3074 if (apriv->scan_timestamp) {
3075 /* Send an empty event to user space.
3076 * We don't send the received data on
3077 * the event because it would require
3078 * us to do complex transcoding, and
3079 * we want to minimise the work done in
3080 * the irq handler. Use a request to
3081 * extract the data - Jean II */
3082 wrqu.data.length = 0;
3083 wrqu.data.flags = 0;
3084 wireless_send_event(dev, SIOCGIWSCAN, &wrqu, NULL);
3085 apriv->scan_timestamp = 0;
3087 if (down_trylock(&apriv->sem) != 0) {
3088 set_bit(JOB_EVENT, &apriv->flags);
3089 wake_up_interruptible(&apriv->thr_wait);
3091 airo_send_event(dev);
3093 memset(wrqu.ap_addr.sa_data, '\0', ETH_ALEN);
3094 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
3096 /* Send event to user space */
3097 wireless_send_event(dev, SIOCGIWAP, &wrqu,NULL);
3101 /* Check to see if there is something to receive */
3102 if ( status & EV_RX ) {
3103 struct sk_buff *skb = NULL;
3104 u16 fc, len, hdrlen = 0;
3118 if (test_bit(FLAG_MPI,&apriv->flags)) {
3119 if (test_bit(FLAG_802_11, &apriv->flags))
3120 mpi_receive_802_11(apriv);
3122 mpi_receive_802_3(apriv);
3123 OUT4500(apriv, EVACK, EV_RX);
3127 fid = IN4500( apriv, RXFID );
3129 /* Get the packet length */
3130 if (test_bit(FLAG_802_11, &apriv->flags)) {
3131 bap_setup (apriv, fid, 4, BAP0);
3132 bap_read (apriv, (u16*)&hdr, sizeof(hdr), BAP0);
3133 /* Bad CRC. Ignore packet */
3134 if (le16_to_cpu(hdr.status) & 2)
3136 if (apriv->wifidev == NULL)
3139 bap_setup (apriv, fid, 0x36, BAP0);
3140 bap_read (apriv, (u16*)&hdr.len, 2, BAP0);
3142 len = le16_to_cpu(hdr.len);
3145 printk( KERN_ERR "airo: Bad size %d\n", len );
3151 if (test_bit(FLAG_802_11, &apriv->flags)) {
3152 bap_read (apriv, (u16*)&fc, sizeof(fc), BAP0);
3153 fc = le16_to_cpu(fc);
3156 if ((fc & 0xe0) == 0xc0)
3162 if ((fc&0x300)==0x300){
3170 hdrlen = ETH_ALEN * 2;
3172 skb = dev_alloc_skb( len + hdrlen + 2 + 2 );
3174 apriv->stats.rx_dropped++;
3177 skb_reserve(skb, 2); /* This way the IP header is aligned */
3178 buffer = (u16*)skb_put (skb, len + hdrlen);
3179 if (test_bit(FLAG_802_11, &apriv->flags)) {
3181 bap_read (apriv, buffer + 1, hdrlen - 2, BAP0);
3183 bap_read (apriv, tmpbuf, 6, BAP0);
3185 bap_read (apriv, &gap, sizeof(gap), BAP0);
3186 gap = le16_to_cpu(gap);
3189 bap_read (apriv, tmpbuf, gap, BAP0);
3191 printk(KERN_ERR "airo: gaplen too big. Problems will follow...\n");
3193 bap_read (apriv, buffer + hdrlen/2, len, BAP0);
3198 bap_read (apriv, buffer, ETH_ALEN*2, BAP0);
3200 if (apriv->micstats.enabled) {
3201 bap_read (apriv,(u16*)&micbuf,sizeof(micbuf),BAP0);
3202 if (ntohs(micbuf.typelen) > 0x05DC)
3203 bap_setup (apriv, fid, 0x44, BAP0);
3205 if (len <= sizeof(micbuf))
3208 len -= sizeof(micbuf);
3209 skb_trim (skb, len + hdrlen);
3213 bap_read(apriv,buffer+ETH_ALEN,len,BAP0);
3215 if (decapsulate(apriv,&micbuf,(etherHead*)buffer,len)) {
3217 dev_kfree_skb_irq (skb);
3222 OUT4500( apriv, EVACK, EV_RX);
3227 if (apriv->spy_data.spy_number > 0) {
3229 struct iw_quality wstats;
3230 /* Prepare spy data : addr + qual */
3231 if (!test_bit(FLAG_802_11, &apriv->flags)) {
3232 sa = (char*)buffer + 6;
3233 bap_setup (apriv, fid, 8, BAP0);
3234 bap_read (apriv, (u16*)hdr.rssi, 2, BAP0);
3236 sa = (char*)buffer + 10;
3237 wstats.qual = hdr.rssi[0];
3239 wstats.level = 0x100 - apriv->rssi[hdr.rssi[1]].rssidBm;
3241 wstats.level = (hdr.rssi[1] + 321) / 2;
3242 wstats.noise = apriv->wstats.qual.noise;
3243 wstats.updated = IW_QUAL_LEVEL_UPDATED
3244 | IW_QUAL_QUAL_UPDATED
3246 /* Update spy records */
3247 wireless_spy_update(dev, sa, &wstats);
3249 #endif /* WIRELESS_SPY */
3250 OUT4500( apriv, EVACK, EV_RX);
3252 if (test_bit(FLAG_802_11, &apriv->flags)) {
3253 skb->mac.raw = skb->data;
3254 skb->pkt_type = PACKET_OTHERHOST;
3255 skb->dev = apriv->wifidev;
3256 skb->protocol = htons(ETH_P_802_2);
3259 skb->protocol = eth_type_trans(skb,dev);
3261 skb->dev->last_rx = jiffies;
3262 skb->ip_summed = CHECKSUM_NONE;
3268 /* Check to see if a packet has been transmitted */
3269 if ( status & ( EV_TX|EV_TXCPY|EV_TXEXC ) ) {
3274 if (test_bit(FLAG_MPI,&apriv->flags)) {
3275 unsigned long flags;
3277 if (status & EV_TXEXC)
3278 get_tx_error(apriv, -1);
3279 spin_lock_irqsave(&apriv->aux_lock, flags);
3280 if (!skb_queue_empty(&apriv->txq)) {
3281 spin_unlock_irqrestore(&apriv->aux_lock,flags);
3282 mpi_send_packet (dev);
3284 clear_bit(FLAG_PENDING_XMIT, &apriv->flags);
3285 spin_unlock_irqrestore(&apriv->aux_lock,flags);
3286 netif_wake_queue (dev);
3288 OUT4500( apriv, EVACK,
3289 status & (EV_TX|EV_TXCPY|EV_TXEXC));
3293 fid = IN4500(apriv, TXCOMPLFID);
3295 for( i = 0; i < MAX_FIDS; i++ ) {
3296 if ( ( apriv->fids[i] & 0xffff ) == fid ) {
3297 len = apriv->fids[i] >> 16;
3302 if (status & EV_TXEXC)
3303 get_tx_error(apriv, index);
3304 OUT4500( apriv, EVACK, status & (EV_TX | EV_TXEXC));
3305 /* Set up to be used again */
3306 apriv->fids[index] &= 0xffff;
3307 if (index < MAX_FIDS / 2) {
3308 if (!test_bit(FLAG_PENDING_XMIT, &apriv->flags))
3309 netif_wake_queue(dev);
3311 if (!test_bit(FLAG_PENDING_XMIT11, &apriv->flags))
3312 netif_wake_queue(apriv->wifidev);
3315 OUT4500( apriv, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3316 printk( KERN_ERR "airo: Unallocated FID was used to xmit\n" );
3320 if ( status & ~STATUS_INTS & ~IGNORE_INTS )
3321 printk( KERN_WARNING "airo: Got weird status %x\n",
3322 status & ~STATUS_INTS & ~IGNORE_INTS );
3325 if (savedInterrupts)
3326 OUT4500( apriv, EVINTEN, savedInterrupts );
3329 return IRQ_RETVAL(handled);
3333 * Routines to talk to the card
3337 * This was originally written for the 4500, hence the name
3338 * NOTE: If use with 8bit mode and SMP bad things will happen!
3339 * Why would some one do 8 bit IO in an SMP machine?!?
3341 static void OUT4500( struct airo_info *ai, u16 reg, u16 val ) {
3342 if (test_bit(FLAG_MPI,&ai->flags))
3345 outw( val, ai->dev->base_addr + reg );
3347 outb( val & 0xff, ai->dev->base_addr + reg );
3348 outb( val >> 8, ai->dev->base_addr + reg + 1 );
3352 static u16 IN4500( struct airo_info *ai, u16 reg ) {
3355 if (test_bit(FLAG_MPI,&ai->flags))
3358 rc = inw( ai->dev->base_addr + reg );
3360 rc = inb( ai->dev->base_addr + reg );
3361 rc += ((int)inb( ai->dev->base_addr + reg + 1 )) << 8;
3366 static int enable_MAC( struct airo_info *ai, Resp *rsp, int lock ) {
3370 /* FLAG_RADIO_OFF : Radio disabled via /proc or Wireless Extensions
3371 * FLAG_RADIO_DOWN : Radio disabled via "ifconfig ethX down"
3372 * Note : we could try to use !netif_running(dev) in enable_MAC()
3373 * instead of this flag, but I don't trust it *within* the
3374 * open/close functions, and testing both flags together is
3375 * "cheaper" - Jean II */
3376 if (ai->flags & FLAG_RADIO_MASK) return SUCCESS;
3378 if (lock && down_interruptible(&ai->sem))
3379 return -ERESTARTSYS;
3381 if (!test_bit(FLAG_ENABLED, &ai->flags)) {
3382 memset(&cmd, 0, sizeof(cmd));
3383 cmd.cmd = MAC_ENABLE;
3384 rc = issuecommand(ai, &cmd, rsp);
3386 set_bit(FLAG_ENABLED, &ai->flags);
3394 printk(KERN_ERR "%s: Cannot enable MAC, err=%d\n",
3399 static void disable_MAC( struct airo_info *ai, int lock ) {
3403 if (lock && down_interruptible(&ai->sem))
3406 if (test_bit(FLAG_ENABLED, &ai->flags)) {
3407 memset(&cmd, 0, sizeof(cmd));
3408 cmd.cmd = MAC_DISABLE; // disable in case already enabled
3409 issuecommand(ai, &cmd, &rsp);
3410 clear_bit(FLAG_ENABLED, &ai->flags);
3416 static void enable_interrupts( struct airo_info *ai ) {
3417 /* Enable the interrupts */
3418 OUT4500( ai, EVINTEN, STATUS_INTS );
3421 static void disable_interrupts( struct airo_info *ai ) {
3422 OUT4500( ai, EVINTEN, 0 );
3425 static void mpi_receive_802_3(struct airo_info *ai)
3429 struct sk_buff *skb;
3436 memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3437 /* Make sure we got something */
3438 if (rxd.rdy && rxd.valid == 0) {
3440 if (len < 12 || len > 2048)
3443 skb = dev_alloc_skb(len);
3445 ai->stats.rx_dropped++;
3448 buffer = skb_put(skb,len);
3450 memcpy(buffer, ai->rxfids[0].virtual_host_addr, ETH_ALEN * 2);
3451 if (ai->micstats.enabled) {
3453 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2,
3455 if (ntohs(micbuf.typelen) <= 0x05DC) {
3456 if (len <= sizeof(micbuf) + ETH_ALEN * 2)
3459 off = sizeof(micbuf);
3460 skb_trim (skb, len - off);
3463 memcpy(buffer + ETH_ALEN * 2,
3464 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2 + off,
3465 len - ETH_ALEN * 2 - off);
3466 if (decapsulate (ai, &micbuf, (etherHead*)buffer, len - off - ETH_ALEN * 2)) {
3468 dev_kfree_skb_irq (skb);
3472 memcpy(buffer, ai->rxfids[0].virtual_host_addr, len);
3475 if (ai->spy_data.spy_number > 0) {
3477 struct iw_quality wstats;
3478 /* Prepare spy data : addr + qual */
3479 sa = buffer + ETH_ALEN;
3480 wstats.qual = 0; /* XXX Where do I get that info from ??? */
3483 /* Update spy records */
3484 wireless_spy_update(ai->dev, sa, &wstats);
3486 #endif /* WIRELESS_SPY */
3489 skb->ip_summed = CHECKSUM_NONE;
3490 skb->protocol = eth_type_trans(skb, ai->dev);
3491 skb->dev->last_rx = jiffies;
3495 if (rxd.valid == 0) {
3499 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3503 void mpi_receive_802_11 (struct airo_info *ai)
3506 struct sk_buff *skb = NULL;
3507 u16 fc, len, hdrlen = 0;
3519 char *ptr = ai->rxfids[0].virtual_host_addr+4;
3521 memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3522 memcpy ((char *)&hdr, ptr, sizeof(hdr));
3524 /* Bad CRC. Ignore packet */
3525 if (le16_to_cpu(hdr.status) & 2)
3527 if (ai->wifidev == NULL)
3529 len = le16_to_cpu(hdr.len);
3531 printk( KERN_ERR "airo: Bad size %d\n", len );
3537 memcpy ((char *)&fc, ptr, sizeof(fc));
3538 fc = le16_to_cpu(fc);
3541 if ((fc & 0xe0) == 0xc0)
3547 if ((fc&0x300)==0x300){
3555 skb = dev_alloc_skb( len + hdrlen + 2 );
3557 ai->stats.rx_dropped++;
3560 buffer = (u16*)skb_put (skb, len + hdrlen);
3561 memcpy ((char *)buffer, ptr, hdrlen);
3565 memcpy ((char *)&gap, ptr, sizeof(gap));
3567 gap = le16_to_cpu(gap);
3573 "airo: gaplen too big. Problems will follow...\n");
3575 memcpy ((char *)buffer + hdrlen, ptr, len);
3577 #ifdef IW_WIRELESS_SPY /* defined in iw_handler.h */
3578 if (ai->spy_data.spy_number > 0) {
3580 struct iw_quality wstats;
3581 /* Prepare spy data : addr + qual */
3582 sa = (char*)buffer + 10;
3583 wstats.qual = hdr.rssi[0];
3585 wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3587 wstats.level = (hdr.rssi[1] + 321) / 2;
3588 wstats.noise = ai->wstats.qual.noise;
3589 wstats.updated = IW_QUAL_QUAL_UPDATED
3590 | IW_QUAL_LEVEL_UPDATED
3592 /* Update spy records */
3593 wireless_spy_update(ai->dev, sa, &wstats);
3595 #endif /* IW_WIRELESS_SPY */
3596 skb->mac.raw = skb->data;
3597 skb->pkt_type = PACKET_OTHERHOST;
3598 skb->dev = ai->wifidev;
3599 skb->protocol = htons(ETH_P_802_2);
3600 skb->dev->last_rx = jiffies;
3601 skb->ip_summed = CHECKSUM_NONE;
3604 if (rxd.valid == 0) {
3608 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3612 static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
3623 memset( &mySsid, 0, sizeof( mySsid ) );
3627 /* The NOP is the first step in getting the card going */
3629 cmd.parm0 = cmd.parm1 = cmd.parm2 = 0;
3630 if (lock && down_interruptible(&ai->sem))
3632 if ( issuecommand( ai, &cmd, &rsp ) != SUCCESS ) {
3637 disable_MAC( ai, 0);
3639 // Let's figure out if we need to use the AUX port
3640 if (!test_bit(FLAG_MPI,&ai->flags)) {
3641 cmd.cmd = CMD_ENABLEAUX;
3642 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
3645 printk(KERN_ERR "airo: Error checking for AUX port\n");
3648 if (!aux_bap || rsp.status & 0xff00) {
3649 ai->bap_read = fast_bap_read;
3650 printk(KERN_DEBUG "airo: Doing fast bap_reads\n");
3652 ai->bap_read = aux_bap_read;
3653 printk(KERN_DEBUG "airo: Doing AUX bap_reads\n");
3658 if (ai->config.len == 0) {
3659 tdsRssiRid rssi_rid;
3660 CapabilityRid cap_rid;
3666 // general configuration (read/modify/write)
3667 status = readConfigRid(ai, lock);
3668 if ( status != SUCCESS ) return ERROR;
3670 status = readCapabilityRid(ai, &cap_rid, lock);
3671 if ( status != SUCCESS ) return ERROR;
3673 status = PC4500_readrid(ai,RID_RSSI,&rssi_rid,sizeof(rssi_rid),lock);
3674 if ( status == SUCCESS ) {
3675 if (ai->rssi || (ai->rssi = kmalloc(512, GFP_KERNEL)) != NULL)
3676 memcpy(ai->rssi, (u8*)&rssi_rid + 2, 512); /* Skip RID length member */
3681 if (cap_rid.softCap & 8)
3682 ai->config.rmode |= RXMODE_NORMALIZED_RSSI;
3684 printk(KERN_WARNING "airo: unknown received signal level scale\n");
3686 ai->config.opmode = adhoc ? MODE_STA_IBSS : MODE_STA_ESS;
3687 ai->config.authType = AUTH_OPEN;
3688 ai->config.modulation = MOD_CCK;
3691 if ((cap_rid.len>=sizeof(cap_rid)) && (cap_rid.extSoftCap&1) &&
3692 (micsetup(ai) == SUCCESS)) {
3693 ai->config.opmode |= MODE_MIC;
3694 set_bit(FLAG_MIC_CAPABLE, &ai->flags);
3698 /* Save off the MAC */
3699 for( i = 0; i < ETH_ALEN; i++ ) {
3700 mac[i] = ai->config.macAddr[i];
3703 /* Check to see if there are any insmod configured
3707 memset(ai->config.rates,0,sizeof(ai->config.rates));
3708 for( i = 0; i < 8 && rates[i]; i++ ) {
3709 ai->config.rates[i] = rates[i];
3712 if ( basic_rate > 0 ) {
3714 for( i = 0; i < 8; i++ ) {
3715 if ( ai->config.rates[i] == basic_rate ||
3716 !ai->config.rates ) {
3717 ai->config.rates[i] = basic_rate | 0x80;
3722 set_bit (FLAG_COMMIT, &ai->flags);
3725 /* Setup the SSIDs if present */
3728 for( i = 0; i < 3 && ssids[i]; i++ ) {
3729 mySsid.ssids[i].len = strlen(ssids[i]);
3730 if ( mySsid.ssids[i].len > 32 )
3731 mySsid.ssids[i].len = 32;
3732 memcpy(mySsid.ssids[i].ssid, ssids[i],
3733 mySsid.ssids[i].len);
3735 mySsid.len = sizeof(mySsid);
3738 status = writeConfigRid(ai, lock);
3739 if ( status != SUCCESS ) return ERROR;
3741 /* Set up the SSID list */
3743 status = writeSsidRid(ai, &mySsid, lock);
3744 if ( status != SUCCESS ) return ERROR;
3747 status = enable_MAC(ai, &rsp, lock);
3748 if ( status != SUCCESS || (rsp.status & 0xFF00) != 0) {
3749 printk( KERN_ERR "airo: Bad MAC enable reason = %x, rid = %x, offset = %d\n", rsp.rsp0, rsp.rsp1, rsp.rsp2 );
3753 /* Grab the initial wep key, we gotta save it for auto_wep */
3754 rc = readWepKeyRid(ai, &wkr, 1, lock);
3755 if (rc == SUCCESS) do {
3756 lastindex = wkr.kindex;
3757 if (wkr.kindex == 0xffff) {
3758 ai->defindex = wkr.mac[0];
3760 rc = readWepKeyRid(ai, &wkr, 0, lock);
3761 } while(lastindex != wkr.kindex);
3764 ai->expires = RUN_AT(3*HZ);
3765 wake_up_interruptible(&ai->thr_wait);
3771 static u16 issuecommand(struct airo_info *ai, Cmd *pCmd, Resp *pRsp) {
3772 // Im really paranoid about letting it run forever!
3773 int max_tries = 600000;
3775 if (IN4500(ai, EVSTAT) & EV_CMD)
3776 OUT4500(ai, EVACK, EV_CMD);
3778 OUT4500(ai, PARAM0, pCmd->parm0);
3779 OUT4500(ai, PARAM1, pCmd->parm1);
3780 OUT4500(ai, PARAM2, pCmd->parm2);
3781 OUT4500(ai, COMMAND, pCmd->cmd);
3783 while (max_tries-- && (IN4500(ai, EVSTAT) & EV_CMD) == 0) {
3784 if ((IN4500(ai, COMMAND)) == pCmd->cmd)
3785 // PC4500 didn't notice command, try again
3786 OUT4500(ai, COMMAND, pCmd->cmd);
3787 if (!in_atomic() && (max_tries & 255) == 0)
3791 if ( max_tries == -1 ) {
3793 "airo: Max tries exceeded when issueing command\n" );
3794 if (IN4500(ai, COMMAND) & COMMAND_BUSY)
3795 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3799 // command completed
3800 pRsp->status = IN4500(ai, STATUS);
3801 pRsp->rsp0 = IN4500(ai, RESP0);
3802 pRsp->rsp1 = IN4500(ai, RESP1);
3803 pRsp->rsp2 = IN4500(ai, RESP2);
3804 if ((pRsp->status & 0xff00)!=0 && pCmd->cmd != CMD_SOFTRESET) {
3805 printk (KERN_ERR "airo: cmd= %x\n", pCmd->cmd);
3806 printk (KERN_ERR "airo: status= %x\n", pRsp->status);
3807 printk (KERN_ERR "airo: Rsp0= %x\n", pRsp->rsp0);
3808 printk (KERN_ERR "airo: Rsp1= %x\n", pRsp->rsp1);
3809 printk (KERN_ERR "airo: Rsp2= %x\n", pRsp->rsp2);
3812 // clear stuck command busy if necessary
3813 if (IN4500(ai, COMMAND) & COMMAND_BUSY) {
3814 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3816 // acknowledge processing the status/response
3817 OUT4500(ai, EVACK, EV_CMD);
3822 /* Sets up the bap to start exchange data. whichbap should
3823 * be one of the BAP0 or BAP1 defines. Locks should be held before
3825 static int bap_setup(struct airo_info *ai, u16 rid, u16 offset, int whichbap )
3830 OUT4500(ai, SELECT0+whichbap, rid);
3831 OUT4500(ai, OFFSET0+whichbap, offset);
3833 int status = IN4500(ai, OFFSET0+whichbap);
3834 if (status & BAP_BUSY) {
3835 /* This isn't really a timeout, but its kinda
3840 } else if ( status & BAP_ERR ) {
3841 /* invalid rid or offset */
3842 printk( KERN_ERR "airo: BAP error %x %d\n",
3845 } else if (status & BAP_DONE) { // success
3848 if ( !(max_tries--) ) {
3850 "airo: BAP setup error too many retries\n" );
3853 // -- PC4500 missed it, try again
3854 OUT4500(ai, SELECT0+whichbap, rid);
3855 OUT4500(ai, OFFSET0+whichbap, offset);
3860 /* should only be called by aux_bap_read. This aux function and the
3861 following use concepts not documented in the developers guide. I
3862 got them from a patch given to my by Aironet */
3863 static u16 aux_setup(struct airo_info *ai, u16 page,
3864 u16 offset, u16 *len)
3868 OUT4500(ai, AUXPAGE, page);
3869 OUT4500(ai, AUXOFF, 0);
3870 next = IN4500(ai, AUXDATA);
3871 *len = IN4500(ai, AUXDATA)&0xff;
3872 if (offset != 4) OUT4500(ai, AUXOFF, offset);
3876 /* requires call to bap_setup() first */
3877 static int aux_bap_read(struct airo_info *ai, u16 *pu16Dst,
3878 int bytelen, int whichbap)
3886 unsigned long flags;
3888 spin_lock_irqsave(&ai->aux_lock, flags);
3889 page = IN4500(ai, SWS0+whichbap);
3890 offset = IN4500(ai, SWS2+whichbap);
3891 next = aux_setup(ai, page, offset, &len);
3892 words = (bytelen+1)>>1;
3894 for (i=0; i<words;) {
3896 count = (len>>1) < (words-i) ? (len>>1) : (words-i);
3898 insw( ai->dev->base_addr+DATA0+whichbap,
3901 insb( ai->dev->base_addr+DATA0+whichbap,
3902 pu16Dst+i, count << 1 );
3905 next = aux_setup(ai, next, 4, &len);
3908 spin_unlock_irqrestore(&ai->aux_lock, flags);
3913 /* requires call to bap_setup() first */
3914 static int fast_bap_read(struct airo_info *ai, u16 *pu16Dst,
3915 int bytelen, int whichbap)
3917 bytelen = (bytelen + 1) & (~1); // round up to even value
3919 insw( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen>>1 );
3921 insb( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen );
3925 /* requires call to bap_setup() first */
3926 static int bap_write(struct airo_info *ai, const u16 *pu16Src,
3927 int bytelen, int whichbap)
3929 bytelen = (bytelen + 1) & (~1); // round up to even value
3931 outsw( ai->dev->base_addr+DATA0+whichbap,
3932 pu16Src, bytelen>>1 );
3934 outsb( ai->dev->base_addr+DATA0+whichbap, pu16Src, bytelen );
3938 static int PC4500_accessrid(struct airo_info *ai, u16 rid, u16 accmd)
3940 Cmd cmd; /* for issuing commands */
3941 Resp rsp; /* response from commands */
3944 memset(&cmd, 0, sizeof(cmd));
3947 status = issuecommand(ai, &cmd, &rsp);
3948 if (status != 0) return status;
3949 if ( (rsp.status & 0x7F00) != 0) {
3950 return (accmd << 8) + (rsp.rsp0 & 0xFF);
3955 /* Note, that we are using BAP1 which is also used by transmit, so
3956 * we must get a lock. */
3957 static int PC4500_readrid(struct airo_info *ai, u16 rid, void *pBuf, int len, int lock)
3963 if (down_interruptible(&ai->sem))
3966 if (test_bit(FLAG_MPI,&ai->flags)) {
3970 memset(&cmd, 0, sizeof(cmd));
3971 memset(&rsp, 0, sizeof(rsp));
3972 ai->config_desc.rid_desc.valid = 1;
3973 ai->config_desc.rid_desc.len = RIDSIZE;
3974 ai->config_desc.rid_desc.rid = 0;
3975 ai->config_desc.rid_desc.host_addr = ai->ridbus;
3977 cmd.cmd = CMD_ACCESS;
3980 memcpy_toio(ai->config_desc.card_ram_off,
3981 &ai->config_desc.rid_desc, sizeof(Rid));
3983 rc = issuecommand(ai, &cmd, &rsp);
3985 if (rsp.status & 0x7f00)
3988 memcpy(pBuf, ai->config_desc.virtual_host_addr, len);
3991 if ((status = PC4500_accessrid(ai, rid, CMD_ACCESS))!=SUCCESS) {
3995 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
3999 // read the rid length field
4000 bap_read(ai, pBuf, 2, BAP1);
4001 // length for remaining part of rid
4002 len = min(len, (int)le16_to_cpu(*(u16*)pBuf)) - 2;
4006 "airo: Rid %x has a length of %d which is too short\n",
4007 (int)rid, (int)len );
4011 // read remainder of the rid
4012 rc = bap_read(ai, ((u16*)pBuf)+1, len, BAP1);
4020 /* Note, that we are using BAP1 which is also used by transmit, so
4021 * make sure this isnt called when a transmit is happening */
4022 static int PC4500_writerid(struct airo_info *ai, u16 rid,
4023 const void *pBuf, int len, int lock)
4028 *(u16*)pBuf = cpu_to_le16((u16)len);
4031 if (down_interruptible(&ai->sem))
4034 if (test_bit(FLAG_MPI,&ai->flags)) {
4038 if (test_bit(FLAG_ENABLED, &ai->flags))
4040 "%s: MAC should be disabled (rid=%04x)\n",
4042 memset(&cmd, 0, sizeof(cmd));
4043 memset(&rsp, 0, sizeof(rsp));
4045 ai->config_desc.rid_desc.valid = 1;
4046 ai->config_desc.rid_desc.len = *((u16 *)pBuf);
4047 ai->config_desc.rid_desc.rid = 0;
4049 cmd.cmd = CMD_WRITERID;
4052 memcpy_toio(ai->config_desc.card_ram_off,
4053 &ai->config_desc.rid_desc, sizeof(Rid));
4055 if (len < 4 || len > 2047) {
4056 printk(KERN_ERR "%s: len=%d\n",__FUNCTION__,len);
4059 memcpy((char *)ai->config_desc.virtual_host_addr,
4062 rc = issuecommand(ai, &cmd, &rsp);
4063 if ((rc & 0xff00) != 0) {
4064 printk(KERN_ERR "%s: Write rid Error %d\n",
4066 printk(KERN_ERR "%s: Cmd=%04x\n",
4067 __FUNCTION__,cmd.cmd);
4070 if ((rsp.status & 0x7f00))
4074 // --- first access so that we can write the rid data
4075 if ( (status = PC4500_accessrid(ai, rid, CMD_ACCESS)) != 0) {
4079 // --- now write the rid data
4080 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4084 bap_write(ai, pBuf, len, BAP1);
4085 // ---now commit the rid data
4086 rc = PC4500_accessrid(ai, rid, 0x100|CMD_ACCESS);
4094 /* Allocates a FID to be used for transmitting packets. We only use
4096 static u16 transmit_allocate(struct airo_info *ai, int lenPayload, int raw)
4098 unsigned int loop = 3000;
4104 cmd.cmd = CMD_ALLOCATETX;
4105 cmd.parm0 = lenPayload;
4106 if (down_interruptible(&ai->sem))
4108 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
4112 if ( (rsp.status & 0xFF00) != 0) {
4116 /* wait for the allocate event/indication
4117 * It makes me kind of nervous that this can just sit here and spin,
4118 * but in practice it only loops like four times. */
4119 while (((IN4500(ai, EVSTAT) & EV_ALLOC) == 0) && --loop);
4125 // get the allocated fid and acknowledge
4126 txFid = IN4500(ai, TXALLOCFID);
4127 OUT4500(ai, EVACK, EV_ALLOC);
4129 /* The CARD is pretty cool since it converts the ethernet packet
4130 * into 802.11. Also note that we don't release the FID since we
4131 * will be using the same one over and over again. */
4132 /* We only have to setup the control once since we are not
4133 * releasing the fid. */
4135 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_11
4136 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4138 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_3
4139 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4140 if (bap_setup(ai, txFid, 0x0008, BAP1) != SUCCESS)
4143 bap_write(ai, &txControl, sizeof(txControl), BAP1);
4151 /* In general BAP1 is dedicated to transmiting packets. However,
4152 since we need a BAP when accessing RIDs, we also use BAP1 for that.
4153 Make sure the BAP1 spinlock is held when this is called. */
4154 static int transmit_802_3_packet(struct airo_info *ai, int len, char *pPacket)
4165 if (len <= ETH_ALEN * 2) {
4166 printk( KERN_WARNING "Short packet %d\n", len );
4169 len -= ETH_ALEN * 2;
4172 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
4173 (ntohs(((u16 *)pPacket)[6]) != 0x888E)) {
4174 if (encapsulate(ai,(etherHead *)pPacket,&pMic,len) != SUCCESS)
4176 miclen = sizeof(pMic);
4180 // packet is destination[6], source[6], payload[len-12]
4181 // write the payload length and dst/src/payload
4182 if (bap_setup(ai, txFid, 0x0036, BAP1) != SUCCESS) return ERROR;
4183 /* The hardware addresses aren't counted as part of the payload, so
4184 * we have to subtract the 12 bytes for the addresses off */
4185 payloadLen = cpu_to_le16(len + miclen);
4186 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4187 bap_write(ai, (const u16*)pPacket, sizeof(etherHead), BAP1);
4189 bap_write(ai, (const u16*)&pMic, miclen, BAP1);
4190 bap_write(ai, (const u16*)(pPacket + sizeof(etherHead)), len, BAP1);
4191 // issue the transmit command
4192 memset( &cmd, 0, sizeof( cmd ) );
4193 cmd.cmd = CMD_TRANSMIT;
4195 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4196 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4200 static int transmit_802_11_packet(struct airo_info *ai, int len, char *pPacket)
4215 fc = le16_to_cpu(*(const u16*)pPacket);
4218 if ((fc & 0xe0) == 0xc0)
4224 if ((fc&0x300)==0x300){
4233 printk( KERN_WARNING "Short packet %d\n", len );
4237 /* packet is 802.11 header + payload
4238 * write the payload length and dst/src/payload */
4239 if (bap_setup(ai, txFid, 6, BAP1) != SUCCESS) return ERROR;
4240 /* The 802.11 header aren't counted as part of the payload, so
4241 * we have to subtract the header bytes off */
4242 payloadLen = cpu_to_le16(len-hdrlen);
4243 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4244 if (bap_setup(ai, txFid, 0x0014, BAP1) != SUCCESS) return ERROR;
4245 bap_write(ai, (const u16*)pPacket, hdrlen, BAP1);
4246 bap_write(ai, hdrlen == 30 ?
4247 (const u16*)&gap.gaplen : (const u16*)&gap, 38 - hdrlen, BAP1);
4249 bap_write(ai, (const u16*)(pPacket + hdrlen), len - hdrlen, BAP1);
4250 // issue the transmit command
4251 memset( &cmd, 0, sizeof( cmd ) );
4252 cmd.cmd = CMD_TRANSMIT;
4254 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4255 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4260 * This is the proc_fs routines. It is a bit messier than I would
4261 * like! Feel free to clean it up!
4264 static ssize_t proc_read( struct file *file,
4265 char __user *buffer,
4269 static ssize_t proc_write( struct file *file,
4270 const char __user *buffer,
4273 static int proc_close( struct inode *inode, struct file *file );
4275 static int proc_stats_open( struct inode *inode, struct file *file );
4276 static int proc_statsdelta_open( struct inode *inode, struct file *file );
4277 static int proc_status_open( struct inode *inode, struct file *file );
4278 static int proc_SSID_open( struct inode *inode, struct file *file );
4279 static int proc_APList_open( struct inode *inode, struct file *file );
4280 static int proc_BSSList_open( struct inode *inode, struct file *file );
4281 static int proc_config_open( struct inode *inode, struct file *file );
4282 static int proc_wepkey_open( struct inode *inode, struct file *file );
4284 static struct file_operations proc_statsdelta_ops = {
4286 .open = proc_statsdelta_open,
4287 .release = proc_close
4290 static struct file_operations proc_stats_ops = {
4292 .open = proc_stats_open,
4293 .release = proc_close
4296 static struct file_operations proc_status_ops = {
4298 .open = proc_status_open,
4299 .release = proc_close
4302 static struct file_operations proc_SSID_ops = {
4304 .write = proc_write,
4305 .open = proc_SSID_open,
4306 .release = proc_close
4309 static struct file_operations proc_BSSList_ops = {
4311 .write = proc_write,
4312 .open = proc_BSSList_open,
4313 .release = proc_close
4316 static struct file_operations proc_APList_ops = {
4318 .write = proc_write,
4319 .open = proc_APList_open,
4320 .release = proc_close
4323 static struct file_operations proc_config_ops = {
4325 .write = proc_write,
4326 .open = proc_config_open,
4327 .release = proc_close
4330 static struct file_operations proc_wepkey_ops = {
4332 .write = proc_write,
4333 .open = proc_wepkey_open,
4334 .release = proc_close
4337 static struct proc_dir_entry *airo_entry;
4346 void (*on_close) (struct inode *, struct file *);
4350 #define SETPROC_OPS(entry, ops) (entry)->proc_fops = &(ops)
4353 static int setup_proc_entry( struct net_device *dev,
4354 struct airo_info *apriv ) {
4355 struct proc_dir_entry *entry;
4356 /* First setup the device directory */
4357 strcpy(apriv->proc_name,dev->name);
4358 apriv->proc_entry = create_proc_entry(apriv->proc_name,
4361 apriv->proc_entry->uid = proc_uid;
4362 apriv->proc_entry->gid = proc_gid;
4363 apriv->proc_entry->owner = THIS_MODULE;
4365 /* Setup the StatsDelta */
4366 entry = create_proc_entry("StatsDelta",
4367 S_IFREG | (S_IRUGO&proc_perm),
4369 entry->uid = proc_uid;
4370 entry->gid = proc_gid;
4372 entry->owner = THIS_MODULE;
4373 SETPROC_OPS(entry, proc_statsdelta_ops);
4375 /* Setup the Stats */
4376 entry = create_proc_entry("Stats",
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_stats_ops);
4385 /* Setup the Status */
4386 entry = create_proc_entry("Status",
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_status_ops);
4395 /* Setup the Config */
4396 entry = create_proc_entry("Config",
4397 S_IFREG | proc_perm,
4399 entry->uid = proc_uid;
4400 entry->gid = proc_gid;
4402 entry->owner = THIS_MODULE;
4403 SETPROC_OPS(entry, proc_config_ops);
4405 /* Setup the SSID */
4406 entry = create_proc_entry("SSID",
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_SSID_ops);
4415 /* Setup the APList */
4416 entry = create_proc_entry("APList",
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_APList_ops);
4425 /* Setup the BSSList */
4426 entry = create_proc_entry("BSSList",
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_BSSList_ops);
4435 /* Setup the WepKey */
4436 entry = create_proc_entry("WepKey",
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_wepkey_ops);
4448 static int takedown_proc_entry( struct net_device *dev,
4449 struct airo_info *apriv ) {
4450 if ( !apriv->proc_entry->namelen ) return 0;
4451 remove_proc_entry("Stats",apriv->proc_entry);
4452 remove_proc_entry("StatsDelta",apriv->proc_entry);
4453 remove_proc_entry("Status",apriv->proc_entry);
4454 remove_proc_entry("Config",apriv->proc_entry);
4455 remove_proc_entry("SSID",apriv->proc_entry);
4456 remove_proc_entry("APList",apriv->proc_entry);
4457 remove_proc_entry("BSSList",apriv->proc_entry);
4458 remove_proc_entry("WepKey",apriv->proc_entry);
4459 remove_proc_entry(apriv->proc_name,airo_entry);
4464 * What we want from the proc_fs is to be able to efficiently read
4465 * and write the configuration. To do this, we want to read the
4466 * configuration when the file is opened and write it when the file is
4467 * closed. So basically we allocate a read buffer at open and fill it
4468 * with data, and allocate a write buffer and read it at close.
4472 * The read routine is generic, it relies on the preallocated rbuffer
4473 * to supply the data.
4475 static ssize_t proc_read( struct file *file,
4476 char __user *buffer,
4480 loff_t pos = *offset;
4481 struct proc_data *priv = (struct proc_data*)file->private_data;
4488 if (pos >= priv->readlen)
4490 if (len > priv->readlen - pos)
4491 len = priv->readlen - pos;
4492 if (copy_to_user(buffer, priv->rbuffer + pos, len))
4494 *offset = pos + len;
4499 * The write routine is generic, it fills in a preallocated rbuffer
4500 * to supply the data.
4502 static ssize_t proc_write( struct file *file,
4503 const char __user *buffer,
4507 loff_t pos = *offset;
4508 struct proc_data *priv = (struct proc_data*)file->private_data;
4515 if (pos >= priv->maxwritelen)
4517 if (len > priv->maxwritelen - pos)
4518 len = priv->maxwritelen - pos;
4519 if (copy_from_user(priv->wbuffer + pos, buffer, len))
4521 if ( pos + len > priv->writelen )
4522 priv->writelen = len + file->f_pos;
4523 *offset = pos + len;
4527 static int proc_status_open( struct inode *inode, struct file *file ) {
4528 struct proc_data *data;
4529 struct proc_dir_entry *dp = PDE(inode);
4530 struct net_device *dev = dp->data;
4531 struct airo_info *apriv = dev->priv;
4532 CapabilityRid cap_rid;
4533 StatusRid status_rid;
4536 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4538 data = (struct proc_data *)file->private_data;
4539 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4540 kfree (file->private_data);
4544 readStatusRid(apriv, &status_rid, 1);
4545 readCapabilityRid(apriv, &cap_rid, 1);
4547 i = sprintf(data->rbuffer, "Status: %s%s%s%s%s%s%s%s%s\n",
4548 status_rid.mode & 1 ? "CFG ": "",
4549 status_rid.mode & 2 ? "ACT ": "",
4550 status_rid.mode & 0x10 ? "SYN ": "",
4551 status_rid.mode & 0x20 ? "LNK ": "",
4552 status_rid.mode & 0x40 ? "LEAP ": "",
4553 status_rid.mode & 0x80 ? "PRIV ": "",
4554 status_rid.mode & 0x100 ? "KEY ": "",
4555 status_rid.mode & 0x200 ? "WEP ": "",
4556 status_rid.mode & 0x8000 ? "ERR ": "");
4557 sprintf( data->rbuffer+i, "Mode: %x\n"
4558 "Signal Strength: %d\n"
4559 "Signal Quality: %d\n"
4564 "Driver Version: %s\n"
4565 "Device: %s\nManufacturer: %s\nFirmware Version: %s\n"
4566 "Radio type: %x\nCountry: %x\nHardware Version: %x\n"
4567 "Software Version: %x\nSoftware Subversion: %x\n"
4568 "Boot block version: %x\n",
4569 (int)status_rid.mode,
4570 (int)status_rid.normalizedSignalStrength,
4571 (int)status_rid.signalQuality,
4572 (int)status_rid.SSIDlen,
4575 (int)status_rid.channel,
4576 (int)status_rid.currentXmitRate/2,
4584 (int)cap_rid.softVer,
4585 (int)cap_rid.softSubVer,
4586 (int)cap_rid.bootBlockVer );
4587 data->readlen = strlen( data->rbuffer );
4591 static int proc_stats_rid_open(struct inode*, struct file*, u16);
4592 static int proc_statsdelta_open( struct inode *inode,
4593 struct file *file ) {
4594 if (file->f_mode&FMODE_WRITE) {
4595 return proc_stats_rid_open(inode, file, RID_STATSDELTACLEAR);
4597 return proc_stats_rid_open(inode, file, RID_STATSDELTA);
4600 static int proc_stats_open( struct inode *inode, struct file *file ) {
4601 return proc_stats_rid_open(inode, file, RID_STATS);
4604 static int proc_stats_rid_open( struct inode *inode,
4607 struct proc_data *data;
4608 struct proc_dir_entry *dp = PDE(inode);
4609 struct net_device *dev = dp->data;
4610 struct airo_info *apriv = dev->priv;
4613 u32 *vals = stats.vals;
4615 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4617 data = (struct proc_data *)file->private_data;
4618 if ((data->rbuffer = kmalloc( 4096, GFP_KERNEL )) == NULL) {
4619 kfree (file->private_data);
4623 readStatsRid(apriv, &stats, rid, 1);
4626 for(i=0; statsLabels[i]!=(char *)-1 &&
4627 i*4<stats.len; i++){
4628 if (!statsLabels[i]) continue;
4629 if (j+strlen(statsLabels[i])+16>4096) {
4631 "airo: Potentially disasterous buffer overflow averted!\n");
4634 j+=sprintf(data->rbuffer+j, "%s: %u\n", statsLabels[i], vals[i]);
4636 if (i*4>=stats.len){
4638 "airo: Got a short rid\n");
4644 static int get_dec_u16( char *buffer, int *start, int limit ) {
4647 for( value = 0; buffer[*start] >= '0' &&
4648 buffer[*start] <= '9' &&
4649 *start < limit; (*start)++ ) {
4652 value += buffer[*start] - '0';
4654 if ( !valid ) return -1;
4658 static int airo_config_commit(struct net_device *dev,
4659 struct iw_request_info *info, void *zwrq,
4662 static void proc_config_on_close( struct inode *inode, struct file *file ) {
4663 struct proc_data *data = file->private_data;
4664 struct proc_dir_entry *dp = PDE(inode);
4665 struct net_device *dev = dp->data;
4666 struct airo_info *ai = dev->priv;
4669 if ( !data->writelen ) return;
4671 readConfigRid(ai, 1);
4672 set_bit (FLAG_COMMIT, &ai->flags);
4674 line = data->wbuffer;
4676 /*** Mode processing */
4677 if ( !strncmp( line, "Mode: ", 6 ) ) {
4679 if ((ai->config.rmode & 0xff) >= RXMODE_RFMON)
4680 set_bit (FLAG_RESET, &ai->flags);
4681 ai->config.rmode &= 0xfe00;
4682 clear_bit (FLAG_802_11, &ai->flags);
4683 ai->config.opmode &= 0xFF00;
4684 ai->config.scanMode = SCANMODE_ACTIVE;
4685 if ( line[0] == 'a' ) {
4686 ai->config.opmode |= 0;
4688 ai->config.opmode |= 1;
4689 if ( line[0] == 'r' ) {
4690 ai->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
4691 ai->config.scanMode = SCANMODE_PASSIVE;
4692 set_bit (FLAG_802_11, &ai->flags);
4693 } else if ( line[0] == 'y' ) {
4694 ai->config.rmode |= RXMODE_RFMON_ANYBSS | RXMODE_DISABLE_802_3_HEADER;
4695 ai->config.scanMode = SCANMODE_PASSIVE;
4696 set_bit (FLAG_802_11, &ai->flags);
4697 } else if ( line[0] == 'l' )
4698 ai->config.rmode |= RXMODE_LANMON;
4700 set_bit (FLAG_COMMIT, &ai->flags);
4703 /*** Radio status */
4704 else if (!strncmp(line,"Radio: ", 7)) {
4706 if (!strncmp(line,"off",3)) {
4707 set_bit (FLAG_RADIO_OFF, &ai->flags);
4709 clear_bit (FLAG_RADIO_OFF, &ai->flags);
4712 /*** NodeName processing */
4713 else if ( !strncmp( line, "NodeName: ", 10 ) ) {
4717 memset( ai->config.nodeName, 0, 16 );
4718 /* Do the name, assume a space between the mode and node name */
4719 for( j = 0; j < 16 && line[j] != '\n'; j++ ) {
4720 ai->config.nodeName[j] = line[j];
4722 set_bit (FLAG_COMMIT, &ai->flags);
4725 /*** PowerMode processing */
4726 else if ( !strncmp( line, "PowerMode: ", 11 ) ) {
4728 if ( !strncmp( line, "PSPCAM", 6 ) ) {
4729 ai->config.powerSaveMode = POWERSAVE_PSPCAM;
4730 set_bit (FLAG_COMMIT, &ai->flags);
4731 } else if ( !strncmp( line, "PSP", 3 ) ) {
4732 ai->config.powerSaveMode = POWERSAVE_PSP;
4733 set_bit (FLAG_COMMIT, &ai->flags);
4735 ai->config.powerSaveMode = POWERSAVE_CAM;
4736 set_bit (FLAG_COMMIT, &ai->flags);
4738 } else if ( !strncmp( line, "DataRates: ", 11 ) ) {
4739 int v, i = 0, k = 0; /* i is index into line,
4740 k is index to rates */
4743 while((v = get_dec_u16(line, &i, 3))!=-1) {
4744 ai->config.rates[k++] = (u8)v;
4748 set_bit (FLAG_COMMIT, &ai->flags);
4749 } else if ( !strncmp( line, "Channel: ", 9 ) ) {
4752 v = get_dec_u16(line, &i, i+3);
4754 ai->config.channelSet = (u16)v;
4755 set_bit (FLAG_COMMIT, &ai->flags);
4757 } else if ( !strncmp( line, "XmitPower: ", 11 ) ) {
4760 v = get_dec_u16(line, &i, i+3);
4762 ai->config.txPower = (u16)v;
4763 set_bit (FLAG_COMMIT, &ai->flags);
4765 } else if ( !strncmp( line, "WEP: ", 5 ) ) {
4769 ai->config.authType = (u16)AUTH_SHAREDKEY;
4772 ai->config.authType = (u16)AUTH_ENCRYPT;
4775 ai->config.authType = (u16)AUTH_OPEN;
4778 set_bit (FLAG_COMMIT, &ai->flags);
4779 } else if ( !strncmp( line, "LongRetryLimit: ", 16 ) ) {
4783 v = get_dec_u16(line, &i, 3);
4784 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4785 ai->config.longRetryLimit = (u16)v;
4786 set_bit (FLAG_COMMIT, &ai->flags);
4787 } else if ( !strncmp( line, "ShortRetryLimit: ", 17 ) ) {
4791 v = get_dec_u16(line, &i, 3);
4792 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4793 ai->config.shortRetryLimit = (u16)v;
4794 set_bit (FLAG_COMMIT, &ai->flags);
4795 } else if ( !strncmp( line, "RTSThreshold: ", 14 ) ) {
4799 v = get_dec_u16(line, &i, 4);
4800 v = (v<0) ? 0 : ((v>2312) ? 2312 : v);
4801 ai->config.rtsThres = (u16)v;
4802 set_bit (FLAG_COMMIT, &ai->flags);
4803 } else if ( !strncmp( line, "TXMSDULifetime: ", 16 ) ) {
4807 v = get_dec_u16(line, &i, 5);
4809 ai->config.txLifetime = (u16)v;
4810 set_bit (FLAG_COMMIT, &ai->flags);
4811 } else if ( !strncmp( line, "RXMSDULifetime: ", 16 ) ) {
4815 v = get_dec_u16(line, &i, 5);
4817 ai->config.rxLifetime = (u16)v;
4818 set_bit (FLAG_COMMIT, &ai->flags);
4819 } else if ( !strncmp( line, "TXDiversity: ", 13 ) ) {
4820 ai->config.txDiversity =
4821 (line[13]=='l') ? 1 :
4822 ((line[13]=='r')? 2: 3);
4823 set_bit (FLAG_COMMIT, &ai->flags);
4824 } else if ( !strncmp( line, "RXDiversity: ", 13 ) ) {
4825 ai->config.rxDiversity =
4826 (line[13]=='l') ? 1 :
4827 ((line[13]=='r')? 2: 3);
4828 set_bit (FLAG_COMMIT, &ai->flags);
4829 } else if ( !strncmp( line, "FragThreshold: ", 15 ) ) {
4833 v = get_dec_u16(line, &i, 4);
4834 v = (v<256) ? 256 : ((v>2312) ? 2312 : v);
4835 v = v & 0xfffe; /* Make sure its even */
4836 ai->config.fragThresh = (u16)v;
4837 set_bit (FLAG_COMMIT, &ai->flags);
4838 } else if (!strncmp(line, "Modulation: ", 12)) {
4841 case 'd': ai->config.modulation=MOD_DEFAULT; set_bit(FLAG_COMMIT, &ai->flags); break;
4842 case 'c': ai->config.modulation=MOD_CCK; set_bit(FLAG_COMMIT, &ai->flags); break;
4843 case 'm': ai->config.modulation=MOD_MOK; set_bit(FLAG_COMMIT, &ai->flags); break;
4845 printk( KERN_WARNING "airo: Unknown modulation\n" );
4847 } else if (!strncmp(line, "Preamble: ", 10)) {
4850 case 'a': ai->config.preamble=PREAMBLE_AUTO; set_bit(FLAG_COMMIT, &ai->flags); break;
4851 case 'l': ai->config.preamble=PREAMBLE_LONG; set_bit(FLAG_COMMIT, &ai->flags); break;
4852 case 's': ai->config.preamble=PREAMBLE_SHORT; set_bit(FLAG_COMMIT, &ai->flags); break;
4853 default: printk(KERN_WARNING "airo: Unknown preamble\n");
4856 printk( KERN_WARNING "Couldn't figure out %s\n", line );
4858 while( line[0] && line[0] != '\n' ) line++;
4859 if ( line[0] ) line++;
4861 airo_config_commit(dev, NULL, NULL, NULL);
4864 static char *get_rmode(u16 mode) {
4866 case RXMODE_RFMON: return "rfmon";
4867 case RXMODE_RFMON_ANYBSS: return "yna (any) bss rfmon";
4868 case RXMODE_LANMON: return "lanmon";
4873 static int proc_config_open( struct inode *inode, struct file *file ) {
4874 struct proc_data *data;
4875 struct proc_dir_entry *dp = PDE(inode);
4876 struct net_device *dev = dp->data;
4877 struct airo_info *ai = dev->priv;
4880 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4882 data = (struct proc_data *)file->private_data;
4883 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4884 kfree (file->private_data);
4887 if ((data->wbuffer = kzalloc( 2048, GFP_KERNEL )) == NULL) {
4888 kfree (data->rbuffer);
4889 kfree (file->private_data);
4892 data->maxwritelen = 2048;
4893 data->on_close = proc_config_on_close;
4895 readConfigRid(ai, 1);
4897 i = sprintf( data->rbuffer,
4902 "DataRates: %d %d %d %d %d %d %d %d\n"
4905 (ai->config.opmode & 0xFF) == 0 ? "adhoc" :
4906 (ai->config.opmode & 0xFF) == 1 ? get_rmode(ai->config.rmode):
4907 (ai->config.opmode & 0xFF) == 2 ? "AP" :
4908 (ai->config.opmode & 0xFF) == 3 ? "AP RPTR" : "Error",
4909 test_bit(FLAG_RADIO_OFF, &ai->flags) ? "off" : "on",
4910 ai->config.nodeName,
4911 ai->config.powerSaveMode == 0 ? "CAM" :
4912 ai->config.powerSaveMode == 1 ? "PSP" :
4913 ai->config.powerSaveMode == 2 ? "PSPCAM" : "Error",
4914 (int)ai->config.rates[0],
4915 (int)ai->config.rates[1],
4916 (int)ai->config.rates[2],
4917 (int)ai->config.rates[3],
4918 (int)ai->config.rates[4],
4919 (int)ai->config.rates[5],
4920 (int)ai->config.rates[6],
4921 (int)ai->config.rates[7],
4922 (int)ai->config.channelSet,
4923 (int)ai->config.txPower
4925 sprintf( data->rbuffer + i,
4926 "LongRetryLimit: %d\n"
4927 "ShortRetryLimit: %d\n"
4928 "RTSThreshold: %d\n"
4929 "TXMSDULifetime: %d\n"
4930 "RXMSDULifetime: %d\n"
4933 "FragThreshold: %d\n"
4937 (int)ai->config.longRetryLimit,
4938 (int)ai->config.shortRetryLimit,
4939 (int)ai->config.rtsThres,
4940 (int)ai->config.txLifetime,
4941 (int)ai->config.rxLifetime,
4942 ai->config.txDiversity == 1 ? "left" :
4943 ai->config.txDiversity == 2 ? "right" : "both",
4944 ai->config.rxDiversity == 1 ? "left" :
4945 ai->config.rxDiversity == 2 ? "right" : "both",
4946 (int)ai->config.fragThresh,
4947 ai->config.authType == AUTH_ENCRYPT ? "encrypt" :
4948 ai->config.authType == AUTH_SHAREDKEY ? "shared" : "open",
4949 ai->config.modulation == 0 ? "default" :
4950 ai->config.modulation == MOD_CCK ? "cck" :
4951 ai->config.modulation == MOD_MOK ? "mok" : "error",
4952 ai->config.preamble == PREAMBLE_AUTO ? "auto" :
4953 ai->config.preamble == PREAMBLE_LONG ? "long" :
4954 ai->config.preamble == PREAMBLE_SHORT ? "short" : "error"
4956 data->readlen = strlen( data->rbuffer );
4960 static void proc_SSID_on_close( struct inode *inode, struct file *file ) {
4961 struct proc_data *data = (struct proc_data *)file->private_data;
4962 struct proc_dir_entry *dp = PDE(inode);
4963 struct net_device *dev = dp->data;
4964 struct airo_info *ai = dev->priv;
4970 if ( !data->writelen ) return;
4972 memset( &SSID_rid, 0, sizeof( SSID_rid ) );
4974 for( i = 0; i < 3; i++ ) {
4976 for( j = 0; j+offset < data->writelen && j < 32 &&
4977 data->wbuffer[offset+j] != '\n'; j++ ) {
4978 SSID_rid.ssids[i].ssid[j] = data->wbuffer[offset+j];
4980 if ( j == 0 ) break;
4981 SSID_rid.ssids[i].len = j;
4983 while( data->wbuffer[offset] != '\n' &&
4984 offset < data->writelen ) offset++;
4988 SSID_rid.len = sizeof(SSID_rid);
4990 writeSsidRid(ai, &SSID_rid, 1);
4991 enable_MAC(ai, &rsp, 1);
4994 static inline u8 hexVal(char c) {
4995 if (c>='0' && c<='9') return c -= '0';
4996 if (c>='a' && c<='f') return c -= 'a'-10;
4997 if (c>='A' && c<='F') return c -= 'A'-10;
5001 static void proc_APList_on_close( struct inode *inode, struct file *file ) {
5002 struct proc_data *data = (struct proc_data *)file->private_data;
5003 struct proc_dir_entry *dp = PDE(inode);
5004 struct net_device *dev = dp->data;
5005 struct airo_info *ai = dev->priv;
5006 APListRid APList_rid;
5010 if ( !data->writelen ) return;
5012 memset( &APList_rid, 0, sizeof(APList_rid) );
5013 APList_rid.len = sizeof(APList_rid);
5015 for( i = 0; i < 4 && data->writelen >= (i+1)*6*3; i++ ) {
5017 for( j = 0; j < 6*3 && data->wbuffer[j+i*6*3]; j++ ) {
5020 APList_rid.ap[i][j/3]=
5021 hexVal(data->wbuffer[j+i*6*3])<<4;
5024 APList_rid.ap[i][j/3]|=
5025 hexVal(data->wbuffer[j+i*6*3]);
5031 writeAPListRid(ai, &APList_rid, 1);
5032 enable_MAC(ai, &rsp, 1);
5035 /* This function wraps PC4500_writerid with a MAC disable */
5036 static int do_writerid( struct airo_info *ai, u16 rid, const void *rid_data,
5037 int len, int dummy ) {
5042 rc = PC4500_writerid(ai, rid, rid_data, len, 1);
5043 enable_MAC(ai, &rsp, 1);
5047 /* Returns the length of the key at the index. If index == 0xffff
5048 * the index of the transmit key is returned. If the key doesn't exist,
5049 * -1 will be returned.
5051 static int get_wep_key(struct airo_info *ai, u16 index) {
5056 rc = readWepKeyRid(ai, &wkr, 1, 1);
5057 if (rc == SUCCESS) do {
5058 lastindex = wkr.kindex;
5059 if (wkr.kindex == index) {
5060 if (index == 0xffff) {
5065 readWepKeyRid(ai, &wkr, 0, 1);
5066 } while(lastindex != wkr.kindex);
5070 static int set_wep_key(struct airo_info *ai, u16 index,
5071 const char *key, u16 keylen, int perm, int lock ) {
5072 static const unsigned char macaddr[ETH_ALEN] = { 0x01, 0, 0, 0, 0, 0 };
5076 memset(&wkr, 0, sizeof(wkr));
5078 // We are selecting which key to use
5079 wkr.len = sizeof(wkr);
5080 wkr.kindex = 0xffff;
5081 wkr.mac[0] = (char)index;
5082 if (perm) printk(KERN_INFO "Setting transmit key to %d\n", index);
5083 if (perm) ai->defindex = (char)index;
5085 // We are actually setting the key
5086 wkr.len = sizeof(wkr);
5089 memcpy( wkr.key, key, keylen );
5090 memcpy( wkr.mac, macaddr, ETH_ALEN );
5091 printk(KERN_INFO "Setting key %d\n", index);
5094 disable_MAC(ai, lock);
5095 writeWepKeyRid(ai, &wkr, perm, lock);
5096 enable_MAC(ai, &rsp, lock);
5100 static void proc_wepkey_on_close( struct inode *inode, struct file *file ) {
5101 struct proc_data *data;
5102 struct proc_dir_entry *dp = PDE(inode);
5103 struct net_device *dev = dp->data;
5104 struct airo_info *ai = dev->priv;
5110 memset(key, 0, sizeof(key));
5112 data = (struct proc_data *)file->private_data;
5113 if ( !data->writelen ) return;
5115 if (data->wbuffer[0] >= '0' && data->wbuffer[0] <= '3' &&
5116 (data->wbuffer[1] == ' ' || data->wbuffer[1] == '\n')) {
5117 index = data->wbuffer[0] - '0';
5118 if (data->wbuffer[1] == '\n') {
5119 set_wep_key(ai, index, NULL, 0, 1, 1);
5124 printk(KERN_ERR "airo: WepKey passed invalid key index\n");
5128 for( i = 0; i < 16*3 && data->wbuffer[i+j]; i++ ) {
5131 key[i/3] = hexVal(data->wbuffer[i+j])<<4;
5134 key[i/3] |= hexVal(data->wbuffer[i+j]);
5138 set_wep_key(ai, index, key, i/3, 1, 1);
5141 static int proc_wepkey_open( struct inode *inode, struct file *file ) {
5142 struct proc_data *data;
5143 struct proc_dir_entry *dp = PDE(inode);
5144 struct net_device *dev = dp->data;
5145 struct airo_info *ai = dev->priv;
5152 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5154 memset(&wkr, 0, sizeof(wkr));
5155 data = (struct proc_data *)file->private_data;
5156 if ((data->rbuffer = kzalloc( 180, GFP_KERNEL )) == NULL) {
5157 kfree (file->private_data);
5161 data->maxwritelen = 80;
5162 if ((data->wbuffer = kzalloc( 80, GFP_KERNEL )) == NULL) {
5163 kfree (data->rbuffer);
5164 kfree (file->private_data);
5167 data->on_close = proc_wepkey_on_close;
5169 ptr = data->rbuffer;
5170 strcpy(ptr, "No wep keys\n");
5171 rc = readWepKeyRid(ai, &wkr, 1, 1);
5172 if (rc == SUCCESS) do {
5173 lastindex = wkr.kindex;
5174 if (wkr.kindex == 0xffff) {
5175 j += sprintf(ptr+j, "Tx key = %d\n",
5178 j += sprintf(ptr+j, "Key %d set with length = %d\n",
5179 (int)wkr.kindex, (int)wkr.klen);
5181 readWepKeyRid(ai, &wkr, 0, 1);
5182 } while((lastindex != wkr.kindex) && (j < 180-30));
5184 data->readlen = strlen( data->rbuffer );
5188 static int proc_SSID_open( struct inode *inode, struct file *file ) {
5189 struct proc_data *data;
5190 struct proc_dir_entry *dp = PDE(inode);
5191 struct net_device *dev = dp->data;
5192 struct airo_info *ai = dev->priv;
5197 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5199 data = (struct proc_data *)file->private_data;
5200 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5201 kfree (file->private_data);
5205 data->maxwritelen = 33*3;
5206 if ((data->wbuffer = kzalloc( 33*3, GFP_KERNEL )) == NULL) {
5207 kfree (data->rbuffer);
5208 kfree (file->private_data);
5211 data->on_close = proc_SSID_on_close;
5213 readSsidRid(ai, &SSID_rid);
5214 ptr = data->rbuffer;
5215 for( i = 0; i < 3; i++ ) {
5217 if ( !SSID_rid.ssids[i].len ) break;
5218 for( j = 0; j < 32 &&
5219 j < SSID_rid.ssids[i].len &&
5220 SSID_rid.ssids[i].ssid[j]; j++ ) {
5221 *ptr++ = SSID_rid.ssids[i].ssid[j];
5226 data->readlen = strlen( data->rbuffer );
5230 static int proc_APList_open( struct inode *inode, struct file *file ) {
5231 struct proc_data *data;
5232 struct proc_dir_entry *dp = PDE(inode);
5233 struct net_device *dev = dp->data;
5234 struct airo_info *ai = dev->priv;
5237 APListRid APList_rid;
5239 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5241 data = (struct proc_data *)file->private_data;
5242 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5243 kfree (file->private_data);
5247 data->maxwritelen = 4*6*3;
5248 if ((data->wbuffer = kzalloc( data->maxwritelen, GFP_KERNEL )) == NULL) {
5249 kfree (data->rbuffer);
5250 kfree (file->private_data);
5253 data->on_close = proc_APList_on_close;
5255 readAPListRid(ai, &APList_rid);
5256 ptr = data->rbuffer;
5257 for( i = 0; i < 4; i++ ) {
5258 // We end when we find a zero MAC
5259 if ( !*(int*)APList_rid.ap[i] &&
5260 !*(int*)&APList_rid.ap[i][2]) break;
5261 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x\n",
5262 (int)APList_rid.ap[i][0],
5263 (int)APList_rid.ap[i][1],
5264 (int)APList_rid.ap[i][2],
5265 (int)APList_rid.ap[i][3],
5266 (int)APList_rid.ap[i][4],
5267 (int)APList_rid.ap[i][5]);
5269 if (i==0) ptr += sprintf(ptr, "Not using specific APs\n");
5272 data->readlen = strlen( data->rbuffer );
5276 static int proc_BSSList_open( struct inode *inode, struct file *file ) {
5277 struct proc_data *data;
5278 struct proc_dir_entry *dp = PDE(inode);
5279 struct net_device *dev = dp->data;
5280 struct airo_info *ai = dev->priv;
5282 BSSListRid BSSList_rid;
5284 /* If doLoseSync is not 1, we won't do a Lose Sync */
5285 int doLoseSync = -1;
5287 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5289 data = (struct proc_data *)file->private_data;
5290 if ((data->rbuffer = kmalloc( 1024, GFP_KERNEL )) == NULL) {
5291 kfree (file->private_data);
5295 data->maxwritelen = 0;
5296 data->wbuffer = NULL;
5297 data->on_close = NULL;
5299 if (file->f_mode & FMODE_WRITE) {
5300 if (!(file->f_mode & FMODE_READ)) {
5304 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
5305 memset(&cmd, 0, sizeof(cmd));
5306 cmd.cmd=CMD_LISTBSS;
5307 if (down_interruptible(&ai->sem))
5308 return -ERESTARTSYS;
5309 issuecommand(ai, &cmd, &rsp);
5316 ptr = data->rbuffer;
5317 /* There is a race condition here if there are concurrent opens.
5318 Since it is a rare condition, we'll just live with it, otherwise
5319 we have to add a spin lock... */
5320 rc = readBSSListRid(ai, doLoseSync, &BSSList_rid);
5321 while(rc == 0 && BSSList_rid.index != 0xffff) {
5322 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x %*s rssi = %d",
5323 (int)BSSList_rid.bssid[0],
5324 (int)BSSList_rid.bssid[1],
5325 (int)BSSList_rid.bssid[2],
5326 (int)BSSList_rid.bssid[3],
5327 (int)BSSList_rid.bssid[4],
5328 (int)BSSList_rid.bssid[5],
5329 (int)BSSList_rid.ssidLen,
5331 (int)BSSList_rid.dBm);
5332 ptr += sprintf(ptr, " channel = %d %s %s %s %s\n",
5333 (int)BSSList_rid.dsChannel,
5334 BSSList_rid.cap & CAP_ESS ? "ESS" : "",
5335 BSSList_rid.cap & CAP_IBSS ? "adhoc" : "",
5336 BSSList_rid.cap & CAP_PRIVACY ? "wep" : "",
5337 BSSList_rid.cap & CAP_SHORTHDR ? "shorthdr" : "");
5338 rc = readBSSListRid(ai, 0, &BSSList_rid);
5341 data->readlen = strlen( data->rbuffer );
5345 static int proc_close( struct inode *inode, struct file *file )
5347 struct proc_data *data = file->private_data;
5349 if (data->on_close != NULL)
5350 data->on_close(inode, file);
5351 kfree(data->rbuffer);
5352 kfree(data->wbuffer);
5357 static struct net_device_list {
5358 struct net_device *dev;
5359 struct net_device_list *next;
5362 /* Since the card doesn't automatically switch to the right WEP mode,
5363 we will make it do it. If the card isn't associated, every secs we
5364 will switch WEP modes to see if that will help. If the card is
5365 associated we will check every minute to see if anything has
5367 static void timer_func( struct net_device *dev ) {
5368 struct airo_info *apriv = dev->priv;
5371 /* We don't have a link so try changing the authtype */
5372 readConfigRid(apriv, 0);
5373 disable_MAC(apriv, 0);
5374 switch(apriv->config.authType) {
5376 /* So drop to OPEN */
5377 apriv->config.authType = AUTH_OPEN;
5379 case AUTH_SHAREDKEY:
5380 if (apriv->keyindex < auto_wep) {
5381 set_wep_key(apriv, apriv->keyindex, NULL, 0, 0, 0);
5382 apriv->config.authType = AUTH_SHAREDKEY;
5385 /* Drop to ENCRYPT */
5386 apriv->keyindex = 0;
5387 set_wep_key(apriv, apriv->defindex, NULL, 0, 0, 0);
5388 apriv->config.authType = AUTH_ENCRYPT;
5391 default: /* We'll escalate to SHAREDKEY */
5392 apriv->config.authType = AUTH_SHAREDKEY;
5394 set_bit (FLAG_COMMIT, &apriv->flags);
5395 writeConfigRid(apriv, 0);
5396 enable_MAC(apriv, &rsp, 0);
5399 /* Schedule check to see if the change worked */
5400 clear_bit(JOB_AUTOWEP, &apriv->flags);
5401 apriv->expires = RUN_AT(HZ*3);
5404 static int add_airo_dev( struct net_device *dev ) {
5405 struct net_device_list *node = kmalloc( sizeof( *node ), GFP_KERNEL );
5410 node->next = airo_devices;
5411 airo_devices = node;
5416 static void del_airo_dev( struct net_device *dev ) {
5417 struct net_device_list **p = &airo_devices;
5418 while( *p && ( (*p)->dev != dev ) )
5420 if ( *p && (*p)->dev == dev )
5425 static int __devinit airo_pci_probe(struct pci_dev *pdev,
5426 const struct pci_device_id *pent)
5428 struct net_device *dev;
5430 if (pci_enable_device(pdev))
5432 pci_set_master(pdev);
5434 if (pdev->device == 0x5000 || pdev->device == 0xa504)
5435 dev = _init_airo_card(pdev->irq, pdev->resource[0].start, 0, pdev, &pdev->dev);
5437 dev = _init_airo_card(pdev->irq, pdev->resource[2].start, 0, pdev, &pdev->dev);
5441 pci_set_drvdata(pdev, dev);
5445 static void __devexit airo_pci_remove(struct pci_dev *pdev)
5449 static int airo_pci_suspend(struct pci_dev *pdev, pm_message_t state)
5451 struct net_device *dev = pci_get_drvdata(pdev);
5452 struct airo_info *ai = dev->priv;
5456 if ((ai->APList == NULL) &&
5457 (ai->APList = kmalloc(sizeof(APListRid), GFP_KERNEL)) == NULL)
5459 if ((ai->SSID == NULL) &&
5460 (ai->SSID = kmalloc(sizeof(SsidRid), GFP_KERNEL)) == NULL)
5462 readAPListRid(ai, ai->APList);
5463 readSsidRid(ai, ai->SSID);
5464 memset(&cmd, 0, sizeof(cmd));
5465 /* the lock will be released at the end of the resume callback */
5466 if (down_interruptible(&ai->sem))
5469 netif_device_detach(dev);
5472 issuecommand(ai, &cmd, &rsp);
5474 pci_enable_wake(pdev, pci_choose_state(pdev, state), 1);
5475 pci_save_state(pdev);
5476 return pci_set_power_state(pdev, pci_choose_state(pdev, state));
5479 static int airo_pci_resume(struct pci_dev *pdev)
5481 struct net_device *dev = pci_get_drvdata(pdev);
5482 struct airo_info *ai = dev->priv;
5484 pci_power_t prev_state = pdev->current_state;
5486 pci_set_power_state(pdev, PCI_D0);
5487 pci_restore_state(pdev);
5488 pci_enable_wake(pdev, PCI_D0, 0);
5490 if (prev_state != PCI_D1) {
5492 mpi_init_descriptors(ai);
5493 setup_card(ai, dev->dev_addr, 0);
5494 clear_bit(FLAG_RADIO_OFF, &ai->flags);
5495 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
5497 OUT4500(ai, EVACK, EV_AWAKEN);
5498 OUT4500(ai, EVACK, EV_AWAKEN);
5502 set_bit (FLAG_COMMIT, &ai->flags);
5506 writeSsidRid(ai, ai->SSID, 0);
5511 writeAPListRid(ai, ai->APList, 0);
5515 writeConfigRid(ai, 0);
5516 enable_MAC(ai, &rsp, 0);
5517 ai->power = PMSG_ON;
5518 netif_device_attach(dev);
5519 netif_wake_queue(dev);
5520 enable_interrupts(ai);
5526 static int __init airo_init_module( void )
5528 int i, have_isa_dev = 0;
5530 airo_entry = create_proc_entry("aironet",
5531 S_IFDIR | airo_perm,
5533 airo_entry->uid = proc_uid;
5534 airo_entry->gid = proc_gid;
5536 for( i = 0; i < 4 && io[i] && irq[i]; i++ ) {
5538 "airo: Trying to configure ISA adapter at irq=%d io=0x%x\n",
5540 if (init_airo_card( irq[i], io[i], 0, NULL ))
5545 printk( KERN_INFO "airo: Probing for PCI adapters\n" );
5546 pci_register_driver(&airo_driver);
5547 printk( KERN_INFO "airo: Finished probing for PCI adapters\n" );
5550 /* Always exit with success, as we are a library module
5551 * as well as a driver module
5556 static void __exit airo_cleanup_module( void )
5558 while( airo_devices ) {
5559 printk( KERN_INFO "airo: Unregistering %s\n", airo_devices->dev->name );
5560 stop_airo_card( airo_devices->dev, 1 );
5563 pci_unregister_driver(&airo_driver);
5565 remove_proc_entry("aironet", proc_root_driver);
5569 * Initial Wireless Extension code for Aironet driver by :
5570 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 17 November 00
5571 * Conversion to new driver API by :
5572 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 26 March 02
5573 * Javier also did a good amount of work here, adding some new extensions
5574 * and fixing my code. Let's just say that without him this code just
5575 * would not work at all... - Jean II
5578 static u8 airo_rssi_to_dbm (tdsRssiEntry *rssi_rid, u8 rssi)
5583 return (0x100 - rssi_rid[rssi].rssidBm);
5586 static u8 airo_dbm_to_pct (tdsRssiEntry *rssi_rid, u8 dbm)
5593 for( i = 0; i < 256; i++ )
5594 if (rssi_rid[i].rssidBm == dbm)
5595 return rssi_rid[i].rssipct;
5601 static int airo_get_quality (StatusRid *status_rid, CapabilityRid *cap_rid)
5605 if ((status_rid->mode & 0x3f) == 0x3f && (cap_rid->hardCap & 8)) {
5606 if (memcmp(cap_rid->prodName, "350", 3))
5607 if (status_rid->signalQuality > 0x20)
5610 quality = 0x20 - status_rid->signalQuality;
5612 if (status_rid->signalQuality > 0xb0)
5614 else if (status_rid->signalQuality < 0x10)
5617 quality = 0xb0 - status_rid->signalQuality;
5622 #define airo_get_max_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x20 : 0xa0)
5623 #define airo_get_avg_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x10 : 0x50);
5625 /*------------------------------------------------------------------*/
5627 * Wireless Handler : get protocol name
5629 static int airo_get_name(struct net_device *dev,
5630 struct iw_request_info *info,
5634 strcpy(cwrq, "IEEE 802.11-DS");
5638 /*------------------------------------------------------------------*/
5640 * Wireless Handler : set frequency
5642 static int airo_set_freq(struct net_device *dev,
5643 struct iw_request_info *info,
5644 struct iw_freq *fwrq,
5647 struct airo_info *local = dev->priv;
5648 int rc = -EINPROGRESS; /* Call commit handler */
5650 /* If setting by frequency, convert to a channel */
5651 if((fwrq->e == 1) &&
5652 (fwrq->m >= (int) 2.412e8) &&
5653 (fwrq->m <= (int) 2.487e8)) {
5654 int f = fwrq->m / 100000;
5656 while((c < 14) && (f != frequency_list[c]))
5658 /* Hack to fall through... */
5662 /* Setting by channel number */
5663 if((fwrq->m > 1000) || (fwrq->e > 0))
5666 int channel = fwrq->m;
5667 /* We should do a better check than that,
5668 * based on the card capability !!! */
5669 if((channel < 1) || (channel > 16)) {
5670 printk(KERN_DEBUG "%s: New channel value of %d is invalid!\n", dev->name, fwrq->m);
5673 readConfigRid(local, 1);
5674 /* Yes ! We can set it !!! */
5675 local->config.channelSet = (u16)(channel - 1);
5676 set_bit (FLAG_COMMIT, &local->flags);
5682 /*------------------------------------------------------------------*/
5684 * Wireless Handler : get frequency
5686 static int airo_get_freq(struct net_device *dev,
5687 struct iw_request_info *info,
5688 struct iw_freq *fwrq,
5691 struct airo_info *local = dev->priv;
5692 StatusRid status_rid; /* Card status info */
5694 readConfigRid(local, 1);
5695 if ((local->config.opmode & 0xFF) == MODE_STA_ESS)
5696 status_rid.channel = local->config.channelSet;
5698 readStatusRid(local, &status_rid, 1);
5700 #ifdef WEXT_USECHANNELS
5701 fwrq->m = ((int)status_rid.channel) + 1;
5705 int f = (int)status_rid.channel;
5706 fwrq->m = frequency_list[f] * 100000;
5714 /*------------------------------------------------------------------*/
5716 * Wireless Handler : set ESSID
5718 static int airo_set_essid(struct net_device *dev,
5719 struct iw_request_info *info,
5720 struct iw_point *dwrq,
5723 struct airo_info *local = dev->priv;
5725 SsidRid SSID_rid; /* SSIDs */
5727 /* Reload the list of current SSID */
5728 readSsidRid(local, &SSID_rid);
5730 /* Check if we asked for `any' */
5731 if(dwrq->flags == 0) {
5732 /* Just send an empty SSID list */
5733 memset(&SSID_rid, 0, sizeof(SSID_rid));
5735 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
5737 /* Check the size of the string */
5738 if(dwrq->length > IW_ESSID_MAX_SIZE+1) {
5741 /* Check if index is valid */
5742 if((index < 0) || (index >= 4)) {
5747 memset(SSID_rid.ssids[index].ssid, 0,
5748 sizeof(SSID_rid.ssids[index].ssid));
5749 memcpy(SSID_rid.ssids[index].ssid, extra, dwrq->length);
5750 SSID_rid.ssids[index].len = dwrq->length - 1;
5752 SSID_rid.len = sizeof(SSID_rid);
5753 /* Write it to the card */
5754 disable_MAC(local, 1);
5755 writeSsidRid(local, &SSID_rid, 1);
5756 enable_MAC(local, &rsp, 1);
5761 /*------------------------------------------------------------------*/
5763 * Wireless Handler : get ESSID
5765 static int airo_get_essid(struct net_device *dev,
5766 struct iw_request_info *info,
5767 struct iw_point *dwrq,
5770 struct airo_info *local = dev->priv;
5771 StatusRid status_rid; /* Card status info */
5773 readStatusRid(local, &status_rid, 1);
5775 /* Note : if dwrq->flags != 0, we should
5776 * get the relevant SSID from the SSID list... */
5778 /* Get the current SSID */
5779 memcpy(extra, status_rid.SSID, status_rid.SSIDlen);
5780 extra[status_rid.SSIDlen] = '\0';
5781 /* If none, we may want to get the one that was set */
5784 dwrq->length = status_rid.SSIDlen + 1;
5785 dwrq->flags = 1; /* active */
5790 /*------------------------------------------------------------------*/
5792 * Wireless Handler : set AP address
5794 static int airo_set_wap(struct net_device *dev,
5795 struct iw_request_info *info,
5796 struct sockaddr *awrq,
5799 struct airo_info *local = dev->priv;
5802 APListRid APList_rid;
5803 static const unsigned char bcast[ETH_ALEN] = { 255, 255, 255, 255, 255, 255 };
5805 if (awrq->sa_family != ARPHRD_ETHER)
5807 else if (!memcmp(bcast, awrq->sa_data, ETH_ALEN)) {
5808 memset(&cmd, 0, sizeof(cmd));
5809 cmd.cmd=CMD_LOSE_SYNC;
5810 if (down_interruptible(&local->sem))
5811 return -ERESTARTSYS;
5812 issuecommand(local, &cmd, &rsp);
5815 memset(&APList_rid, 0, sizeof(APList_rid));
5816 APList_rid.len = sizeof(APList_rid);
5817 memcpy(APList_rid.ap[0], awrq->sa_data, ETH_ALEN);
5818 disable_MAC(local, 1);
5819 writeAPListRid(local, &APList_rid, 1);
5820 enable_MAC(local, &rsp, 1);
5825 /*------------------------------------------------------------------*/
5827 * Wireless Handler : get AP address
5829 static int airo_get_wap(struct net_device *dev,
5830 struct iw_request_info *info,
5831 struct sockaddr *awrq,
5834 struct airo_info *local = dev->priv;
5835 StatusRid status_rid; /* Card status info */
5837 readStatusRid(local, &status_rid, 1);
5839 /* Tentative. This seems to work, wow, I'm lucky !!! */
5840 memcpy(awrq->sa_data, status_rid.bssid[0], ETH_ALEN);
5841 awrq->sa_family = ARPHRD_ETHER;
5846 /*------------------------------------------------------------------*/
5848 * Wireless Handler : set Nickname
5850 static int airo_set_nick(struct net_device *dev,
5851 struct iw_request_info *info,
5852 struct iw_point *dwrq,
5855 struct airo_info *local = dev->priv;
5857 /* Check the size of the string */
5858 if(dwrq->length > 16 + 1) {
5861 readConfigRid(local, 1);
5862 memset(local->config.nodeName, 0, sizeof(local->config.nodeName));
5863 memcpy(local->config.nodeName, extra, dwrq->length);
5864 set_bit (FLAG_COMMIT, &local->flags);
5866 return -EINPROGRESS; /* Call commit handler */
5869 /*------------------------------------------------------------------*/
5871 * Wireless Handler : get Nickname
5873 static int airo_get_nick(struct net_device *dev,
5874 struct iw_request_info *info,
5875 struct iw_point *dwrq,
5878 struct airo_info *local = dev->priv;
5880 readConfigRid(local, 1);
5881 strncpy(extra, local->config.nodeName, 16);
5883 dwrq->length = strlen(extra) + 1;
5888 /*------------------------------------------------------------------*/
5890 * Wireless Handler : set Bit-Rate
5892 static int airo_set_rate(struct net_device *dev,
5893 struct iw_request_info *info,
5894 struct iw_param *vwrq,
5897 struct airo_info *local = dev->priv;
5898 CapabilityRid cap_rid; /* Card capability info */
5902 /* First : get a valid bit rate value */
5903 readCapabilityRid(local, &cap_rid, 1);
5905 /* Which type of value ? */
5906 if((vwrq->value < 8) && (vwrq->value >= 0)) {
5907 /* Setting by rate index */
5908 /* Find value in the magic rate table */
5909 brate = cap_rid.supportedRates[vwrq->value];
5911 /* Setting by frequency value */
5912 u8 normvalue = (u8) (vwrq->value/500000);
5914 /* Check if rate is valid */
5915 for(i = 0 ; i < 8 ; i++) {
5916 if(normvalue == cap_rid.supportedRates[i]) {
5922 /* -1 designed the max rate (mostly auto mode) */
5923 if(vwrq->value == -1) {
5924 /* Get the highest available rate */
5925 for(i = 0 ; i < 8 ; i++) {
5926 if(cap_rid.supportedRates[i] == 0)
5930 brate = cap_rid.supportedRates[i - 1];
5932 /* Check that it is valid */
5937 readConfigRid(local, 1);
5938 /* Now, check if we want a fixed or auto value */
5939 if(vwrq->fixed == 0) {
5940 /* Fill all the rates up to this max rate */
5941 memset(local->config.rates, 0, 8);
5942 for(i = 0 ; i < 8 ; i++) {
5943 local->config.rates[i] = cap_rid.supportedRates[i];
5944 if(local->config.rates[i] == brate)
5949 /* One rate, fixed */
5950 memset(local->config.rates, 0, 8);
5951 local->config.rates[0] = brate;
5953 set_bit (FLAG_COMMIT, &local->flags);
5955 return -EINPROGRESS; /* Call commit handler */
5958 /*------------------------------------------------------------------*/
5960 * Wireless Handler : get Bit-Rate
5962 static int airo_get_rate(struct net_device *dev,
5963 struct iw_request_info *info,
5964 struct iw_param *vwrq,
5967 struct airo_info *local = dev->priv;
5968 StatusRid status_rid; /* Card status info */
5970 readStatusRid(local, &status_rid, 1);
5972 vwrq->value = status_rid.currentXmitRate * 500000;
5973 /* If more than one rate, set auto */
5974 readConfigRid(local, 1);
5975 vwrq->fixed = (local->config.rates[1] == 0);
5980 /*------------------------------------------------------------------*/
5982 * Wireless Handler : set RTS threshold
5984 static int airo_set_rts(struct net_device *dev,
5985 struct iw_request_info *info,
5986 struct iw_param *vwrq,
5989 struct airo_info *local = dev->priv;
5990 int rthr = vwrq->value;
5994 if((rthr < 0) || (rthr > 2312)) {
5997 readConfigRid(local, 1);
5998 local->config.rtsThres = rthr;
5999 set_bit (FLAG_COMMIT, &local->flags);
6001 return -EINPROGRESS; /* Call commit handler */
6004 /*------------------------------------------------------------------*/
6006 * Wireless Handler : get RTS threshold
6008 static int airo_get_rts(struct net_device *dev,
6009 struct iw_request_info *info,
6010 struct iw_param *vwrq,
6013 struct airo_info *local = dev->priv;
6015 readConfigRid(local, 1);
6016 vwrq->value = local->config.rtsThres;
6017 vwrq->disabled = (vwrq->value >= 2312);
6023 /*------------------------------------------------------------------*/
6025 * Wireless Handler : set Fragmentation threshold
6027 static int airo_set_frag(struct net_device *dev,
6028 struct iw_request_info *info,
6029 struct iw_param *vwrq,
6032 struct airo_info *local = dev->priv;
6033 int fthr = vwrq->value;
6037 if((fthr < 256) || (fthr > 2312)) {
6040 fthr &= ~0x1; /* Get an even value - is it really needed ??? */
6041 readConfigRid(local, 1);
6042 local->config.fragThresh = (u16)fthr;
6043 set_bit (FLAG_COMMIT, &local->flags);
6045 return -EINPROGRESS; /* Call commit handler */
6048 /*------------------------------------------------------------------*/
6050 * Wireless Handler : get Fragmentation threshold
6052 static int airo_get_frag(struct net_device *dev,
6053 struct iw_request_info *info,
6054 struct iw_param *vwrq,
6057 struct airo_info *local = dev->priv;
6059 readConfigRid(local, 1);
6060 vwrq->value = local->config.fragThresh;
6061 vwrq->disabled = (vwrq->value >= 2312);
6067 /*------------------------------------------------------------------*/
6069 * Wireless Handler : set Mode of Operation
6071 static int airo_set_mode(struct net_device *dev,
6072 struct iw_request_info *info,
6076 struct airo_info *local = dev->priv;
6079 readConfigRid(local, 1);
6080 if ((local->config.rmode & 0xff) >= RXMODE_RFMON)
6085 local->config.opmode &= 0xFF00;
6086 local->config.opmode |= MODE_STA_IBSS;
6087 local->config.rmode &= 0xfe00;
6088 local->config.scanMode = SCANMODE_ACTIVE;
6089 clear_bit (FLAG_802_11, &local->flags);
6092 local->config.opmode &= 0xFF00;
6093 local->config.opmode |= MODE_STA_ESS;
6094 local->config.rmode &= 0xfe00;
6095 local->config.scanMode = SCANMODE_ACTIVE;
6096 clear_bit (FLAG_802_11, &local->flags);
6098 case IW_MODE_MASTER:
6099 local->config.opmode &= 0xFF00;
6100 local->config.opmode |= MODE_AP;
6101 local->config.rmode &= 0xfe00;
6102 local->config.scanMode = SCANMODE_ACTIVE;
6103 clear_bit (FLAG_802_11, &local->flags);
6105 case IW_MODE_REPEAT:
6106 local->config.opmode &= 0xFF00;
6107 local->config.opmode |= MODE_AP_RPTR;
6108 local->config.rmode &= 0xfe00;
6109 local->config.scanMode = SCANMODE_ACTIVE;
6110 clear_bit (FLAG_802_11, &local->flags);
6112 case IW_MODE_MONITOR:
6113 local->config.opmode &= 0xFF00;
6114 local->config.opmode |= MODE_STA_ESS;
6115 local->config.rmode &= 0xfe00;
6116 local->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
6117 local->config.scanMode = SCANMODE_PASSIVE;
6118 set_bit (FLAG_802_11, &local->flags);
6124 set_bit (FLAG_RESET, &local->flags);
6125 set_bit (FLAG_COMMIT, &local->flags);
6127 return -EINPROGRESS; /* Call commit handler */
6130 /*------------------------------------------------------------------*/
6132 * Wireless Handler : get Mode of Operation
6134 static int airo_get_mode(struct net_device *dev,
6135 struct iw_request_info *info,
6139 struct airo_info *local = dev->priv;
6141 readConfigRid(local, 1);
6142 /* If not managed, assume it's ad-hoc */
6143 switch (local->config.opmode & 0xFF) {
6145 *uwrq = IW_MODE_INFRA;
6148 *uwrq = IW_MODE_MASTER;
6151 *uwrq = IW_MODE_REPEAT;
6154 *uwrq = IW_MODE_ADHOC;
6160 /*------------------------------------------------------------------*/
6162 * Wireless Handler : set Encryption Key
6164 static int airo_set_encode(struct net_device *dev,
6165 struct iw_request_info *info,
6166 struct iw_point *dwrq,
6169 struct airo_info *local = dev->priv;
6170 CapabilityRid cap_rid; /* Card capability info */
6172 /* Is WEP supported ? */
6173 readCapabilityRid(local, &cap_rid, 1);
6174 /* Older firmware doesn't support this...
6175 if(!(cap_rid.softCap & 2)) {
6178 readConfigRid(local, 1);
6180 /* Basic checking: do we have a key to set ?
6181 * Note : with the new API, it's impossible to get a NULL pointer.
6182 * Therefore, we need to check a key size == 0 instead.
6183 * New version of iwconfig properly set the IW_ENCODE_NOKEY flag
6184 * when no key is present (only change flags), but older versions
6185 * don't do it. - Jean II */
6186 if (dwrq->length > 0) {
6188 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6189 int current_index = get_wep_key(local, 0xffff);
6190 /* Check the size of the key */
6191 if (dwrq->length > MAX_KEY_SIZE) {
6194 /* Check the index (none -> use current) */
6195 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4:1)))
6196 index = current_index;
6197 /* Set the length */
6198 if (dwrq->length > MIN_KEY_SIZE)
6199 key.len = MAX_KEY_SIZE;
6201 if (dwrq->length > 0)
6202 key.len = MIN_KEY_SIZE;
6204 /* Disable the key */
6206 /* Check if the key is not marked as invalid */
6207 if(!(dwrq->flags & IW_ENCODE_NOKEY)) {
6209 memset(key.key, 0, MAX_KEY_SIZE);
6210 /* Copy the key in the driver */
6211 memcpy(key.key, extra, dwrq->length);
6212 /* Send the key to the card */
6213 set_wep_key(local, index, key.key, key.len, 1, 1);
6215 /* WE specify that if a valid key is set, encryption
6216 * should be enabled (user may turn it off later)
6217 * This is also how "iwconfig ethX key on" works */
6218 if((index == current_index) && (key.len > 0) &&
6219 (local->config.authType == AUTH_OPEN)) {
6220 local->config.authType = AUTH_ENCRYPT;
6221 set_bit (FLAG_COMMIT, &local->flags);
6224 /* Do we want to just set the transmit key index ? */
6225 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6226 if ((index >= 0) && (index < ((cap_rid.softCap & 0x80)?4:1))) {
6227 set_wep_key(local, index, NULL, 0, 1, 1);
6229 /* Don't complain if only change the mode */
6230 if(!dwrq->flags & IW_ENCODE_MODE) {
6234 /* Read the flags */
6235 if(dwrq->flags & IW_ENCODE_DISABLED)
6236 local->config.authType = AUTH_OPEN; // disable encryption
6237 if(dwrq->flags & IW_ENCODE_RESTRICTED)
6238 local->config.authType = AUTH_SHAREDKEY; // Only Both
6239 if(dwrq->flags & IW_ENCODE_OPEN)
6240 local->config.authType = AUTH_ENCRYPT; // Only Wep
6241 /* Commit the changes to flags if needed */
6242 if(dwrq->flags & IW_ENCODE_MODE)
6243 set_bit (FLAG_COMMIT, &local->flags);
6244 return -EINPROGRESS; /* Call commit handler */
6247 /*------------------------------------------------------------------*/
6249 * Wireless Handler : get Encryption Key
6251 static int airo_get_encode(struct net_device *dev,
6252 struct iw_request_info *info,
6253 struct iw_point *dwrq,
6256 struct airo_info *local = dev->priv;
6257 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6258 CapabilityRid cap_rid; /* Card capability info */
6260 /* Is it supported ? */
6261 readCapabilityRid(local, &cap_rid, 1);
6262 if(!(cap_rid.softCap & 2)) {
6265 readConfigRid(local, 1);
6266 /* Check encryption mode */
6267 switch(local->config.authType) {
6269 dwrq->flags = IW_ENCODE_OPEN;
6271 case AUTH_SHAREDKEY:
6272 dwrq->flags = IW_ENCODE_RESTRICTED;
6276 dwrq->flags = IW_ENCODE_DISABLED;
6279 /* We can't return the key, so set the proper flag and return zero */
6280 dwrq->flags |= IW_ENCODE_NOKEY;
6281 memset(extra, 0, 16);
6283 /* Which key do we want ? -1 -> tx index */
6284 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4 : 1)))
6285 index = get_wep_key(local, 0xffff);
6286 dwrq->flags |= index + 1;
6287 /* Copy the key to the user buffer */
6288 dwrq->length = get_wep_key(local, index);
6289 if (dwrq->length > 16) {
6295 /*------------------------------------------------------------------*/
6297 * Wireless Handler : set Tx-Power
6299 static int airo_set_txpow(struct net_device *dev,
6300 struct iw_request_info *info,
6301 struct iw_param *vwrq,
6304 struct airo_info *local = dev->priv;
6305 CapabilityRid cap_rid; /* Card capability info */
6309 readCapabilityRid(local, &cap_rid, 1);
6311 if (vwrq->disabled) {
6312 set_bit (FLAG_RADIO_OFF, &local->flags);
6313 set_bit (FLAG_COMMIT, &local->flags);
6314 return -EINPROGRESS; /* Call commit handler */
6316 if (vwrq->flags != IW_TXPOW_MWATT) {
6319 clear_bit (FLAG_RADIO_OFF, &local->flags);
6320 for (i = 0; cap_rid.txPowerLevels[i] && (i < 8); i++)
6321 if ((vwrq->value==cap_rid.txPowerLevels[i])) {
6322 readConfigRid(local, 1);
6323 local->config.txPower = vwrq->value;
6324 set_bit (FLAG_COMMIT, &local->flags);
6325 rc = -EINPROGRESS; /* Call commit handler */
6331 /*------------------------------------------------------------------*/
6333 * Wireless Handler : get Tx-Power
6335 static int airo_get_txpow(struct net_device *dev,
6336 struct iw_request_info *info,
6337 struct iw_param *vwrq,
6340 struct airo_info *local = dev->priv;
6342 readConfigRid(local, 1);
6343 vwrq->value = local->config.txPower;
6344 vwrq->fixed = 1; /* No power control */
6345 vwrq->disabled = test_bit(FLAG_RADIO_OFF, &local->flags);
6346 vwrq->flags = IW_TXPOW_MWATT;
6351 /*------------------------------------------------------------------*/
6353 * Wireless Handler : set Retry limits
6355 static int airo_set_retry(struct net_device *dev,
6356 struct iw_request_info *info,
6357 struct iw_param *vwrq,
6360 struct airo_info *local = dev->priv;
6363 if(vwrq->disabled) {
6366 readConfigRid(local, 1);
6367 if(vwrq->flags & IW_RETRY_LIMIT) {
6368 if(vwrq->flags & IW_RETRY_MAX)
6369 local->config.longRetryLimit = vwrq->value;
6370 else if (vwrq->flags & IW_RETRY_MIN)
6371 local->config.shortRetryLimit = vwrq->value;
6373 /* No modifier : set both */
6374 local->config.longRetryLimit = vwrq->value;
6375 local->config.shortRetryLimit = vwrq->value;
6377 set_bit (FLAG_COMMIT, &local->flags);
6378 rc = -EINPROGRESS; /* Call commit handler */
6380 if(vwrq->flags & IW_RETRY_LIFETIME) {
6381 local->config.txLifetime = vwrq->value / 1024;
6382 set_bit (FLAG_COMMIT, &local->flags);
6383 rc = -EINPROGRESS; /* Call commit handler */
6388 /*------------------------------------------------------------------*/
6390 * Wireless Handler : get Retry limits
6392 static int airo_get_retry(struct net_device *dev,
6393 struct iw_request_info *info,
6394 struct iw_param *vwrq,
6397 struct airo_info *local = dev->priv;
6399 vwrq->disabled = 0; /* Can't be disabled */
6401 readConfigRid(local, 1);
6402 /* Note : by default, display the min retry number */
6403 if((vwrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
6404 vwrq->flags = IW_RETRY_LIFETIME;
6405 vwrq->value = (int)local->config.txLifetime * 1024;
6406 } else if((vwrq->flags & IW_RETRY_MAX)) {
6407 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
6408 vwrq->value = (int)local->config.longRetryLimit;
6410 vwrq->flags = IW_RETRY_LIMIT;
6411 vwrq->value = (int)local->config.shortRetryLimit;
6412 if((int)local->config.shortRetryLimit != (int)local->config.longRetryLimit)
6413 vwrq->flags |= IW_RETRY_MIN;
6419 /*------------------------------------------------------------------*/
6421 * Wireless Handler : get range info
6423 static int airo_get_range(struct net_device *dev,
6424 struct iw_request_info *info,
6425 struct iw_point *dwrq,
6428 struct airo_info *local = dev->priv;
6429 struct iw_range *range = (struct iw_range *) extra;
6430 CapabilityRid cap_rid; /* Card capability info */
6434 readCapabilityRid(local, &cap_rid, 1);
6436 dwrq->length = sizeof(struct iw_range);
6437 memset(range, 0, sizeof(*range));
6438 range->min_nwid = 0x0000;
6439 range->max_nwid = 0x0000;
6440 range->num_channels = 14;
6441 /* Should be based on cap_rid.country to give only
6442 * what the current card support */
6444 for(i = 0; i < 14; i++) {
6445 range->freq[k].i = i + 1; /* List index */
6446 range->freq[k].m = frequency_list[i] * 100000;
6447 range->freq[k++].e = 1; /* Values in table in MHz -> * 10^5 * 10 */
6449 range->num_frequency = k;
6451 range->sensitivity = 65535;
6453 /* Hum... Should put the right values there */
6455 range->max_qual.qual = 100; /* % */
6457 range->max_qual.qual = airo_get_max_quality(&cap_rid);
6458 range->max_qual.level = 0x100 - 120; /* -120 dBm */
6459 range->max_qual.noise = 0x100 - 120; /* -120 dBm */
6461 /* Experimental measurements - boundary 11/5.5 Mb/s */
6462 /* Note : with or without the (local->rssi), results
6463 * are somewhat different. - Jean II */
6465 range->avg_qual.qual = 50; /* % */
6466 range->avg_qual.level = 0x100 - 70; /* -70 dBm */
6468 range->avg_qual.qual = airo_get_avg_quality(&cap_rid);
6469 range->avg_qual.level = 0x100 - 80; /* -80 dBm */
6471 range->avg_qual.noise = 0x100 - 85; /* -85 dBm */
6473 for(i = 0 ; i < 8 ; i++) {
6474 range->bitrate[i] = cap_rid.supportedRates[i] * 500000;
6475 if(range->bitrate[i] == 0)
6478 range->num_bitrates = i;
6480 /* Set an indication of the max TCP throughput
6481 * in bit/s that we can expect using this interface.
6482 * May be use for QoS stuff... Jean II */
6484 range->throughput = 5000 * 1000;
6486 range->throughput = 1500 * 1000;
6489 range->max_rts = 2312;
6490 range->min_frag = 256;
6491 range->max_frag = 2312;
6493 if(cap_rid.softCap & 2) {
6495 range->encoding_size[0] = 5;
6497 if (cap_rid.softCap & 0x100) {
6498 range->encoding_size[1] = 13;
6499 range->num_encoding_sizes = 2;
6501 range->num_encoding_sizes = 1;
6502 range->max_encoding_tokens = (cap_rid.softCap & 0x80) ? 4 : 1;
6504 range->num_encoding_sizes = 0;
6505 range->max_encoding_tokens = 0;
6508 range->max_pmp = 5000000; /* 5 secs */
6510 range->max_pmt = 65535 * 1024; /* ??? */
6511 range->pmp_flags = IW_POWER_PERIOD;
6512 range->pmt_flags = IW_POWER_TIMEOUT;
6513 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
6515 /* Transmit Power - values are in mW */
6516 for(i = 0 ; i < 8 ; i++) {
6517 range->txpower[i] = cap_rid.txPowerLevels[i];
6518 if(range->txpower[i] == 0)
6521 range->num_txpower = i;
6522 range->txpower_capa = IW_TXPOW_MWATT;
6523 range->we_version_source = 12;
6524 range->we_version_compiled = WIRELESS_EXT;
6525 range->retry_capa = IW_RETRY_LIMIT | IW_RETRY_LIFETIME;
6526 range->retry_flags = IW_RETRY_LIMIT;
6527 range->r_time_flags = IW_RETRY_LIFETIME;
6528 range->min_retry = 1;
6529 range->max_retry = 65535;
6530 range->min_r_time = 1024;
6531 range->max_r_time = 65535 * 1024;
6533 /* Event capability (kernel + driver) */
6534 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
6535 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
6536 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
6537 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
6538 range->event_capa[1] = IW_EVENT_CAPA_K_1;
6539 range->event_capa[4] = IW_EVENT_CAPA_MASK(IWEVTXDROP);
6543 /*------------------------------------------------------------------*/
6545 * Wireless Handler : set Power Management
6547 static int airo_set_power(struct net_device *dev,
6548 struct iw_request_info *info,
6549 struct iw_param *vwrq,
6552 struct airo_info *local = dev->priv;
6554 readConfigRid(local, 1);
6555 if (vwrq->disabled) {
6556 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6559 local->config.powerSaveMode = POWERSAVE_CAM;
6560 local->config.rmode &= 0xFF00;
6561 local->config.rmode |= RXMODE_BC_MC_ADDR;
6562 set_bit (FLAG_COMMIT, &local->flags);
6563 return -EINPROGRESS; /* Call commit handler */
6565 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
6566 local->config.fastListenDelay = (vwrq->value + 500) / 1024;
6567 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6568 set_bit (FLAG_COMMIT, &local->flags);
6569 } else if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
6570 local->config.fastListenInterval = local->config.listenInterval = (vwrq->value + 500) / 1024;
6571 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6572 set_bit (FLAG_COMMIT, &local->flags);
6574 switch (vwrq->flags & IW_POWER_MODE) {
6575 case IW_POWER_UNICAST_R:
6576 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6579 local->config.rmode &= 0xFF00;
6580 local->config.rmode |= RXMODE_ADDR;
6581 set_bit (FLAG_COMMIT, &local->flags);
6583 case IW_POWER_ALL_R:
6584 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6587 local->config.rmode &= 0xFF00;
6588 local->config.rmode |= RXMODE_BC_MC_ADDR;
6589 set_bit (FLAG_COMMIT, &local->flags);
6595 // Note : we may want to factor local->need_commit here
6596 // Note2 : may also want to factor RXMODE_RFMON test
6597 return -EINPROGRESS; /* Call commit handler */
6600 /*------------------------------------------------------------------*/
6602 * Wireless Handler : get Power Management
6604 static int airo_get_power(struct net_device *dev,
6605 struct iw_request_info *info,
6606 struct iw_param *vwrq,
6609 struct airo_info *local = dev->priv;
6612 readConfigRid(local, 1);
6613 mode = local->config.powerSaveMode;
6614 if ((vwrq->disabled = (mode == POWERSAVE_CAM)))
6616 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
6617 vwrq->value = (int)local->config.fastListenDelay * 1024;
6618 vwrq->flags = IW_POWER_TIMEOUT;
6620 vwrq->value = (int)local->config.fastListenInterval * 1024;
6621 vwrq->flags = IW_POWER_PERIOD;
6623 if ((local->config.rmode & 0xFF) == RXMODE_ADDR)
6624 vwrq->flags |= IW_POWER_UNICAST_R;
6626 vwrq->flags |= IW_POWER_ALL_R;
6631 /*------------------------------------------------------------------*/
6633 * Wireless Handler : set Sensitivity
6635 static int airo_set_sens(struct net_device *dev,
6636 struct iw_request_info *info,
6637 struct iw_param *vwrq,
6640 struct airo_info *local = dev->priv;
6642 readConfigRid(local, 1);
6643 local->config.rssiThreshold = vwrq->disabled ? RSSI_DEFAULT : vwrq->value;
6644 set_bit (FLAG_COMMIT, &local->flags);
6646 return -EINPROGRESS; /* Call commit handler */
6649 /*------------------------------------------------------------------*/
6651 * Wireless Handler : get Sensitivity
6653 static int airo_get_sens(struct net_device *dev,
6654 struct iw_request_info *info,
6655 struct iw_param *vwrq,
6658 struct airo_info *local = dev->priv;
6660 readConfigRid(local, 1);
6661 vwrq->value = local->config.rssiThreshold;
6662 vwrq->disabled = (vwrq->value == 0);
6668 /*------------------------------------------------------------------*/
6670 * Wireless Handler : get AP List
6671 * Note : this is deprecated in favor of IWSCAN
6673 static int airo_get_aplist(struct net_device *dev,
6674 struct iw_request_info *info,
6675 struct iw_point *dwrq,
6678 struct airo_info *local = dev->priv;
6679 struct sockaddr *address = (struct sockaddr *) extra;
6680 struct iw_quality qual[IW_MAX_AP];
6683 int loseSync = capable(CAP_NET_ADMIN) ? 1: -1;
6685 for (i = 0; i < IW_MAX_AP; i++) {
6686 if (readBSSListRid(local, loseSync, &BSSList))
6689 memcpy(address[i].sa_data, BSSList.bssid, ETH_ALEN);
6690 address[i].sa_family = ARPHRD_ETHER;
6692 qual[i].level = 0x100 - BSSList.dBm;
6693 qual[i].qual = airo_dbm_to_pct( local->rssi, BSSList.dBm );
6694 qual[i].updated = IW_QUAL_QUAL_UPDATED
6695 | IW_QUAL_LEVEL_UPDATED
6698 qual[i].level = (BSSList.dBm + 321) / 2;
6700 qual[i].updated = IW_QUAL_QUAL_INVALID
6701 | IW_QUAL_LEVEL_UPDATED
6704 qual[i].noise = local->wstats.qual.noise;
6705 if (BSSList.index == 0xffff)
6709 StatusRid status_rid; /* Card status info */
6710 readStatusRid(local, &status_rid, 1);
6712 i < min(IW_MAX_AP, 4) &&
6713 (status_rid.bssid[i][0]
6714 & status_rid.bssid[i][1]
6715 & status_rid.bssid[i][2]
6716 & status_rid.bssid[i][3]
6717 & status_rid.bssid[i][4]
6718 & status_rid.bssid[i][5])!=0xff &&
6719 (status_rid.bssid[i][0]
6720 | status_rid.bssid[i][1]
6721 | status_rid.bssid[i][2]
6722 | status_rid.bssid[i][3]
6723 | status_rid.bssid[i][4]
6724 | status_rid.bssid[i][5]);
6726 memcpy(address[i].sa_data,
6727 status_rid.bssid[i], ETH_ALEN);
6728 address[i].sa_family = ARPHRD_ETHER;
6731 dwrq->flags = 1; /* Should be define'd */
6732 memcpy(extra + sizeof(struct sockaddr)*i,
6733 &qual, sizeof(struct iw_quality)*i);
6740 /*------------------------------------------------------------------*/
6742 * Wireless Handler : Initiate Scan
6744 static int airo_set_scan(struct net_device *dev,
6745 struct iw_request_info *info,
6746 struct iw_param *vwrq,
6749 struct airo_info *ai = dev->priv;
6753 /* Note : you may have realised that, as this is a SET operation,
6754 * this is privileged and therefore a normal user can't
6756 * This is not an error, while the device perform scanning,
6757 * traffic doesn't flow, so it's a perfect DoS...
6759 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
6761 /* Initiate a scan command */
6762 memset(&cmd, 0, sizeof(cmd));
6763 cmd.cmd=CMD_LISTBSS;
6764 if (down_interruptible(&ai->sem))
6765 return -ERESTARTSYS;
6766 issuecommand(ai, &cmd, &rsp);
6767 ai->scan_timestamp = jiffies;
6770 /* At this point, just return to the user. */
6775 /*------------------------------------------------------------------*/
6777 * Translate scan data returned from the card to a card independent
6778 * format that the Wireless Tools will understand - Jean II
6780 static inline char *airo_translate_scan(struct net_device *dev,
6785 struct airo_info *ai = dev->priv;
6786 struct iw_event iwe; /* Temporary buffer */
6788 char * current_val; /* For rates */
6791 /* First entry *MUST* be the AP MAC address */
6792 iwe.cmd = SIOCGIWAP;
6793 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
6794 memcpy(iwe.u.ap_addr.sa_data, bss->bssid, ETH_ALEN);
6795 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_ADDR_LEN);
6797 /* Other entries will be displayed in the order we give them */
6800 iwe.u.data.length = bss->ssidLen;
6801 if(iwe.u.data.length > 32)
6802 iwe.u.data.length = 32;
6803 iwe.cmd = SIOCGIWESSID;
6804 iwe.u.data.flags = 1;
6805 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, bss->ssid);
6808 iwe.cmd = SIOCGIWMODE;
6809 capabilities = le16_to_cpu(bss->cap);
6810 if(capabilities & (CAP_ESS | CAP_IBSS)) {
6811 if(capabilities & CAP_ESS)
6812 iwe.u.mode = IW_MODE_MASTER;
6814 iwe.u.mode = IW_MODE_ADHOC;
6815 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_UINT_LEN);
6819 iwe.cmd = SIOCGIWFREQ;
6820 iwe.u.freq.m = le16_to_cpu(bss->dsChannel);
6821 /* iwe.u.freq.m containt the channel (starting 1), our
6822 * frequency_list array start at index 0...
6824 iwe.u.freq.m = frequency_list[iwe.u.freq.m - 1] * 100000;
6826 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_FREQ_LEN);
6828 /* Add quality statistics */
6831 iwe.u.qual.level = 0x100 - bss->dBm;
6832 iwe.u.qual.qual = airo_dbm_to_pct( ai->rssi, bss->dBm );
6833 iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED
6834 | IW_QUAL_LEVEL_UPDATED
6837 iwe.u.qual.level = (bss->dBm + 321) / 2;
6838 iwe.u.qual.qual = 0;
6839 iwe.u.qual.updated = IW_QUAL_QUAL_INVALID
6840 | IW_QUAL_LEVEL_UPDATED
6843 iwe.u.qual.noise = ai->wstats.qual.noise;
6844 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
6846 /* Add encryption capability */
6847 iwe.cmd = SIOCGIWENCODE;
6848 if(capabilities & CAP_PRIVACY)
6849 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
6851 iwe.u.data.flags = IW_ENCODE_DISABLED;
6852 iwe.u.data.length = 0;
6853 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, bss->ssid);
6855 /* Rate : stuffing multiple values in a single event require a bit
6856 * more of magic - Jean II */
6857 current_val = current_ev + IW_EV_LCP_LEN;
6859 iwe.cmd = SIOCGIWRATE;
6860 /* Those two flags are ignored... */
6861 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
6863 for(i = 0 ; i < 8 ; i++) {
6864 /* NULL terminated */
6865 if(bss->rates[i] == 0)
6867 /* Bit rate given in 500 kb/s units (+ 0x80) */
6868 iwe.u.bitrate.value = ((bss->rates[i] & 0x7f) * 500000);
6869 /* Add new value to event */
6870 current_val = iwe_stream_add_value(current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
6872 /* Check if we added any event */
6873 if((current_val - current_ev) > IW_EV_LCP_LEN)
6874 current_ev = current_val;
6876 /* The other data in the scan result are not really
6877 * interesting, so for now drop it - Jean II */
6881 /*------------------------------------------------------------------*/
6883 * Wireless Handler : Read Scan Results
6885 static int airo_get_scan(struct net_device *dev,
6886 struct iw_request_info *info,
6887 struct iw_point *dwrq,
6890 struct airo_info *ai = dev->priv;
6893 char *current_ev = extra;
6895 /* When we are associated again, the scan has surely finished.
6896 * Just in case, let's make sure enough time has elapsed since
6897 * we started the scan. - Javier */
6898 if(ai->scan_timestamp && time_before(jiffies,ai->scan_timestamp+3*HZ)) {
6899 /* Important note : we don't want to block the caller
6900 * until results are ready for various reasons.
6901 * First, managing wait queues is complex and racy
6902 * (there may be multiple simultaneous callers).
6903 * Second, we grab some rtnetlink lock before comming
6904 * here (in dev_ioctl()).
6905 * Third, the caller can wait on the Wireless Event
6909 ai->scan_timestamp = 0;
6911 /* There's only a race with proc_BSSList_open(), but its
6912 * consequences are begnign. So I don't bother fixing it - Javier */
6914 /* Try to read the first entry of the scan result */
6915 rc = PC4500_readrid(ai, RID_BSSLISTFIRST, &BSSList, sizeof(BSSList), 1);
6916 if((rc) || (BSSList.index == 0xffff)) {
6917 /* Client error, no scan results...
6918 * The caller need to restart the scan. */
6922 /* Read and parse all entries */
6923 while((!rc) && (BSSList.index != 0xffff)) {
6924 /* Translate to WE format this entry */
6925 current_ev = airo_translate_scan(dev, current_ev,
6926 extra + dwrq->length,
6929 /* Check if there is space for one more entry */
6930 if((extra + dwrq->length - current_ev) <= IW_EV_ADDR_LEN) {
6931 /* Ask user space to try again with a bigger buffer */
6935 /* Read next entry */
6936 rc = PC4500_readrid(ai, RID_BSSLISTNEXT,
6937 &BSSList, sizeof(BSSList), 1);
6939 /* Length of data */
6940 dwrq->length = (current_ev - extra);
6941 dwrq->flags = 0; /* todo */
6946 /*------------------------------------------------------------------*/
6948 * Commit handler : called after a bunch of SET operations
6950 static int airo_config_commit(struct net_device *dev,
6951 struct iw_request_info *info, /* NULL */
6952 void *zwrq, /* NULL */
6953 char *extra) /* NULL */
6955 struct airo_info *local = dev->priv;
6958 if (!test_bit (FLAG_COMMIT, &local->flags))
6961 /* Some of the "SET" function may have modified some of the
6962 * parameters. It's now time to commit them in the card */
6963 disable_MAC(local, 1);
6964 if (test_bit (FLAG_RESET, &local->flags)) {
6965 APListRid APList_rid;
6968 readAPListRid(local, &APList_rid);
6969 readSsidRid(local, &SSID_rid);
6970 if (test_bit(FLAG_MPI,&local->flags))
6971 setup_card(local, dev->dev_addr, 1 );
6973 reset_airo_card(dev);
6974 disable_MAC(local, 1);
6975 writeSsidRid(local, &SSID_rid, 1);
6976 writeAPListRid(local, &APList_rid, 1);
6978 if (down_interruptible(&local->sem))
6979 return -ERESTARTSYS;
6980 writeConfigRid(local, 0);
6981 enable_MAC(local, &rsp, 0);
6982 if (test_bit (FLAG_RESET, &local->flags))
6983 airo_set_promisc(local);
6990 /*------------------------------------------------------------------*/
6992 * Structures to export the Wireless Handlers
6995 static const struct iw_priv_args airo_private_args[] = {
6996 /*{ cmd, set_args, get_args, name } */
6997 { AIROIOCTL, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
6998 IW_PRIV_TYPE_BYTE | 2047, "airoioctl" },
6999 { AIROIDIFC, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
7000 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "airoidifc" },
7003 static const iw_handler airo_handler[] =
7005 (iw_handler) airo_config_commit, /* SIOCSIWCOMMIT */
7006 (iw_handler) airo_get_name, /* SIOCGIWNAME */
7007 (iw_handler) NULL, /* SIOCSIWNWID */
7008 (iw_handler) NULL, /* SIOCGIWNWID */
7009 (iw_handler) airo_set_freq, /* SIOCSIWFREQ */
7010 (iw_handler) airo_get_freq, /* SIOCGIWFREQ */
7011 (iw_handler) airo_set_mode, /* SIOCSIWMODE */
7012 (iw_handler) airo_get_mode, /* SIOCGIWMODE */
7013 (iw_handler) airo_set_sens, /* SIOCSIWSENS */
7014 (iw_handler) airo_get_sens, /* SIOCGIWSENS */
7015 (iw_handler) NULL, /* SIOCSIWRANGE */
7016 (iw_handler) airo_get_range, /* SIOCGIWRANGE */
7017 (iw_handler) NULL, /* SIOCSIWPRIV */
7018 (iw_handler) NULL, /* SIOCGIWPRIV */
7019 (iw_handler) NULL, /* SIOCSIWSTATS */
7020 (iw_handler) NULL, /* SIOCGIWSTATS */
7021 iw_handler_set_spy, /* SIOCSIWSPY */
7022 iw_handler_get_spy, /* SIOCGIWSPY */
7023 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
7024 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
7025 (iw_handler) airo_set_wap, /* SIOCSIWAP */
7026 (iw_handler) airo_get_wap, /* SIOCGIWAP */
7027 (iw_handler) NULL, /* -- hole -- */
7028 (iw_handler) airo_get_aplist, /* SIOCGIWAPLIST */
7029 (iw_handler) airo_set_scan, /* SIOCSIWSCAN */
7030 (iw_handler) airo_get_scan, /* SIOCGIWSCAN */
7031 (iw_handler) airo_set_essid, /* SIOCSIWESSID */
7032 (iw_handler) airo_get_essid, /* SIOCGIWESSID */
7033 (iw_handler) airo_set_nick, /* SIOCSIWNICKN */
7034 (iw_handler) airo_get_nick, /* SIOCGIWNICKN */
7035 (iw_handler) NULL, /* -- hole -- */
7036 (iw_handler) NULL, /* -- hole -- */
7037 (iw_handler) airo_set_rate, /* SIOCSIWRATE */
7038 (iw_handler) airo_get_rate, /* SIOCGIWRATE */
7039 (iw_handler) airo_set_rts, /* SIOCSIWRTS */
7040 (iw_handler) airo_get_rts, /* SIOCGIWRTS */
7041 (iw_handler) airo_set_frag, /* SIOCSIWFRAG */
7042 (iw_handler) airo_get_frag, /* SIOCGIWFRAG */
7043 (iw_handler) airo_set_txpow, /* SIOCSIWTXPOW */
7044 (iw_handler) airo_get_txpow, /* SIOCGIWTXPOW */
7045 (iw_handler) airo_set_retry, /* SIOCSIWRETRY */
7046 (iw_handler) airo_get_retry, /* SIOCGIWRETRY */
7047 (iw_handler) airo_set_encode, /* SIOCSIWENCODE */
7048 (iw_handler) airo_get_encode, /* SIOCGIWENCODE */
7049 (iw_handler) airo_set_power, /* SIOCSIWPOWER */
7050 (iw_handler) airo_get_power, /* SIOCGIWPOWER */
7053 /* Note : don't describe AIROIDIFC and AIROOLDIDIFC in here.
7054 * We want to force the use of the ioctl code, because those can't be
7055 * won't work the iw_handler code (because they simultaneously read
7056 * and write data and iw_handler can't do that).
7057 * Note that it's perfectly legal to read/write on a single ioctl command,
7058 * you just can't use iwpriv and need to force it via the ioctl handler.
7060 static const iw_handler airo_private_handler[] =
7062 NULL, /* SIOCIWFIRSTPRIV */
7065 static const struct iw_handler_def airo_handler_def =
7067 .num_standard = sizeof(airo_handler)/sizeof(iw_handler),
7068 .num_private = sizeof(airo_private_handler)/sizeof(iw_handler),
7069 .num_private_args = sizeof(airo_private_args)/sizeof(struct iw_priv_args),
7070 .standard = airo_handler,
7071 .private = airo_private_handler,
7072 .private_args = airo_private_args,
7073 .get_wireless_stats = airo_get_wireless_stats,
7077 * This defines the configuration part of the Wireless Extensions
7078 * Note : irq and spinlock protection will occur in the subroutines
7081 * o Check input value more carefully and fill correct values in range
7082 * o Test and shakeout the bugs (if any)
7086 * Javier Achirica did a great job of merging code from the unnamed CISCO
7087 * developer that added support for flashing the card.
7089 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
7092 struct airo_info *ai = (struct airo_info *)dev->priv;
7094 if (ai->power.event)
7104 int val = AIROMAGIC;
7106 if (copy_from_user(&com,rq->ifr_data,sizeof(com)))
7108 else if (copy_to_user(com.data,(char *)&val,sizeof(val)))
7117 /* Get the command struct and hand it off for evaluation by
7118 * the proper subfunction
7122 if (copy_from_user(&com,rq->ifr_data,sizeof(com))) {
7127 /* Separate R/W functions bracket legality here
7129 if ( com.command == AIRORSWVERSION ) {
7130 if (copy_to_user(com.data, swversion, sizeof(swversion)))
7135 else if ( com.command <= AIRORRID)
7136 rc = readrids(dev,&com);
7137 else if ( com.command >= AIROPCAP && com.command <= (AIROPLEAPUSR+2) )
7138 rc = writerids(dev,&com);
7139 else if ( com.command >= AIROFLSHRST && com.command <= AIRORESTART )
7140 rc = flashcard(dev,&com);
7142 rc = -EINVAL; /* Bad command in ioctl */
7145 #endif /* CISCO_EXT */
7147 // All other calls are currently unsupported
7155 * Get the Wireless stats out of the driver
7156 * Note : irq and spinlock protection will occur in the subroutines
7159 * o Check if work in Ad-Hoc mode (otherwise, use SPY, as in wvlan_cs)
7163 static void airo_read_wireless_stats(struct airo_info *local)
7165 StatusRid status_rid;
7167 CapabilityRid cap_rid;
7168 u32 *vals = stats_rid.vals;
7170 /* Get stats out of the card */
7171 clear_bit(JOB_WSTATS, &local->flags);
7172 if (local->power.event) {
7176 readCapabilityRid(local, &cap_rid, 0);
7177 readStatusRid(local, &status_rid, 0);
7178 readStatsRid(local, &stats_rid, RID_STATS, 0);
7182 local->wstats.status = status_rid.mode;
7184 /* Signal quality and co */
7186 local->wstats.qual.level = airo_rssi_to_dbm( local->rssi, status_rid.sigQuality );
7187 /* normalizedSignalStrength appears to be a percentage */
7188 local->wstats.qual.qual = status_rid.normalizedSignalStrength;
7190 local->wstats.qual.level = (status_rid.normalizedSignalStrength + 321) / 2;
7191 local->wstats.qual.qual = airo_get_quality(&status_rid, &cap_rid);
7193 if (status_rid.len >= 124) {
7194 local->wstats.qual.noise = 0x100 - status_rid.noisedBm;
7195 local->wstats.qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
7197 local->wstats.qual.noise = 0;
7198 local->wstats.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_INVALID | IW_QUAL_DBM;
7201 /* Packets discarded in the wireless adapter due to wireless
7202 * specific problems */
7203 local->wstats.discard.nwid = vals[56] + vals[57] + vals[58];/* SSID Mismatch */
7204 local->wstats.discard.code = vals[6];/* RxWepErr */
7205 local->wstats.discard.fragment = vals[30];
7206 local->wstats.discard.retries = vals[10];
7207 local->wstats.discard.misc = vals[1] + vals[32];
7208 local->wstats.miss.beacon = vals[34];
7211 static struct iw_statistics *airo_get_wireless_stats(struct net_device *dev)
7213 struct airo_info *local = dev->priv;
7215 if (!test_bit(JOB_WSTATS, &local->flags)) {
7216 /* Get stats out of the card if available */
7217 if (down_trylock(&local->sem) != 0) {
7218 set_bit(JOB_WSTATS, &local->flags);
7219 wake_up_interruptible(&local->thr_wait);
7221 airo_read_wireless_stats(local);
7224 return &local->wstats;
7229 * This just translates from driver IOCTL codes to the command codes to
7230 * feed to the radio's host interface. Things can be added/deleted
7231 * as needed. This represents the READ side of control I/O to
7234 static int readrids(struct net_device *dev, aironet_ioctl *comp) {
7235 unsigned short ridcode;
7236 unsigned char *iobuf;
7238 struct airo_info *ai = dev->priv;
7241 if (test_bit(FLAG_FLASHING, &ai->flags))
7244 switch(comp->command)
7246 case AIROGCAP: ridcode = RID_CAPABILITIES; break;
7247 case AIROGCFG: ridcode = RID_CONFIG;
7248 if (test_bit(FLAG_COMMIT, &ai->flags)) {
7249 disable_MAC (ai, 1);
7250 writeConfigRid (ai, 1);
7251 enable_MAC (ai, &rsp, 1);
7254 case AIROGSLIST: ridcode = RID_SSID; break;
7255 case AIROGVLIST: ridcode = RID_APLIST; break;
7256 case AIROGDRVNAM: ridcode = RID_DRVNAME; break;
7257 case AIROGEHTENC: ridcode = RID_ETHERENCAP; break;
7258 case AIROGWEPKTMP: ridcode = RID_WEP_TEMP;
7259 /* Only super-user can read WEP keys */
7260 if (!capable(CAP_NET_ADMIN))
7263 case AIROGWEPKNV: ridcode = RID_WEP_PERM;
7264 /* Only super-user can read WEP keys */
7265 if (!capable(CAP_NET_ADMIN))
7268 case AIROGSTAT: ridcode = RID_STATUS; break;
7269 case AIROGSTATSD32: ridcode = RID_STATSDELTA; break;
7270 case AIROGSTATSC32: ridcode = RID_STATS; break;
7273 if (copy_to_user(comp->data, &ai->micstats,
7274 min((int)comp->len,(int)sizeof(ai->micstats))))
7278 case AIRORRID: ridcode = comp->ridnum; break;
7284 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7287 PC4500_readrid(ai,ridcode,iobuf,RIDSIZE, 1);
7288 /* get the count of bytes in the rid docs say 1st 2 bytes is it.
7289 * then return it to the user
7290 * 9/22/2000 Honor user given length
7294 if (copy_to_user(comp->data, iobuf, min(len, (int)RIDSIZE))) {
7303 * Danger Will Robinson write the rids here
7306 static int writerids(struct net_device *dev, aironet_ioctl *comp) {
7307 struct airo_info *ai = dev->priv;
7313 static int (* writer)(struct airo_info *, u16 rid, const void *, int, int);
7314 unsigned char *iobuf;
7316 /* Only super-user can write RIDs */
7317 if (!capable(CAP_NET_ADMIN))
7320 if (test_bit(FLAG_FLASHING, &ai->flags))
7324 writer = do_writerid;
7326 switch(comp->command)
7328 case AIROPSIDS: ridcode = RID_SSID; break;
7329 case AIROPCAP: ridcode = RID_CAPABILITIES; break;
7330 case AIROPAPLIST: ridcode = RID_APLIST; break;
7331 case AIROPCFG: ai->config.len = 0;
7332 clear_bit(FLAG_COMMIT, &ai->flags);
7333 ridcode = RID_CONFIG; break;
7334 case AIROPWEPKEYNV: ridcode = RID_WEP_PERM; break;
7335 case AIROPLEAPUSR: ridcode = RID_LEAPUSERNAME; break;
7336 case AIROPLEAPPWD: ridcode = RID_LEAPPASSWORD; break;
7337 case AIROPWEPKEY: ridcode = RID_WEP_TEMP; writer = PC4500_writerid;
7339 case AIROPLEAPUSR+1: ridcode = 0xFF2A; break;
7340 case AIROPLEAPUSR+2: ridcode = 0xFF2B; break;
7342 /* this is not really a rid but a command given to the card
7346 if (enable_MAC(ai, &rsp, 1) != 0)
7351 * Evidently this code in the airo driver does not get a symbol
7352 * as disable_MAC. it's probably so short the compiler does not gen one.
7358 /* This command merely clears the counts does not actually store any data
7359 * only reads rid. But as it changes the cards state, I put it in the
7360 * writerid routines.
7363 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7366 PC4500_readrid(ai,RID_STATSDELTACLEAR,iobuf,RIDSIZE, 1);
7369 enabled = ai->micstats.enabled;
7370 memset(&ai->micstats,0,sizeof(ai->micstats));
7371 ai->micstats.enabled = enabled;
7374 if (copy_to_user(comp->data, iobuf,
7375 min((int)comp->len, (int)RIDSIZE))) {
7383 return -EOPNOTSUPP; /* Blarg! */
7385 if(comp->len > RIDSIZE)
7388 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7391 if (copy_from_user(iobuf,comp->data,comp->len)) {
7396 if (comp->command == AIROPCFG) {
7397 ConfigRid *cfg = (ConfigRid *)iobuf;
7399 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags))
7400 cfg->opmode |= MODE_MIC;
7402 if ((cfg->opmode & 0xFF) == MODE_STA_IBSS)
7403 set_bit (FLAG_ADHOC, &ai->flags);
7405 clear_bit (FLAG_ADHOC, &ai->flags);
7408 if((*writer)(ai, ridcode, iobuf,comp->len,1)) {
7416 /*****************************************************************************
7417 * Ancillary flash / mod functions much black magic lurkes here *
7418 *****************************************************************************
7422 * Flash command switch table
7425 static int flashcard(struct net_device *dev, aironet_ioctl *comp) {
7428 /* Only super-user can modify flash */
7429 if (!capable(CAP_NET_ADMIN))
7432 switch(comp->command)
7435 return cmdreset((struct airo_info *)dev->priv);
7438 if (!((struct airo_info *)dev->priv)->flash &&
7439 (((struct airo_info *)dev->priv)->flash = kmalloc (FLASHSIZE, GFP_KERNEL)) == NULL)
7441 return setflashmode((struct airo_info *)dev->priv);
7443 case AIROFLSHGCHR: /* Get char from aux */
7444 if(comp->len != sizeof(int))
7446 if (copy_from_user(&z,comp->data,comp->len))
7448 return flashgchar((struct airo_info *)dev->priv,z,8000);
7450 case AIROFLSHPCHR: /* Send char to card. */
7451 if(comp->len != sizeof(int))
7453 if (copy_from_user(&z,comp->data,comp->len))
7455 return flashpchar((struct airo_info *)dev->priv,z,8000);
7457 case AIROFLPUTBUF: /* Send 32k to card */
7458 if (!((struct airo_info *)dev->priv)->flash)
7460 if(comp->len > FLASHSIZE)
7462 if(copy_from_user(((struct airo_info *)dev->priv)->flash,comp->data,comp->len))
7465 flashputbuf((struct airo_info *)dev->priv);
7469 if(flashrestart((struct airo_info *)dev->priv,dev))
7476 #define FLASH_COMMAND 0x7e7e
7480 * Disable MAC and do soft reset on
7484 static int cmdreset(struct airo_info *ai) {
7488 printk(KERN_INFO "Waitbusy hang before RESET\n");
7492 OUT4500(ai,COMMAND,CMD_SOFTRESET);
7494 ssleep(1); /* WAS 600 12/7/00 */
7497 printk(KERN_INFO "Waitbusy hang AFTER RESET\n");
7504 * Put the card in legendary flash
7508 static int setflashmode (struct airo_info *ai) {
7509 set_bit (FLAG_FLASHING, &ai->flags);
7511 OUT4500(ai, SWS0, FLASH_COMMAND);
7512 OUT4500(ai, SWS1, FLASH_COMMAND);
7514 OUT4500(ai, SWS0, FLASH_COMMAND);
7515 OUT4500(ai, COMMAND,0x10);
7517 OUT4500(ai, SWS2, FLASH_COMMAND);
7518 OUT4500(ai, SWS3, FLASH_COMMAND);
7519 OUT4500(ai, COMMAND,0);
7521 msleep(500); /* 500ms delay */
7524 clear_bit (FLAG_FLASHING, &ai->flags);
7525 printk(KERN_INFO "Waitbusy hang after setflash mode\n");
7531 /* Put character to SWS0 wait for dwelltime
7535 static int flashpchar(struct airo_info *ai,int byte,int dwelltime) {
7546 /* Wait for busy bit d15 to go false indicating buffer empty */
7547 while ((IN4500 (ai, SWS0) & 0x8000) && waittime > 0) {
7552 /* timeout for busy clear wait */
7554 printk(KERN_INFO "flash putchar busywait timeout! \n");
7558 /* Port is clear now write byte and wait for it to echo back */
7560 OUT4500(ai,SWS0,byte);
7563 echo = IN4500(ai,SWS1);
7564 } while (dwelltime >= 0 && echo != byte);
7568 return (echo == byte) ? 0 : -EIO;
7572 * Get a character from the card matching matchbyte
7575 static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime){
7577 unsigned char rbyte=0;
7580 rchar = IN4500(ai,SWS1);
7582 if(dwelltime && !(0x8000 & rchar)){
7587 rbyte = 0xff & rchar;
7589 if( (rbyte == matchbyte) && (0x8000 & rchar) ){
7593 if( rbyte == 0x81 || rbyte == 0x82 || rbyte == 0x83 || rbyte == 0x1a || 0xffff == rchar)
7597 }while(dwelltime > 0);
7602 * Transfer 32k of firmware data from user buffer to our buffer and
7606 static int flashputbuf(struct airo_info *ai){
7610 if (test_bit(FLAG_MPI,&ai->flags))
7611 memcpy_toio(ai->pciaux + 0x8000, ai->flash, FLASHSIZE);
7613 OUT4500(ai,AUXPAGE,0x100);
7614 OUT4500(ai,AUXOFF,0);
7616 for(nwords=0;nwords != FLASHSIZE / 2;nwords++){
7617 OUT4500(ai,AUXDATA,ai->flash[nwords] & 0xffff);
7620 OUT4500(ai,SWS0,0x8000);
7628 static int flashrestart(struct airo_info *ai,struct net_device *dev){
7631 ssleep(1); /* Added 12/7/00 */
7632 clear_bit (FLAG_FLASHING, &ai->flags);
7633 if (test_bit(FLAG_MPI, &ai->flags)) {
7634 status = mpi_init_descriptors(ai);
7635 if (status != SUCCESS)
7638 status = setup_card(ai, dev->dev_addr, 1);
7640 if (!test_bit(FLAG_MPI,&ai->flags))
7641 for( i = 0; i < MAX_FIDS; i++ ) {
7642 ai->fids[i] = transmit_allocate
7643 ( ai, 2312, i >= MAX_FIDS / 2 );
7646 ssleep(1); /* Added 12/7/00 */
7649 #endif /* CISCO_EXT */
7652 This program is free software; you can redistribute it and/or
7653 modify it under the terms of the GNU General Public License
7654 as published by the Free Software Foundation; either version 2
7655 of the License, or (at your option) any later version.
7657 This program is distributed in the hope that it will be useful,
7658 but WITHOUT ANY WARRANTY; without even the implied warranty of
7659 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
7660 GNU General Public License for more details.
7664 Redistribution and use in source and binary forms, with or without
7665 modification, are permitted provided that the following conditions
7668 1. Redistributions of source code must retain the above copyright
7669 notice, this list of conditions and the following disclaimer.
7670 2. Redistributions in binary form must reproduce the above copyright
7671 notice, this list of conditions and the following disclaimer in the
7672 documentation and/or other materials provided with the distribution.
7673 3. The name of the author may not be used to endorse or promote
7674 products derived from this software without specific prior written
7677 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
7678 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
7679 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
7680 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
7681 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
7682 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
7683 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
7684 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
7685 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
7686 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
7687 POSSIBILITY OF SUCH DAMAGE.
7690 module_init(airo_init_module);
7691 module_exit(airo_cleanup_module);