]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/net/wireless/airo.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
airo: clean up and clarify interrupt-time task handling
[mirror_ubuntu-artful-kernel.git] / drivers / net / wireless / airo.c
CommitLineData
1da177e4
LT		 1/*======================================================================
2
3 Aironet driver for 4500 and 4800 series cards
4
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
7 the end of this file.
8
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>.
19
20======================================================================*/
21
f12cc209 22#include <linux/err.h>
1da177e4
LT		 23#include <linux/init.h>
24
25#include <linux/kernel.h>
26#include <linux/module.h>
27#include <linux/proc_fs.h>
1da177e4
LT		 28
29#include <linux/sched.h>
30#include <linux/ptrace.h>
31#include <linux/slab.h>
32#include <linux/string.h>
33#include <linux/timer.h>
34#include <linux/interrupt.h>
35#include <linux/in.h>
36#include <linux/bitops.h>
378f058c 37#include <linux/scatterlist.h>
a39d3e79 38#include <linux/crypto.h>
1da177e4
LT		 39#include <asm/io.h>
40#include <asm/system.h>
593c2b9c 41#include <asm/unaligned.h>
1da177e4
LT		 42
43#include <linux/netdevice.h>
44#include <linux/etherdevice.h>
45#include <linux/skbuff.h>
46#include <linux/if_arp.h>
47#include <linux/ioport.h>
48#include <linux/pci.h>
49#include <asm/uaccess.h>
3b4c7d64 50#include <linux/kthread.h>
7dfb7103 51#include <linux/freezer.h>
1da177e4 52
2c706002
JB		 53#include <linux/ieee80211.h>
54
d3808760
AB		 55#include "airo.h"
56
1138c37b
MS		 57#define DRV_NAME "airo"
58
1da177e4
LT		 59#ifdef CONFIG_PCI
60static struct pci_device_id card_ids[] = {
61 { 0x14b9, 1, PCI_ANY_ID, PCI_ANY_ID, },
62 { 0x14b9, 0x4500, PCI_ANY_ID, PCI_ANY_ID },
63 { 0x14b9, 0x4800, PCI_ANY_ID, PCI_ANY_ID, },
64 { 0x14b9, 0x0340, PCI_ANY_ID, PCI_ANY_ID, },
65 { 0x14b9, 0x0350, PCI_ANY_ID, PCI_ANY_ID, },
66 { 0x14b9, 0x5000, PCI_ANY_ID, PCI_ANY_ID, },
67 { 0x14b9, 0xa504, PCI_ANY_ID, PCI_ANY_ID, },
68 { 0, }
69};
70MODULE_DEVICE_TABLE(pci, card_ids);
71
72static int airo_pci_probe(struct pci_dev *, const struct pci_device_id *);
73static void airo_pci_remove(struct pci_dev *);
05adc3b7 74static int airo_pci_suspend(struct pci_dev *pdev, pm_message_t state);
1da177e4
LT		 75static int airo_pci_resume(struct pci_dev *pdev);
76
77static struct pci_driver airo_driver = {
1138c37b 78 .name = DRV_NAME,
1da177e4
LT		 79 .id_table = card_ids,
80 .probe = airo_pci_probe,
81 .remove = __devexit_p(airo_pci_remove),
82 .suspend = airo_pci_suspend,
83 .resume = airo_pci_resume,
84};
85#endif /* CONFIG_PCI */
86
87/* Include Wireless Extension definition and check version - Jean II */
88#include <linux/wireless.h>
e292c737
PM		 89#define WIRELESS_SPY /* enable iwspy support */
90#include <net/iw_handler.h> /* New driver API */
1da177e4 91
e292c737 92#define CISCO_EXT /* enable Cisco extensions */
1da177e4
LT		 93#ifdef CISCO_EXT
94#include <linux/delay.h>
95#endif
96
1da177e4
LT		 97/* Hack to do some power saving */
98#define POWER_ON_DOWN
99
100/* As you can see this list is HUGH!
101 I really don't know what a lot of these counts are about, but they
102 are all here for completeness. If the IGNLABEL macro is put in
103 infront of the label, that statistic will not be included in the list
104 of statistics in the /proc filesystem */
105
106#define IGNLABEL(comment) NULL
107static char *statsLabels[] = {
108 "RxOverrun",
109 IGNLABEL("RxPlcpCrcErr"),
110 IGNLABEL("RxPlcpFormatErr"),
111 IGNLABEL("RxPlcpLengthErr"),
112 "RxMacCrcErr",
113 "RxMacCrcOk",
114 "RxWepErr",
115 "RxWepOk",
116 "RetryLong",
117 "RetryShort",
118 "MaxRetries",
119 "NoAck",
120 "NoCts",
121 "RxAck",
122 "RxCts",
123 "TxAck",
124 "TxRts",
125 "TxCts",
126 "TxMc",
127 "TxBc",
128 "TxUcFrags",
129 "TxUcPackets",
130 "TxBeacon",
131 "RxBeacon",
132 "TxSinColl",
133 "TxMulColl",
134 "DefersNo",
135 "DefersProt",
136 "DefersEngy",
137 "DupFram",
138 "RxFragDisc",
139 "TxAged",
140 "RxAged",
141 "LostSync-MaxRetry",
142 "LostSync-MissedBeacons",
143 "LostSync-ArlExceeded",
144 "LostSync-Deauth",
145 "LostSync-Disassoced",
146 "LostSync-TsfTiming",
147 "HostTxMc",
148 "HostTxBc",
149 "HostTxUc",
150 "HostTxFail",
151 "HostRxMc",
152 "HostRxBc",
153 "HostRxUc",
154 "HostRxDiscard",
155 IGNLABEL("HmacTxMc"),
156 IGNLABEL("HmacTxBc"),
157 IGNLABEL("HmacTxUc"),
158 IGNLABEL("HmacTxFail"),
159 IGNLABEL("HmacRxMc"),
160 IGNLABEL("HmacRxBc"),
161 IGNLABEL("HmacRxUc"),
162 IGNLABEL("HmacRxDiscard"),
163 IGNLABEL("HmacRxAccepted"),
164 "SsidMismatch",
165 "ApMismatch",
166 "RatesMismatch",
167 "AuthReject",
168 "AuthTimeout",
169 "AssocReject",
170 "AssocTimeout",
171 IGNLABEL("ReasonOutsideTable"),
172 IGNLABEL("ReasonStatus1"),
173 IGNLABEL("ReasonStatus2"),
174 IGNLABEL("ReasonStatus3"),
175 IGNLABEL("ReasonStatus4"),
176 IGNLABEL("ReasonStatus5"),
177 IGNLABEL("ReasonStatus6"),
178 IGNLABEL("ReasonStatus7"),
179 IGNLABEL("ReasonStatus8"),
180 IGNLABEL("ReasonStatus9"),
181 IGNLABEL("ReasonStatus10"),
182 IGNLABEL("ReasonStatus11"),
183 IGNLABEL("ReasonStatus12"),
184 IGNLABEL("ReasonStatus13"),
185 IGNLABEL("ReasonStatus14"),
186 IGNLABEL("ReasonStatus15"),
187 IGNLABEL("ReasonStatus16"),
188 IGNLABEL("ReasonStatus17"),
189 IGNLABEL("ReasonStatus18"),
190 IGNLABEL("ReasonStatus19"),
191 "RxMan",
192 "TxMan",
193 "RxRefresh",
194 "TxRefresh",
195 "RxPoll",
196 "TxPoll",
197 "HostRetries",
198 "LostSync-HostReq",
199 "HostTxBytes",
200 "HostRxBytes",
201 "ElapsedUsec",
202 "ElapsedSec",
203 "LostSyncBetterAP",
204 "PrivacyMismatch",
205 "Jammed",
206 "DiscRxNotWepped",
207 "PhyEleMismatch",
208 (char*)-1 };
209#ifndef RUN_AT
210#define RUN_AT(x) (jiffies+(x))
211#endif
212
213
214/* These variables are for insmod, since it seems that the rates
215 can only be set in setup_card. Rates should be a comma separated
216 (no spaces) list of rates (up to 8). */
217
218static int rates[8];
219static int basic_rate;
220static char *ssids[3];
221
222static int io[4];
223static int irq[4];
224
225static
226int maxencrypt /* = 0 */; /* The highest rate that the card can encrypt at.
227 0 means no limit. For old cards this was 4 */
228
229static int auto_wep /* = 0 */; /* If set, it tries to figure out the wep mode */
230static int aux_bap /* = 0 */; /* Checks to see if the aux ports are needed to read
231 the bap, needed on some older cards and buses. */
232static int adhoc;
233
234static int probe = 1;
235
236static int proc_uid /* = 0 */;
237
238static int proc_gid /* = 0 */;
239
240static int airo_perm = 0555;
241
242static int proc_perm = 0644;
243
244MODULE_AUTHOR("Benjamin Reed");
245MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet \
d73ae55a
BN		 246cards. Direct support for ISA/PCI/MPI cards and support \
247for PCMCIA when used with airo_cs.");
1da177e4
LT		 248MODULE_LICENSE("Dual BSD/GPL");
249MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340/350");
250module_param_array(io, int, NULL, 0);
251module_param_array(irq, int, NULL, 0);
252module_param(basic_rate, int, 0);
253module_param_array(rates, int, NULL, 0);
254module_param_array(ssids, charp, NULL, 0);
255module_param(auto_wep, int, 0);
256MODULE_PARM_DESC(auto_wep, "If non-zero, the driver will keep looping through \
257the authentication options until an association is made. The value of \
258auto_wep is number of the wep keys to check. A value of 2 will try using \
259the key at index 0 and index 1.");
260module_param(aux_bap, int, 0);
261MODULE_PARM_DESC(aux_bap, "If non-zero, the driver will switch into a mode \
262than seems to work better for older cards with some older buses. Before \
263switching it checks that the switch is needed.");
264module_param(maxencrypt, int, 0);
265MODULE_PARM_DESC(maxencrypt, "The maximum speed that the card can do \
266encryption. Units are in 512kbs. Zero (default) means there is no limit. \
267Older cards used to be limited to 2mbs (4).");
268module_param(adhoc, int, 0);
269MODULE_PARM_DESC(adhoc, "If non-zero, the card will start in adhoc mode.");
270module_param(probe, int, 0);
271MODULE_PARM_DESC(probe, "If zero, the driver won't start the card.");
272
273module_param(proc_uid, int, 0);
274MODULE_PARM_DESC(proc_uid, "The uid that the /proc files will belong to.");
275module_param(proc_gid, int, 0);
276MODULE_PARM_DESC(proc_gid, "The gid that the /proc files will belong to.");
277module_param(airo_perm, int, 0);
278MODULE_PARM_DESC(airo_perm, "The permission bits of /proc/[driver/]aironet.");
279module_param(proc_perm, int, 0);
280MODULE_PARM_DESC(proc_perm, "The permission bits of the files in /proc");
281
282/* This is a kind of sloppy hack to get this information to OUT4500 and
283 IN4500. I would be extremely interested in the situation where this
284 doesn't work though!!! */
e292c737 285static int do8bitIO /* = 0 */;
1da177e4
LT		 286
287/* Return codes */
288#define SUCCESS 0
289#define ERROR -1
290#define NO_PACKET -2
291
292/* Commands */
293#define NOP2 0x0000
294#define MAC_ENABLE 0x0001
295#define MAC_DISABLE 0x0002
296#define CMD_LOSE_SYNC 0x0003 /* Not sure what this does... */
297#define CMD_SOFTRESET 0x0004
298#define HOSTSLEEP 0x0005
299#define CMD_MAGIC_PKT 0x0006
300#define CMD_SETWAKEMASK 0x0007
301#define CMD_READCFG 0x0008
302#define CMD_SETMODE 0x0009
303#define CMD_ALLOCATETX 0x000a
304#define CMD_TRANSMIT 0x000b
305#define CMD_DEALLOCATETX 0x000c
306#define NOP 0x0010
307#define CMD_WORKAROUND 0x0011
308#define CMD_ALLOCATEAUX 0x0020
309#define CMD_ACCESS 0x0021
310#define CMD_PCIBAP 0x0022
311#define CMD_PCIAUX 0x0023
312#define CMD_ALLOCBUF 0x0028
313#define CMD_GETTLV 0x0029
314#define CMD_PUTTLV 0x002a
315#define CMD_DELTLV 0x002b
316#define CMD_FINDNEXTTLV 0x002c
317#define CMD_PSPNODES 0x0030
318#define CMD_SETCW 0x0031
319#define CMD_SETPCF 0x0032
320#define CMD_SETPHYREG 0x003e
321#define CMD_TXTEST 0x003f
322#define MAC_ENABLETX 0x0101
323#define CMD_LISTBSS 0x0103
324#define CMD_SAVECFG 0x0108
325#define CMD_ENABLEAUX 0x0111
326#define CMD_WRITERID 0x0121
327#define CMD_USEPSPNODES 0x0130
328#define MAC_ENABLERX 0x0201
329
330/* Command errors */
331#define ERROR_QUALIF 0x00
332#define ERROR_ILLCMD 0x01
333#define ERROR_ILLFMT 0x02
334#define ERROR_INVFID 0x03
335#define ERROR_INVRID 0x04
336#define ERROR_LARGE 0x05
337#define ERROR_NDISABL 0x06
338#define ERROR_ALLOCBSY 0x07
339#define ERROR_NORD 0x0B
340#define ERROR_NOWR 0x0C
341#define ERROR_INVFIDTX 0x0D
342#define ERROR_TESTACT 0x0E
343#define ERROR_TAGNFND 0x12
344#define ERROR_DECODE 0x20
345#define ERROR_DESCUNAV 0x21
346#define ERROR_BADLEN 0x22
347#define ERROR_MODE 0x80
348#define ERROR_HOP 0x81
349#define ERROR_BINTER 0x82
350#define ERROR_RXMODE 0x83
351#define ERROR_MACADDR 0x84
352#define ERROR_RATES 0x85
353#define ERROR_ORDER 0x86
354#define ERROR_SCAN 0x87
355#define ERROR_AUTH 0x88
356#define ERROR_PSMODE 0x89
357#define ERROR_RTYPE 0x8A
358#define ERROR_DIVER 0x8B
359#define ERROR_SSID 0x8C
360#define ERROR_APLIST 0x8D
361#define ERROR_AUTOWAKE 0x8E
362#define ERROR_LEAP 0x8F
363
364/* Registers */
365#define COMMAND 0x00
366#define PARAM0 0x02
367#define PARAM1 0x04
368#define PARAM2 0x06
369#define STATUS 0x08
370#define RESP0 0x0a
371#define RESP1 0x0c
372#define RESP2 0x0e
373#define LINKSTAT 0x10
374#define SELECT0 0x18
375#define OFFSET0 0x1c
376#define RXFID 0x20
377#define TXALLOCFID 0x22
378#define TXCOMPLFID 0x24
379#define DATA0 0x36
380#define EVSTAT 0x30
381#define EVINTEN 0x32
382#define EVACK 0x34
383#define SWS0 0x28
384#define SWS1 0x2a
385#define SWS2 0x2c
386#define SWS3 0x2e
387#define AUXPAGE 0x3A
388#define AUXOFF 0x3C
389#define AUXDATA 0x3E
390
391#define FID_TX 1
392#define FID_RX 2
393/* Offset into aux memory for descriptors */
394#define AUX_OFFSET 0x800
395/* Size of allocated packets */
396#define PKTSIZE 1840
397#define RIDSIZE 2048
398/* Size of the transmit queue */
399#define MAXTXQ 64
400
401/* BAP selectors */
e292c737
PM		 402#define BAP0 0 /* Used for receiving packets */
403#define BAP1 2 /* Used for xmiting packets and working with RIDS */
1da177e4
LT		 404
405/* Flags */
406#define COMMAND_BUSY 0x8000
407
408#define BAP_BUSY 0x8000
409#define BAP_ERR 0x4000
410#define BAP_DONE 0x2000
411
412#define PROMISC 0xffff
413#define NOPROMISC 0x0000
414
415#define EV_CMD 0x10
416#define EV_CLEARCOMMANDBUSY 0x4000
417#define EV_RX 0x01
418#define EV_TX 0x02
419#define EV_TXEXC 0x04
420#define EV_ALLOC 0x08
421#define EV_LINK 0x80
422#define EV_AWAKE 0x100
423#define EV_TXCPY 0x400
424#define EV_UNKNOWN 0x800
425#define EV_MIC 0x1000 /* Message Integrity Check Interrupt */
426#define EV_AWAKEN 0x2000
427#define STATUS_INTS (EV_AWAKE|EV_LINK|EV_TXEXC|EV_TX|EV_TXCPY|EV_RX|EV_MIC)
428
429#ifdef CHECK_UNKNOWN_INTS
430#define IGNORE_INTS ( EV_CMD | EV_UNKNOWN)
431#else
432#define IGNORE_INTS (~STATUS_INTS)
433#endif
434
435/* RID TYPES */
436#define RID_RW 0x20
437
438/* The RIDs */
439#define RID_CAPABILITIES 0xFF00
440#define RID_APINFO 0xFF01
441#define RID_RADIOINFO 0xFF02
442#define RID_UNKNOWN3 0xFF03
443#define RID_RSSI 0xFF04
444#define RID_CONFIG 0xFF10
445#define RID_SSID 0xFF11
446#define RID_APLIST 0xFF12
447#define RID_DRVNAME 0xFF13
448#define RID_ETHERENCAP 0xFF14
449#define RID_WEP_TEMP 0xFF15
450#define RID_WEP_PERM 0xFF16
451#define RID_MODULATION 0xFF17
452#define RID_OPTIONS 0xFF18
453#define RID_ACTUALCONFIG 0xFF20 /*readonly*/
454#define RID_FACTORYCONFIG 0xFF21
455#define RID_UNKNOWN22 0xFF22
456#define RID_LEAPUSERNAME 0xFF23
457#define RID_LEAPPASSWORD 0xFF24
458#define RID_STATUS 0xFF50
459#define RID_BEACON_HST 0xFF51
460#define RID_BUSY_HST 0xFF52
461#define RID_RETRIES_HST 0xFF53
462#define RID_UNKNOWN54 0xFF54
463#define RID_UNKNOWN55 0xFF55
464#define RID_UNKNOWN56 0xFF56
465#define RID_MIC 0xFF57
466#define RID_STATS16 0xFF60
467#define RID_STATS16DELTA 0xFF61
468#define RID_STATS16DELTACLEAR 0xFF62
469#define RID_STATS 0xFF68
470#define RID_STATSDELTA 0xFF69
471#define RID_STATSDELTACLEAR 0xFF6A
472#define RID_ECHOTEST_RID 0xFF70
473#define RID_ECHOTEST_RESULTS 0xFF71
474#define RID_BSSLISTFIRST 0xFF72
475#define RID_BSSLISTNEXT 0xFF73
3c304956
DW		 476#define RID_WPA_BSSLISTFIRST 0xFF74
477#define RID_WPA_BSSLISTNEXT 0xFF75
1da177e4
LT		 478
479typedef struct {
480 u16 cmd;
481 u16 parm0;
482 u16 parm1;
483 u16 parm2;
484} Cmd;
485
486typedef struct {
487 u16 status;
488 u16 rsp0;
489 u16 rsp1;
490 u16 rsp2;
491} Resp;
492
493/*
494 * Rids and endian-ness: The Rids will always be in cpu endian, since
495 * this all the patches from the big-endian guys end up doing that.
496 * so all rid access should use the read/writeXXXRid routines.
497 */
498
499/* This is redundant for x86 archs, but it seems necessary for ARM */
500#pragma pack(1)
501
502/* This structure came from an email sent to me from an engineer at
503 aironet for inclusion into this driver */
504typedef struct {
4293ea33
AV		 505 __le16 len;
506 __le16 kindex;
1da177e4 507 u8 mac[ETH_ALEN];
4293ea33 508 __le16 klen;
1da177e4
LT		 509 u8 key[16];
510} WepKeyRid;
511
512/* These structures are from the Aironet's PC4500 Developers Manual */
513typedef struct {
0dd2212f 514 __le16 len;
1da177e4
LT		 515 u8 ssid[32];
516} Ssid;
517
518typedef struct {
0dd2212f 519 __le16 len;
1da177e4
LT		 520 Ssid ssids[3];
521} SsidRid;
522
523typedef struct {
3eb9b41f
AV		 524 __le16 len;
525 __le16 modulation;
526#define MOD_DEFAULT cpu_to_le16(0)
527#define MOD_CCK cpu_to_le16(1)
528#define MOD_MOK cpu_to_le16(2)
1da177e4
LT		 529} ModulationRid;
530
531typedef struct {
3eb9b41f
AV		 532 __le16 len; /* sizeof(ConfigRid) */
533 __le16 opmode; /* operating mode */
534#define MODE_STA_IBSS cpu_to_le16(0)
535#define MODE_STA_ESS cpu_to_le16(1)
536#define MODE_AP cpu_to_le16(2)
537#define MODE_AP_RPTR cpu_to_le16(3)
538#define MODE_CFG_MASK cpu_to_le16(0xff)
539#define MODE_ETHERNET_HOST cpu_to_le16(0<<8) /* rx payloads converted */
540#define MODE_LLC_HOST cpu_to_le16(1<<8) /* rx payloads left as is */
541#define MODE_AIRONET_EXTEND cpu_to_le16(1<<9) /* enable Aironet extenstions */
542#define MODE_AP_INTERFACE cpu_to_le16(1<<10) /* enable ap interface extensions */
543#define MODE_ANTENNA_ALIGN cpu_to_le16(1<<11) /* enable antenna alignment */
544#define MODE_ETHER_LLC cpu_to_le16(1<<12) /* enable ethernet LLC */
545#define MODE_LEAF_NODE cpu_to_le16(1<<13) /* enable leaf node bridge */
546#define MODE_CF_POLLABLE cpu_to_le16(1<<14) /* enable CF pollable */
547#define MODE_MIC cpu_to_le16(1<<15) /* enable MIC */
548 __le16 rmode; /* receive mode */
549#define RXMODE_BC_MC_ADDR cpu_to_le16(0)
550#define RXMODE_BC_ADDR cpu_to_le16(1) /* ignore multicasts */
551#define RXMODE_ADDR cpu_to_le16(2) /* ignore multicast and broadcast */
552#define RXMODE_RFMON cpu_to_le16(3) /* wireless monitor mode */
553#define RXMODE_RFMON_ANYBSS cpu_to_le16(4)
554#define RXMODE_LANMON cpu_to_le16(5) /* lan style monitor -- data packets only */
555#define RXMODE_MASK cpu_to_le16(255)
556#define RXMODE_DISABLE_802_3_HEADER cpu_to_le16(1<<8) /* disables 802.3 header on rx */
557#define RXMODE_FULL_MASK (RXMODE_MASK | RXMODE_DISABLE_802_3_HEADER)
558#define RXMODE_NORMALIZED_RSSI cpu_to_le16(1<<9) /* return normalized RSSI */
559 __le16 fragThresh;
560 __le16 rtsThres;
1da177e4
LT		 561 u8 macAddr[ETH_ALEN];
562 u8 rates[8];
3eb9b41f
AV		 563 __le16 shortRetryLimit;
564 __le16 longRetryLimit;
565 __le16 txLifetime; /* in kusec */
566 __le16 rxLifetime; /* in kusec */
567 __le16 stationary;
568 __le16 ordering;
569 __le16 u16deviceType; /* for overriding device type */
570 __le16 cfpRate;
571 __le16 cfpDuration;
572 __le16 _reserved1[3];
1da177e4 573 /*---------- Scanning/Associating ----------*/
3eb9b41f
AV		 574 __le16 scanMode;
575#define SCANMODE_ACTIVE cpu_to_le16(0)
576#define SCANMODE_PASSIVE cpu_to_le16(1)
577#define SCANMODE_AIROSCAN cpu_to_le16(2)
578 __le16 probeDelay; /* in kusec */
579 __le16 probeEnergyTimeout; /* in kusec */
580 __le16 probeResponseTimeout;
581 __le16 beaconListenTimeout;
582 __le16 joinNetTimeout;
583 __le16 authTimeout;
584 __le16 authType;
585#define AUTH_OPEN cpu_to_le16(0x1)
586#define AUTH_ENCRYPT cpu_to_le16(0x101)
587#define AUTH_SHAREDKEY cpu_to_le16(0x102)
588#define AUTH_ALLOW_UNENCRYPTED cpu_to_le16(0x200)
589 __le16 associationTimeout;
590 __le16 specifiedApTimeout;
591 __le16 offlineScanInterval;
592 __le16 offlineScanDuration;
593 __le16 linkLossDelay;
594 __le16 maxBeaconLostTime;
595 __le16 refreshInterval;
596#define DISABLE_REFRESH cpu_to_le16(0xFFFF)
597 __le16 _reserved1a[1];
1da177e4 598 /*---------- Power save operation ----------*/
3eb9b41f
AV		 599 __le16 powerSaveMode;
600#define POWERSAVE_CAM cpu_to_le16(0)
601#define POWERSAVE_PSP cpu_to_le16(1)
602#define POWERSAVE_PSPCAM cpu_to_le16(2)
603 __le16 sleepForDtims;
604 __le16 listenInterval;
605 __le16 fastListenInterval;
606 __le16 listenDecay;
607 __le16 fastListenDelay;
608 __le16 _reserved2[2];
1da177e4 609 /*---------- Ap/Ibss config items ----------*/
3eb9b41f
AV		 610 __le16 beaconPeriod;
611 __le16 atimDuration;
612 __le16 hopPeriod;
613 __le16 channelSet;
614 __le16 channel;
615 __le16 dtimPeriod;
616 __le16 bridgeDistance;
617 __le16 radioID;
1da177e4 618 /*---------- Radio configuration ----------*/
3eb9b41f
AV		 619 __le16 radioType;
620#define RADIOTYPE_DEFAULT cpu_to_le16(0)
621#define RADIOTYPE_802_11 cpu_to_le16(1)
622#define RADIOTYPE_LEGACY cpu_to_le16(2)
1da177e4
LT		 623 u8 rxDiversity;
624 u8 txDiversity;
3eb9b41f 625 __le16 txPower;
1da177e4 626#define TXPOWER_DEFAULT 0
3eb9b41f 627 __le16 rssiThreshold;
1da177e4 628#define RSSI_DEFAULT 0
3eb9b41f
AV		 629 __le16 modulation;
630#define PREAMBLE_AUTO cpu_to_le16(0)
631#define PREAMBLE_LONG cpu_to_le16(1)
632#define PREAMBLE_SHORT cpu_to_le16(2)
633 __le16 preamble;
634 __le16 homeProduct;
635 __le16 radioSpecific;
1da177e4
LT		 636 /*---------- Aironet Extensions ----------*/
637 u8 nodeName[16];
3eb9b41f
AV		 638 __le16 arlThreshold;
639 __le16 arlDecay;
640 __le16 arlDelay;
641 __le16 _reserved4[1];
1da177e4
LT		 642 /*---------- Aironet Extensions ----------*/
643 u8 magicAction;
644#define MAGIC_ACTION_STSCHG 1
645#define MAGIC_ACTION_RESUME 2
646#define MAGIC_IGNORE_MCAST (1<<8)
647#define MAGIC_IGNORE_BCAST (1<<9)
648#define MAGIC_SWITCH_TO_PSP (0<<10)
649#define MAGIC_STAY_IN_CAM (1<<10)
650 u8 magicControl;
3eb9b41f 651 __le16 autoWake;
1da177e4
LT		 652} ConfigRid;
653
654typedef struct {
329e2c00 655 __le16 len;
1da177e4 656 u8 mac[ETH_ALEN];
329e2c00
AV		 657 __le16 mode;
658 __le16 errorCode;
659 __le16 sigQuality;
660 __le16 SSIDlen;
1da177e4
LT		 661 char SSID[32];
662 char apName[16];
663 u8 bssid[4][ETH_ALEN];
329e2c00
AV		 664 __le16 beaconPeriod;
665 __le16 dimPeriod;
666 __le16 atimDuration;
667 __le16 hopPeriod;
668 __le16 channelSet;
669 __le16 channel;
670 __le16 hopsToBackbone;
671 __le16 apTotalLoad;
672 __le16 generatedLoad;
673 __le16 accumulatedArl;
674 __le16 signalQuality;
675 __le16 currentXmitRate;
676 __le16 apDevExtensions;
677 __le16 normalizedSignalStrength;
678 __le16 shortPreamble;
1da177e4
LT		 679 u8 apIP[4];
680 u8 noisePercent; /* Noise percent in last second */
681 u8 noisedBm; /* Noise dBm in last second */
682 u8 noiseAvePercent; /* Noise percent in last minute */
683 u8 noiseAvedBm; /* Noise dBm in last minute */
684 u8 noiseMaxPercent; /* Highest noise percent in last minute */
685 u8 noiseMaxdBm; /* Highest noise dbm in last minute */
329e2c00 686 __le16 load;
1da177e4 687 u8 carrier[4];
329e2c00 688 __le16 assocStatus;
1da177e4
LT		 689#define STAT_NOPACKETS 0
690#define STAT_NOCARRIERSET 10
691#define STAT_GOTCARRIERSET 11
692#define STAT_WRONGSSID 20
693#define STAT_BADCHANNEL 25
694#define STAT_BADBITRATES 30
695#define STAT_BADPRIVACY 35
696#define STAT_APFOUND 40
697#define STAT_APREJECTED 50
698#define STAT_AUTHENTICATING 60
699#define STAT_DEAUTHENTICATED 61
700#define STAT_AUTHTIMEOUT 62
701#define STAT_ASSOCIATING 70
702#define STAT_DEASSOCIATED 71
703#define STAT_ASSOCTIMEOUT 72
704#define STAT_NOTAIROAP 73
705#define STAT_ASSOCIATED 80
706#define STAT_LEAPING 90
707#define STAT_LEAPFAILED 91
708#define STAT_LEAPTIMEDOUT 92
709#define STAT_LEAPCOMPLETE 93
710} StatusRid;
711
712typedef struct {
a23ace5f
AV		 713 __le16 len;
714 __le16 spacer;
715 __le32 vals[100];
1da177e4
LT		 716} StatsRid;
717
718
719typedef struct {
a749716e 720 __le16 len;
1da177e4
LT		 721 u8 ap[4][ETH_ALEN];
722} APListRid;
723
724typedef struct {
56d81bd3 725 __le16 len;
1da177e4
LT		 726 char oui[3];
727 char zero;
56d81bd3 728 __le16 prodNum;
1da177e4
LT		 729 char manName[32];
730 char prodName[16];
731 char prodVer[8];
732 char factoryAddr[ETH_ALEN];
733 char aironetAddr[ETH_ALEN];
56d81bd3
AV		 734 __le16 radioType;
735 __le16 country;
1da177e4
LT		 736 char callid[ETH_ALEN];
737 char supportedRates[8];
738 char rxDiversity;
739 char txDiversity;
56d81bd3
AV		 740 __le16 txPowerLevels[8];
741 __le16 hardVer;
742 __le16 hardCap;
743 __le16 tempRange;
744 __le16 softVer;
745 __le16 softSubVer;
746 __le16 interfaceVer;
747 __le16 softCap;
748 __le16 bootBlockVer;
749 __le16 requiredHard;
750 __le16 extSoftCap;
1da177e4
LT		 751} CapabilityRid;
752
3c304956
DW		 753
754/* Only present on firmware >= 5.30.17 */
755typedef struct {
17e70491 756 __le16 unknown[4];
3c304956
DW		 757 u8 fixed[12]; /* WLAN management frame */
758 u8 iep[624];
759} BSSListRidExtra;
760
1da177e4 761typedef struct {
17e70491
AV		 762 __le16 len;
763 __le16 index; /* First is 0 and 0xffff means end of list */
1da177e4
LT		 764#define RADIO_FH 1 /* Frequency hopping radio type */
765#define RADIO_DS 2 /* Direct sequence radio type */
766#define RADIO_TMA 4 /* Proprietary radio used in old cards (2500) */
17e70491 767 __le16 radioType;
1da177e4
LT		 768 u8 bssid[ETH_ALEN]; /* Mac address of the BSS */
769 u8 zero;
770 u8 ssidLen;
771 u8 ssid[32];
17e70491
AV		 772 __le16 dBm;
773#define CAP_ESS cpu_to_le16(1<<0)
774#define CAP_IBSS cpu_to_le16(1<<1)
775#define CAP_PRIVACY cpu_to_le16(1<<4)
776#define CAP_SHORTHDR cpu_to_le16(1<<5)
777 __le16 cap;
778 __le16 beaconInterval;
1da177e4
LT		 779 u8 rates[8]; /* Same as rates for config rid */
780 struct { /* For frequency hopping only */
17e70491 781 __le16 dwell;
1da177e4
LT		 782 u8 hopSet;
783 u8 hopPattern;
784 u8 hopIndex;
785 u8 fill;
786 } fh;
17e70491
AV		 787 __le16 dsChannel;
788 __le16 atimWindow;
3c304956
DW		 789
790 /* Only present on firmware >= 5.30.17 */
791 BSSListRidExtra extra;
1da177e4
LT		 792} BSSListRid;
793
9e75af30
DW		 794typedef struct {
795 BSSListRid bss;
796 struct list_head list;
797} BSSListElement;
798
1da177e4
LT		 799typedef struct {
800 u8 rssipct;
801 u8 rssidBm;
802} tdsRssiEntry;
803
804typedef struct {
805 u16 len;
806 tdsRssiEntry x[256];
807} tdsRssiRid;
808
809typedef struct {
810 u16 len;
811 u16 state;
812 u16 multicastValid;
813 u8 multicast[16];
814 u16 unicastValid;
815 u8 unicast[16];
816} MICRid;
817
818typedef struct {
593c2b9c 819 __be16 typelen;
1da177e4
LT		 820
821 union {
822 u8 snap[8];
823 struct {
824 u8 dsap;
825 u8 ssap;
826 u8 control;
827 u8 orgcode[3];
828 u8 fieldtype[2];
829 } llc;
830 } u;
593c2b9c
AV		 831 __be32 mic;
832 __be32 seq;
1da177e4
LT		 833} MICBuffer;
834
835typedef struct {
836 u8 da[ETH_ALEN];
837 u8 sa[ETH_ALEN];
838} etherHead;
839
840#pragma pack()
841
842#define TXCTL_TXOK (1<<1) /* report if tx is ok */
843#define TXCTL_TXEX (1<<2) /* report if tx fails */
844#define TXCTL_802_3 (0<<3) /* 802.3 packet */
845#define TXCTL_802_11 (1<<3) /* 802.11 mac packet */
846#define TXCTL_ETHERNET (0<<4) /* payload has ethertype */
847#define TXCTL_LLC (1<<4) /* payload is llc */
848#define TXCTL_RELEASE (0<<5) /* release after completion */
849#define TXCTL_NORELEASE (1<<5) /* on completion returns to host */
850
851#define BUSY_FID 0x10000
852
853#ifdef CISCO_EXT
854#define AIROMAGIC 0xa55a
855/* Warning : SIOCDEVPRIVATE may disapear during 2.5.X - Jean II */
856#ifdef SIOCIWFIRSTPRIV
857#ifdef SIOCDEVPRIVATE
858#define AIROOLDIOCTL SIOCDEVPRIVATE
859#define AIROOLDIDIFC AIROOLDIOCTL + 1
860#endif /* SIOCDEVPRIVATE */
861#else /* SIOCIWFIRSTPRIV */
862#define SIOCIWFIRSTPRIV SIOCDEVPRIVATE
863#endif /* SIOCIWFIRSTPRIV */
864/* This may be wrong. When using the new SIOCIWFIRSTPRIV range, we probably
865 * should use only "GET" ioctls (last bit set to 1). "SET" ioctls are root
866 * only and don't return the modified struct ifreq to the application which
867 * is usually a problem. - Jean II */
868#define AIROIOCTL SIOCIWFIRSTPRIV
869#define AIROIDIFC AIROIOCTL + 1
870
871/* Ioctl constants to be used in airo_ioctl.command */
872
873#define AIROGCAP 0 // Capability rid
874#define AIROGCFG 1 // USED A LOT
875#define AIROGSLIST 2 // System ID list
876#define AIROGVLIST 3 // List of specified AP's
877#define AIROGDRVNAM 4 // NOTUSED
878#define AIROGEHTENC 5 // NOTUSED
879#define AIROGWEPKTMP 6
880#define AIROGWEPKNV 7
881#define AIROGSTAT 8
882#define AIROGSTATSC32 9
883#define AIROGSTATSD32 10
884#define AIROGMICRID 11
885#define AIROGMICSTATS 12
886#define AIROGFLAGS 13
887#define AIROGID 14
888#define AIRORRID 15
889#define AIRORSWVERSION 17
890
891/* Leave gap of 40 commands after AIROGSTATSD32 for future */
892
893#define AIROPCAP AIROGSTATSD32 + 40
894#define AIROPVLIST AIROPCAP + 1
895#define AIROPSLIST AIROPVLIST + 1
896#define AIROPCFG AIROPSLIST + 1
897#define AIROPSIDS AIROPCFG + 1
898#define AIROPAPLIST AIROPSIDS + 1
899#define AIROPMACON AIROPAPLIST + 1 /* Enable mac */
900#define AIROPMACOFF AIROPMACON + 1 /* Disable mac */
901#define AIROPSTCLR AIROPMACOFF + 1
902#define AIROPWEPKEY AIROPSTCLR + 1
903#define AIROPWEPKEYNV AIROPWEPKEY + 1
904#define AIROPLEAPPWD AIROPWEPKEYNV + 1
905#define AIROPLEAPUSR AIROPLEAPPWD + 1
906
907/* Flash codes */
908
909#define AIROFLSHRST AIROPWEPKEYNV + 40
910#define AIROFLSHGCHR AIROFLSHRST + 1
911#define AIROFLSHSTFL AIROFLSHGCHR + 1
912#define AIROFLSHPCHR AIROFLSHSTFL + 1
913#define AIROFLPUTBUF AIROFLSHPCHR + 1
914#define AIRORESTART AIROFLPUTBUF + 1
915
916#define FLASHSIZE 32768
917#define AUXMEMSIZE (256 * 1024)
918
919typedef struct aironet_ioctl {
920 unsigned short command; // What to do
921 unsigned short len; // Len of data
922 unsigned short ridnum; // rid number
923 unsigned char __user *data; // d-data
924} aironet_ioctl;
925
62595eb9 926static char swversion[] = "2.1";
1da177e4
LT		 927#endif /* CISCO_EXT */
928
929#define NUM_MODULES 2
930#define MIC_MSGLEN_MAX 2400
931#define EMMH32_MSGLEN_MAX MIC_MSGLEN_MAX
15db2763 932#define AIRO_DEF_MTU 2312
1da177e4
LT		 933
934typedef struct {
935 u32 size; // size
936 u8 enabled; // MIC enabled or not
937 u32 rxSuccess; // successful packets received
938 u32 rxIncorrectMIC; // pkts dropped due to incorrect MIC comparison
939 u32 rxNotMICed; // pkts dropped due to not being MIC'd
940 u32 rxMICPlummed; // pkts dropped due to not having a MIC plummed
941 u32 rxWrongSequence; // pkts dropped due to sequence number violation
942 u32 reserve[32];
943} mic_statistics;
944
945typedef struct {
946 u32 coeff[((EMMH32_MSGLEN_MAX)+3)>>2];
947 u64 accum; // accumulated mic, reduced to u32 in final()
948 int position; // current position (byte offset) in message
949 union {
950 u8 d8[4];
593c2b9c 951 __be32 d32;
1da177e4
LT		 952 } part; // saves partial message word across update() calls
953} emmh32_context;
954
955typedef struct {
956 emmh32_context seed; // Context - the seed
957 u32 rx; // Received sequence number
958 u32 tx; // Tx sequence number
959 u32 window; // Start of window
960 u8 valid; // Flag to say if context is valid or not
961 u8 key[16];
962} miccntx;
963
964typedef struct {
965 miccntx mCtx; // Multicast context
966 miccntx uCtx; // Unicast context
967} mic_module;
968
969typedef struct {
970 unsigned int rid: 16;
971 unsigned int len: 15;
972 unsigned int valid: 1;
973 dma_addr_t host_addr;
974} Rid;
975
976typedef struct {
977 unsigned int offset: 15;
978 unsigned int eoc: 1;
979 unsigned int len: 15;
980 unsigned int valid: 1;
981 dma_addr_t host_addr;
982} TxFid;
983
f55d4517
DW		 984struct rx_hdr {
985 __le16 status, len;
986 u8 rssi[2];
987 u8 rate;
988 u8 freq;
989 __le16 tmp[4];
990} __attribute__ ((packed));
991
1da177e4
LT		 992typedef struct {
993 unsigned int ctl: 15;
994 unsigned int rdy: 1;
995 unsigned int len: 15;
996 unsigned int valid: 1;
997 dma_addr_t host_addr;
998} RxFid;
999
1000/*
1001 * Host receive descriptor
1002 */
1003typedef struct {
1004 unsigned char __iomem *card_ram_off; /* offset into card memory of the
1005 desc */
1006 RxFid rx_desc; /* card receive descriptor */
1007 char *virtual_host_addr; /* virtual address of host receive
1008 buffer */
1009 int pending;
1010} HostRxDesc;
1011
1012/*
1013 * Host transmit descriptor
1014 */
1015typedef struct {
1016 unsigned char __iomem *card_ram_off; /* offset into card memory of the
1017 desc */
1018 TxFid tx_desc; /* card transmit descriptor */
1019 char *virtual_host_addr; /* virtual address of host receive
1020 buffer */
1021 int pending;
1022} HostTxDesc;
1023
1024/*
1025 * Host RID descriptor
1026 */
1027typedef struct {
1028 unsigned char __iomem *card_ram_off; /* offset into card memory of the
1029 descriptor */
1030 Rid rid_desc; /* card RID descriptor */
1031 char *virtual_host_addr; /* virtual address of host receive
1032 buffer */
1033} HostRidDesc;
1034
1035typedef struct {
1036 u16 sw0;
1037 u16 sw1;
1038 u16 status;
1039 u16 len;
1040#define HOST_SET (1 << 0)
1041#define HOST_INT_TX (1 << 1) /* Interrupt on successful TX */
1042#define HOST_INT_TXERR (1 << 2) /* Interrupt on unseccessful TX */
1043#define HOST_LCC_PAYLOAD (1 << 4) /* LLC payload, 0 = Ethertype */
1044#define HOST_DONT_RLSE (1 << 5) /* Don't release buffer when done */
1045#define HOST_DONT_RETRY (1 << 6) /* Don't retry trasmit */
1046#define HOST_CLR_AID (1 << 7) /* clear AID failure */
1047#define HOST_RTS (1 << 9) /* Force RTS use */
1048#define HOST_SHORT (1 << 10) /* Do short preamble */
1049 u16 ctl;
1050 u16 aid;
1051 u16 retries;
1052 u16 fill;
1053} TxCtlHdr;
1054
1055typedef struct {
1056 u16 ctl;
1057 u16 duration;
1058 char addr1[6];
1059 char addr2[6];
1060 char addr3[6];
1061 u16 seq;
1062 char addr4[6];
1063} WifiHdr;
1064
1065
1066typedef struct {
1067 TxCtlHdr ctlhdr;
1068 u16 fill1;
1069 u16 fill2;
1070 WifiHdr wifihdr;
1071 u16 gaplen;
1072 u16 status;
1073} WifiCtlHdr;
1074
ff1d2767 1075static WifiCtlHdr wifictlhdr8023 = {
1da177e4
LT		 1076 .ctlhdr = {
1077 .ctl = HOST_DONT_RLSE,
1078 }
1079};
1080
1da177e4
LT		 1081// A few details needed for WEP (Wireless Equivalent Privacy)
1082#define MAX_KEY_SIZE 13 // 128 (?) bits
1083#define MIN_KEY_SIZE 5 // 40 bits RC4 - WEP
1084typedef struct wep_key_t {
1085 u16 len;
1086 u8 key[16]; /* 40-bit and 104-bit keys */
1087} wep_key_t;
1088
1089/* Backward compatibility */
1090#ifndef IW_ENCODE_NOKEY
1091#define IW_ENCODE_NOKEY 0x0800 /* Key is write only, so not present */
1092#define IW_ENCODE_MODE (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
1093#endif /* IW_ENCODE_NOKEY */
1094
1095/* List of Wireless Handlers (new API) */
1096static const struct iw_handler_def airo_handler_def;
1da177e4
LT		 1097
1098static const char version[] = "airo.c 0.6 (Ben Reed & Javier Achirica)";
1099
1100struct airo_info;
1101
1102static int get_dec_u16( char *buffer, int *start, int limit );
1103static void OUT4500( struct airo_info *, u16 register, u16 value );
1104static unsigned short IN4500( struct airo_info *, u16 register );
1105static u16 setup_card(struct airo_info*, u8 *mac, int lock);
175ec1a1 1106static int enable_MAC(struct airo_info *ai, int lock);
1da177e4
LT		 1107static void disable_MAC(struct airo_info *ai, int lock);
1108static void enable_interrupts(struct airo_info*);
1109static void disable_interrupts(struct airo_info*);
1110static u16 issuecommand(struct airo_info*, Cmd *pCmd, Resp *pRsp);
1111static int bap_setup(struct airo_info*, u16 rid, u16 offset, int whichbap);
b8c06bc1 1112static int aux_bap_read(struct airo_info*, __le16 *pu16Dst, int bytelen,
1da177e4 1113 int whichbap);
b8c06bc1 1114static int fast_bap_read(struct airo_info*, __le16 *pu16Dst, int bytelen,
1da177e4 1115 int whichbap);
b8c06bc1 1116static int bap_write(struct airo_info*, const __le16 *pu16Src, int bytelen,
1da177e4
LT		 1117 int whichbap);
1118static int PC4500_accessrid(struct airo_info*, u16 rid, u16 accmd);
1119static int PC4500_readrid(struct airo_info*, u16 rid, void *pBuf, int len, int lock);
1120static int PC4500_writerid(struct airo_info*, u16 rid, const void
1121 *pBuf, int len, int lock);
1122static int do_writerid( struct airo_info*, u16 rid, const void *rid_data,
1123 int len, int dummy );
1124static u16 transmit_allocate(struct airo_info*, int lenPayload, int raw);
1125static int transmit_802_3_packet(struct airo_info*, int len, char *pPacket);
1126static int transmit_802_11_packet(struct airo_info*, int len, char *pPacket);
1127
1128static int mpi_send_packet (struct net_device *dev);
1129static void mpi_unmap_card(struct pci_dev *pci);
1130static void mpi_receive_802_3(struct airo_info *ai);
1131static void mpi_receive_802_11(struct airo_info *ai);
1132static int waitbusy (struct airo_info *ai);
1133
7d12e780 1134static irqreturn_t airo_interrupt( int irq, void* dev_id);
1da177e4
LT		 1135static int airo_thread(void *data);
1136static void timer_func( struct net_device *dev );
1137static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
ff1d2767 1138static struct iw_statistics *airo_get_wireless_stats (struct net_device *dev);
1da177e4 1139static void airo_read_wireless_stats (struct airo_info *local);
1da177e4
LT		 1140#ifdef CISCO_EXT
1141static int readrids(struct net_device *dev, aironet_ioctl *comp);
1142static int writerids(struct net_device *dev, aironet_ioctl *comp);
ff1d2767 1143static int flashcard(struct net_device *dev, aironet_ioctl *comp);
1da177e4 1144#endif /* CISCO_EXT */
1da177e4
LT		 1145static void micinit(struct airo_info *ai);
1146static int micsetup(struct airo_info *ai);
1147static int encapsulate(struct airo_info *ai, etherHead *pPacket, MICBuffer *buffer, int len);
1148static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *pPacket, u16 payLen);
1149
41480af2
DW		 1150static u8 airo_rssi_to_dbm (tdsRssiEntry *rssi_rid, u8 rssi);
1151static u8 airo_dbm_to_pct (tdsRssiEntry *rssi_rid, u8 dbm);
1152
9e75af30
DW		 1153static void airo_networks_free(struct airo_info *ai);
1154
1da177e4 1155struct airo_info {
1da177e4 1156 struct net_device *dev;
af5b5c9a 1157 struct list_head dev_list;
1da177e4
LT		 1158 /* Note, we can have MAX_FIDS outstanding. FIDs are 16-bits, so we
1159 use the high bit to mark whether it is in use. */
1160#define MAX_FIDS 6
1161#define MPI_MAX_FIDS 1
1162 int fids[MAX_FIDS];
1163 ConfigRid config;
1164 char keyindex; // Used with auto wep
1165 char defindex; // Used with auto wep
1166 struct proc_dir_entry *proc_entry;
1167 spinlock_t aux_lock;
1da177e4
LT		 1168#define FLAG_RADIO_OFF 0 /* User disabling of MAC */
1169#define FLAG_RADIO_DOWN 1 /* ifup/ifdown disabling of MAC */
1170#define FLAG_RADIO_MASK 0x03
1171#define FLAG_ENABLED 2
1172#define FLAG_ADHOC 3 /* Needed by MIC */
1173#define FLAG_MIC_CAPABLE 4
1174#define FLAG_UPDATE_MULTI 5
1175#define FLAG_UPDATE_UNI 6
1176#define FLAG_802_11 7
3c304956 1177#define FLAG_PROMISC 8 /* IFF_PROMISC 0x100 - include/linux/if.h */
1da177e4
LT		 1178#define FLAG_PENDING_XMIT 9
1179#define FLAG_PENDING_XMIT11 10
1180#define FLAG_MPI 11
1181#define FLAG_REGISTERED 12
1182#define FLAG_COMMIT 13
1183#define FLAG_RESET 14
1184#define FLAG_FLASHING 15
3c304956
DW		 1185#define FLAG_WPA_CAPABLE 16
1186 unsigned long flags;
1187#define JOB_DIE 0
1188#define JOB_XMIT 1
1189#define JOB_XMIT11 2
1190#define JOB_STATS 3
1191#define JOB_PROMISC 4
1192#define JOB_MIC 5
1193#define JOB_EVENT 6
1194#define JOB_AUTOWEP 7
1195#define JOB_WSTATS 8
1196#define JOB_SCAN_RESULTS 9
1197 unsigned long jobs;
b8c06bc1 1198 int (*bap_read)(struct airo_info*, __le16 *pu16Dst, int bytelen,
1da177e4
LT		 1199 int whichbap);
1200 unsigned short *flash;
1201 tdsRssiEntry *rssi;
3b4c7d64
SB		 1202 struct task_struct *list_bss_task;
1203 struct task_struct *airo_thread_task;
1da177e4 1204 struct semaphore sem;
1da177e4 1205 wait_queue_head_t thr_wait;
1da177e4
LT		 1206 unsigned long expires;
1207 struct {
1208 struct sk_buff *skb;
1209 int fid;
1210 } xmit, xmit11;
1211 struct net_device *wifidev;
1da177e4 1212 struct iw_statistics wstats; // wireless stats
9e75af30 1213 unsigned long scan_timeout; /* Time scan should be read */
1da177e4
LT		 1214 struct iw_spy_data spy_data;
1215 struct iw_public_data wireless_data;
1da177e4 1216 /* MIC stuff */
f12cc209 1217 struct crypto_cipher *tfm;
1da177e4
LT		 1218 mic_module mod[2];
1219 mic_statistics micstats;
1da177e4
LT		 1220 HostRxDesc rxfids[MPI_MAX_FIDS]; // rx/tx/config MPI350 descriptors
1221 HostTxDesc txfids[MPI_MAX_FIDS];
1222 HostRidDesc config_desc;
1223 unsigned long ridbus; // phys addr of config_desc
1224 struct sk_buff_head txq;// tx queue used by mpi350 code
1225 struct pci_dev *pci;
1226 unsigned char __iomem *pcimem;
1227 unsigned char __iomem *pciaux;
1228 unsigned char *shared;
1229 dma_addr_t shared_dma;
1cc68ae0 1230 pm_message_t power;
1da177e4
LT		 1231 SsidRid *SSID;
1232 APListRid *APList;
1233#define PCI_SHARED_LEN 2*MPI_MAX_FIDS*PKTSIZE+RIDSIZE
1234 char proc_name[IFNAMSIZ];
9e75af30 1235
3c304956
DW		 1236 /* WPA-related stuff */
1237 unsigned int bssListFirst;
1238 unsigned int bssListNext;
1239 unsigned int bssListRidLen;
1240
9e75af30
DW		 1241 struct list_head network_list;
1242 struct list_head network_free_list;
1243 BSSListElement *networks;
1da177e4
LT		 1244};
1245
b8c06bc1
AV		 1246static inline int bap_read(struct airo_info *ai, __le16 *pu16Dst, int bytelen,
1247 int whichbap)
1248{
1da177e4
LT		 1249 return ai->bap_read(ai, pu16Dst, bytelen, whichbap);
1250}
1251
1252static int setup_proc_entry( struct net_device *dev,
1253 struct airo_info *apriv );
1254static int takedown_proc_entry( struct net_device *dev,
1255 struct airo_info *apriv );
1256
ff1d2767
JM		 1257static int cmdreset(struct airo_info *ai);
1258static int setflashmode (struct airo_info *ai);
1259static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime);
1260static int flashputbuf(struct airo_info *ai);
1261static int flashrestart(struct airo_info *ai,struct net_device *dev);
1262
934d8bf1 1263#define airo_print(type, name, fmt, args...) \
1138c37b 1264 printk(type DRV_NAME "(%s): " fmt "\n", name, ##args)
934d8bf1
DW		 1265
1266#define airo_print_info(name, fmt, args...) \
1267 airo_print(KERN_INFO, name, fmt, ##args)
1268
1269#define airo_print_dbg(name, fmt, args...) \
1270 airo_print(KERN_DEBUG, name, fmt, ##args)
1271
1272#define airo_print_warn(name, fmt, args...) \
1273 airo_print(KERN_WARNING, name, fmt, ##args)
1274
1275#define airo_print_err(name, fmt, args...) \
1276 airo_print(KERN_ERR, name, fmt, ##args)
1277
faf3994a 1278#define AIRO_FLASH(dev) (((struct airo_info *)dev->ml_priv)->flash)
934d8bf1 1279
1da177e4
LT		 1280/***********************************************************************
1281 * MIC ROUTINES *
1282 ***********************************************************************
1283 */
1284
1285static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq);
1286static void MoveWindow(miccntx *context, u32 micSeq);
f12cc209
HX		 1287static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen,
1288 struct crypto_cipher *tfm);
ff1d2767
JM		 1289static void emmh32_init(emmh32_context *context);
1290static void emmh32_update(emmh32_context *context, u8 *pOctets, int len);
1291static void emmh32_final(emmh32_context *context, u8 digest[4]);
1292static int flashpchar(struct airo_info *ai,int byte,int dwelltime);
1da177e4
LT		 1293
1294/* micinit - Initialize mic seed */
1295
1296static void micinit(struct airo_info *ai)
1297{
1298 MICRid mic_rid;
1299
3c304956 1300 clear_bit(JOB_MIC, &ai->jobs);
1da177e4
LT		 1301 PC4500_readrid(ai, RID_MIC, &mic_rid, sizeof(mic_rid), 0);
1302 up(&ai->sem);
1303
1304 ai->micstats.enabled = (mic_rid.state & 0x00FF) ? 1 : 0;
1305
1306 if (ai->micstats.enabled) {
1307 /* Key must be valid and different */
1308 if (mic_rid.multicastValid && (!ai->mod[0].mCtx.valid ||
1309 (memcmp (ai->mod[0].mCtx.key, mic_rid.multicast,
1310 sizeof(ai->mod[0].mCtx.key)) != 0))) {
1311 /* Age current mic Context */
1312 memcpy(&ai->mod[1].mCtx,&ai->mod[0].mCtx,sizeof(miccntx));
1313 /* Initialize new context */
1314 memcpy(&ai->mod[0].mCtx.key,mic_rid.multicast,sizeof(mic_rid.multicast));
1315 ai->mod[0].mCtx.window = 33; //Window always points to the middle
1316 ai->mod[0].mCtx.rx = 0; //Rx Sequence numbers
1317 ai->mod[0].mCtx.tx = 0; //Tx sequence numbers
1318 ai->mod[0].mCtx.valid = 1; //Key is now valid
1319
1320 /* Give key to mic seed */
1321 emmh32_setseed(&ai->mod[0].mCtx.seed,mic_rid.multicast,sizeof(mic_rid.multicast), ai->tfm);
1322 }
1323
1324 /* Key must be valid and different */
1325 if (mic_rid.unicastValid && (!ai->mod[0].uCtx.valid ||
1326 (memcmp(ai->mod[0].uCtx.key, mic_rid.unicast,
1327 sizeof(ai->mod[0].uCtx.key)) != 0))) {
1328 /* Age current mic Context */
1329 memcpy(&ai->mod[1].uCtx,&ai->mod[0].uCtx,sizeof(miccntx));
1330 /* Initialize new context */
1331 memcpy(&ai->mod[0].uCtx.key,mic_rid.unicast,sizeof(mic_rid.unicast));
1332
1333 ai->mod[0].uCtx.window = 33; //Window always points to the middle
1334 ai->mod[0].uCtx.rx = 0; //Rx Sequence numbers
1335 ai->mod[0].uCtx.tx = 0; //Tx sequence numbers
1336 ai->mod[0].uCtx.valid = 1; //Key is now valid
1337
1338 //Give key to mic seed
1339 emmh32_setseed(&ai->mod[0].uCtx.seed, mic_rid.unicast, sizeof(mic_rid.unicast), ai->tfm);
1340 }
1341 } else {
1342 /* So next time we have a valid key and mic is enabled, we will update
1343 * the sequence number if the key is the same as before.
1344 */
1345 ai->mod[0].uCtx.valid = 0;
1346 ai->mod[0].mCtx.valid = 0;
1347 }
1348}
1349
1350/* micsetup - Get ready for business */
1351
1352static int micsetup(struct airo_info *ai) {
1353 int i;
1354
1355 if (ai->tfm == NULL)
f12cc209 1356 ai->tfm = crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC);
1da177e4 1357
f12cc209 1358 if (IS_ERR(ai->tfm)) {
934d8bf1 1359 airo_print_err(ai->dev->name, "failed to load transform for AES");
f12cc209 1360 ai->tfm = NULL;
1da177e4
LT		 1361 return ERROR;
1362 }
1363
1364 for (i=0; i < NUM_MODULES; i++) {
1365 memset(&ai->mod[i].mCtx,0,sizeof(miccntx));
1366 memset(&ai->mod[i].uCtx,0,sizeof(miccntx));
1367 }
1368 return SUCCESS;
1369}
1370
ff1d2767 1371static char micsnap[] = {0xAA,0xAA,0x03,0x00,0x40,0x96,0x00,0x02};
1da177e4
LT		 1372
1373/*===========================================================================
1374 * Description: Mic a packet
1375 *
1376 * Inputs: etherHead * pointer to an 802.3 frame
1377 *
1378 * Returns: BOOLEAN if successful, otherwise false.
1379 * PacketTxLen will be updated with the mic'd packets size.
1380 *
1381 * Caveats: It is assumed that the frame buffer will already
1382 * be big enough to hold the largets mic message possible.
1383 * (No memory allocation is done here).
1384 *
1385 * Author: sbraneky (10/15/01)
1386 * Merciless hacks by rwilcher (1/14/02)
1387 */
1388
1389static int encapsulate(struct airo_info *ai ,etherHead *frame, MICBuffer *mic, int payLen)
1390{
1391 miccntx *context;
1392
1393 // Determine correct context
1394 // If not adhoc, always use unicast key
1395
1396 if (test_bit(FLAG_ADHOC, &ai->flags) && (frame->da[0] & 0x1))
1397 context = &ai->mod[0].mCtx;
1398 else
1399 context = &ai->mod[0].uCtx;
1400
1401 if (!context->valid)
1402 return ERROR;
1403
1404 mic->typelen = htons(payLen + 16); //Length of Mic'd packet
1405
1406 memcpy(&mic->u.snap, micsnap, sizeof(micsnap)); // Add Snap
1407
1408 // Add Tx sequence
1409 mic->seq = htonl(context->tx);
1410 context->tx += 2;
1411
1412 emmh32_init(&context->seed); // Mic the packet
1413 emmh32_update(&context->seed,frame->da,ETH_ALEN * 2); // DA,SA
1414 emmh32_update(&context->seed,(u8*)&mic->typelen,10); // Type/Length and Snap
1415 emmh32_update(&context->seed,(u8*)&mic->seq,sizeof(mic->seq)); //SEQ
1416 emmh32_update(&context->seed,frame->da + ETH_ALEN * 2,payLen); //payload
1417 emmh32_final(&context->seed, (u8*)&mic->mic);
1418
1419 /* New Type/length ?????????? */
1420 mic->typelen = 0; //Let NIC know it could be an oversized packet
1421 return SUCCESS;
1422}
1423
1424typedef enum {
1425 NONE,
1426 NOMIC,
1427 NOMICPLUMMED,
1428 SEQUENCE,
1429 INCORRECTMIC,
1430} mic_error;
1431
1432/*===========================================================================
1433 * Description: Decapsulates a MIC'd packet and returns the 802.3 packet
1434 * (removes the MIC stuff) if packet is a valid packet.
1435 *
1436 * Inputs: etherHead pointer to the 802.3 packet
1437 *
1438 * Returns: BOOLEAN - TRUE if packet should be dropped otherwise FALSE
1439 *
1440 * Author: sbraneky (10/15/01)
1441 * Merciless hacks by rwilcher (1/14/02)
1442 *---------------------------------------------------------------------------
1443 */
1444
1445static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *eth, u16 payLen)
1446{
1447 int i;
1448 u32 micSEQ;
1449 miccntx *context;
1450 u8 digest[4];
1451 mic_error micError = NONE;
1452
1453 // Check if the packet is a Mic'd packet
1454
1455 if (!ai->micstats.enabled) {
1456 //No Mic set or Mic OFF but we received a MIC'd packet.
1457 if (memcmp ((u8*)eth + 14, micsnap, sizeof(micsnap)) == 0) {
1458 ai->micstats.rxMICPlummed++;
1459 return ERROR;
1460 }
1461 return SUCCESS;
1462 }
1463
1464 if (ntohs(mic->typelen) == 0x888E)
1465 return SUCCESS;
1466
1467 if (memcmp (mic->u.snap, micsnap, sizeof(micsnap)) != 0) {
1468 // Mic enabled but packet isn't Mic'd
1469 ai->micstats.rxMICPlummed++;
1470 return ERROR;
1471 }
1472
1473 micSEQ = ntohl(mic->seq); //store SEQ as CPU order
1474
1475 //At this point we a have a mic'd packet and mic is enabled
1476 //Now do the mic error checking.
1477
1478 //Receive seq must be odd
1479 if ( (micSEQ & 1) == 0 ) {
1480 ai->micstats.rxWrongSequence++;
1481 return ERROR;
1482 }
1483
1484 for (i = 0; i < NUM_MODULES; i++) {
1485 int mcast = eth->da[0] & 1;
1486 //Determine proper context
1487 context = mcast ? &ai->mod[i].mCtx : &ai->mod[i].uCtx;
1488
1489 //Make sure context is valid
1490 if (!context->valid) {
1491 if (i == 0)
1492 micError = NOMICPLUMMED;
1493 continue;
1494 }
1495 //DeMic it
1496
1497 if (!mic->typelen)
1498 mic->typelen = htons(payLen + sizeof(MICBuffer) - 2);
1499
1500 emmh32_init(&context->seed);
1501 emmh32_update(&context->seed, eth->da, ETH_ALEN*2);
1502 emmh32_update(&context->seed, (u8 *)&mic->typelen, sizeof(mic->typelen)+sizeof(mic->u.snap));
1503 emmh32_update(&context->seed, (u8 *)&mic->seq,sizeof(mic->seq));
1504 emmh32_update(&context->seed, eth->da + ETH_ALEN*2,payLen);
1505 //Calculate MIC
1506 emmh32_final(&context->seed, digest);
1507
1508 if (memcmp(digest, &mic->mic, 4)) { //Make sure the mics match
1509 //Invalid Mic
1510 if (i == 0)
1511 micError = INCORRECTMIC;
1512 continue;
1513 }
1514
1515 //Check Sequence number if mics pass
1516 if (RxSeqValid(ai, context, mcast, micSEQ) == SUCCESS) {
1517 ai->micstats.rxSuccess++;
1518 return SUCCESS;
1519 }
1520 if (i == 0)
1521 micError = SEQUENCE;
1522 }
1523
1524 // Update statistics
1525 switch (micError) {
1526 case NOMICPLUMMED: ai->micstats.rxMICPlummed++; break;
1527 case SEQUENCE: ai->micstats.rxWrongSequence++; break;
1528 case INCORRECTMIC: ai->micstats.rxIncorrectMIC++; break;
1529 case NONE: break;
1530 case NOMIC: break;
1531 }
1532 return ERROR;
1533}
1534
1535/*===========================================================================
1536 * Description: Checks the Rx Seq number to make sure it is valid
1537 * and hasn't already been received
1538 *
1539 * Inputs: miccntx - mic context to check seq against
1540 * micSeq - the Mic seq number
1541 *
1542 * Returns: TRUE if valid otherwise FALSE.
1543 *
1544 * Author: sbraneky (10/15/01)
1545 * Merciless hacks by rwilcher (1/14/02)
1546 *---------------------------------------------------------------------------
1547 */
1548
1549static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq)
1550{
1551 u32 seq,index;
1552
1553 //Allow for the ap being rebooted - if it is then use the next
1554 //sequence number of the current sequence number - might go backwards
1555
1556 if (mcast) {
1557 if (test_bit(FLAG_UPDATE_MULTI, &ai->flags)) {
1558 clear_bit (FLAG_UPDATE_MULTI, &ai->flags);
1559 context->window = (micSeq > 33) ? micSeq : 33;
1560 context->rx = 0; // Reset rx
1561 }
1562 } else if (test_bit(FLAG_UPDATE_UNI, &ai->flags)) {
1563 clear_bit (FLAG_UPDATE_UNI, &ai->flags);
1564 context->window = (micSeq > 33) ? micSeq : 33; // Move window
1565 context->rx = 0; // Reset rx
1566 }
1567
1568 //Make sequence number relative to START of window
1569 seq = micSeq - (context->window - 33);
1570
1571 //Too old of a SEQ number to check.
1572 if ((s32)seq < 0)
1573 return ERROR;
1574
1575 if ( seq > 64 ) {
1576 //Window is infinite forward
1577 MoveWindow(context,micSeq);
1578 return SUCCESS;
1579 }
1580
1581 // We are in the window. Now check the context rx bit to see if it was already sent
1582 seq >>= 1; //divide by 2 because we only have odd numbers
1583 index = 1 << seq; //Get an index number
1584
1585 if (!(context->rx & index)) {
1586 //micSEQ falls inside the window.
1587 //Add seqence number to the list of received numbers.
1588 context->rx |= index;
1589
1590 MoveWindow(context,micSeq);
1591
1592 return SUCCESS;
1593 }
1594 return ERROR;
1595}
1596
1597static void MoveWindow(miccntx *context, u32 micSeq)
1598{
1599 u32 shift;
1600
1601 //Move window if seq greater than the middle of the window
1602 if (micSeq > context->window) {
1603 shift = (micSeq - context->window) >> 1;
1604
1605 //Shift out old
1606 if (shift < 32)
1607 context->rx >>= shift;
1608 else
1609 context->rx = 0;
1610
1611 context->window = micSeq; //Move window
1612 }
1613}
1614
1615/*==============================================*/
1616/*========== EMMH ROUTINES ====================*/
1617/*==============================================*/
1618
1619/* mic accumulate */
1620#define MIC_ACCUM(val) \
1621 context->accum += (u64)(val) * context->coeff[coeff_position++];
1622
1623static unsigned char aes_counter[16];
1624
1625/* expand the key to fill the MMH coefficient array */
f12cc209
HX		 1626static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen,
1627 struct crypto_cipher *tfm)
1da177e4
LT		 1628{
1629 /* take the keying material, expand if necessary, truncate at 16-bytes */
1630 /* run through AES counter mode to generate context->coeff[] */
1631
1632 int i,j;
1633 u32 counter;
1634 u8 *cipher, plain[16];
1da177e4
LT		 1635
1636 crypto_cipher_setkey(tfm, pkey, 16);
1637 counter = 0;
e7c04fd3 1638 for (i = 0; i < ARRAY_SIZE(context->coeff); ) {
1da177e4
LT		 1639 aes_counter[15] = (u8)(counter >> 0);
1640 aes_counter[14] = (u8)(counter >> 8);
1641 aes_counter[13] = (u8)(counter >> 16);
1642 aes_counter[12] = (u8)(counter >> 24);
1643 counter++;
1644 memcpy (plain, aes_counter, 16);
f12cc209
HX		 1645 crypto_cipher_encrypt_one(tfm, plain, plain);
1646 cipher = plain;
e7c04fd3 1647 for (j = 0; (j < 16) && (i < ARRAY_SIZE(context->coeff)); ) {
593c2b9c 1648 context->coeff[i++] = ntohl(*(__be32 *)&cipher[j]);
1da177e4
LT		 1649 j += 4;
1650 }
1651 }
1652}
1653
1654/* prepare for calculation of a new mic */
ff1d2767 1655static void emmh32_init(emmh32_context *context)
1da177e4
LT		 1656{
1657 /* prepare for new mic calculation */
1658 context->accum = 0;
1659 context->position = 0;
1660}
1661
1662/* add some bytes to the mic calculation */
ff1d2767 1663static void emmh32_update(emmh32_context *context, u8 *pOctets, int len)
1da177e4
LT		 1664{
1665 int coeff_position, byte_position;
1666
1667 if (len == 0) return;
1668
1669 coeff_position = context->position >> 2;
1670
1671 /* deal with partial 32-bit word left over from last update */
1672 byte_position = context->position & 3;
1673 if (byte_position) {
1674 /* have a partial word in part to deal with */
1675 do {
1676 if (len == 0) return;
1677 context->part.d8[byte_position++] = *pOctets++;
1678 context->position++;
1679 len--;
1680 } while (byte_position < 4);
593c2b9c 1681 MIC_ACCUM(ntohl(context->part.d32));
1da177e4
LT		 1682 }
1683
1684 /* deal with full 32-bit words */
1685 while (len >= 4) {
593c2b9c 1686 MIC_ACCUM(ntohl(*(__be32 *)pOctets));
1da177e4
LT		 1687 context->position += 4;
1688 pOctets += 4;
1689 len -= 4;
1690 }
1691
1692 /* deal with partial 32-bit word that will be left over from this update */
1693 byte_position = 0;
1694 while (len > 0) {
1695 context->part.d8[byte_position++] = *pOctets++;
1696 context->position++;
1697 len--;
1698 }
1699}
1700
1701/* mask used to zero empty bytes for final partial word */
1702static u32 mask32[4] = { 0x00000000L, 0xFF000000L, 0xFFFF0000L, 0xFFFFFF00L };
1703
1704/* calculate the mic */
ff1d2767 1705static void emmh32_final(emmh32_context *context, u8 digest[4])
1da177e4
LT		 1706{
1707 int coeff_position, byte_position;
1708 u32 val;
1709
1710 u64 sum, utmp;
1711 s64 stmp;
1712
1713 coeff_position = context->position >> 2;
1714
1715 /* deal with partial 32-bit word left over from last update */
1716 byte_position = context->position & 3;
1717 if (byte_position) {
1718 /* have a partial word in part to deal with */
593c2b9c 1719 val = ntohl(context->part.d32);
1da177e4
LT		 1720 MIC_ACCUM(val & mask32[byte_position]); /* zero empty bytes */
1721 }
1722
1723 /* reduce the accumulated u64 to a 32-bit MIC */
1724 sum = context->accum;
1725 stmp = (sum & 0xffffffffLL) - ((sum >> 32) * 15);
1726 utmp = (stmp & 0xffffffffLL) - ((stmp >> 32) * 15);
1727 sum = utmp & 0xffffffffLL;
1728 if (utmp > 0x10000000fLL)
1729 sum -= 15;
1730
1731 val = (u32)sum;
1732 digest[0] = (val>>24) & 0xFF;
1733 digest[1] = (val>>16) & 0xFF;
1734 digest[2] = (val>>8) & 0xFF;
1735 digest[3] = val & 0xFF;
1736}
1da177e4
LT		 1737
1738static int readBSSListRid(struct airo_info *ai, int first,
17e70491
AV		 1739 BSSListRid *list)
1740{
3c304956
DW		 1741 Cmd cmd;
1742 Resp rsp;
1da177e4
LT		 1743
1744 if (first == 1) {
3c304956
DW		 1745 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
1746 memset(&cmd, 0, sizeof(cmd));
1747 cmd.cmd=CMD_LISTBSS;
1748 if (down_interruptible(&ai->sem))
1749 return -ERESTARTSYS;
3b4c7d64 1750 ai->list_bss_task = current;
3c304956
DW		 1751 issuecommand(ai, &cmd, &rsp);
1752 up(&ai->sem);
1753 /* Let the command take effect */
3b4c7d64
SB		 1754 schedule_timeout_uninterruptible(3 * HZ);
1755 ai->list_bss_task = NULL;
3c304956 1756 }
17e70491 1757 return PC4500_readrid(ai, first ? ai->bssListFirst : ai->bssListNext,
3c304956 1758 list, ai->bssListRidLen, 1);
1da177e4
LT		 1759}
1760
4293ea33
AV		 1761static int readWepKeyRid(struct airo_info *ai, WepKeyRid *wkr, int temp, int lock)
1762{
1763 return PC4500_readrid(ai, temp ? RID_WEP_TEMP : RID_WEP_PERM,
1da177e4 1764 wkr, sizeof(*wkr), lock);
1da177e4 1765}
1da177e4 1766
4293ea33
AV		 1767static int writeWepKeyRid(struct airo_info *ai, WepKeyRid *wkr, int perm, int lock)
1768{
1769 int rc;
1770 rc = PC4500_writerid(ai, RID_WEP_TEMP, wkr, sizeof(*wkr), lock);
1771 if (rc!=SUCCESS)
1772 airo_print_err(ai->dev->name, "WEP_TEMP set %x", rc);
1da177e4 1773 if (perm) {
4293ea33
AV		 1774 rc = PC4500_writerid(ai, RID_WEP_PERM, wkr, sizeof(*wkr), lock);
1775 if (rc!=SUCCESS)
934d8bf1 1776 airo_print_err(ai->dev->name, "WEP_PERM set %x", rc);
1da177e4
LT		 1777 }
1778 return rc;
1779}
1780
0dd2212f
AV		 1781static int readSsidRid(struct airo_info*ai, SsidRid *ssidr)
1782{
1783 return PC4500_readrid(ai, RID_SSID, ssidr, sizeof(*ssidr), 1);
1da177e4 1784}
1da177e4 1785
0dd2212f
AV		 1786static int writeSsidRid(struct airo_info*ai, SsidRid *pssidr, int lock)
1787{
1788 return PC4500_writerid(ai, RID_SSID, pssidr, sizeof(*pssidr), lock);
1da177e4 1789}
0dd2212f 1790
3eb9b41f
AV		 1791static int readConfigRid(struct airo_info *ai, int lock)
1792{
1da177e4 1793 int rc;
1da177e4
LT		 1794 ConfigRid cfg;
1795
1796 if (ai->config.len)
1797 return SUCCESS;
1798
1799 rc = PC4500_readrid(ai, RID_ACTUALCONFIG, &cfg, sizeof(cfg), lock);
1800 if (rc != SUCCESS)
1801 return rc;
1802
1da177e4
LT		 1803 ai->config = cfg;
1804 return SUCCESS;
1805}
3eb9b41f
AV		 1806
1807static inline void checkThrottle(struct airo_info *ai)
1808{
1da177e4
LT		 1809 int i;
1810/* Old hardware had a limit on encryption speed */
1811 if (ai->config.authType != AUTH_OPEN && maxencrypt) {
1812 for(i=0; i<8; i++) {
1813 if (ai->config.rates[i] > maxencrypt) {
1814 ai->config.rates[i] = 0;
1815 }
1816 }
1817 }
1818}
3eb9b41f
AV		 1819
1820static int writeConfigRid(struct airo_info *ai, int lock)
1821{
1da177e4
LT		 1822 ConfigRid cfgr;
1823
1824 if (!test_bit (FLAG_COMMIT, &ai->flags))
1825 return SUCCESS;
1826
1827 clear_bit (FLAG_COMMIT, &ai->flags);
1828 clear_bit (FLAG_RESET, &ai->flags);
1829 checkThrottle(ai);
1830 cfgr = ai->config;
1831
3eb9b41f 1832 if ((cfgr.opmode & MODE_CFG_MASK) == MODE_STA_IBSS)
1da177e4
LT		 1833 set_bit(FLAG_ADHOC, &ai->flags);
1834 else
1835 clear_bit(FLAG_ADHOC, &ai->flags);
1836
1da177e4
LT		 1837 return PC4500_writerid( ai, RID_CONFIG, &cfgr, sizeof(cfgr), lock);
1838}
1da177e4 1839
329e2c00
AV		 1840static int readStatusRid(struct airo_info *ai, StatusRid *statr, int lock)
1841{
1842 return PC4500_readrid(ai, RID_STATUS, statr, sizeof(*statr), lock);
1da177e4 1843}
a749716e
AV		 1844
1845static int readAPListRid(struct airo_info *ai, APListRid *aplr)
1846{
1847 return PC4500_readrid(ai, RID_APLIST, aplr, sizeof(*aplr), 1);
1da177e4 1848}
a749716e
AV		 1849
1850static int writeAPListRid(struct airo_info *ai, APListRid *aplr, int lock)
1851{
1852 return PC4500_writerid(ai, RID_APLIST, aplr, sizeof(*aplr), lock);
1da177e4 1853}
1da177e4 1854
56d81bd3
AV		 1855static int readCapabilityRid(struct airo_info *ai, CapabilityRid *capr, int lock)
1856{
1857 return PC4500_readrid(ai, RID_CAPABILITIES, capr, sizeof(*capr), lock);
1da177e4 1858}
1da177e4 1859
a23ace5f
AV		 1860static int readStatsRid(struct airo_info*ai, StatsRid *sr, int rid, int lock)
1861{
1862 return PC4500_readrid(ai, rid, sr, sizeof(*sr), lock);
1da177e4
LT		 1863}
1864
1c2b7db8
MS		 1865static void try_auto_wep(struct airo_info *ai)
1866{
1867 if (auto_wep && !(ai->flags & FLAG_RADIO_DOWN)) {
1868 ai->expires = RUN_AT(3*HZ);
1869 wake_up_interruptible(&ai->thr_wait);
1870 }
1871}
1872
1da177e4 1873static int airo_open(struct net_device *dev) {
faf3994a 1874 struct airo_info *ai = dev->ml_priv;
1c2b7db8 1875 int rc = 0;
1da177e4 1876
1c2b7db8 1877 if (test_bit(FLAG_FLASHING, &ai->flags))
1da177e4
LT		 1878 return -EIO;
1879
1880 /* Make sure the card is configured.
1881 * Wireless Extensions may postpone config changes until the card
1882 * is open (to pipeline changes and speed-up card setup). If
1883 * those changes are not yet commited, do it now - Jean II */
1c2b7db8
MS		 1884 if (test_bit(FLAG_COMMIT, &ai->flags)) {
1885 disable_MAC(ai, 1);
1886 writeConfigRid(ai, 1);
1da177e4
LT		 1887 }
1888
1c2b7db8
MS		 1889 if (ai->wifidev != dev) {
1890 clear_bit(JOB_DIE, &ai->jobs);
1891 ai->airo_thread_task = kthread_run(airo_thread, dev, dev->name);
1892 if (IS_ERR(ai->airo_thread_task))
1893 return (int)PTR_ERR(ai->airo_thread_task);
1894
1895 rc = request_irq(dev->irq, airo_interrupt, IRQF_SHARED,
1896 dev->name, dev);
1897 if (rc) {
1898 airo_print_err(dev->name,
1899 "register interrupt %d failed, rc %d",
1900 dev->irq, rc);
1901 set_bit(JOB_DIE, &ai->jobs);
1902 kthread_stop(ai->airo_thread_task);
1903 return rc;
1904 }
1905
1da177e4 1906 /* Power on the MAC controller (which may have been disabled) */
1c2b7db8
MS		 1907 clear_bit(FLAG_RADIO_DOWN, &ai->flags);
1908 enable_interrupts(ai);
1909
1910 try_auto_wep(ai);
1da177e4 1911 }
175ec1a1 1912 enable_MAC(ai, 1);
1da177e4
LT		 1913
1914 netif_start_queue(dev);
1915 return 0;
1916}
1917
1918static int mpi_start_xmit(struct sk_buff *skb, struct net_device *dev) {
1919 int npacks, pending;
1920 unsigned long flags;
faf3994a 1921 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 1922
1923 if (!skb) {
c94c93da 1924 airo_print_err(dev->name, "%s: skb == NULL!",__func__);
1da177e4
LT		 1925 return 0;
1926 }
1927 npacks = skb_queue_len (&ai->txq);
1928
1929 if (npacks >= MAXTXQ - 1) {
1930 netif_stop_queue (dev);
1931 if (npacks > MAXTXQ) {
5d9276da 1932 dev->stats.tx_fifo_errors++;
1da177e4
LT		 1933 return 1;
1934 }
1935 skb_queue_tail (&ai->txq, skb);
1936 return 0;
1937 }
1938
1939 spin_lock_irqsave(&ai->aux_lock, flags);
1940 skb_queue_tail (&ai->txq, skb);
1941 pending = test_bit(FLAG_PENDING_XMIT, &ai->flags);
1942 spin_unlock_irqrestore(&ai->aux_lock,flags);
1943 netif_wake_queue (dev);
1944
1945 if (pending == 0) {
1946 set_bit(FLAG_PENDING_XMIT, &ai->flags);
1947 mpi_send_packet (dev);
1948 }
1949 return 0;
1950}
1951
1952/*
1953 * @mpi_send_packet
1954 *
1955 * Attempt to transmit a packet. Can be called from interrupt
1956 * or transmit . return number of packets we tried to send
1957 */
1958
1959static int mpi_send_packet (struct net_device *dev)
1960{
1961 struct sk_buff *skb;
1962 unsigned char *buffer;
593c2b9c
AV		 1963 s16 len;
1964 __le16 *payloadLen;
faf3994a 1965 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 1966 u8 *sendbuf;
1967
1968 /* get a packet to send */
1969
79ea13ce 1970 if ((skb = skb_dequeue(&ai->txq)) == NULL) {
934d8bf1
DW		 1971 airo_print_err(dev->name,
1972 "%s: Dequeue'd zero in send_packet()",
c94c93da 1973 __func__);
1da177e4
LT		 1974 return 0;
1975 }
1976
1977 /* check min length*/
1978 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1979 buffer = skb->data;
1980
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);
1985
1986/*
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 * ------------------------------------------------
1992 */
1993
1994 memcpy((char *)ai->txfids[0].virtual_host_addr,
1995 (char *)&wifictlhdr8023, sizeof(wifictlhdr8023));
1996
593c2b9c 1997 payloadLen = (__le16 *)(ai->txfids[0].virtual_host_addr +
1da177e4
LT		 1998 sizeof(wifictlhdr8023));
1999 sendbuf = ai->txfids[0].virtual_host_addr +
2000 sizeof(wifictlhdr8023) + 2 ;
2001
2002 /*
2003 * Firmware automaticly puts 802 header on so
2004 * we don't need to account for it in the length
2005 */
1da177e4 2006 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
593c2b9c 2007 (ntohs(((__be16 *)buffer)[6]) != 0x888E)) {
1da177e4
LT		 2008 MICBuffer pMic;
2009
2010 if (encapsulate(ai, (etherHead *)buffer, &pMic, len - sizeof(etherHead)) != SUCCESS)
2011 return ERROR;
2012
2013 *payloadLen = cpu_to_le16(len-sizeof(etherHead)+sizeof(pMic));
2014 ai->txfids[0].tx_desc.len += sizeof(pMic);
2015 /* copy data into airo dma buffer */
2016 memcpy (sendbuf, buffer, sizeof(etherHead));
2017 buffer += sizeof(etherHead);
2018 sendbuf += sizeof(etherHead);
2019 memcpy (sendbuf, &pMic, sizeof(pMic));
2020 sendbuf += sizeof(pMic);
2021 memcpy (sendbuf, buffer, len - sizeof(etherHead));
a39d3e79 2022 } else {
1da177e4
LT		 2023 *payloadLen = cpu_to_le16(len - sizeof(etherHead));
2024
2025 dev->trans_start = jiffies;
2026
2027 /* copy data into airo dma buffer */
2028 memcpy(sendbuf, buffer, len);
2029 }
2030
2031 memcpy_toio(ai->txfids[0].card_ram_off,
2032 &ai->txfids[0].tx_desc, sizeof(TxFid));
2033
2034 OUT4500(ai, EVACK, 8);
2035
2036 dev_kfree_skb_any(skb);
2037 return 1;
2038}
2039
29b09fcc 2040static void get_tx_error(struct airo_info *ai, s32 fid)
1da177e4 2041{
593c2b9c 2042 __le16 status;
1da177e4
LT		 2043
2044 if (fid < 0)
2045 status = ((WifiCtlHdr *)ai->txfids[0].virtual_host_addr)->ctlhdr.status;
2046 else {
2047 if (bap_setup(ai, ai->fids[fid] & 0xffff, 4, BAP0) != SUCCESS)
2048 return;
2049 bap_read(ai, &status, 2, BAP0);
2050 }
2051 if (le16_to_cpu(status) & 2) /* Too many retries */
5d9276da 2052 ai->dev->stats.tx_aborted_errors++;
1da177e4 2053 if (le16_to_cpu(status) & 4) /* Transmit lifetime exceeded */
5d9276da 2054 ai->dev->stats.tx_heartbeat_errors++;
1da177e4
LT		 2055 if (le16_to_cpu(status) & 8) /* Aid fail */
2056 { }
2057 if (le16_to_cpu(status) & 0x10) /* MAC disabled */
5d9276da 2058 ai->dev->stats.tx_carrier_errors++;
1da177e4
LT		 2059 if (le16_to_cpu(status) & 0x20) /* Association lost */
2060 { }
2061 /* We produce a TXDROP event only for retry or lifetime
2062 * exceeded, because that's the only status that really mean
2063 * that this particular node went away.
2064 * Other errors means that *we* screwed up. - Jean II */
2065 if ((le16_to_cpu(status) & 2) ||
2066 (le16_to_cpu(status) & 4)) {
2067 union iwreq_data wrqu;
2068 char junk[0x18];
2069
2070 /* Faster to skip over useless data than to do
2071 * another bap_setup(). We are at offset 0x6 and
2072 * need to go to 0x18 and read 6 bytes - Jean II */
b8c06bc1 2073 bap_read(ai, (__le16 *) junk, 0x18, BAP0);
1da177e4
LT		 2074
2075 /* Copy 802.11 dest address.
2076 * We use the 802.11 header because the frame may
2077 * not be 802.3 or may be mangled...
2078 * In Ad-Hoc mode, it will be the node address.
2079 * In managed mode, it will be most likely the AP addr
2080 * User space will figure out how to convert it to
2081 * whatever it needs (IP address or else).
2082 * - Jean II */
2083 memcpy(wrqu.addr.sa_data, junk + 0x12, ETH_ALEN);
2084 wrqu.addr.sa_family = ARPHRD_ETHER;
2085
2086 /* Send event to user space */
2087 wireless_send_event(ai->dev, IWEVTXDROP, &wrqu, NULL);
2088 }
2089}
2090
2091static void airo_end_xmit(struct net_device *dev) {
2092 u16 status;
2093 int i;
faf3994a 2094 struct airo_info *priv = dev->ml_priv;
1da177e4
LT		 2095 struct sk_buff *skb = priv->xmit.skb;
2096 int fid = priv->xmit.fid;
2097 u32 *fids = priv->fids;
2098
3c304956 2099 clear_bit(JOB_XMIT, &priv->jobs);
1da177e4
LT		 2100 clear_bit(FLAG_PENDING_XMIT, &priv->flags);
2101 status = transmit_802_3_packet (priv, fids[fid], skb->data);
2102 up(&priv->sem);
2103
2104 i = 0;
2105 if ( status == SUCCESS ) {
2106 dev->trans_start = jiffies;
2107 for (; i < MAX_FIDS / 2 && (priv->fids[i] & 0xffff0000); i++);
2108 } else {
2109 priv->fids[fid] &= 0xffff;
5d9276da 2110 dev->stats.tx_window_errors++;
1da177e4
LT		 2111 }
2112 if (i < MAX_FIDS / 2)
2113 netif_wake_queue(dev);
2114 dev_kfree_skb(skb);
2115}
2116
2117static int airo_start_xmit(struct sk_buff *skb, struct net_device *dev) {
2118 s16 len;
2119 int i, j;
faf3994a 2120 struct airo_info *priv = dev->ml_priv;
1da177e4
LT		 2121 u32 *fids = priv->fids;
2122
2123 if ( skb == NULL ) {
c94c93da 2124 airo_print_err(dev->name, "%s: skb == NULL!", __func__);
1da177e4
LT		 2125 return 0;
2126 }
2127
2128 /* Find a vacant FID */
2129 for( i = 0; i < MAX_FIDS / 2 && (fids[i] & 0xffff0000); i++ );
2130 for( j = i + 1; j < MAX_FIDS / 2 && (fids[j] & 0xffff0000); j++ );
2131
2132 if ( j >= MAX_FIDS / 2 ) {
2133 netif_stop_queue(dev);
2134
2135 if (i == MAX_FIDS / 2) {
5d9276da 2136 dev->stats.tx_fifo_errors++;
1da177e4
LT		 2137 return 1;
2138 }
2139 }
2140 /* check min length*/
2141 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2142 /* Mark fid as used & save length for later */
2143 fids[i] |= (len << 16);
2144 priv->xmit.skb = skb;
2145 priv->xmit.fid = i;
2146 if (down_trylock(&priv->sem) != 0) {
2147 set_bit(FLAG_PENDING_XMIT, &priv->flags);
2148 netif_stop_queue(dev);
3c304956 2149 set_bit(JOB_XMIT, &priv->jobs);
1da177e4
LT		 2150 wake_up_interruptible(&priv->thr_wait);
2151 } else
2152 airo_end_xmit(dev);
2153 return 0;
2154}
2155
2156static void airo_end_xmit11(struct net_device *dev) {
2157 u16 status;
2158 int i;
faf3994a 2159 struct airo_info *priv = dev->ml_priv;
1da177e4
LT		 2160 struct sk_buff *skb = priv->xmit11.skb;
2161 int fid = priv->xmit11.fid;
2162 u32 *fids = priv->fids;
2163
3c304956 2164 clear_bit(JOB_XMIT11, &priv->jobs);
1da177e4
LT		 2165 clear_bit(FLAG_PENDING_XMIT11, &priv->flags);
2166 status = transmit_802_11_packet (priv, fids[fid], skb->data);
2167 up(&priv->sem);
2168
2169 i = MAX_FIDS / 2;
2170 if ( status == SUCCESS ) {
2171 dev->trans_start = jiffies;
2172 for (; i < MAX_FIDS && (priv->fids[i] & 0xffff0000); i++);
2173 } else {
2174 priv->fids[fid] &= 0xffff;
5d9276da 2175 dev->stats.tx_window_errors++;
1da177e4
LT		 2176 }
2177 if (i < MAX_FIDS)
2178 netif_wake_queue(dev);
2179 dev_kfree_skb(skb);
2180}
2181
2182static int airo_start_xmit11(struct sk_buff *skb, struct net_device *dev) {
2183 s16 len;
2184 int i, j;
faf3994a 2185 struct airo_info *priv = dev->ml_priv;
1da177e4
LT		 2186 u32 *fids = priv->fids;
2187
2188 if (test_bit(FLAG_MPI, &priv->flags)) {
2189 /* Not implemented yet for MPI350 */
2190 netif_stop_queue(dev);
2191 return -ENETDOWN;
2192 }
2193
2194 if ( skb == NULL ) {
c94c93da 2195 airo_print_err(dev->name, "%s: skb == NULL!", __func__);
1da177e4
LT		 2196 return 0;
2197 }
2198
2199 /* Find a vacant FID */
2200 for( i = MAX_FIDS / 2; i < MAX_FIDS && (fids[i] & 0xffff0000); i++ );
2201 for( j = i + 1; j < MAX_FIDS && (fids[j] & 0xffff0000); j++ );
2202
2203 if ( j >= MAX_FIDS ) {
2204 netif_stop_queue(dev);
2205
2206 if (i == MAX_FIDS) {
5d9276da 2207 dev->stats.tx_fifo_errors++;
1da177e4
LT		 2208 return 1;
2209 }
2210 }
2211 /* check min length*/
2212 len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
2213 /* Mark fid as used & save length for later */
2214 fids[i] |= (len << 16);
2215 priv->xmit11.skb = skb;
2216 priv->xmit11.fid = i;
2217 if (down_trylock(&priv->sem) != 0) {
2218 set_bit(FLAG_PENDING_XMIT11, &priv->flags);
2219 netif_stop_queue(dev);
3c304956 2220 set_bit(JOB_XMIT11, &priv->jobs);
1da177e4
LT		 2221 wake_up_interruptible(&priv->thr_wait);
2222 } else
2223 airo_end_xmit11(dev);
2224 return 0;
2225}
2226
5d9276da 2227static void airo_read_stats(struct net_device *dev)
a23ace5f 2228{
faf3994a 2229 struct airo_info *ai = dev->ml_priv;
1da177e4 2230 StatsRid stats_rid;
a23ace5f 2231 __le32 *vals = stats_rid.vals;
1da177e4 2232
3c304956 2233 clear_bit(JOB_STATS, &ai->jobs);
ca078bae 2234 if (ai->power.event) {
1da177e4
LT		 2235 up(&ai->sem);
2236 return;
2237 }
2238 readStatsRid(ai, &stats_rid, RID_STATS, 0);
2239 up(&ai->sem);
2240
5d9276da 2241 dev->stats.rx_packets = le32_to_cpu(vals[43]) + le32_to_cpu(vals[44]) +
a23ace5f 2242 le32_to_cpu(vals[45]);
5d9276da 2243 dev->stats.tx_packets = le32_to_cpu(vals[39]) + le32_to_cpu(vals[40]) +
a23ace5f 2244 le32_to_cpu(vals[41]);
5d9276da
PZ		 2245 dev->stats.rx_bytes = le32_to_cpu(vals[92]);
2246 dev->stats.tx_bytes = le32_to_cpu(vals[91]);
2247 dev->stats.rx_errors = le32_to_cpu(vals[0]) + le32_to_cpu(vals[2]) +
a23ace5f 2248 le32_to_cpu(vals[3]) + le32_to_cpu(vals[4]);
5d9276da
PZ		 2249 dev->stats.tx_errors = le32_to_cpu(vals[42]) +
2250 dev->stats.tx_fifo_errors;
2251 dev->stats.multicast = le32_to_cpu(vals[43]);
2252 dev->stats.collisions = le32_to_cpu(vals[89]);
1da177e4
LT		 2253
2254 /* detailed rx_errors: */
5d9276da
PZ		 2255 dev->stats.rx_length_errors = le32_to_cpu(vals[3]);
2256 dev->stats.rx_crc_errors = le32_to_cpu(vals[4]);
2257 dev->stats.rx_frame_errors = le32_to_cpu(vals[2]);
2258 dev->stats.rx_fifo_errors = le32_to_cpu(vals[0]);
1da177e4
LT		 2259}
2260
ff1d2767 2261static struct net_device_stats *airo_get_stats(struct net_device *dev)
1da177e4 2262{
faf3994a 2263 struct airo_info *local = dev->ml_priv;
1da177e4 2264
3c304956 2265 if (!test_bit(JOB_STATS, &local->jobs)) {
1da177e4
LT		 2266 /* Get stats out of the card if available */
2267 if (down_trylock(&local->sem) != 0) {
3c304956 2268 set_bit(JOB_STATS, &local->jobs);
1da177e4
LT		 2269 wake_up_interruptible(&local->thr_wait);
2270 } else
5d9276da 2271 airo_read_stats(dev);
1da177e4
LT		 2272 }
2273
5d9276da 2274 return &dev->stats;
1da177e4
LT		 2275}
2276
2277static void airo_set_promisc(struct airo_info *ai) {
2278 Cmd cmd;
2279 Resp rsp;
2280
2281 memset(&cmd, 0, sizeof(cmd));
2282 cmd.cmd=CMD_SETMODE;
3c304956 2283 clear_bit(JOB_PROMISC, &ai->jobs);
1da177e4
LT		 2284 cmd.parm0=(ai->flags&IFF_PROMISC) ? PROMISC : NOPROMISC;
2285 issuecommand(ai, &cmd, &rsp);
2286 up(&ai->sem);
2287}
2288
2289static void airo_set_multicast_list(struct net_device *dev) {
faf3994a 2290 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 2291
2292 if ((dev->flags ^ ai->flags) & IFF_PROMISC) {
2293 change_bit(FLAG_PROMISC, &ai->flags);
2294 if (down_trylock(&ai->sem) != 0) {
3c304956 2295 set_bit(JOB_PROMISC, &ai->jobs);
1da177e4
LT		 2296 wake_up_interruptible(&ai->thr_wait);
2297 } else
2298 airo_set_promisc(ai);
2299 }
2300
2301 if ((dev->flags&IFF_ALLMULTI)||dev->mc_count>0) {
2302 /* Turn on multicast. (Should be already setup...) */
2303 }
2304}
2305
2306static int airo_set_mac_address(struct net_device *dev, void *p)
2307{
faf3994a 2308 struct airo_info *ai = dev->ml_priv;
1da177e4 2309 struct sockaddr *addr = p;
1da177e4
LT		 2310
2311 readConfigRid(ai, 1);
2312 memcpy (ai->config.macAddr, addr->sa_data, dev->addr_len);
2313 set_bit (FLAG_COMMIT, &ai->flags);
2314 disable_MAC(ai, 1);
2315 writeConfigRid (ai, 1);
175ec1a1 2316 enable_MAC(ai, 1);
1da177e4
LT		 2317 memcpy (ai->dev->dev_addr, addr->sa_data, dev->addr_len);
2318 if (ai->wifidev)
2319 memcpy (ai->wifidev->dev_addr, addr->sa_data, dev->addr_len);
2320 return 0;
2321}
2322
2323static int airo_change_mtu(struct net_device *dev, int new_mtu)
2324{
2325 if ((new_mtu < 68) || (new_mtu > 2400))
2326 return -EINVAL;
2327 dev->mtu = new_mtu;
2328 return 0;
2329}
2330
af5b5c9a
MS		 2331static LIST_HEAD(airo_devices);
2332
2333static void add_airo_dev(struct airo_info *ai)
2334{
2335 /* Upper layers already keep track of PCI devices,
2336 * so we only need to remember our non-PCI cards. */
2337 if (!ai->pci)
2338 list_add_tail(&ai->dev_list, &airo_devices);
2339}
2340
2341static void del_airo_dev(struct airo_info *ai)
2342{
2343 if (!ai->pci)
2344 list_del(&ai->dev_list);
2345}
1da177e4
LT		 2346
2347static int airo_close(struct net_device *dev) {
faf3994a 2348 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 2349
2350 netif_stop_queue(dev);
2351
2352 if (ai->wifidev != dev) {
2353#ifdef POWER_ON_DOWN
2354 /* Shut power to the card. The idea is that the user can save
2355 * power when he doesn't need the card with "ifconfig down".
2356 * That's the method that is most friendly towards the network
2357 * stack (i.e. the network stack won't try to broadcast
2358 * anything on the interface and routes are gone. Jean II */
2359 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2360 disable_MAC(ai, 1);
2361#endif
2362 disable_interrupts( ai );
1c2b7db8
MS		 2363
2364 free_irq(dev->irq, dev);
2365
2366 set_bit(JOB_DIE, &ai->jobs);
2367 kthread_stop(ai->airo_thread_task);
1da177e4
LT		 2368 }
2369 return 0;
2370}
2371
1da177e4
LT		 2372void stop_airo_card( struct net_device *dev, int freeres )
2373{
faf3994a 2374 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 2375
2376 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2377 disable_MAC(ai, 1);
2378 disable_interrupts(ai);
1da177e4
LT		 2379 takedown_proc_entry( dev, ai );
2380 if (test_bit(FLAG_REGISTERED, &ai->flags)) {
2381 unregister_netdev( dev );
2382 if (ai->wifidev) {
2383 unregister_netdev(ai->wifidev);
2384 free_netdev(ai->wifidev);
2385 ai->wifidev = NULL;
2386 }
2387 clear_bit(FLAG_REGISTERED, &ai->flags);
2388 }
1da177e4
LT		 2389 /*
2390 * Clean out tx queue
2391 */
b03efcfb 2392 if (test_bit(FLAG_MPI, &ai->flags) && !skb_queue_empty(&ai->txq)) {
1da177e4
LT		 2393 struct sk_buff *skb = NULL;
2394 for (;(skb = skb_dequeue(&ai->txq));)
2395 dev_kfree_skb(skb);
2396 }
2397
9e75af30
DW		 2398 airo_networks_free (ai);
2399
b4558ea9
JJ		 2400 kfree(ai->flash);
2401 kfree(ai->rssi);
2402 kfree(ai->APList);
2403 kfree(ai->SSID);
1da177e4
LT		 2404 if (freeres) {
2405 /* PCMCIA frees this stuff, so only for PCI and ISA */
2406 release_region( dev->base_addr, 64 );
2407 if (test_bit(FLAG_MPI, &ai->flags)) {
2408 if (ai->pci)
2409 mpi_unmap_card(ai->pci);
2410 if (ai->pcimem)
2411 iounmap(ai->pcimem);
2412 if (ai->pciaux)
2413 iounmap(ai->pciaux);
2414 pci_free_consistent(ai->pci, PCI_SHARED_LEN,
2415 ai->shared, ai->shared_dma);
2416 }
2417 }
f12cc209 2418 crypto_free_cipher(ai->tfm);
af5b5c9a 2419 del_airo_dev(ai);
1da177e4
LT		 2420 free_netdev( dev );
2421}
2422
2423EXPORT_SYMBOL(stop_airo_card);
2424
b95cce35 2425static int wll_header_parse(const struct sk_buff *skb, unsigned char *haddr)
1da177e4 2426{
98e399f8 2427 memcpy(haddr, skb_mac_header(skb) + 10, ETH_ALEN);
1da177e4
LT		 2428 return ETH_ALEN;
2429}
2430
2431static void mpi_unmap_card(struct pci_dev *pci)
2432{
2433 unsigned long mem_start = pci_resource_start(pci, 1);
2434 unsigned long mem_len = pci_resource_len(pci, 1);
2435 unsigned long aux_start = pci_resource_start(pci, 2);
2436 unsigned long aux_len = AUXMEMSIZE;
2437
2438 release_mem_region(aux_start, aux_len);
2439 release_mem_region(mem_start, mem_len);
2440}
2441
2442/*************************************************************
2443 * This routine assumes that descriptors have been setup .
2444 * Run at insmod time or after reset when the decriptors
2445 * have been initialized . Returns 0 if all is well nz
2446 * otherwise . Does not allocate memory but sets up card
2447 * using previously allocated descriptors.
2448 */
2449static int mpi_init_descriptors (struct airo_info *ai)
2450{
2451 Cmd cmd;
2452 Resp rsp;
2453 int i;
2454 int rc = SUCCESS;
2455
2456 /* Alloc card RX descriptors */
2457 netif_stop_queue(ai->dev);
2458
2459 memset(&rsp,0,sizeof(rsp));
2460 memset(&cmd,0,sizeof(cmd));
2461
2462 cmd.cmd = CMD_ALLOCATEAUX;
2463 cmd.parm0 = FID_RX;
2464 cmd.parm1 = (ai->rxfids[0].card_ram_off - ai->pciaux);
2465 cmd.parm2 = MPI_MAX_FIDS;
2466 rc=issuecommand(ai, &cmd, &rsp);
2467 if (rc != SUCCESS) {
934d8bf1 2468 airo_print_err(ai->dev->name, "Couldn't allocate RX FID");
1da177e4
LT		 2469 return rc;
2470 }
2471
2472 for (i=0; i<MPI_MAX_FIDS; i++) {
2473 memcpy_toio(ai->rxfids[i].card_ram_off,
2474 &ai->rxfids[i].rx_desc, sizeof(RxFid));
2475 }
2476
2477 /* Alloc card TX descriptors */
2478
2479 memset(&rsp,0,sizeof(rsp));
2480 memset(&cmd,0,sizeof(cmd));
2481
2482 cmd.cmd = CMD_ALLOCATEAUX;
2483 cmd.parm0 = FID_TX;
2484 cmd.parm1 = (ai->txfids[0].card_ram_off - ai->pciaux);
2485 cmd.parm2 = MPI_MAX_FIDS;
2486
2487 for (i=0; i<MPI_MAX_FIDS; i++) {
2488 ai->txfids[i].tx_desc.valid = 1;
2489 memcpy_toio(ai->txfids[i].card_ram_off,
2490 &ai->txfids[i].tx_desc, sizeof(TxFid));
2491 }
2492 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2493
2494 rc=issuecommand(ai, &cmd, &rsp);
2495 if (rc != SUCCESS) {
934d8bf1 2496 airo_print_err(ai->dev->name, "Couldn't allocate TX FID");
1da177e4
LT		 2497 return rc;
2498 }
2499
2500 /* Alloc card Rid descriptor */
2501 memset(&rsp,0,sizeof(rsp));
2502 memset(&cmd,0,sizeof(cmd));
2503
2504 cmd.cmd = CMD_ALLOCATEAUX;
2505 cmd.parm0 = RID_RW;
2506 cmd.parm1 = (ai->config_desc.card_ram_off - ai->pciaux);
2507 cmd.parm2 = 1; /* Magic number... */
2508 rc=issuecommand(ai, &cmd, &rsp);
2509 if (rc != SUCCESS) {
934d8bf1 2510 airo_print_err(ai->dev->name, "Couldn't allocate RID");
1da177e4
LT		 2511 return rc;
2512 }
2513
2514 memcpy_toio(ai->config_desc.card_ram_off,
2515 &ai->config_desc.rid_desc, sizeof(Rid));
2516
2517 return rc;
2518}
2519
2520/*
2521 * We are setting up three things here:
2522 * 1) Map AUX memory for descriptors: Rid, TxFid, or RxFid.
2523 * 2) Map PCI memory for issueing commands.
2524 * 3) Allocate memory (shared) to send and receive ethernet frames.
2525 */
1138c37b 2526static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci)
1da177e4
LT		 2527{
2528 unsigned long mem_start, mem_len, aux_start, aux_len;
2529 int rc = -1;
2530 int i;
2759c8d5
JG		 2531 dma_addr_t busaddroff;
2532 unsigned char *vpackoff;
1da177e4
LT		 2533 unsigned char __iomem *pciaddroff;
2534
2535 mem_start = pci_resource_start(pci, 1);
2536 mem_len = pci_resource_len(pci, 1);
2537 aux_start = pci_resource_start(pci, 2);
2538 aux_len = AUXMEMSIZE;
2539
1138c37b
MS		 2540 if (!request_mem_region(mem_start, mem_len, DRV_NAME)) {
2541 airo_print_err("", "Couldn't get region %x[%x]",
2542 (int)mem_start, (int)mem_len);
1da177e4
LT		 2543 goto out;
2544 }
1138c37b
MS		 2545 if (!request_mem_region(aux_start, aux_len, DRV_NAME)) {
2546 airo_print_err("", "Couldn't get region %x[%x]",
2547 (int)aux_start, (int)aux_len);
1da177e4
LT		 2548 goto free_region1;
2549 }
2550
2551 ai->pcimem = ioremap(mem_start, mem_len);
2552 if (!ai->pcimem) {
1138c37b
MS		 2553 airo_print_err("", "Couldn't map region %x[%x]",
2554 (int)mem_start, (int)mem_len);
1da177e4
LT		 2555 goto free_region2;
2556 }
2557 ai->pciaux = ioremap(aux_start, aux_len);
2558 if (!ai->pciaux) {
1138c37b
MS		 2559 airo_print_err("", "Couldn't map region %x[%x]",
2560 (int)aux_start, (int)aux_len);
1da177e4
LT		 2561 goto free_memmap;
2562 }
2563
2564 /* Reserve PKTSIZE for each fid and 2K for the Rids */
2565 ai->shared = pci_alloc_consistent(pci, PCI_SHARED_LEN, &ai->shared_dma);
2566 if (!ai->shared) {
1138c37b
MS		 2567 airo_print_err("", "Couldn't alloc_consistent %d",
2568 PCI_SHARED_LEN);
1da177e4
LT		 2569 goto free_auxmap;
2570 }
2571
2572 /*
2573 * Setup descriptor RX, TX, CONFIG
2574 */
2759c8d5 2575 busaddroff = ai->shared_dma;
1da177e4
LT		 2576 pciaddroff = ai->pciaux + AUX_OFFSET;
2577 vpackoff = ai->shared;
2578
2579 /* RX descriptor setup */
2580 for(i = 0; i < MPI_MAX_FIDS; i++) {
2581 ai->rxfids[i].pending = 0;
2582 ai->rxfids[i].card_ram_off = pciaddroff;
2583 ai->rxfids[i].virtual_host_addr = vpackoff;
2759c8d5 2584 ai->rxfids[i].rx_desc.host_addr = busaddroff;
1da177e4
LT		 2585 ai->rxfids[i].rx_desc.valid = 1;
2586 ai->rxfids[i].rx_desc.len = PKTSIZE;
2587 ai->rxfids[i].rx_desc.rdy = 0;
2588
2589 pciaddroff += sizeof(RxFid);
2590 busaddroff += PKTSIZE;
2591 vpackoff += PKTSIZE;
2592 }
2593
2594 /* TX descriptor setup */
2595 for(i = 0; i < MPI_MAX_FIDS; i++) {
2596 ai->txfids[i].card_ram_off = pciaddroff;
2597 ai->txfids[i].virtual_host_addr = vpackoff;
2598 ai->txfids[i].tx_desc.valid = 1;
2759c8d5 2599 ai->txfids[i].tx_desc.host_addr = busaddroff;
1da177e4
LT		 2600 memcpy(ai->txfids[i].virtual_host_addr,
2601 &wifictlhdr8023, sizeof(wifictlhdr8023));
2602
2603 pciaddroff += sizeof(TxFid);
2604 busaddroff += PKTSIZE;
2605 vpackoff += PKTSIZE;
2606 }
2607 ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2608
2609 /* Rid descriptor setup */
2610 ai->config_desc.card_ram_off = pciaddroff;
2611 ai->config_desc.virtual_host_addr = vpackoff;
2759c8d5
JG		 2612 ai->config_desc.rid_desc.host_addr = busaddroff;
2613 ai->ridbus = busaddroff;
1da177e4
LT		 2614 ai->config_desc.rid_desc.rid = 0;
2615 ai->config_desc.rid_desc.len = RIDSIZE;
2616 ai->config_desc.rid_desc.valid = 1;
2617 pciaddroff += sizeof(Rid);
2618 busaddroff += RIDSIZE;
2619 vpackoff += RIDSIZE;
2620
2621 /* Tell card about descriptors */
2622 if (mpi_init_descriptors (ai) != SUCCESS)
2623 goto free_shared;
2624
2625 return 0;
2626 free_shared:
2627 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2628 free_auxmap:
2629 iounmap(ai->pciaux);
2630 free_memmap:
2631 iounmap(ai->pcimem);
2632 free_region2:
2633 release_mem_region(aux_start, aux_len);
2634 free_region1:
2635 release_mem_region(mem_start, mem_len);
2636 out:
2637 return rc;
2638}
2639
3b04ddde
SH		 2640static const struct header_ops airo_header_ops = {
2641 .parse = wll_header_parse,
2642};
2643
1da177e4
LT		 2644static void wifi_setup(struct net_device *dev)
2645{
3b04ddde 2646 dev->header_ops = &airo_header_ops;
1da177e4
LT		 2647 dev->hard_start_xmit = &airo_start_xmit11;
2648 dev->get_stats = &airo_get_stats;
2649 dev->set_mac_address = &airo_set_mac_address;
2650 dev->do_ioctl = &airo_ioctl;
1da177e4 2651 dev->wireless_handlers = &airo_handler_def;
1da177e4
LT		 2652 dev->change_mtu = &airo_change_mtu;
2653 dev->open = &airo_open;
2654 dev->stop = &airo_close;
2655
2656 dev->type = ARPHRD_IEEE80211;
2657 dev->hard_header_len = ETH_HLEN;
15db2763 2658 dev->mtu = AIRO_DEF_MTU;
1da177e4
LT		 2659 dev->addr_len = ETH_ALEN;
2660 dev->tx_queue_len = 100;
2661
2662 memset(dev->broadcast,0xFF, ETH_ALEN);
2663
2664 dev->flags = IFF_BROADCAST|IFF_MULTICAST;
2665}
2666
2667static struct net_device *init_wifidev(struct airo_info *ai,
2668 struct net_device *ethdev)
2669{
2670 int err;
2671 struct net_device *dev = alloc_netdev(0, "wifi%d", wifi_setup);
2672 if (!dev)
2673 return NULL;
faf3994a 2674 dev->ml_priv = ethdev->ml_priv;
1da177e4
LT		 2675 dev->irq = ethdev->irq;
2676 dev->base_addr = ethdev->base_addr;
1da177e4 2677 dev->wireless_data = ethdev->wireless_data;
229ce3ab 2678 SET_NETDEV_DEV(dev, ethdev->dev.parent);
1da177e4
LT		 2679 memcpy(dev->dev_addr, ethdev->dev_addr, dev->addr_len);
2680 err = register_netdev(dev);
2681 if (err<0) {
2682 free_netdev(dev);
2683 return NULL;
2684 }
2685 return dev;
2686}
2687
ff1d2767 2688static int reset_card( struct net_device *dev , int lock) {
faf3994a 2689 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 2690
2691 if (lock && down_interruptible(&ai->sem))
2692 return -1;
2693 waitbusy (ai);
2694 OUT4500(ai,COMMAND,CMD_SOFTRESET);
2695 msleep(200);
2696 waitbusy (ai);
2697 msleep(200);
2698 if (lock)
2699 up(&ai->sem);
2700 return 0;
2701}
2702
3c304956 2703#define AIRO_MAX_NETWORK_COUNT 64
9e75af30
DW		 2704static int airo_networks_allocate(struct airo_info *ai)
2705{
2706 if (ai->networks)
2707 return 0;
2708
2709 ai->networks =
3c304956 2710 kzalloc(AIRO_MAX_NETWORK_COUNT * sizeof(BSSListElement),
9e75af30
DW		 2711 GFP_KERNEL);
2712 if (!ai->networks) {
1138c37b 2713 airo_print_warn("", "Out of memory allocating beacons");
9e75af30
DW		 2714 return -ENOMEM;
2715 }
2716
2717 return 0;
2718}
2719
2720static void airo_networks_free(struct airo_info *ai)
2721{
9e75af30
DW		 2722 kfree(ai->networks);
2723 ai->networks = NULL;
2724}
2725
2726static void airo_networks_initialize(struct airo_info *ai)
2727{
2728 int i;
2729
2730 INIT_LIST_HEAD(&ai->network_free_list);
2731 INIT_LIST_HEAD(&ai->network_list);
3c304956 2732 for (i = 0; i < AIRO_MAX_NETWORK_COUNT; i++)
9e75af30
DW		 2733 list_add_tail(&ai->networks[i].list,
2734 &ai->network_free_list);
2735}
2736
3c304956
DW		 2737static int airo_test_wpa_capable(struct airo_info *ai)
2738{
2739 int status;
2740 CapabilityRid cap_rid;
3c304956
DW		 2741
2742 status = readCapabilityRid(ai, &cap_rid, 1);
2743 if (status != SUCCESS) return 0;
2744
2745 /* Only firmware versions 5.30.17 or better can do WPA */
56d81bd3
AV		 2746 if (le16_to_cpu(cap_rid.softVer) > 0x530
2747 || (le16_to_cpu(cap_rid.softVer) == 0x530
2748 && le16_to_cpu(cap_rid.softSubVer) >= 17)) {
1138c37b 2749 airo_print_info("", "WPA is supported.");
3c304956
DW		 2750 return 1;
2751 }
2752
2753 /* No WPA support */
1138c37b 2754 airo_print_info("", "WPA unsupported (only firmware versions 5.30.17"
3c304956
DW		 2755 " and greater support WPA. Detected %s)", cap_rid.prodVer);
2756 return 0;
2757}
2758
ff1d2767
JM		 2759static struct net_device *_init_airo_card( unsigned short irq, int port,
2760 int is_pcmcia, struct pci_dev *pci,
2761 struct device *dmdev )
1da177e4
LT		 2762{
2763 struct net_device *dev;
2764 struct airo_info *ai;
2765 int i, rc;
2766
2767 /* Create the network device object. */
1138c37b
MS		 2768 dev = alloc_netdev(sizeof(*ai), "", ether_setup);
2769 if (!dev) {
934d8bf1 2770 airo_print_err("", "Couldn't alloc_etherdev");
1da177e4 2771 return NULL;
1da177e4
LT		 2772 }
2773
faf3994a 2774 ai = dev->ml_priv = netdev_priv(dev);
1da177e4 2775 ai->wifidev = NULL;
fb038c27 2776 ai->flags = 1 << FLAG_RADIO_DOWN;
3c304956 2777 ai->jobs = 0;
934d8bf1 2778 ai->dev = dev;
1da177e4 2779 if (pci && (pci->device == 0x5000 || pci->device == 0xa504)) {
1138c37b 2780 airo_print_dbg("", "Found an MPI350 card");
1da177e4
LT		 2781 set_bit(FLAG_MPI, &ai->flags);
2782 }
1da177e4
LT		 2783 spin_lock_init(&ai->aux_lock);
2784 sema_init(&ai->sem, 1);
2785 ai->config.len = 0;
2786 ai->pci = pci;
2787 init_waitqueue_head (&ai->thr_wait);
1da177e4 2788 ai->tfm = NULL;
af5b5c9a 2789 add_airo_dev(ai);
1da177e4 2790
9e75af30 2791 if (airo_networks_allocate (ai))
1c2b7db8 2792 goto err_out_free;
9e75af30
DW		 2793 airo_networks_initialize (ai);
2794
1da177e4
LT		 2795 /* The Airo-specific entries in the device structure. */
2796 if (test_bit(FLAG_MPI,&ai->flags)) {
2797 skb_queue_head_init (&ai->txq);
2798 dev->hard_start_xmit = &mpi_start_xmit;
2799 } else
2800 dev->hard_start_xmit = &airo_start_xmit;
2801 dev->get_stats = &airo_get_stats;
2802 dev->set_multicast_list = &airo_set_multicast_list;
2803 dev->set_mac_address = &airo_set_mac_address;
2804 dev->do_ioctl = &airo_ioctl;
1da177e4
LT		 2805 dev->wireless_handlers = &airo_handler_def;
2806 ai->wireless_data.spy_data = &ai->spy_data;
2807 dev->wireless_data = &ai->wireless_data;
1da177e4
LT		 2808 dev->change_mtu = &airo_change_mtu;
2809 dev->open = &airo_open;
2810 dev->stop = &airo_close;
2811 dev->irq = irq;
2812 dev->base_addr = port;
2813
2814 SET_NETDEV_DEV(dev, dmdev);
2815
1d97f384
MC		 2816 reset_card (dev, 1);
2817 msleep(400);
1da177e4 2818
1da177e4 2819 if (!is_pcmcia) {
1138c37b 2820 if (!request_region(dev->base_addr, 64, DRV_NAME)) {
1da177e4 2821 rc = -EBUSY;
934d8bf1 2822 airo_print_err(dev->name, "Couldn't request region");
1c2b7db8 2823 goto err_out_nets;
1da177e4
LT		 2824 }
2825 }
2826
2827 if (test_bit(FLAG_MPI,&ai->flags)) {
1138c37b
MS		 2828 if (mpi_map_card(ai, pci)) {
2829 airo_print_err("", "Could not map memory");
1da177e4
LT		 2830 goto err_out_res;
2831 }
2832 }
2833
2834 if (probe) {
2835 if ( setup_card( ai, dev->dev_addr, 1 ) != SUCCESS ) {
934d8bf1 2836 airo_print_err(dev->name, "MAC could not be enabled" );
1da177e4
LT		 2837 rc = -EIO;
2838 goto err_out_map;
2839 }
2840 } else if (!test_bit(FLAG_MPI,&ai->flags)) {
2841 ai->bap_read = fast_bap_read;
2842 set_bit(FLAG_FLASHING, &ai->flags);
2843 }
2844
3c304956
DW		 2845 /* Test for WPA support */
2846 if (airo_test_wpa_capable(ai)) {
2847 set_bit(FLAG_WPA_CAPABLE, &ai->flags);
2848 ai->bssListFirst = RID_WPA_BSSLISTFIRST;
2849 ai->bssListNext = RID_WPA_BSSLISTNEXT;
2850 ai->bssListRidLen = sizeof(BSSListRid);
2851 } else {
2852 ai->bssListFirst = RID_BSSLISTFIRST;
2853 ai->bssListNext = RID_BSSLISTNEXT;
2854 ai->bssListRidLen = sizeof(BSSListRid) - sizeof(BSSListRidExtra);
2855 }
2856
1138c37b 2857 strcpy(dev->name, "eth%d");
1da177e4
LT		 2858 rc = register_netdev(dev);
2859 if (rc) {
934d8bf1 2860 airo_print_err(dev->name, "Couldn't register_netdev");
1da177e4
LT		 2861 goto err_out_map;
2862 }
2863 ai->wifidev = init_wifidev(ai, dev);
431aca5a
FM		 2864 if (!ai->wifidev)
2865 goto err_out_reg;
1da177e4
LT		 2866
2867 set_bit(FLAG_REGISTERED,&ai->flags);
e174961c 2868 airo_print_info(dev->name, "MAC enabled %pM", dev->dev_addr);
1da177e4
LT		 2869
2870 /* Allocate the transmit buffers */
2871 if (probe && !test_bit(FLAG_MPI,&ai->flags))
2872 for( i = 0; i < MAX_FIDS; i++ )
15db2763 2873 ai->fids[i] = transmit_allocate(ai,AIRO_DEF_MTU,i>=MAX_FIDS/2);
1da177e4 2874
faf3994a 2875 if (setup_proc_entry(dev, dev->ml_priv) < 0)
431aca5a
FM		 2876 goto err_out_wifi;
2877
1da177e4
LT		 2878 return dev;
2879
431aca5a
FM		 2880err_out_wifi:
2881 unregister_netdev(ai->wifidev);
2882 free_netdev(ai->wifidev);
2883err_out_reg:
2884 unregister_netdev(dev);
1da177e4
LT		 2885err_out_map:
2886 if (test_bit(FLAG_MPI,&ai->flags) && pci) {
2887 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2888 iounmap(ai->pciaux);
2889 iounmap(ai->pcimem);
2890 mpi_unmap_card(ai->pci);
2891 }
2892err_out_res:
2893 if (!is_pcmcia)
2894 release_region( dev->base_addr, 64 );
4d881901
MS		 2895err_out_nets:
2896 airo_networks_free(ai);
af5b5c9a 2897 del_airo_dev(ai);
1da177e4
LT		 2898err_out_free:
2899 free_netdev(dev);
2900 return NULL;
2901}
2902
2903struct net_device *init_airo_card( unsigned short irq, int port, int is_pcmcia,
2904 struct device *dmdev)
2905{
2906 return _init_airo_card ( irq, port, is_pcmcia, NULL, dmdev);
2907}
2908
2909EXPORT_SYMBOL(init_airo_card);
2910
2911static int waitbusy (struct airo_info *ai) {
2912 int delay = 0;
b212f337 2913 while ((IN4500(ai, COMMAND) & COMMAND_BUSY) && (delay < 10000)) {
1da177e4
LT		 2914 udelay (10);
2915 if ((++delay % 20) == 0)
2916 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
2917 }
2918 return delay < 10000;
2919}
2920
2921int reset_airo_card( struct net_device *dev )
2922{
2923 int i;
faf3994a 2924 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 2925
2926 if (reset_card (dev, 1))
2927 return -1;
2928
2929 if ( setup_card(ai, dev->dev_addr, 1 ) != SUCCESS ) {
934d8bf1 2930 airo_print_err(dev->name, "MAC could not be enabled");
1da177e4
LT		 2931 return -1;
2932 }
e174961c 2933 airo_print_info(dev->name, "MAC enabled %pM", dev->dev_addr);
1da177e4
LT		 2934 /* Allocate the transmit buffers if needed */
2935 if (!test_bit(FLAG_MPI,&ai->flags))
2936 for( i = 0; i < MAX_FIDS; i++ )
15db2763 2937 ai->fids[i] = transmit_allocate (ai,AIRO_DEF_MTU,i>=MAX_FIDS/2);
1da177e4
LT		 2938
2939 enable_interrupts( ai );
2940 netif_wake_queue(dev);
2941 return 0;
2942}
2943
2944EXPORT_SYMBOL(reset_airo_card);
2945
2946static void airo_send_event(struct net_device *dev) {
faf3994a 2947 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 2948 union iwreq_data wrqu;
2949 StatusRid status_rid;
2950
3c304956 2951 clear_bit(JOB_EVENT, &ai->jobs);
1da177e4
LT		 2952 PC4500_readrid(ai, RID_STATUS, &status_rid, sizeof(status_rid), 0);
2953 up(&ai->sem);
2954 wrqu.data.length = 0;
2955 wrqu.data.flags = 0;
2956 memcpy(wrqu.ap_addr.sa_data, status_rid.bssid[0], ETH_ALEN);
2957 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
2958
2959 /* Send event to user space */
2960 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
2961}
2962
9e75af30
DW		 2963static void airo_process_scan_results (struct airo_info *ai) {
2964 union iwreq_data wrqu;
3c304956 2965 BSSListRid bss;
9e75af30
DW		 2966 int rc;
2967 BSSListElement * loop_net;
2968 BSSListElement * tmp_net;
2969
2970 /* Blow away current list of scan results */
2971 list_for_each_entry_safe (loop_net, tmp_net, &ai->network_list, list) {
2972 list_move_tail (&loop_net->list, &ai->network_free_list);
2973 /* Don't blow away ->list, just BSS data */
2974 memset (loop_net, 0, sizeof (loop_net->bss));
2975 }
2976
2977 /* Try to read the first entry of the scan result */
3c304956 2978 rc = PC4500_readrid(ai, ai->bssListFirst, &bss, ai->bssListRidLen, 0);
17e70491 2979 if((rc) || (bss.index == cpu_to_le16(0xffff))) {
9e75af30
DW		 2980 /* No scan results */
2981 goto out;
2982 }
2983
2984 /* Read and parse all entries */
2985 tmp_net = NULL;
17e70491 2986 while((!rc) && (bss.index != cpu_to_le16(0xffff))) {
9e75af30
DW		 2987 /* Grab a network off the free list */
2988 if (!list_empty(&ai->network_free_list)) {
2989 tmp_net = list_entry(ai->network_free_list.next,
2990 BSSListElement, list);
2991 list_del(ai->network_free_list.next);
2992 }
2993
2994 if (tmp_net != NULL) {
3c304956 2995 memcpy(tmp_net, &bss, sizeof(tmp_net->bss));
9e75af30
DW		 2996 list_add_tail(&tmp_net->list, &ai->network_list);
2997 tmp_net = NULL;
2998 }
2999
3000 /* Read next entry */
3c304956
DW		 3001 rc = PC4500_readrid(ai, ai->bssListNext,
3002 &bss, ai->bssListRidLen, 0);
9e75af30
DW		 3003 }
3004
3005out:
3006 ai->scan_timeout = 0;
3c304956 3007 clear_bit(JOB_SCAN_RESULTS, &ai->jobs);
9e75af30
DW		 3008 up(&ai->sem);
3009
3010 /* Send an empty event to user space.
3011 * We don't send the received data on
3012 * the event because it would require
3013 * us to do complex transcoding, and
3014 * we want to minimise the work done in
3015 * the irq handler. Use a request to
3016 * extract the data - Jean II */
3017 wrqu.data.length = 0;
3018 wrqu.data.flags = 0;
3019 wireless_send_event(ai->dev, SIOCGIWSCAN, &wrqu, NULL);
3020}
3021
1da177e4
LT		 3022static int airo_thread(void *data) {
3023 struct net_device *dev = data;
faf3994a 3024 struct airo_info *ai = dev->ml_priv;
1da177e4 3025 int locked;
83144186
RW		 3026
3027 set_freezable();
1da177e4 3028 while(1) {
1da177e4 3029 /* make swsusp happy with our thread */
3e1d1d28 3030 try_to_freeze();
1da177e4 3031
3c304956 3032 if (test_bit(JOB_DIE, &ai->jobs))
1da177e4
LT		 3033 break;
3034
3c304956 3035 if (ai->jobs) {
1da177e4
LT		 3036 locked = down_interruptible(&ai->sem);
3037 } else {
3038 wait_queue_t wait;
3039
3040 init_waitqueue_entry(&wait, current);
3041 add_wait_queue(&ai->thr_wait, &wait);
3042 for (;;) {
3043 set_current_state(TASK_INTERRUPTIBLE);
3c304956 3044 if (ai->jobs)
1da177e4 3045 break;
9e75af30
DW		 3046 if (ai->expires || ai->scan_timeout) {
3047 if (ai->scan_timeout &&
3048 time_after_eq(jiffies,ai->scan_timeout)){
3c304956 3049 set_bit(JOB_SCAN_RESULTS, &ai->jobs);
9e75af30
DW		 3050 break;
3051 } else if (ai->expires &&
3052 time_after_eq(jiffies,ai->expires)){
3c304956 3053 set_bit(JOB_AUTOWEP, &ai->jobs);
1da177e4
LT		 3054 break;
3055 }
5bb85f18
DK		 3056 if (!kthread_should_stop() &&
3057 !freezing(current)) {
9e75af30
DW		 3058 unsigned long wake_at;
3059 if (!ai->expires || !ai->scan_timeout) {
3060 wake_at = max(ai->expires,
3061 ai->scan_timeout);
3062 } else {
3063 wake_at = min(ai->expires,
3064 ai->scan_timeout);
3065 }
3066 schedule_timeout(wake_at - jiffies);
1da177e4
LT		 3067 continue;
3068 }
5bb85f18
DK		 3069 } else if (!kthread_should_stop() &&
3070 !freezing(current)) {
1da177e4
LT		 3071 schedule();
3072 continue;
3073 }
3074 break;
3075 }
3076 current->state = TASK_RUNNING;
3077 remove_wait_queue(&ai->thr_wait, &wait);
3078 locked = 1;
3079 }
3080
3081 if (locked)
3082 continue;
3083
3c304956 3084 if (test_bit(JOB_DIE, &ai->jobs)) {
1da177e4
LT		 3085 up(&ai->sem);
3086 break;
3087 }
3088
ca078bae 3089 if (ai->power.event || test_bit(FLAG_FLASHING, &ai->flags)) {
1da177e4
LT		 3090 up(&ai->sem);
3091 continue;
3092 }
3093
3c304956 3094 if (test_bit(JOB_XMIT, &ai->jobs))
1da177e4 3095 airo_end_xmit(dev);
3c304956 3096 else if (test_bit(JOB_XMIT11, &ai->jobs))
1da177e4 3097 airo_end_xmit11(dev);
3c304956 3098 else if (test_bit(JOB_STATS, &ai->jobs))
5d9276da 3099 airo_read_stats(dev);
3c304956 3100 else if (test_bit(JOB_WSTATS, &ai->jobs))
1da177e4 3101 airo_read_wireless_stats(ai);
3c304956 3102 else if (test_bit(JOB_PROMISC, &ai->jobs))
1da177e4 3103 airo_set_promisc(ai);
3c304956 3104 else if (test_bit(JOB_MIC, &ai->jobs))
1da177e4 3105 micinit(ai);
3c304956 3106 else if (test_bit(JOB_EVENT, &ai->jobs))
1da177e4 3107 airo_send_event(dev);
3c304956 3108 else if (test_bit(JOB_AUTOWEP, &ai->jobs))
1da177e4 3109 timer_func(dev);
3c304956 3110 else if (test_bit(JOB_SCAN_RESULTS, &ai->jobs))
9e75af30
DW		 3111 airo_process_scan_results(ai);
3112 else /* Shouldn't get here, but we make sure to unlock */
3113 up(&ai->sem);
1da177e4 3114 }
3b4c7d64
SB		 3115
3116 return 0;
1da177e4
LT		 3117}
3118
0300b332
AV		 3119static int header_len(__le16 ctl)
3120{
3121 u16 fc = le16_to_cpu(ctl);
3122 switch (fc & 0xc) {
3123 case 4:
3124 if ((fc & 0xe0) == 0xc0)
3125 return 10; /* one-address control packet */
3126 return 16; /* two-address control packet */
3127 case 8:
3128 if ((fc & 0x300) == 0x300)
3129 return 30; /* WDS packet */
3130 }
3131 return 24;
3132}
3133
f55d4517 3134static void airo_handle_cisco_mic(struct airo_info *ai)
28fc1f5a 3135{
f55d4517
DW		 3136 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags)) {
3137 set_bit(JOB_MIC, &ai->jobs);
3138 wake_up_interruptible(&ai->thr_wait);
3139 }
3140}
3141
3142/* Airo Status codes */
3143#define STAT_NOBEACON 0x8000 /* Loss of sync - missed beacons */
3144#define STAT_MAXRETRIES 0x8001 /* Loss of sync - max retries */
3145#define STAT_MAXARL 0x8002 /* Loss of sync - average retry level exceeded*/
3146#define STAT_FORCELOSS 0x8003 /* Loss of sync - host request */
3147#define STAT_TSFSYNC 0x8004 /* Loss of sync - TSF synchronization */
3148#define STAT_DEAUTH 0x8100 /* low byte is 802.11 reason code */
3149#define STAT_DISASSOC 0x8200 /* low byte is 802.11 reason code */
3150#define STAT_ASSOC_FAIL 0x8400 /* low byte is 802.11 reason code */
3151#define STAT_AUTH_FAIL 0x0300 /* low byte is 802.11 reason code */
3152#define STAT_ASSOC 0x0400 /* Associated */
3153#define STAT_REASSOC 0x0600 /* Reassociated? Only on firmware >= 5.30.17 */
3154
3155static void airo_print_status(const char *devname, u16 status)
3156{
3157 u8 reason = status & 0xFF;
3158
3159 switch (status) {
3160 case STAT_NOBEACON:
3161 airo_print_dbg(devname, "link lost (missed beacons)");
3162 break;
3163 case STAT_MAXRETRIES:
3164 case STAT_MAXARL:
3165 airo_print_dbg(devname, "link lost (max retries)");
3166 break;
3167 case STAT_FORCELOSS:
3168 airo_print_dbg(devname, "link lost (local choice)");
3169 break;
3170 case STAT_TSFSYNC:
3171 airo_print_dbg(devname, "link lost (TSF sync lost)");
3172 break;
3173 case STAT_DEAUTH:
3174 airo_print_dbg(devname, "deauthenticated (reason: %d)", reason);
3175 break;
3176 case STAT_DISASSOC:
3177 airo_print_dbg(devname, "disassociated (reason: %d)", reason);
3178 break;
3179 case STAT_ASSOC_FAIL:
3180 airo_print_dbg(devname, "association failed (reason: %d)",
3181 reason);
3182 break;
3183 case STAT_AUTH_FAIL:
3184 airo_print_dbg(devname, "authentication failed (reason: %d)",
3185 reason);
3186 break;
3187 default:
3188 break;
3189 }
3190}
3191
3192static void airo_handle_link(struct airo_info *ai)
3193{
3194 union iwreq_data wrqu;
3195 int scan_forceloss = 0;
1da177e4 3196 u16 status;
f55d4517
DW		 3197
3198 /* Get new status and acknowledge the link change */
3199 status = le16_to_cpu(IN4500(ai, LINKSTAT));
3200 OUT4500(ai, EVACK, EV_LINK);
3201
3202 if ((status == STAT_FORCELOSS) && (ai->scan_timeout > 0))
3203 scan_forceloss = 1;
3204
3205 airo_print_status(ai->dev->name, status);
3206
3207 if ((status == STAT_ASSOC) || (status == STAT_REASSOC)) {
3208 if (auto_wep)
3209 ai->expires = 0;
3210 if (ai->list_bss_task)
3211 wake_up_process(ai->list_bss_task);
3212 set_bit(FLAG_UPDATE_UNI, &ai->flags);
3213 set_bit(FLAG_UPDATE_MULTI, &ai->flags);
3214
3215 if (down_trylock(&ai->sem) != 0) {
3216 set_bit(JOB_EVENT, &ai->jobs);
3217 wake_up_interruptible(&ai->thr_wait);
3218 } else
3219 airo_send_event(ai->dev);
3220 } else if (!scan_forceloss) {
3221 if (auto_wep && !ai->expires) {
3222 ai->expires = RUN_AT(3*HZ);
3223 wake_up_interruptible(&ai->thr_wait);
3224 }
3225
3226 /* Send event to user space */
3227 memset(wrqu.ap_addr.sa_data, '\0', ETH_ALEN);
3228 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
3229 wireless_send_event(ai->dev, SIOCGIWAP, &wrqu, NULL);
3230 }
3231}
3232
3233static void airo_handle_rx(struct airo_info *ai)
3234{
3235 struct sk_buff *skb = NULL;
3236 __le16 fc, v, *buffer, tmpbuf[4];
3237 u16 len, hdrlen = 0, gap, fid;
3238 struct rx_hdr hdr;
3239 int success = 0;
3240
3241 if (test_bit(FLAG_MPI, &ai->flags)) {
3242 if (test_bit(FLAG_802_11, &ai->flags))
3243 mpi_receive_802_11(ai);
3244 else
3245 mpi_receive_802_3(ai);
3246 OUT4500(ai, EVACK, EV_RX);
3247 return;
3248 }
3249
3250 fid = IN4500(ai, RXFID);
3251
3252 /* Get the packet length */
3253 if (test_bit(FLAG_802_11, &ai->flags)) {
3254 bap_setup (ai, fid, 4, BAP0);
3255 bap_read (ai, (__le16*)&hdr, sizeof(hdr), BAP0);
3256 /* Bad CRC. Ignore packet */
3257 if (le16_to_cpu(hdr.status) & 2)
3258 hdr.len = 0;
3259 if (ai->wifidev == NULL)
3260 hdr.len = 0;
3261 } else {
3262 bap_setup(ai, fid, 0x36, BAP0);
3263 bap_read(ai, &hdr.len, 2, BAP0);
3264 }
3265 len = le16_to_cpu(hdr.len);
3266
3267 if (len > AIRO_DEF_MTU) {
3268 airo_print_err(ai->dev->name, "Bad size %d", len);
3269 goto done;
3270 }
3271 if (len == 0)
3272 goto done;
3273
3274 if (test_bit(FLAG_802_11, &ai->flags)) {
3275 bap_read(ai, &fc, sizeof (fc), BAP0);
3276 hdrlen = header_len(fc);
3277 } else
3278 hdrlen = ETH_ALEN * 2;
3279
3280 skb = dev_alloc_skb(len + hdrlen + 2 + 2);
3281 if (!skb) {
3282 ai->dev->stats.rx_dropped++;
3283 goto done;
3284 }
3285
3286 skb_reserve(skb, 2); /* This way the IP header is aligned */
3287 buffer = (__le16 *) skb_put(skb, len + hdrlen);
3288 if (test_bit(FLAG_802_11, &ai->flags)) {
3289 buffer[0] = fc;
3290 bap_read(ai, buffer + 1, hdrlen - 2, BAP0);
3291 if (hdrlen == 24)
3292 bap_read(ai, tmpbuf, 6, BAP0);
3293
3294 bap_read(ai, &v, sizeof(v), BAP0);
3295 gap = le16_to_cpu(v);
3296 if (gap) {
3297 if (gap <= 8) {
3298 bap_read(ai, tmpbuf, gap, BAP0);
3299 } else {
3300 airo_print_err(ai->dev->name, "gaplen too "
3301 "big. Problems will follow...");
3302 }
3303 }
3304 bap_read(ai, buffer + hdrlen/2, len, BAP0);
3305 } else {
3306 MICBuffer micbuf;
3307
3308 bap_read(ai, buffer, ETH_ALEN * 2, BAP0);
3309 if (ai->micstats.enabled) {
3310 bap_read(ai, (__le16 *) &micbuf, sizeof (micbuf), BAP0);
3311 if (ntohs(micbuf.typelen) > 0x05DC)
3312 bap_setup(ai, fid, 0x44, BAP0);
3313 else {
3314 if (len <= sizeof (micbuf)) {
3315 dev_kfree_skb_irq(skb);
3316 goto done;
3317 }
3318
3319 len -= sizeof(micbuf);
3320 skb_trim(skb, len + hdrlen);
3321 }
3322 }
3323
3324 bap_read(ai, buffer + ETH_ALEN, len, BAP0);
3325 if (decapsulate(ai, &micbuf, (etherHead*) buffer, len))
3326 dev_kfree_skb_irq (skb);
3327 else
3328 success = 1;
3329 }
3330
3331#ifdef WIRELESS_SPY
3332 if (success && (ai->spy_data.spy_number > 0)) {
3333 char *sa;
3334 struct iw_quality wstats;
3335
3336 /* Prepare spy data : addr + qual */
3337 if (!test_bit(FLAG_802_11, &ai->flags)) {
3338 sa = (char *) buffer + 6;
3339 bap_setup(ai, fid, 8, BAP0);
3340 bap_read(ai, (__le16 *) hdr.rssi, 2, BAP0);
3341 } else
3342 sa = (char *) buffer + 10;
3343 wstats.qual = hdr.rssi[0];
3344 if (ai->rssi)
3345 wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3346 else
3347 wstats.level = (hdr.rssi[1] + 321) / 2;
3348 wstats.noise = ai->wstats.qual.noise;
3349 wstats.updated = IW_QUAL_LEVEL_UPDATED
3350 | IW_QUAL_QUAL_UPDATED
3351 | IW_QUAL_DBM;
3352 /* Update spy records */
3353 wireless_spy_update(ai->dev, sa, &wstats);
3354 }
3355#endif /* WIRELESS_SPY */
3356
3357done:
3358 OUT4500(ai, EVACK, EV_RX);
3359
3360 if (success) {
3361 if (test_bit(FLAG_802_11, &ai->flags)) {
3362 skb_reset_mac_header(skb);
3363 skb->pkt_type = PACKET_OTHERHOST;
3364 skb->dev = ai->wifidev;
3365 skb->protocol = htons(ETH_P_802_2);
3366 } else
3367 skb->protocol = eth_type_trans(skb, ai->dev);
3368 skb->ip_summed = CHECKSUM_NONE;
3369
3370 netif_rx(skb);
3371 }
3372}
3373
3374static void airo_handle_tx(struct airo_info *ai, u16 status)
3375{
3376 int i, len = 0, index = -1;
1da177e4 3377 u16 fid;
f55d4517
DW		 3378
3379 if (test_bit(FLAG_MPI, &ai->flags)) {
3380 unsigned long flags;
3381
3382 if (status & EV_TXEXC)
3383 get_tx_error(ai, -1);
3384
3385 spin_lock_irqsave(&ai->aux_lock, flags);
3386 if (!skb_queue_empty(&ai->txq)) {
3387 spin_unlock_irqrestore(&ai->aux_lock,flags);
3388 mpi_send_packet(ai->dev);
3389 } else {
3390 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
3391 spin_unlock_irqrestore(&ai->aux_lock,flags);
3392 netif_wake_queue(ai->dev);
3393 }
3394 OUT4500(ai, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3395 return;
3396 }
3397
3398 fid = IN4500(ai, TXCOMPLFID);
3399
3400 for(i = 0; i < MAX_FIDS; i++) {
3401 if ((ai->fids[i] & 0xffff) == fid) {
3402 len = ai->fids[i] >> 16;
3403 index = i;
3404 }
3405 }
3406
3407 if (index != -1) {
3408 if (status & EV_TXEXC)
3409 get_tx_error(ai, index);
3410
3411 OUT4500(ai, EVACK, status & (EV_TX | EV_TXEXC));
3412
3413 /* Set up to be used again */
3414 ai->fids[index] &= 0xffff;
3415 if (index < MAX_FIDS / 2) {
3416 if (!test_bit(FLAG_PENDING_XMIT, &ai->flags))
3417 netif_wake_queue(ai->dev);
3418 } else {
3419 if (!test_bit(FLAG_PENDING_XMIT11, &ai->flags))
3420 netif_wake_queue(ai->wifidev);
3421 }
3422 } else {
3423 OUT4500(ai, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3424 airo_print_err(ai->dev->name, "Unallocated FID was used to xmit");
3425 }
3426}
3427
3428static irqreturn_t airo_interrupt(int irq, void *dev_id)
3429{
3430 struct net_device *dev = dev_id;
3431 u16 status, savedInterrupts = 0;
3432 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 3433 int handled = 0;
3434
3435 if (!netif_device_present(dev))
3436 return IRQ_NONE;
3437
3438 for (;;) {
f55d4517
DW		 3439 status = IN4500(ai, EVSTAT);
3440 if (!(status & STATUS_INTS) || (status == 0xffff))
3441 break;
1da177e4
LT		 3442
3443 handled = 1;
3444
f55d4517
DW		 3445 if (status & EV_AWAKE) {
3446 OUT4500(ai, EVACK, EV_AWAKE);
3447 OUT4500(ai, EVACK, EV_AWAKE);
1da177e4
LT		 3448 }
3449
3450 if (!savedInterrupts) {
f55d4517
DW		 3451 savedInterrupts = IN4500(ai, EVINTEN);
3452 OUT4500(ai, EVINTEN, 0);
1da177e4
LT		 3453 }
3454
f55d4517
DW		 3455 if (status & EV_MIC) {
3456 OUT4500(ai, EVACK, EV_MIC);
3457 airo_handle_cisco_mic(ai);
1da177e4 3458 }
1da177e4 3459
f55d4517
DW		 3460 if (status & EV_LINK) {
3461 /* Link status changed */
3462 airo_handle_link(ai);
1da177e4
LT		 3463 }
3464
3465 /* Check to see if there is something to receive */
f55d4517
DW		 3466 if (status & EV_RX)
3467 airo_handle_rx(ai);
1da177e4
LT		 3468
3469 /* Check to see if a packet has been transmitted */
f55d4517
DW		 3470 if (status & (EV_TX | EV_TXCPY | EV_TXEXC))
3471 airo_handle_tx(ai, status);
1da177e4 3472
f55d4517
DW		 3473 if ( status & ~STATUS_INTS & ~IGNORE_INTS ) {
3474 airo_print_warn(ai->dev->name, "Got weird status %x",
1da177e4 3475 status & ~STATUS_INTS & ~IGNORE_INTS );
f55d4517 3476 }
1da177e4
LT		 3477 }
3478
3479 if (savedInterrupts)
f55d4517 3480 OUT4500(ai, EVINTEN, savedInterrupts);
1da177e4 3481
1da177e4
LT		 3482 return IRQ_RETVAL(handled);
3483}
3484
3485/*
3486 * Routines to talk to the card
3487 */
3488
3489/*
3490 * This was originally written for the 4500, hence the name
3491 * NOTE: If use with 8bit mode and SMP bad things will happen!
3492 * Why would some one do 8 bit IO in an SMP machine?!?
3493 */
3494static void OUT4500( struct airo_info *ai, u16 reg, u16 val ) {
3495 if (test_bit(FLAG_MPI,&ai->flags))
3496 reg <<= 1;
3497 if ( !do8bitIO )
3498 outw( val, ai->dev->base_addr + reg );
3499 else {
3500 outb( val & 0xff, ai->dev->base_addr + reg );
3501 outb( val >> 8, ai->dev->base_addr + reg + 1 );
3502 }
3503}
3504
3505static u16 IN4500( struct airo_info *ai, u16 reg ) {
3506 unsigned short rc;
3507
3508 if (test_bit(FLAG_MPI,&ai->flags))
3509 reg <<= 1;
3510 if ( !do8bitIO )
3511 rc = inw( ai->dev->base_addr + reg );
3512 else {
3513 rc = inb( ai->dev->base_addr + reg );
3514 rc += ((int)inb( ai->dev->base_addr + reg + 1 )) << 8;
3515 }
3516 return rc;
3517}
3518
175ec1a1
MS		 3519static int enable_MAC(struct airo_info *ai, int lock)
3520{
1da177e4 3521 int rc;
175ec1a1
MS		 3522 Cmd cmd;
3523 Resp rsp;
1da177e4
LT		 3524
3525 /* FLAG_RADIO_OFF : Radio disabled via /proc or Wireless Extensions
3526 * FLAG_RADIO_DOWN : Radio disabled via "ifconfig ethX down"
3527 * Note : we could try to use !netif_running(dev) in enable_MAC()
3528 * instead of this flag, but I don't trust it *within* the
3529 * open/close functions, and testing both flags together is
3530 * "cheaper" - Jean II */
3531 if (ai->flags & FLAG_RADIO_MASK) return SUCCESS;
3532
3533 if (lock && down_interruptible(&ai->sem))
3534 return -ERESTARTSYS;
3535
3536 if (!test_bit(FLAG_ENABLED, &ai->flags)) {
3537 memset(&cmd, 0, sizeof(cmd));
3538 cmd.cmd = MAC_ENABLE;
175ec1a1 3539 rc = issuecommand(ai, &cmd, &rsp);
1da177e4
LT		 3540 if (rc == SUCCESS)
3541 set_bit(FLAG_ENABLED, &ai->flags);
3542 } else
3543 rc = SUCCESS;
3544
3545 if (lock)
3546 up(&ai->sem);
3547
3548 if (rc)
175ec1a1
MS		 3549 airo_print_err(ai->dev->name, "Cannot enable MAC");
3550 else if ((rsp.status & 0xFF00) != 0) {
3551 airo_print_err(ai->dev->name, "Bad MAC enable reason=%x, "
3552 "rid=%x, offset=%d", rsp.rsp0, rsp.rsp1, rsp.rsp2);
3553 rc = ERROR;
3554 }
1da177e4
LT		 3555 return rc;
3556}
3557
3558static void disable_MAC( struct airo_info *ai, int lock ) {
3559 Cmd cmd;
3560 Resp rsp;
3561
3562 if (lock && down_interruptible(&ai->sem))
3563 return;
3564
3565 if (test_bit(FLAG_ENABLED, &ai->flags)) {
3566 memset(&cmd, 0, sizeof(cmd));
3567 cmd.cmd = MAC_DISABLE; // disable in case already enabled
3568 issuecommand(ai, &cmd, &rsp);
3569 clear_bit(FLAG_ENABLED, &ai->flags);
3570 }
3571 if (lock)
3572 up(&ai->sem);
3573}
3574
3575static void enable_interrupts( struct airo_info *ai ) {
3576 /* Enable the interrupts */
3577 OUT4500( ai, EVINTEN, STATUS_INTS );
3578}
3579
3580static void disable_interrupts( struct airo_info *ai ) {
3581 OUT4500( ai, EVINTEN, 0 );
3582}
3583
3584static void mpi_receive_802_3(struct airo_info *ai)
3585{
3586 RxFid rxd;
3587 int len = 0;
3588 struct sk_buff *skb;
3589 char *buffer;
1da177e4
LT		 3590 int off = 0;
3591 MICBuffer micbuf;
1da177e4
LT		 3592
3593 memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3594 /* Make sure we got something */
3595 if (rxd.rdy && rxd.valid == 0) {
3596 len = rxd.len + 12;
3597 if (len < 12 || len > 2048)
3598 goto badrx;
3599
3600 skb = dev_alloc_skb(len);
3601 if (!skb) {
5d9276da 3602 ai->dev->stats.rx_dropped++;
1da177e4
LT		 3603 goto badrx;
3604 }
3605 buffer = skb_put(skb,len);
1da177e4
LT		 3606 memcpy(buffer, ai->rxfids[0].virtual_host_addr, ETH_ALEN * 2);
3607 if (ai->micstats.enabled) {
3608 memcpy(&micbuf,
3609 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2,
3610 sizeof(micbuf));
3611 if (ntohs(micbuf.typelen) <= 0x05DC) {
3612 if (len <= sizeof(micbuf) + ETH_ALEN * 2)
3613 goto badmic;
3614
3615 off = sizeof(micbuf);
3616 skb_trim (skb, len - off);
3617 }
3618 }
3619 memcpy(buffer + ETH_ALEN * 2,
3620 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2 + off,
3621 len - ETH_ALEN * 2 - off);
3622 if (decapsulate (ai, &micbuf, (etherHead*)buffer, len - off - ETH_ALEN * 2)) {
3623badmic:
3624 dev_kfree_skb_irq (skb);
3625 goto badrx;
3626 }
1da177e4
LT		 3627#ifdef WIRELESS_SPY
3628 if (ai->spy_data.spy_number > 0) {
3629 char *sa;
3630 struct iw_quality wstats;
3631 /* Prepare spy data : addr + qual */
3632 sa = buffer + ETH_ALEN;
3633 wstats.qual = 0; /* XXX Where do I get that info from ??? */
3634 wstats.level = 0;
3635 wstats.updated = 0;
3636 /* Update spy records */
3637 wireless_spy_update(ai->dev, sa, &wstats);
3638 }
3639#endif /* WIRELESS_SPY */
3640
1da177e4
LT		 3641 skb->ip_summed = CHECKSUM_NONE;
3642 skb->protocol = eth_type_trans(skb, ai->dev);
1da177e4
LT		 3643 netif_rx(skb);
3644 }
3645badrx:
3646 if (rxd.valid == 0) {
3647 rxd.valid = 1;
3648 rxd.rdy = 0;
3649 rxd.len = PKTSIZE;
3650 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3651 }
3652}
3653
2ed5ba89 3654static void mpi_receive_802_11(struct airo_info *ai)
1da177e4
LT		 3655{
3656 RxFid rxd;
3657 struct sk_buff *skb = NULL;
0300b332
AV		 3658 u16 len, hdrlen = 0;
3659 __le16 fc;
f55d4517 3660 struct rx_hdr hdr;
1da177e4
LT		 3661 u16 gap;
3662 u16 *buffer;
f55d4517 3663 char *ptr = ai->rxfids[0].virtual_host_addr + 4;
1da177e4
LT		 3664
3665 memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3666 memcpy ((char *)&hdr, ptr, sizeof(hdr));
3667 ptr += sizeof(hdr);
3668 /* Bad CRC. Ignore packet */
3669 if (le16_to_cpu(hdr.status) & 2)
3670 hdr.len = 0;
3671 if (ai->wifidev == NULL)
3672 hdr.len = 0;
3673 len = le16_to_cpu(hdr.len);
15db2763 3674 if (len > AIRO_DEF_MTU) {
934d8bf1 3675 airo_print_err(ai->dev->name, "Bad size %d", len);
1da177e4
LT		 3676 goto badrx;
3677 }
3678 if (len == 0)
3679 goto badrx;
3680
0300b332
AV		 3681 fc = get_unaligned((__le16 *)ptr);
3682 hdrlen = header_len(fc);
1da177e4
LT		 3683
3684 skb = dev_alloc_skb( len + hdrlen + 2 );
3685 if ( !skb ) {
5d9276da 3686 ai->dev->stats.rx_dropped++;
1da177e4
LT		 3687 goto badrx;
3688 }
3689 buffer = (u16*)skb_put (skb, len + hdrlen);
3690 memcpy ((char *)buffer, ptr, hdrlen);
3691 ptr += hdrlen;
3692 if (hdrlen == 24)
3693 ptr += 6;
533dd1b0 3694 gap = get_unaligned_le16(ptr);
593c2b9c 3695 ptr += sizeof(__le16);
1da177e4
LT		 3696 if (gap) {
3697 if (gap <= 8)
3698 ptr += gap;
3699 else
934d8bf1
DW		 3700 airo_print_err(ai->dev->name,
3701 "gaplen too big. Problems will follow...");
1da177e4
LT		 3702 }
3703 memcpy ((char *)buffer + hdrlen, ptr, len);
3704 ptr += len;
3705#ifdef IW_WIRELESS_SPY /* defined in iw_handler.h */
3706 if (ai->spy_data.spy_number > 0) {
3707 char *sa;
3708 struct iw_quality wstats;
3709 /* Prepare spy data : addr + qual */
3710 sa = (char*)buffer + 10;
3711 wstats.qual = hdr.rssi[0];
3712 if (ai->rssi)
3713 wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3714 else
3715 wstats.level = (hdr.rssi[1] + 321) / 2;
41480af2
DW		 3716 wstats.noise = ai->wstats.qual.noise;
3717 wstats.updated = IW_QUAL_QUAL_UPDATED
3718 | IW_QUAL_LEVEL_UPDATED
ce6623c3 3719 | IW_QUAL_DBM;
1da177e4
LT		 3720 /* Update spy records */
3721 wireless_spy_update(ai->dev, sa, &wstats);
3722 }
3723#endif /* IW_WIRELESS_SPY */
459a98ed 3724 skb_reset_mac_header(skb);
1da177e4
LT		 3725 skb->pkt_type = PACKET_OTHERHOST;
3726 skb->dev = ai->wifidev;
3727 skb->protocol = htons(ETH_P_802_2);
1da177e4
LT		 3728 skb->ip_summed = CHECKSUM_NONE;
3729 netif_rx( skb );
f55d4517 3730
1da177e4
LT		 3731badrx:
3732 if (rxd.valid == 0) {
3733 rxd.valid = 1;
3734 rxd.rdy = 0;
3735 rxd.len = PKTSIZE;
3736 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3737 }
3738}
3739
3740static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
3741{
3742 Cmd cmd;
3743 Resp rsp;
3744 int status;
3745 int i;
3746 SsidRid mySsid;
4293ea33 3747 __le16 lastindex;
1da177e4
LT		 3748 WepKeyRid wkr;
3749 int rc;
3750
3751 memset( &mySsid, 0, sizeof( mySsid ) );
b4558ea9
JJ		 3752 kfree (ai->flash);
3753 ai->flash = NULL;
1da177e4
LT		 3754
3755 /* The NOP is the first step in getting the card going */
3756 cmd.cmd = NOP;
3757 cmd.parm0 = cmd.parm1 = cmd.parm2 = 0;
3758 if (lock && down_interruptible(&ai->sem))
3759 return ERROR;
3760 if ( issuecommand( ai, &cmd, &rsp ) != SUCCESS ) {
3761 if (lock)
3762 up(&ai->sem);
3763 return ERROR;
3764 }
3765 disable_MAC( ai, 0);
3766
3767 // Let's figure out if we need to use the AUX port
3768 if (!test_bit(FLAG_MPI,&ai->flags)) {
3769 cmd.cmd = CMD_ENABLEAUX;
3770 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
3771 if (lock)
3772 up(&ai->sem);
934d8bf1 3773 airo_print_err(ai->dev->name, "Error checking for AUX port");
1da177e4
LT		 3774 return ERROR;
3775 }
3776 if (!aux_bap || rsp.status & 0xff00) {
3777 ai->bap_read = fast_bap_read;
934d8bf1 3778 airo_print_dbg(ai->dev->name, "Doing fast bap_reads");
1da177e4
LT		 3779 } else {
3780 ai->bap_read = aux_bap_read;
934d8bf1 3781 airo_print_dbg(ai->dev->name, "Doing AUX bap_reads");
1da177e4
LT		 3782 }
3783 }
3784 if (lock)
3785 up(&ai->sem);
3786 if (ai->config.len == 0) {
3787 tdsRssiRid rssi_rid;
3788 CapabilityRid cap_rid;
3789
b4558ea9
JJ		 3790 kfree(ai->APList);
3791 ai->APList = NULL;
3792 kfree(ai->SSID);
3793 ai->SSID = NULL;
1da177e4
LT		 3794 // general configuration (read/modify/write)
3795 status = readConfigRid(ai, lock);
3796 if ( status != SUCCESS ) return ERROR;
3797
3798 status = readCapabilityRid(ai, &cap_rid, lock);
3799 if ( status != SUCCESS ) return ERROR;
3800
3801 status = PC4500_readrid(ai,RID_RSSI,&rssi_rid,sizeof(rssi_rid),lock);
3802 if ( status == SUCCESS ) {
3803 if (ai->rssi || (ai->rssi = kmalloc(512, GFP_KERNEL)) != NULL)
41480af2 3804 memcpy(ai->rssi, (u8*)&rssi_rid + 2, 512); /* Skip RID length member */
1da177e4
LT		 3805 }
3806 else {
b4558ea9
JJ		 3807 kfree(ai->rssi);
3808 ai->rssi = NULL;
56d81bd3 3809 if (cap_rid.softCap & cpu_to_le16(8))
1da177e4
LT		 3810 ai->config.rmode |= RXMODE_NORMALIZED_RSSI;
3811 else
934d8bf1
DW		 3812 airo_print_warn(ai->dev->name, "unknown received signal "
3813 "level scale");
1da177e4
LT		 3814 }
3815 ai->config.opmode = adhoc ? MODE_STA_IBSS : MODE_STA_ESS;
3816 ai->config.authType = AUTH_OPEN;
3817 ai->config.modulation = MOD_CCK;
3818
56d81bd3 3819 if (le16_to_cpu(cap_rid.len) >= sizeof(cap_rid) &&
15617858 3820 (cap_rid.extSoftCap & cpu_to_le16(1)) &&
56d81bd3 3821 micsetup(ai) == SUCCESS) {
1da177e4
LT		 3822 ai->config.opmode |= MODE_MIC;
3823 set_bit(FLAG_MIC_CAPABLE, &ai->flags);
3824 }
1da177e4
LT		 3825
3826 /* Save off the MAC */
3827 for( i = 0; i < ETH_ALEN; i++ ) {
3828 mac[i] = ai->config.macAddr[i];
3829 }
3830
3831 /* Check to see if there are any insmod configured
3832 rates to add */
3833 if ( rates[0] ) {
3834 int i = 0;
3835 memset(ai->config.rates,0,sizeof(ai->config.rates));
3836 for( i = 0; i < 8 && rates[i]; i++ ) {
3837 ai->config.rates[i] = rates[i];
3838 }
3839 }
3840 if ( basic_rate > 0 ) {
3841 int i;
3842 for( i = 0; i < 8; i++ ) {
3843 if ( ai->config.rates[i] == basic_rate ||
3844 !ai->config.rates ) {
3845 ai->config.rates[i] = basic_rate | 0x80;
3846 break;
3847 }
3848 }
3849 }
3850 set_bit (FLAG_COMMIT, &ai->flags);
3851 }
3852
3853 /* Setup the SSIDs if present */
3854 if ( ssids[0] ) {
3855 int i;
3856 for( i = 0; i < 3 && ssids[i]; i++ ) {
0dd2212f
AV		 3857 size_t len = strlen(ssids[i]);
3858 if (len > 32)
3859 len = 32;
3860 mySsid.ssids[i].len = cpu_to_le16(len);
3861 memcpy(mySsid.ssids[i].ssid, ssids[i], len);
1da177e4 3862 }
0dd2212f 3863 mySsid.len = cpu_to_le16(sizeof(mySsid));
1da177e4
LT		 3864 }
3865
3866 status = writeConfigRid(ai, lock);
3867 if ( status != SUCCESS ) return ERROR;
3868
3869 /* Set up the SSID list */
3870 if ( ssids[0] ) {
3871 status = writeSsidRid(ai, &mySsid, lock);
3872 if ( status != SUCCESS ) return ERROR;
3873 }
3874
175ec1a1
MS		 3875 status = enable_MAC(ai, lock);
3876 if (status != SUCCESS)
1da177e4 3877 return ERROR;
1da177e4
LT		 3878
3879 /* Grab the initial wep key, we gotta save it for auto_wep */
3880 rc = readWepKeyRid(ai, &wkr, 1, lock);
3881 if (rc == SUCCESS) do {
3882 lastindex = wkr.kindex;
4293ea33 3883 if (wkr.kindex == cpu_to_le16(0xffff)) {
1da177e4
LT		 3884 ai->defindex = wkr.mac[0];
3885 }
3886 rc = readWepKeyRid(ai, &wkr, 0, lock);
3887 } while(lastindex != wkr.kindex);
3888
1c2b7db8 3889 try_auto_wep(ai);
1da177e4
LT		 3890
3891 return SUCCESS;
3892}
3893
3894static u16 issuecommand(struct airo_info *ai, Cmd *pCmd, Resp *pRsp) {
3895 // Im really paranoid about letting it run forever!
3896 int max_tries = 600000;
3897
3898 if (IN4500(ai, EVSTAT) & EV_CMD)
3899 OUT4500(ai, EVACK, EV_CMD);
3900
3901 OUT4500(ai, PARAM0, pCmd->parm0);
3902 OUT4500(ai, PARAM1, pCmd->parm1);
3903 OUT4500(ai, PARAM2, pCmd->parm2);
3904 OUT4500(ai, COMMAND, pCmd->cmd);
3905
3906 while (max_tries-- && (IN4500(ai, EVSTAT) & EV_CMD) == 0) {
3907 if ((IN4500(ai, COMMAND)) == pCmd->cmd)
3908 // PC4500 didn't notice command, try again
3909 OUT4500(ai, COMMAND, pCmd->cmd);
3910 if (!in_atomic() && (max_tries & 255) == 0)
3911 schedule();
3912 }
3913
3914 if ( max_tries == -1 ) {
934d8bf1
DW		 3915 airo_print_err(ai->dev->name,
3916 "Max tries exceeded when issueing command");
1da177e4
LT		 3917 if (IN4500(ai, COMMAND) & COMMAND_BUSY)
3918 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3919 return ERROR;
3920 }
3921
3922 // command completed
3923 pRsp->status = IN4500(ai, STATUS);
3924 pRsp->rsp0 = IN4500(ai, RESP0);
3925 pRsp->rsp1 = IN4500(ai, RESP1);
3926 pRsp->rsp2 = IN4500(ai, RESP2);
13dca9b8
RS		 3927 if ((pRsp->status & 0xff00)!=0 && pCmd->cmd != CMD_SOFTRESET)
3928 airo_print_err(ai->dev->name,
3929 "cmd:%x status:%x rsp0:%x rsp1:%x rsp2:%x",
3930 pCmd->cmd, pRsp->status, pRsp->rsp0, pRsp->rsp1,
3931 pRsp->rsp2);
1da177e4
LT		 3932
3933 // clear stuck command busy if necessary
3934 if (IN4500(ai, COMMAND) & COMMAND_BUSY) {
3935 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3936 }
3937 // acknowledge processing the status/response
3938 OUT4500(ai, EVACK, EV_CMD);
3939
3940 return SUCCESS;
3941}
3942
3943/* Sets up the bap to start exchange data. whichbap should
3944 * be one of the BAP0 or BAP1 defines. Locks should be held before
3945 * calling! */
3946static int bap_setup(struct airo_info *ai, u16 rid, u16 offset, int whichbap )
3947{
3948 int timeout = 50;
3949 int max_tries = 3;
3950
3951 OUT4500(ai, SELECT0+whichbap, rid);
3952 OUT4500(ai, OFFSET0+whichbap, offset);
3953 while (1) {
3954 int status = IN4500(ai, OFFSET0+whichbap);
3955 if (status & BAP_BUSY) {
3956 /* This isn't really a timeout, but its kinda
3957 close */
3958 if (timeout--) {
3959 continue;
3960 }
3961 } else if ( status & BAP_ERR ) {
3962 /* invalid rid or offset */
934d8bf1 3963 airo_print_err(ai->dev->name, "BAP error %x %d",
1da177e4
LT		 3964 status, whichbap );
3965 return ERROR;
3966 } else if (status & BAP_DONE) { // success
3967 return SUCCESS;
3968 }
3969 if ( !(max_tries--) ) {
934d8bf1 3970 airo_print_err(ai->dev->name,
1138c37b 3971 "BAP setup error too many retries\n");
1da177e4
LT		 3972 return ERROR;
3973 }
3974 // -- PC4500 missed it, try again
3975 OUT4500(ai, SELECT0+whichbap, rid);
3976 OUT4500(ai, OFFSET0+whichbap, offset);
3977 timeout = 50;
3978 }
3979}
3980
3981/* should only be called by aux_bap_read. This aux function and the
3982 following use concepts not documented in the developers guide. I
3983 got them from a patch given to my by Aironet */
3984static u16 aux_setup(struct airo_info *ai, u16 page,
3985 u16 offset, u16 *len)
3986{
3987 u16 next;
3988
3989 OUT4500(ai, AUXPAGE, page);
3990 OUT4500(ai, AUXOFF, 0);
3991 next = IN4500(ai, AUXDATA);
3992 *len = IN4500(ai, AUXDATA)&0xff;
3993 if (offset != 4) OUT4500(ai, AUXOFF, offset);
3994 return next;
3995}
3996
3997/* requires call to bap_setup() first */
b8c06bc1 3998static int aux_bap_read(struct airo_info *ai, __le16 *pu16Dst,
1da177e4
LT		 3999 int bytelen, int whichbap)
4000{
4001 u16 len;
4002 u16 page;
4003 u16 offset;
4004 u16 next;
4005 int words;
4006 int i;
4007 unsigned long flags;
4008
4009 spin_lock_irqsave(&ai->aux_lock, flags);
4010 page = IN4500(ai, SWS0+whichbap);
4011 offset = IN4500(ai, SWS2+whichbap);
4012 next = aux_setup(ai, page, offset, &len);
4013 words = (bytelen+1)>>1;
4014
4015 for (i=0; i<words;) {
4016 int count;
4017 count = (len>>1) < (words-i) ? (len>>1) : (words-i);
4018 if ( !do8bitIO )
4019 insw( ai->dev->base_addr+DATA0+whichbap,
4020 pu16Dst+i,count );
4021 else
4022 insb( ai->dev->base_addr+DATA0+whichbap,
4023 pu16Dst+i, count << 1 );
4024 i += count;
4025 if (i<words) {
4026 next = aux_setup(ai, next, 4, &len);
4027 }
4028 }
4029 spin_unlock_irqrestore(&ai->aux_lock, flags);
4030 return SUCCESS;
4031}
4032
4033
4034/* requires call to bap_setup() first */
b8c06bc1 4035static int fast_bap_read(struct airo_info *ai, __le16 *pu16Dst,
1da177e4
LT		 4036 int bytelen, int whichbap)
4037{
4038 bytelen = (bytelen + 1) & (~1); // round up to even value
4039 if ( !do8bitIO )
4040 insw( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen>>1 );
4041 else
4042 insb( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen );
4043 return SUCCESS;
4044}
4045
4046/* requires call to bap_setup() first */
b8c06bc1 4047static int bap_write(struct airo_info *ai, const __le16 *pu16Src,
1da177e4
LT		 4048 int bytelen, int whichbap)
4049{
4050 bytelen = (bytelen + 1) & (~1); // round up to even value
4051 if ( !do8bitIO )
4052 outsw( ai->dev->base_addr+DATA0+whichbap,
4053 pu16Src, bytelen>>1 );
4054 else
4055 outsb( ai->dev->base_addr+DATA0+whichbap, pu16Src, bytelen );
4056 return SUCCESS;
4057}
4058
4059static int PC4500_accessrid(struct airo_info *ai, u16 rid, u16 accmd)
4060{
4061 Cmd cmd; /* for issuing commands */
4062 Resp rsp; /* response from commands */
4063 u16 status;
4064
4065 memset(&cmd, 0, sizeof(cmd));
4066 cmd.cmd = accmd;
4067 cmd.parm0 = rid;
4068 status = issuecommand(ai, &cmd, &rsp);
4069 if (status != 0) return status;
4070 if ( (rsp.status & 0x7F00) != 0) {
4071 return (accmd << 8) + (rsp.rsp0 & 0xFF);
4072 }
4073 return 0;
4074}
4075
4076/* Note, that we are using BAP1 which is also used by transmit, so
4077 * we must get a lock. */
4078static int PC4500_readrid(struct airo_info *ai, u16 rid, void *pBuf, int len, int lock)
4079{
4080 u16 status;
4081 int rc = SUCCESS;
4082
4083 if (lock) {
4084 if (down_interruptible(&ai->sem))
4085 return ERROR;
4086 }
4087 if (test_bit(FLAG_MPI,&ai->flags)) {
4088 Cmd cmd;
4089 Resp rsp;
4090
4091 memset(&cmd, 0, sizeof(cmd));
4092 memset(&rsp, 0, sizeof(rsp));
4093 ai->config_desc.rid_desc.valid = 1;
4094 ai->config_desc.rid_desc.len = RIDSIZE;
4095 ai->config_desc.rid_desc.rid = 0;
4096 ai->config_desc.rid_desc.host_addr = ai->ridbus;
4097
4098 cmd.cmd = CMD_ACCESS;
4099 cmd.parm0 = rid;
4100
4101 memcpy_toio(ai->config_desc.card_ram_off,
4102 &ai->config_desc.rid_desc, sizeof(Rid));
4103
4104 rc = issuecommand(ai, &cmd, &rsp);
4105
4106 if (rsp.status & 0x7f00)
4107 rc = rsp.rsp0;
4108 if (!rc)
4109 memcpy(pBuf, ai->config_desc.virtual_host_addr, len);
4110 goto done;
4111 } else {
4112 if ((status = PC4500_accessrid(ai, rid, CMD_ACCESS))!=SUCCESS) {
4113 rc = status;
4114 goto done;
4115 }
4116 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4117 rc = ERROR;
4118 goto done;
4119 }
4120 // read the rid length field
4121 bap_read(ai, pBuf, 2, BAP1);
4122 // length for remaining part of rid
593c2b9c 4123 len = min(len, (int)le16_to_cpu(*(__le16*)pBuf)) - 2;
1da177e4
LT		 4124
4125 if ( len <= 2 ) {
934d8bf1
DW		 4126 airo_print_err(ai->dev->name,
4127 "Rid %x has a length of %d which is too short",
1da177e4
LT		 4128 (int)rid, (int)len );
4129 rc = ERROR;
4130 goto done;
4131 }
4132 // read remainder of the rid
b8c06bc1 4133 rc = bap_read(ai, ((__le16*)pBuf)+1, len, BAP1);
1da177e4
LT		 4134 }
4135done:
4136 if (lock)
4137 up(&ai->sem);
4138 return rc;
4139}
4140
4141/* Note, that we are using BAP1 which is also used by transmit, so
4142 * make sure this isnt called when a transmit is happening */
4143static int PC4500_writerid(struct airo_info *ai, u16 rid,
4144 const void *pBuf, int len, int lock)
4145{
4146 u16 status;
4147 int rc = SUCCESS;
4148
593c2b9c 4149 *(__le16*)pBuf = cpu_to_le16((u16)len);
1da177e4
LT		 4150
4151 if (lock) {
4152 if (down_interruptible(&ai->sem))
4153 return ERROR;
4154 }
4155 if (test_bit(FLAG_MPI,&ai->flags)) {
4156 Cmd cmd;
4157 Resp rsp;
4158
f89b2321 4159 if (test_bit(FLAG_ENABLED, &ai->flags) && (RID_WEP_TEMP != rid))
934d8bf1
DW		 4160 airo_print_err(ai->dev->name,
4161 "%s: MAC should be disabled (rid=%04x)",
c94c93da 4162 __func__, rid);
1da177e4
LT		 4163 memset(&cmd, 0, sizeof(cmd));
4164 memset(&rsp, 0, sizeof(rsp));
4165
4166 ai->config_desc.rid_desc.valid = 1;
4167 ai->config_desc.rid_desc.len = *((u16 *)pBuf);
4168 ai->config_desc.rid_desc.rid = 0;
4169
4170 cmd.cmd = CMD_WRITERID;
4171 cmd.parm0 = rid;
4172
4173 memcpy_toio(ai->config_desc.card_ram_off,
4174 &ai->config_desc.rid_desc, sizeof(Rid));
4175
4176 if (len < 4 || len > 2047) {
c94c93da 4177 airo_print_err(ai->dev->name, "%s: len=%d", __func__, len);
1da177e4
LT		 4178 rc = -1;
4179 } else {
4180 memcpy((char *)ai->config_desc.virtual_host_addr,
4181 pBuf, len);
4182
4183 rc = issuecommand(ai, &cmd, &rsp);
4184 if ((rc & 0xff00) != 0) {
934d8bf1 4185 airo_print_err(ai->dev->name, "%s: Write rid Error %d",
c94c93da 4186 __func__, rc);
934d8bf1 4187 airo_print_err(ai->dev->name, "%s: Cmd=%04x",
c94c93da 4188 __func__, cmd.cmd);
1da177e4
LT		 4189 }
4190
4191 if ((rsp.status & 0x7f00))
4192 rc = rsp.rsp0;
4193 }
4194 } else {
4195 // --- first access so that we can write the rid data
4196 if ( (status = PC4500_accessrid(ai, rid, CMD_ACCESS)) != 0) {
4197 rc = status;
4198 goto done;
4199 }
4200 // --- now write the rid data
4201 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4202 rc = ERROR;
4203 goto done;
4204 }
4205 bap_write(ai, pBuf, len, BAP1);
4206 // ---now commit the rid data
4207 rc = PC4500_accessrid(ai, rid, 0x100|CMD_ACCESS);
4208 }
4209done:
4210 if (lock)
4211 up(&ai->sem);
4212 return rc;
4213}
4214
4215/* Allocates a FID to be used for transmitting packets. We only use
4216 one for now. */
4217static u16 transmit_allocate(struct airo_info *ai, int lenPayload, int raw)
4218{
4219 unsigned int loop = 3000;
4220 Cmd cmd;
4221 Resp rsp;
4222 u16 txFid;
593c2b9c 4223 __le16 txControl;
1da177e4
LT		 4224
4225 cmd.cmd = CMD_ALLOCATETX;
4226 cmd.parm0 = lenPayload;
4227 if (down_interruptible(&ai->sem))
4228 return ERROR;
4229 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
4230 txFid = ERROR;
4231 goto done;
4232 }
4233 if ( (rsp.status & 0xFF00) != 0) {
4234 txFid = ERROR;
4235 goto done;
4236 }
4237 /* wait for the allocate event/indication
4238 * It makes me kind of nervous that this can just sit here and spin,
4239 * but in practice it only loops like four times. */
4240 while (((IN4500(ai, EVSTAT) & EV_ALLOC) == 0) && --loop);
4241 if (!loop) {
4242 txFid = ERROR;
4243 goto done;
4244 }
4245
4246 // get the allocated fid and acknowledge
4247 txFid = IN4500(ai, TXALLOCFID);
4248 OUT4500(ai, EVACK, EV_ALLOC);
4249
4250 /* The CARD is pretty cool since it converts the ethernet packet
4251 * into 802.11. Also note that we don't release the FID since we
4252 * will be using the same one over and over again. */
4253 /* We only have to setup the control once since we are not
4254 * releasing the fid. */
4255 if (raw)
4256 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_11
4257 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4258 else
4259 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_3
4260 | TXCTL_ETHERNET | TXCTL_NORELEASE);
4261 if (bap_setup(ai, txFid, 0x0008, BAP1) != SUCCESS)
4262 txFid = ERROR;
4263 else
4264 bap_write(ai, &txControl, sizeof(txControl), BAP1);
4265
4266done:
4267 up(&ai->sem);
4268
4269 return txFid;
4270}
4271
4272/* In general BAP1 is dedicated to transmiting packets. However,
4273 since we need a BAP when accessing RIDs, we also use BAP1 for that.
4274 Make sure the BAP1 spinlock is held when this is called. */
4275static int transmit_802_3_packet(struct airo_info *ai, int len, char *pPacket)
4276{
593c2b9c 4277 __le16 payloadLen;
1da177e4
LT		 4278 Cmd cmd;
4279 Resp rsp;
4280 int miclen = 0;
4281 u16 txFid = len;
4282 MICBuffer pMic;
4283
4284 len >>= 16;
4285
4286 if (len <= ETH_ALEN * 2) {
934d8bf1 4287 airo_print_warn(ai->dev->name, "Short packet %d", len);
1da177e4
LT		 4288 return ERROR;
4289 }
4290 len -= ETH_ALEN * 2;
4291
1da177e4 4292 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
593c2b9c 4293 (ntohs(((__be16 *)pPacket)[6]) != 0x888E)) {
1da177e4
LT		 4294 if (encapsulate(ai,(etherHead *)pPacket,&pMic,len) != SUCCESS)
4295 return ERROR;
4296 miclen = sizeof(pMic);
4297 }
1da177e4
LT		 4298 // packet is destination[6], source[6], payload[len-12]
4299 // write the payload length and dst/src/payload
4300 if (bap_setup(ai, txFid, 0x0036, BAP1) != SUCCESS) return ERROR;
4301 /* The hardware addresses aren't counted as part of the payload, so
4302 * we have to subtract the 12 bytes for the addresses off */
4303 payloadLen = cpu_to_le16(len + miclen);
4304 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
b8c06bc1 4305 bap_write(ai, (__le16*)pPacket, sizeof(etherHead), BAP1);
1da177e4 4306 if (miclen)
b8c06bc1
AV		 4307 bap_write(ai, (__le16*)&pMic, miclen, BAP1);
4308 bap_write(ai, (__le16*)(pPacket + sizeof(etherHead)), len, BAP1);
1da177e4
LT		 4309 // issue the transmit command
4310 memset( &cmd, 0, sizeof( cmd ) );
4311 cmd.cmd = CMD_TRANSMIT;
4312 cmd.parm0 = txFid;
4313 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4314 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4315 return SUCCESS;
4316}
4317
4318static int transmit_802_11_packet(struct airo_info *ai, int len, char *pPacket)
4319{
593c2b9c 4320 __le16 fc, payloadLen;
1da177e4
LT		 4321 Cmd cmd;
4322 Resp rsp;
4323 int hdrlen;
977b143c
AV		 4324 static u8 tail[(30-10) + 2 + 6] = {[30-10] = 6};
4325 /* padding of header to full size + le16 gaplen (6) + gaplen bytes */
1da177e4
LT		 4326 u16 txFid = len;
4327 len >>= 16;
1da177e4 4328
0300b332
AV		 4329 fc = *(__le16*)pPacket;
4330 hdrlen = header_len(fc);
1da177e4
LT		 4331
4332 if (len < hdrlen) {
934d8bf1 4333 airo_print_warn(ai->dev->name, "Short packet %d", len);
1da177e4
LT		 4334 return ERROR;
4335 }
4336
4337 /* packet is 802.11 header + payload
4338 * write the payload length and dst/src/payload */
4339 if (bap_setup(ai, txFid, 6, BAP1) != SUCCESS) return ERROR;
4340 /* The 802.11 header aren't counted as part of the payload, so
4341 * we have to subtract the header bytes off */
4342 payloadLen = cpu_to_le16(len-hdrlen);
4343 bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4344 if (bap_setup(ai, txFid, 0x0014, BAP1) != SUCCESS) return ERROR;
b8c06bc1
AV		 4345 bap_write(ai, (__le16 *)pPacket, hdrlen, BAP1);
4346 bap_write(ai, (__le16 *)(tail + (hdrlen - 10)), 38 - hdrlen, BAP1);
1da177e4 4347
b8c06bc1 4348 bap_write(ai, (__le16 *)(pPacket + hdrlen), len - hdrlen, BAP1);
1da177e4
LT		 4349 // issue the transmit command
4350 memset( &cmd, 0, sizeof( cmd ) );
4351 cmd.cmd = CMD_TRANSMIT;
4352 cmd.parm0 = txFid;
4353 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4354 if ( (rsp.status & 0xFF00) != 0) return ERROR;
4355 return SUCCESS;
4356}
4357
4358/*
4359 * This is the proc_fs routines. It is a bit messier than I would
4360 * like! Feel free to clean it up!
4361 */
4362
4363static ssize_t proc_read( struct file *file,
4364 char __user *buffer,
4365 size_t len,
4366 loff_t *offset);
4367
4368static ssize_t proc_write( struct file *file,
4369 const char __user *buffer,
4370 size_t len,
4371 loff_t *offset );
4372static int proc_close( struct inode *inode, struct file *file );
4373
4374static int proc_stats_open( struct inode *inode, struct file *file );
4375static int proc_statsdelta_open( struct inode *inode, struct file *file );
4376static int proc_status_open( struct inode *inode, struct file *file );
4377static int proc_SSID_open( struct inode *inode, struct file *file );
4378static int proc_APList_open( struct inode *inode, struct file *file );
4379static int proc_BSSList_open( struct inode *inode, struct file *file );
4380static int proc_config_open( struct inode *inode, struct file *file );
4381static int proc_wepkey_open( struct inode *inode, struct file *file );
4382
d54b1fdb 4383static const struct file_operations proc_statsdelta_ops = {
a95609cb 4384 .owner = THIS_MODULE,
1da177e4
LT		 4385 .read = proc_read,
4386 .open = proc_statsdelta_open,
4387 .release = proc_close
4388};
4389
d54b1fdb 4390static const struct file_operations proc_stats_ops = {
a95609cb 4391 .owner = THIS_MODULE,
1da177e4
LT		 4392 .read = proc_read,
4393 .open = proc_stats_open,
4394 .release = proc_close
4395};
4396
d54b1fdb 4397static const struct file_operations proc_status_ops = {
a95609cb 4398 .owner = THIS_MODULE,
1da177e4
LT		 4399 .read = proc_read,
4400 .open = proc_status_open,
4401 .release = proc_close
4402};
4403
d54b1fdb 4404static const struct file_operations proc_SSID_ops = {
a95609cb 4405 .owner = THIS_MODULE,
1da177e4
LT		 4406 .read = proc_read,
4407 .write = proc_write,
4408 .open = proc_SSID_open,
4409 .release = proc_close
4410};
4411
d54b1fdb 4412static const struct file_operations proc_BSSList_ops = {
a95609cb 4413 .owner = THIS_MODULE,
1da177e4
LT		 4414 .read = proc_read,
4415 .write = proc_write,
4416 .open = proc_BSSList_open,
4417 .release = proc_close
4418};
4419
d54b1fdb 4420static const struct file_operations proc_APList_ops = {
a95609cb 4421 .owner = THIS_MODULE,
1da177e4
LT		 4422 .read = proc_read,
4423 .write = proc_write,
4424 .open = proc_APList_open,
4425 .release = proc_close
4426};
4427
d54b1fdb 4428static const struct file_operations proc_config_ops = {
a95609cb 4429 .owner = THIS_MODULE,
1da177e4
LT		 4430 .read = proc_read,
4431 .write = proc_write,
4432 .open = proc_config_open,
4433 .release = proc_close
4434};
4435
d54b1fdb 4436static const struct file_operations proc_wepkey_ops = {
a95609cb 4437 .owner = THIS_MODULE,
1da177e4
LT		 4438 .read = proc_read,
4439 .write = proc_write,
4440 .open = proc_wepkey_open,
4441 .release = proc_close
4442};
4443
4444static struct proc_dir_entry *airo_entry;
4445
4446struct proc_data {
4447 int release_buffer;
4448 int readlen;
4449 char *rbuffer;
4450 int writelen;
4451 int maxwritelen;
4452 char *wbuffer;
4453 void (*on_close) (struct inode *, struct file *);
4454};
4455
1da177e4
LT		 4456static int setup_proc_entry( struct net_device *dev,
4457 struct airo_info *apriv ) {
4458 struct proc_dir_entry *entry;
4459 /* First setup the device directory */
4460 strcpy(apriv->proc_name,dev->name);
4461 apriv->proc_entry = create_proc_entry(apriv->proc_name,
4462 S_IFDIR|airo_perm,
4463 airo_entry);
431aca5a
FM		 4464 if (!apriv->proc_entry)
4465 goto fail;
4466 apriv->proc_entry->uid = proc_uid;
4467 apriv->proc_entry->gid = proc_gid;
4468 apriv->proc_entry->owner = THIS_MODULE;
1da177e4
LT		 4469
4470 /* Setup the StatsDelta */
a95609cb
DL		 4471 entry = proc_create_data("StatsDelta",
4472 S_IFREG | (S_IRUGO&proc_perm),
4473 apriv->proc_entry, &proc_statsdelta_ops, dev);
431aca5a
FM		 4474 if (!entry)
4475 goto fail_stats_delta;
4476 entry->uid = proc_uid;
4477 entry->gid = proc_gid;
1da177e4
LT		 4478
4479 /* Setup the Stats */
a95609cb
DL		 4480 entry = proc_create_data("Stats",
4481 S_IFREG | (S_IRUGO&proc_perm),
4482 apriv->proc_entry, &proc_stats_ops, dev);
431aca5a
FM		 4483 if (!entry)
4484 goto fail_stats;
4485 entry->uid = proc_uid;
4486 entry->gid = proc_gid;
1da177e4
LT		 4487
4488 /* Setup the Status */
a95609cb
DL		 4489 entry = proc_create_data("Status",
4490 S_IFREG | (S_IRUGO&proc_perm),
4491 apriv->proc_entry, &proc_status_ops, dev);
431aca5a
FM		 4492 if (!entry)
4493 goto fail_status;
4494 entry->uid = proc_uid;
4495 entry->gid = proc_gid;
1da177e4
LT		 4496
4497 /* Setup the Config */
a95609cb
DL		 4498 entry = proc_create_data("Config",
4499 S_IFREG | proc_perm,
4500 apriv->proc_entry, &proc_config_ops, dev);
431aca5a
FM		 4501 if (!entry)
4502 goto fail_config;
4503 entry->uid = proc_uid;
4504 entry->gid = proc_gid;
1da177e4
LT		 4505
4506 /* Setup the SSID */
a95609cb
DL		 4507 entry = proc_create_data("SSID",
4508 S_IFREG | proc_perm,
4509 apriv->proc_entry, &proc_SSID_ops, dev);
431aca5a
FM		 4510 if (!entry)
4511 goto fail_ssid;
4512 entry->uid = proc_uid;
4513 entry->gid = proc_gid;
1da177e4
LT		 4514
4515 /* Setup the APList */
a95609cb
DL		 4516 entry = proc_create_data("APList",
4517 S_IFREG | proc_perm,
4518 apriv->proc_entry, &proc_APList_ops, dev);
431aca5a
FM		 4519 if (!entry)
4520 goto fail_aplist;
4521 entry->uid = proc_uid;
4522 entry->gid = proc_gid;
1da177e4
LT		 4523
4524 /* Setup the BSSList */
a95609cb
DL		 4525 entry = proc_create_data("BSSList",
4526 S_IFREG | proc_perm,
4527 apriv->proc_entry, &proc_BSSList_ops, dev);
431aca5a
FM		 4528 if (!entry)
4529 goto fail_bsslist;
1da177e4
LT		 4530 entry->uid = proc_uid;
4531 entry->gid = proc_gid;
1da177e4
LT		 4532
4533 /* Setup the WepKey */
a95609cb
DL		 4534 entry = proc_create_data("WepKey",
4535 S_IFREG | proc_perm,
4536 apriv->proc_entry, &proc_wepkey_ops, dev);
431aca5a
FM		 4537 if (!entry)
4538 goto fail_wepkey;
4539 entry->uid = proc_uid;
4540 entry->gid = proc_gid;
1da177e4
LT		 4541
4542 return 0;
431aca5a
FM		 4543
4544fail_wepkey:
4545 remove_proc_entry("BSSList", apriv->proc_entry);
4546fail_bsslist:
4547 remove_proc_entry("APList", apriv->proc_entry);
4548fail_aplist:
4549 remove_proc_entry("SSID", apriv->proc_entry);
4550fail_ssid:
4551 remove_proc_entry("Config", apriv->proc_entry);
4552fail_config:
4553 remove_proc_entry("Status", apriv->proc_entry);
4554fail_status:
4555 remove_proc_entry("Stats", apriv->proc_entry);
4556fail_stats:
4557 remove_proc_entry("StatsDelta", apriv->proc_entry);
4558fail_stats_delta:
4559 remove_proc_entry(apriv->proc_name, airo_entry);
4560fail:
4561 return -ENOMEM;
1da177e4
LT		 4562}
4563
4564static int takedown_proc_entry( struct net_device *dev,
4565 struct airo_info *apriv ) {
4566 if ( !apriv->proc_entry->namelen ) return 0;
4567 remove_proc_entry("Stats",apriv->proc_entry);
4568 remove_proc_entry("StatsDelta",apriv->proc_entry);
4569 remove_proc_entry("Status",apriv->proc_entry);
4570 remove_proc_entry("Config",apriv->proc_entry);
4571 remove_proc_entry("SSID",apriv->proc_entry);
4572 remove_proc_entry("APList",apriv->proc_entry);
4573 remove_proc_entry("BSSList",apriv->proc_entry);
4574 remove_proc_entry("WepKey",apriv->proc_entry);
4575 remove_proc_entry(apriv->proc_name,airo_entry);
4576 return 0;
4577}
4578
4579/*
4580 * What we want from the proc_fs is to be able to efficiently read
4581 * and write the configuration. To do this, we want to read the
4582 * configuration when the file is opened and write it when the file is
4583 * closed. So basically we allocate a read buffer at open and fill it
4584 * with data, and allocate a write buffer and read it at close.
4585 */
4586
4587/*
4588 * The read routine is generic, it relies on the preallocated rbuffer
4589 * to supply the data.
4590 */
4591static ssize_t proc_read( struct file *file,
4592 char __user *buffer,
4593 size_t len,
4594 loff_t *offset )
4595{
cc0d9ff2 4596 struct proc_data *priv = file->private_data;
1da177e4
LT		 4597
4598 if (!priv->rbuffer)
4599 return -EINVAL;
4600
cc0d9ff2
AM		 4601 return simple_read_from_buffer(buffer, len, offset, priv->rbuffer,
4602 priv->readlen);
1da177e4
LT		 4603}
4604
4605/*
4606 * The write routine is generic, it fills in a preallocated rbuffer
4607 * to supply the data.
4608 */
4609static ssize_t proc_write( struct file *file,
4610 const char __user *buffer,
4611 size_t len,
4612 loff_t *offset )
4613{
4614 loff_t pos = *offset;
4615 struct proc_data *priv = (struct proc_data*)file->private_data;
4616
4617 if (!priv->wbuffer)
4618 return -EINVAL;
4619
4620 if (pos < 0)
4621 return -EINVAL;
4622 if (pos >= priv->maxwritelen)
4623 return 0;
4624 if (len > priv->maxwritelen - pos)
4625 len = priv->maxwritelen - pos;
4626 if (copy_from_user(priv->wbuffer + pos, buffer, len))
4627 return -EFAULT;
4628 if ( pos + len > priv->writelen )
4629 priv->writelen = len + file->f_pos;
4630 *offset = pos + len;
4631 return len;
4632}
4633
329e2c00
AV		 4634static int proc_status_open(struct inode *inode, struct file *file)
4635{
1da177e4
LT		 4636 struct proc_data *data;
4637 struct proc_dir_entry *dp = PDE(inode);
4638 struct net_device *dev = dp->data;
faf3994a 4639 struct airo_info *apriv = dev->ml_priv;
1da177e4
LT		 4640 CapabilityRid cap_rid;
4641 StatusRid status_rid;
329e2c00 4642 u16 mode;
1da177e4
LT		 4643 int i;
4644
b69a3aa8 4645 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
1da177e4 4646 return -ENOMEM;
1da177e4
LT		 4647 data = (struct proc_data *)file->private_data;
4648 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4649 kfree (file->private_data);
4650 return -ENOMEM;
4651 }
4652
4653 readStatusRid(apriv, &status_rid, 1);
4654 readCapabilityRid(apriv, &cap_rid, 1);
4655
329e2c00
AV		 4656 mode = le16_to_cpu(status_rid.mode);
4657
1da177e4 4658 i = sprintf(data->rbuffer, "Status: %s%s%s%s%s%s%s%s%s\n",
329e2c00
AV		 4659 mode & 1 ? "CFG ": "",
4660 mode & 2 ? "ACT ": "",
4661 mode & 0x10 ? "SYN ": "",
4662 mode & 0x20 ? "LNK ": "",
4663 mode & 0x40 ? "LEAP ": "",
4664 mode & 0x80 ? "PRIV ": "",
4665 mode & 0x100 ? "KEY ": "",
4666 mode & 0x200 ? "WEP ": "",
4667 mode & 0x8000 ? "ERR ": "");
1da177e4
LT		 4668 sprintf( data->rbuffer+i, "Mode: %x\n"
4669 "Signal Strength: %d\n"
4670 "Signal Quality: %d\n"
4671 "SSID: %-.*s\n"
4672 "AP: %-.16s\n"
4673 "Freq: %d\n"
4674 "BitRate: %dmbs\n"
4675 "Driver Version: %s\n"
4676 "Device: %s\nManufacturer: %s\nFirmware Version: %s\n"
4677 "Radio type: %x\nCountry: %x\nHardware Version: %x\n"
4678 "Software Version: %x\nSoftware Subversion: %x\n"
4679 "Boot block version: %x\n",
329e2c00
AV		 4680 le16_to_cpu(status_rid.mode),
4681 le16_to_cpu(status_rid.normalizedSignalStrength),
4682 le16_to_cpu(status_rid.signalQuality),
4683 le16_to_cpu(status_rid.SSIDlen),
1da177e4
LT		 4684 status_rid.SSID,
4685 status_rid.apName,
329e2c00
AV		 4686 le16_to_cpu(status_rid.channel),
4687 le16_to_cpu(status_rid.currentXmitRate) / 2,
1da177e4
LT		 4688 version,
4689 cap_rid.prodName,
4690 cap_rid.manName,
4691 cap_rid.prodVer,
56d81bd3
AV		 4692 le16_to_cpu(cap_rid.radioType),
4693 le16_to_cpu(cap_rid.country),
4694 le16_to_cpu(cap_rid.hardVer),
4695 le16_to_cpu(cap_rid.softVer),
4696 le16_to_cpu(cap_rid.softSubVer),
4697 le16_to_cpu(cap_rid.bootBlockVer));
1da177e4
LT		 4698 data->readlen = strlen( data->rbuffer );
4699 return 0;
4700}
4701
4702static int proc_stats_rid_open(struct inode*, struct file*, u16);
4703static int proc_statsdelta_open( struct inode *inode,
4704 struct file *file ) {
4705 if (file->f_mode&FMODE_WRITE) {
4706 return proc_stats_rid_open(inode, file, RID_STATSDELTACLEAR);
4707 }
4708 return proc_stats_rid_open(inode, file, RID_STATSDELTA);
4709}
4710
4711static int proc_stats_open( struct inode *inode, struct file *file ) {
4712 return proc_stats_rid_open(inode, file, RID_STATS);
4713}
4714
4715static int proc_stats_rid_open( struct inode *inode,
4716 struct file *file,
a23ace5f
AV		 4717 u16 rid )
4718{
1da177e4
LT		 4719 struct proc_data *data;
4720 struct proc_dir_entry *dp = PDE(inode);
4721 struct net_device *dev = dp->data;
faf3994a 4722 struct airo_info *apriv = dev->ml_priv;
1da177e4
LT		 4723 StatsRid stats;
4724 int i, j;
a23ace5f
AV		 4725 __le32 *vals = stats.vals;
4726 int len = le16_to_cpu(stats.len);
1da177e4 4727
b69a3aa8 4728 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
1da177e4 4729 return -ENOMEM;
1da177e4
LT		 4730 data = (struct proc_data *)file->private_data;
4731 if ((data->rbuffer = kmalloc( 4096, GFP_KERNEL )) == NULL) {
4732 kfree (file->private_data);
4733 return -ENOMEM;
4734 }
4735
4736 readStatsRid(apriv, &stats, rid, 1);
4737
4738 j = 0;
a23ace5f 4739 for(i=0; statsLabels[i]!=(char *)-1 && i*4<len; i++) {
1da177e4
LT		 4740 if (!statsLabels[i]) continue;
4741 if (j+strlen(statsLabels[i])+16>4096) {
934d8bf1
DW		 4742 airo_print_warn(apriv->dev->name,
4743 "Potentially disasterous buffer overflow averted!");
1da177e4
LT		 4744 break;
4745 }
a23ace5f
AV		 4746 j+=sprintf(data->rbuffer+j, "%s: %u\n", statsLabels[i],
4747 le32_to_cpu(vals[i]));
1da177e4 4748 }
a23ace5f 4749 if (i*4 >= len) {
934d8bf1 4750 airo_print_warn(apriv->dev->name, "Got a short rid");
1da177e4
LT		 4751 }
4752 data->readlen = j;
4753 return 0;
4754}
4755
4756static int get_dec_u16( char *buffer, int *start, int limit ) {
4757 u16 value;
4758 int valid = 0;
4759 for( value = 0; buffer[*start] >= '0' &&
4760 buffer[*start] <= '9' &&
4761 *start < limit; (*start)++ ) {
4762 valid = 1;
4763 value *= 10;
4764 value += buffer[*start] - '0';
4765 }
4766 if ( !valid ) return -1;
4767 return value;
4768}
4769
4770static int airo_config_commit(struct net_device *dev,
4771 struct iw_request_info *info, void *zwrq,
4772 char *extra);
4773
3eb9b41f
AV		 4774static inline int sniffing_mode(struct airo_info *ai)
4775{
4776 return le16_to_cpu(ai->config.rmode & RXMODE_MASK) >=
4777 le16_to_cpu(RXMODE_RFMON);
4778}
4779
4780static void proc_config_on_close(struct inode *inode, struct file *file)
4781{
1da177e4
LT		 4782 struct proc_data *data = file->private_data;
4783 struct proc_dir_entry *dp = PDE(inode);
4784 struct net_device *dev = dp->data;
faf3994a 4785 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 4786 char *line;
4787
4788 if ( !data->writelen ) return;
4789
4790 readConfigRid(ai, 1);
4791 set_bit (FLAG_COMMIT, &ai->flags);
4792
4793 line = data->wbuffer;
4794 while( line[0] ) {
4795/*** Mode processing */
4796 if ( !strncmp( line, "Mode: ", 6 ) ) {
4797 line += 6;
3eb9b41f
AV		 4798 if (sniffing_mode(ai))
4799 set_bit (FLAG_RESET, &ai->flags);
4800 ai->config.rmode &= ~RXMODE_FULL_MASK;
1da177e4 4801 clear_bit (FLAG_802_11, &ai->flags);
3eb9b41f 4802 ai->config.opmode &= ~MODE_CFG_MASK;
1da177e4
LT		 4803 ai->config.scanMode = SCANMODE_ACTIVE;
4804 if ( line[0] == 'a' ) {
3eb9b41f 4805 ai->config.opmode |= MODE_STA_IBSS;
1da177e4 4806 } else {
3eb9b41f 4807 ai->config.opmode |= MODE_STA_ESS;
1da177e4
LT		 4808 if ( line[0] == 'r' ) {
4809 ai->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
4810 ai->config.scanMode = SCANMODE_PASSIVE;
4811 set_bit (FLAG_802_11, &ai->flags);
4812 } else if ( line[0] == 'y' ) {
4813 ai->config.rmode |= RXMODE_RFMON_ANYBSS | RXMODE_DISABLE_802_3_HEADER;
4814 ai->config.scanMode = SCANMODE_PASSIVE;
4815 set_bit (FLAG_802_11, &ai->flags);
4816 } else if ( line[0] == 'l' )
4817 ai->config.rmode |= RXMODE_LANMON;
4818 }
4819 set_bit (FLAG_COMMIT, &ai->flags);
4820 }
4821
4822/*** Radio status */
4823 else if (!strncmp(line,"Radio: ", 7)) {
4824 line += 7;
4825 if (!strncmp(line,"off",3)) {
4826 set_bit (FLAG_RADIO_OFF, &ai->flags);
4827 } else {
4828 clear_bit (FLAG_RADIO_OFF, &ai->flags);
4829 }
4830 }
4831/*** NodeName processing */
4832 else if ( !strncmp( line, "NodeName: ", 10 ) ) {
4833 int j;
4834
4835 line += 10;
4836 memset( ai->config.nodeName, 0, 16 );
4837/* Do the name, assume a space between the mode and node name */
4838 for( j = 0; j < 16 && line[j] != '\n'; j++ ) {
4839 ai->config.nodeName[j] = line[j];
4840 }
4841 set_bit (FLAG_COMMIT, &ai->flags);
4842 }
4843
4844/*** PowerMode processing */
4845 else if ( !strncmp( line, "PowerMode: ", 11 ) ) {
4846 line += 11;
4847 if ( !strncmp( line, "PSPCAM", 6 ) ) {
4848 ai->config.powerSaveMode = POWERSAVE_PSPCAM;
4849 set_bit (FLAG_COMMIT, &ai->flags);
4850 } else if ( !strncmp( line, "PSP", 3 ) ) {
4851 ai->config.powerSaveMode = POWERSAVE_PSP;
4852 set_bit (FLAG_COMMIT, &ai->flags);
4853 } else {
4854 ai->config.powerSaveMode = POWERSAVE_CAM;
4855 set_bit (FLAG_COMMIT, &ai->flags);
4856 }
4857 } else if ( !strncmp( line, "DataRates: ", 11 ) ) {
4858 int v, i = 0, k = 0; /* i is index into line,
4859 k is index to rates */
4860
4861 line += 11;
4862 while((v = get_dec_u16(line, &i, 3))!=-1) {
4863 ai->config.rates[k++] = (u8)v;
4864 line += i + 1;
4865 i = 0;
4866 }
4867 set_bit (FLAG_COMMIT, &ai->flags);
4868 } else if ( !strncmp( line, "Channel: ", 9 ) ) {
4869 int v, i = 0;
4870 line += 9;
4871 v = get_dec_u16(line, &i, i+3);
4872 if ( v != -1 ) {
3eb9b41f 4873 ai->config.channelSet = cpu_to_le16(v);
1da177e4
LT		 4874 set_bit (FLAG_COMMIT, &ai->flags);
4875 }
4876 } else if ( !strncmp( line, "XmitPower: ", 11 ) ) {
4877 int v, i = 0;
4878 line += 11;
4879 v = get_dec_u16(line, &i, i+3);
4880 if ( v != -1 ) {
3eb9b41f 4881 ai->config.txPower = cpu_to_le16(v);
1da177e4
LT		 4882 set_bit (FLAG_COMMIT, &ai->flags);
4883 }
4884 } else if ( !strncmp( line, "WEP: ", 5 ) ) {
4885 line += 5;
4886 switch( line[0] ) {
4887 case 's':
3eb9b41f 4888 ai->config.authType = AUTH_SHAREDKEY;
1da177e4
LT		 4889 break;
4890 case 'e':
3eb9b41f 4891 ai->config.authType = AUTH_ENCRYPT;
1da177e4
LT		 4892 break;
4893 default:
3eb9b41f 4894 ai->config.authType = AUTH_OPEN;
1da177e4
LT		 4895 break;
4896 }
4897 set_bit (FLAG_COMMIT, &ai->flags);
4898 } else if ( !strncmp( line, "LongRetryLimit: ", 16 ) ) {
4899 int v, i = 0;
4900
4901 line += 16;
4902 v = get_dec_u16(line, &i, 3);
4903 v = (v<0) ? 0 : ((v>255) ? 255 : v);
3eb9b41f 4904 ai->config.longRetryLimit = cpu_to_le16(v);
1da177e4
LT		 4905 set_bit (FLAG_COMMIT, &ai->flags);
4906 } else if ( !strncmp( line, "ShortRetryLimit: ", 17 ) ) {
4907 int v, i = 0;
4908
4909 line += 17;
4910 v = get_dec_u16(line, &i, 3);
4911 v = (v<0) ? 0 : ((v>255) ? 255 : v);
3eb9b41f 4912 ai->config.shortRetryLimit = cpu_to_le16(v);
1da177e4
LT		 4913 set_bit (FLAG_COMMIT, &ai->flags);
4914 } else if ( !strncmp( line, "RTSThreshold: ", 14 ) ) {
4915 int v, i = 0;
4916
4917 line += 14;
4918 v = get_dec_u16(line, &i, 4);
15db2763 4919 v = (v<0) ? 0 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v);
3eb9b41f 4920 ai->config.rtsThres = cpu_to_le16(v);
1da177e4
LT		 4921 set_bit (FLAG_COMMIT, &ai->flags);
4922 } else if ( !strncmp( line, "TXMSDULifetime: ", 16 ) ) {
4923 int v, i = 0;
4924
4925 line += 16;
4926 v = get_dec_u16(line, &i, 5);
4927 v = (v<0) ? 0 : v;
3eb9b41f 4928 ai->config.txLifetime = cpu_to_le16(v);
1da177e4
LT		 4929 set_bit (FLAG_COMMIT, &ai->flags);
4930 } else if ( !strncmp( line, "RXMSDULifetime: ", 16 ) ) {
4931 int v, i = 0;
4932
4933 line += 16;
4934 v = get_dec_u16(line, &i, 5);
4935 v = (v<0) ? 0 : v;
3eb9b41f 4936 ai->config.rxLifetime = cpu_to_le16(v);
1da177e4
LT		 4937 set_bit (FLAG_COMMIT, &ai->flags);
4938 } else if ( !strncmp( line, "TXDiversity: ", 13 ) ) {
4939 ai->config.txDiversity =
4940 (line[13]=='l') ? 1 :
4941 ((line[13]=='r')? 2: 3);
4942 set_bit (FLAG_COMMIT, &ai->flags);
4943 } else if ( !strncmp( line, "RXDiversity: ", 13 ) ) {
4944 ai->config.rxDiversity =
4945 (line[13]=='l') ? 1 :
4946 ((line[13]=='r')? 2: 3);
4947 set_bit (FLAG_COMMIT, &ai->flags);
4948 } else if ( !strncmp( line, "FragThreshold: ", 15 ) ) {
4949 int v, i = 0;
4950
4951 line += 15;
4952 v = get_dec_u16(line, &i, 4);
15db2763 4953 v = (v<256) ? 256 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v);
1da177e4 4954 v = v & 0xfffe; /* Make sure its even */
3eb9b41f 4955 ai->config.fragThresh = cpu_to_le16(v);
1da177e4
LT		 4956 set_bit (FLAG_COMMIT, &ai->flags);
4957 } else if (!strncmp(line, "Modulation: ", 12)) {
4958 line += 12;
4959 switch(*line) {
4960 case 'd': ai->config.modulation=MOD_DEFAULT; set_bit(FLAG_COMMIT, &ai->flags); break;
4961 case 'c': ai->config.modulation=MOD_CCK; set_bit(FLAG_COMMIT, &ai->flags); break;
4962 case 'm': ai->config.modulation=MOD_MOK; set_bit(FLAG_COMMIT, &ai->flags); break;
934d8bf1 4963 default: airo_print_warn(ai->dev->name, "Unknown modulation");
1da177e4
LT		 4964 }
4965 } else if (!strncmp(line, "Preamble: ", 10)) {
4966 line += 10;
4967 switch(*line) {
4968 case 'a': ai->config.preamble=PREAMBLE_AUTO; set_bit(FLAG_COMMIT, &ai->flags); break;
4969 case 'l': ai->config.preamble=PREAMBLE_LONG; set_bit(FLAG_COMMIT, &ai->flags); break;
4970 case 's': ai->config.preamble=PREAMBLE_SHORT; set_bit(FLAG_COMMIT, &ai->flags); break;
934d8bf1 4971 default: airo_print_warn(ai->dev->name, "Unknown preamble");
1da177e4
LT		 4972 }
4973 } else {
934d8bf1 4974 airo_print_warn(ai->dev->name, "Couldn't figure out %s", line);
1da177e4
LT		 4975 }
4976 while( line[0] && line[0] != '\n' ) line++;
4977 if ( line[0] ) line++;
4978 }
4979 airo_config_commit(dev, NULL, NULL, NULL);
4980}
4981
3eb9b41f
AV		 4982static char *get_rmode(__le16 mode)
4983{
4984 switch(mode & RXMODE_MASK) {
1da177e4
LT		 4985 case RXMODE_RFMON: return "rfmon";
4986 case RXMODE_RFMON_ANYBSS: return "yna (any) bss rfmon";
4987 case RXMODE_LANMON: return "lanmon";
4988 }
4989 return "ESS";
4990}
4991
3eb9b41f
AV		 4992static int proc_config_open(struct inode *inode, struct file *file)
4993{
1da177e4
LT		 4994 struct proc_data *data;
4995 struct proc_dir_entry *dp = PDE(inode);
4996 struct net_device *dev = dp->data;
faf3994a 4997 struct airo_info *ai = dev->ml_priv;
1da177e4 4998 int i;
3eb9b41f 4999 __le16 mode;
1da177e4 5000
b69a3aa8 5001 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
1da177e4 5002 return -ENOMEM;
1da177e4
LT		 5003 data = (struct proc_data *)file->private_data;
5004 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
5005 kfree (file->private_data);
5006 return -ENOMEM;
5007 }
b69a3aa8 5008 if ((data->wbuffer = kzalloc( 2048, GFP_KERNEL )) == NULL) {
1da177e4
LT		 5009 kfree (data->rbuffer);
5010 kfree (file->private_data);
5011 return -ENOMEM;
5012 }
1da177e4
LT		 5013 data->maxwritelen = 2048;
5014 data->on_close = proc_config_on_close;
5015
5016 readConfigRid(ai, 1);
5017
3eb9b41f 5018 mode = ai->config.opmode & MODE_CFG_MASK;
1da177e4
LT		 5019 i = sprintf( data->rbuffer,
5020 "Mode: %s\n"
5021 "Radio: %s\n"
5022 "NodeName: %-16s\n"
5023 "PowerMode: %s\n"
5024 "DataRates: %d %d %d %d %d %d %d %d\n"
5025 "Channel: %d\n"
5026 "XmitPower: %d\n",
3eb9b41f
AV		 5027 mode == MODE_STA_IBSS ? "adhoc" :
5028 mode == MODE_STA_ESS ? get_rmode(ai->config.rmode):
5029 mode == MODE_AP ? "AP" :
5030 mode == MODE_AP_RPTR ? "AP RPTR" : "Error",
1da177e4
LT		 5031 test_bit(FLAG_RADIO_OFF, &ai->flags) ? "off" : "on",
5032 ai->config.nodeName,
3eb9b41f
AV		 5033 ai->config.powerSaveMode == POWERSAVE_CAM ? "CAM" :
5034 ai->config.powerSaveMode == POWERSAVE_PSP ? "PSP" :
5035 ai->config.powerSaveMode == POWERSAVE_PSPCAM ? "PSPCAM" :
5036 "Error",
1da177e4
LT		 5037 (int)ai->config.rates[0],
5038 (int)ai->config.rates[1],
5039 (int)ai->config.rates[2],
5040 (int)ai->config.rates[3],
5041 (int)ai->config.rates[4],
5042 (int)ai->config.rates[5],
5043 (int)ai->config.rates[6],
5044 (int)ai->config.rates[7],
3eb9b41f
AV		 5045 le16_to_cpu(ai->config.channelSet),
5046 le16_to_cpu(ai->config.txPower)
1da177e4
LT		 5047 );
5048 sprintf( data->rbuffer + i,
5049 "LongRetryLimit: %d\n"
5050 "ShortRetryLimit: %d\n"
5051 "RTSThreshold: %d\n"
5052 "TXMSDULifetime: %d\n"
5053 "RXMSDULifetime: %d\n"
5054 "TXDiversity: %s\n"
5055 "RXDiversity: %s\n"
5056 "FragThreshold: %d\n"
5057 "WEP: %s\n"
5058 "Modulation: %s\n"
5059 "Preamble: %s\n",
3eb9b41f
AV		 5060 le16_to_cpu(ai->config.longRetryLimit),
5061 le16_to_cpu(ai->config.shortRetryLimit),
5062 le16_to_cpu(ai->config.rtsThres),
5063 le16_to_cpu(ai->config.txLifetime),
5064 le16_to_cpu(ai->config.rxLifetime),
1da177e4
LT		 5065 ai->config.txDiversity == 1 ? "left" :
5066 ai->config.txDiversity == 2 ? "right" : "both",
5067 ai->config.rxDiversity == 1 ? "left" :
5068 ai->config.rxDiversity == 2 ? "right" : "both",
3eb9b41f 5069 le16_to_cpu(ai->config.fragThresh),
1da177e4
LT		 5070 ai->config.authType == AUTH_ENCRYPT ? "encrypt" :
5071 ai->config.authType == AUTH_SHAREDKEY ? "shared" : "open",
3eb9b41f 5072 ai->config.modulation == MOD_DEFAULT ? "default" :
1da177e4
LT		 5073 ai->config.modulation == MOD_CCK ? "cck" :
5074 ai->config.modulation == MOD_MOK ? "mok" : "error",
5075 ai->config.preamble == PREAMBLE_AUTO ? "auto" :
5076 ai->config.preamble == PREAMBLE_LONG ? "long" :
5077 ai->config.preamble == PREAMBLE_SHORT ? "short" : "error"
5078 );
5079 data->readlen = strlen( data->rbuffer );
5080 return 0;
5081}
5082
0dd2212f
AV		 5083static void proc_SSID_on_close(struct inode *inode, struct file *file)
5084{
1da177e4
LT		 5085 struct proc_data *data = (struct proc_data *)file->private_data;
5086 struct proc_dir_entry *dp = PDE(inode);
5087 struct net_device *dev = dp->data;
faf3994a 5088 struct airo_info *ai = dev->ml_priv;
1da177e4 5089 SsidRid SSID_rid;
1da177e4 5090 int i;
0dd2212f
AV		 5091 char *p = data->wbuffer;
5092 char *end = p + data->writelen;
1da177e4 5093
0dd2212f
AV		 5094 if (!data->writelen)
5095 return;
1da177e4 5096
0dd2212f 5097 *end = '\n'; /* sentinel; we have space for it */
1da177e4 5098
0dd2212f
AV		 5099 memset(&SSID_rid, 0, sizeof(SSID_rid));
5100
5101 for (i = 0; i < 3 && p < end; i++) {
5102 int j = 0;
5103 /* copy up to 32 characters from this line */
5104 while (*p != '\n' && j < 32)
5105 SSID_rid.ssids[i].ssid[j++] = *p++;
5106 if (j == 0)
5107 break;
5108 SSID_rid.ssids[i].len = cpu_to_le16(j);
5109 /* skip to the beginning of the next line */
5110 while (*p++ != '\n')
5111 ;
1da177e4
LT		 5112 }
5113 if (i)
0dd2212f 5114 SSID_rid.len = cpu_to_le16(sizeof(SSID_rid));
1da177e4
LT		 5115 disable_MAC(ai, 1);
5116 writeSsidRid(ai, &SSID_rid, 1);
175ec1a1 5117 enable_MAC(ai, 1);
1da177e4
LT		 5118}
5119
77933d72 5120static inline u8 hexVal(char c) {
1da177e4
LT		 5121 if (c>='0' && c<='9') return c -= '0';
5122 if (c>='a' && c<='f') return c -= 'a'-10;
5123 if (c>='A' && c<='F') return c -= 'A'-10;
5124 return 0;
5125}
5126
5127static void proc_APList_on_close( struct inode *inode, struct file *file ) {
5128 struct proc_data *data = (struct proc_data *)file->private_data;
5129 struct proc_dir_entry *dp = PDE(inode);
5130 struct net_device *dev = dp->data;
faf3994a 5131 struct airo_info *ai = dev->ml_priv;
1da177e4 5132 APListRid APList_rid;
1da177e4
LT		 5133 int i;
5134
5135 if ( !data->writelen ) return;
5136
5137 memset( &APList_rid, 0, sizeof(APList_rid) );
a749716e 5138 APList_rid.len = cpu_to_le16(sizeof(APList_rid));
1da177e4
LT		 5139
5140 for( i = 0; i < 4 && data->writelen >= (i+1)*6*3; i++ ) {
5141 int j;
5142 for( j = 0; j < 6*3 && data->wbuffer[j+i*6*3]; j++ ) {
5143 switch(j%3) {
5144 case 0:
5145 APList_rid.ap[i][j/3]=
5146 hexVal(data->wbuffer[j+i*6*3])<<4;
5147 break;
5148 case 1:
5149 APList_rid.ap[i][j/3]|=
5150 hexVal(data->wbuffer[j+i*6*3]);
5151 break;
5152 }
5153 }
5154 }
5155 disable_MAC(ai, 1);
5156 writeAPListRid(ai, &APList_rid, 1);
175ec1a1 5157 enable_MAC(ai, 1);
1da177e4
LT		 5158}
5159
5160/* This function wraps PC4500_writerid with a MAC disable */
5161static int do_writerid( struct airo_info *ai, u16 rid, const void *rid_data,
5162 int len, int dummy ) {
5163 int rc;
1da177e4
LT		 5164
5165 disable_MAC(ai, 1);
5166 rc = PC4500_writerid(ai, rid, rid_data, len, 1);
175ec1a1 5167 enable_MAC(ai, 1);
1da177e4
LT		 5168 return rc;
5169}
5170
5171/* Returns the length of the key at the index. If index == 0xffff
5172 * the index of the transmit key is returned. If the key doesn't exist,
5173 * -1 will be returned.
5174 */
5175static int get_wep_key(struct airo_info *ai, u16 index) {
5176 WepKeyRid wkr;
5177 int rc;
4293ea33 5178 __le16 lastindex;
1da177e4
LT		 5179
5180 rc = readWepKeyRid(ai, &wkr, 1, 1);
5181 if (rc == SUCCESS) do {
5182 lastindex = wkr.kindex;
4293ea33 5183 if (wkr.kindex == cpu_to_le16(index)) {
1da177e4
LT		 5184 if (index == 0xffff) {
5185 return wkr.mac[0];
5186 }
4293ea33 5187 return le16_to_cpu(wkr.klen);
1da177e4
LT		 5188 }
5189 readWepKeyRid(ai, &wkr, 0, 1);
4293ea33 5190 } while (lastindex != wkr.kindex);
1da177e4
LT		 5191 return -1;
5192}
5193
5194static int set_wep_key(struct airo_info *ai, u16 index,
4293ea33
AV		 5195 const char *key, u16 keylen, int perm, int lock )
5196{
1da177e4
LT		 5197 static const unsigned char macaddr[ETH_ALEN] = { 0x01, 0, 0, 0, 0, 0 };
5198 WepKeyRid wkr;
1da177e4
LT		 5199
5200 memset(&wkr, 0, sizeof(wkr));
5201 if (keylen == 0) {
5202// We are selecting which key to use
4293ea33
AV		 5203 wkr.len = cpu_to_le16(sizeof(wkr));
5204 wkr.kindex = cpu_to_le16(0xffff);
1da177e4 5205 wkr.mac[0] = (char)index;
1da177e4
LT		 5206 if (perm) ai->defindex = (char)index;
5207 } else {
5208// We are actually setting the key
4293ea33
AV		 5209 wkr.len = cpu_to_le16(sizeof(wkr));
5210 wkr.kindex = cpu_to_le16(index);
5211 wkr.klen = cpu_to_le16(keylen);
1da177e4
LT		 5212 memcpy( wkr.key, key, keylen );
5213 memcpy( wkr.mac, macaddr, ETH_ALEN );
1da177e4
LT		 5214 }
5215
f89b2321 5216 if (perm) disable_MAC(ai, lock);
1da177e4 5217 writeWepKeyRid(ai, &wkr, perm, lock);
175ec1a1 5218 if (perm) enable_MAC(ai, lock);
1da177e4
LT		 5219 return 0;
5220}
5221
5222static void proc_wepkey_on_close( struct inode *inode, struct file *file ) {
5223 struct proc_data *data;
5224 struct proc_dir_entry *dp = PDE(inode);
5225 struct net_device *dev = dp->data;
faf3994a 5226 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 5227 int i;
5228 char key[16];
5229 u16 index = 0;
5230 int j = 0;
5231
5232 memset(key, 0, sizeof(key));
5233
5234 data = (struct proc_data *)file->private_data;
5235 if ( !data->writelen ) return;
5236
5237 if (data->wbuffer[0] >= '0' && data->wbuffer[0] <= '3' &&
5238 (data->wbuffer[1] == ' ' || data->wbuffer[1] == '\n')) {
5239 index = data->wbuffer[0] - '0';
5240 if (data->wbuffer[1] == '\n') {
5241 set_wep_key(ai, index, NULL, 0, 1, 1);
5242 return;
5243 }
5244 j = 2;
5245 } else {
934d8bf1 5246 airo_print_err(ai->dev->name, "WepKey passed invalid key index");
1da177e4
LT		 5247 return;
5248 }
5249
5250 for( i = 0; i < 16*3 && data->wbuffer[i+j]; i++ ) {
5251 switch(i%3) {
5252 case 0:
5253 key[i/3] = hexVal(data->wbuffer[i+j])<<4;
5254 break;
5255 case 1:
5256 key[i/3] |= hexVal(data->wbuffer[i+j]);
5257 break;
5258 }
5259 }
5260 set_wep_key(ai, index, key, i/3, 1, 1);
5261}
5262
4293ea33
AV		 5263static int proc_wepkey_open( struct inode *inode, struct file *file )
5264{
1da177e4
LT		 5265 struct proc_data *data;
5266 struct proc_dir_entry *dp = PDE(inode);
5267 struct net_device *dev = dp->data;
faf3994a 5268 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 5269 char *ptr;
5270 WepKeyRid wkr;
4293ea33 5271 __le16 lastindex;
1da177e4
LT		 5272 int j=0;
5273 int rc;
5274
b69a3aa8 5275 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
1da177e4 5276 return -ENOMEM;
1da177e4
LT		 5277 memset(&wkr, 0, sizeof(wkr));
5278 data = (struct proc_data *)file->private_data;
b69a3aa8 5279 if ((data->rbuffer = kzalloc( 180, GFP_KERNEL )) == NULL) {
1da177e4
LT		 5280 kfree (file->private_data);
5281 return -ENOMEM;
5282 }
1da177e4
LT		 5283 data->writelen = 0;
5284 data->maxwritelen = 80;
b69a3aa8 5285 if ((data->wbuffer = kzalloc( 80, GFP_KERNEL )) == NULL) {
1da177e4
LT		 5286 kfree (data->rbuffer);
5287 kfree (file->private_data);
5288 return -ENOMEM;
5289 }
1da177e4
LT		 5290 data->on_close = proc_wepkey_on_close;
5291
5292 ptr = data->rbuffer;
5293 strcpy(ptr, "No wep keys\n");
5294 rc = readWepKeyRid(ai, &wkr, 1, 1);
5295 if (rc == SUCCESS) do {
5296 lastindex = wkr.kindex;
4293ea33 5297 if (wkr.kindex == cpu_to_le16(0xffff)) {
1da177e4
LT		 5298 j += sprintf(ptr+j, "Tx key = %d\n",
5299 (int)wkr.mac[0]);
5300 } else {
5301 j += sprintf(ptr+j, "Key %d set with length = %d\n",
4293ea33
AV		 5302 le16_to_cpu(wkr.kindex),
5303 le16_to_cpu(wkr.klen));
1da177e4
LT		 5304 }
5305 readWepKeyRid(ai, &wkr, 0, 1);
5306 } while((lastindex != wkr.kindex) && (j < 180-30));
5307
5308 data->readlen = strlen( data->rbuffer );
5309 return 0;
5310}
5311
0dd2212f
AV		 5312static int proc_SSID_open(struct inode *inode, struct file *file)
5313{
1da177e4
LT		 5314 struct proc_data *data;
5315 struct proc_dir_entry *dp = PDE(inode);
5316 struct net_device *dev = dp->data;
faf3994a 5317 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 5318 int i;
5319 char *ptr;
5320 SsidRid SSID_rid;
5321
b69a3aa8 5322 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
1da177e4 5323 return -ENOMEM;
1da177e4
LT		 5324 data = (struct proc_data *)file->private_data;
5325 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5326 kfree (file->private_data);
5327 return -ENOMEM;
5328 }
5329 data->writelen = 0;
5330 data->maxwritelen = 33*3;
0dd2212f
AV		 5331 /* allocate maxwritelen + 1; we'll want a sentinel */
5332 if ((data->wbuffer = kzalloc(33*3 + 1, GFP_KERNEL)) == NULL) {
1da177e4
LT		 5333 kfree (data->rbuffer);
5334 kfree (file->private_data);
5335 return -ENOMEM;
5336 }
1da177e4
LT		 5337 data->on_close = proc_SSID_on_close;
5338
5339 readSsidRid(ai, &SSID_rid);
5340 ptr = data->rbuffer;
0dd2212f 5341 for (i = 0; i < 3; i++) {
1da177e4 5342 int j;
0dd2212f
AV		 5343 size_t len = le16_to_cpu(SSID_rid.ssids[i].len);
5344 if (!len)
5345 break;
5346 if (len > 32)
5347 len = 32;
5348 for (j = 0; j < len && SSID_rid.ssids[i].ssid[j]; j++)
1da177e4 5349 *ptr++ = SSID_rid.ssids[i].ssid[j];
1da177e4
LT		 5350 *ptr++ = '\n';
5351 }
5352 *ptr = '\0';
5353 data->readlen = strlen( data->rbuffer );
5354 return 0;
5355}
5356
5357static int proc_APList_open( struct inode *inode, struct file *file ) {
5358 struct proc_data *data;
5359 struct proc_dir_entry *dp = PDE(inode);
5360 struct net_device *dev = dp->data;
faf3994a 5361 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 5362 int i;
5363 char *ptr;
5364 APListRid APList_rid;
5365
b69a3aa8 5366 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
1da177e4 5367 return -ENOMEM;
1da177e4
LT		 5368 data = (struct proc_data *)file->private_data;
5369 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5370 kfree (file->private_data);
5371 return -ENOMEM;
5372 }
5373 data->writelen = 0;
5374 data->maxwritelen = 4*6*3;
b69a3aa8 5375 if ((data->wbuffer = kzalloc( data->maxwritelen, GFP_KERNEL )) == NULL) {
1da177e4
LT		 5376 kfree (data->rbuffer);
5377 kfree (file->private_data);
5378 return -ENOMEM;
5379 }
1da177e4
LT		 5380 data->on_close = proc_APList_on_close;
5381
5382 readAPListRid(ai, &APList_rid);
5383 ptr = data->rbuffer;
5384 for( i = 0; i < 4; i++ ) {
5385// We end when we find a zero MAC
5386 if ( !*(int*)APList_rid.ap[i] &&
5387 !*(int*)&APList_rid.ap[i][2]) break;
e174961c 5388 ptr += sprintf(ptr, "%pM\n", APList_rid.ap[i]);
1da177e4
LT		 5389 }
5390 if (i==0) ptr += sprintf(ptr, "Not using specific APs\n");
5391
5392 *ptr = '\0';
5393 data->readlen = strlen( data->rbuffer );
5394 return 0;
5395}
5396
5397static int proc_BSSList_open( struct inode *inode, struct file *file ) {
5398 struct proc_data *data;
5399 struct proc_dir_entry *dp = PDE(inode);
5400 struct net_device *dev = dp->data;
faf3994a 5401 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 5402 char *ptr;
5403 BSSListRid BSSList_rid;
5404 int rc;
5405 /* If doLoseSync is not 1, we won't do a Lose Sync */
5406 int doLoseSync = -1;
5407
b69a3aa8 5408 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
1da177e4 5409 return -ENOMEM;
1da177e4
LT		 5410 data = (struct proc_data *)file->private_data;
5411 if ((data->rbuffer = kmalloc( 1024, GFP_KERNEL )) == NULL) {
5412 kfree (file->private_data);
5413 return -ENOMEM;
5414 }
5415 data->writelen = 0;
5416 data->maxwritelen = 0;
5417 data->wbuffer = NULL;
5418 data->on_close = NULL;
5419
5420 if (file->f_mode & FMODE_WRITE) {
5421 if (!(file->f_mode & FMODE_READ)) {
5422 Cmd cmd;
5423 Resp rsp;
5424
5425 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
5426 memset(&cmd, 0, sizeof(cmd));
5427 cmd.cmd=CMD_LISTBSS;
5428 if (down_interruptible(&ai->sem))
5429 return -ERESTARTSYS;
5430 issuecommand(ai, &cmd, &rsp);
5431 up(&ai->sem);
5432 data->readlen = 0;
5433 return 0;
5434 }
5435 doLoseSync = 1;
5436 }
5437 ptr = data->rbuffer;
5438 /* There is a race condition here if there are concurrent opens.
5439 Since it is a rare condition, we'll just live with it, otherwise
5440 we have to add a spin lock... */
5441 rc = readBSSListRid(ai, doLoseSync, &BSSList_rid);
17e70491 5442 while(rc == 0 && BSSList_rid.index != cpu_to_le16(0xffff)) {
e174961c
JB		 5443 ptr += sprintf(ptr, "%pM %*s rssi = %d",
5444 BSSList_rid.bssid,
1da177e4
LT		 5445 (int)BSSList_rid.ssidLen,
5446 BSSList_rid.ssid,
17e70491 5447 le16_to_cpu(BSSList_rid.dBm));
1da177e4 5448 ptr += sprintf(ptr, " channel = %d %s %s %s %s\n",
17e70491 5449 le16_to_cpu(BSSList_rid.dsChannel),
1da177e4
LT		 5450 BSSList_rid.cap & CAP_ESS ? "ESS" : "",
5451 BSSList_rid.cap & CAP_IBSS ? "adhoc" : "",
5452 BSSList_rid.cap & CAP_PRIVACY ? "wep" : "",
5453 BSSList_rid.cap & CAP_SHORTHDR ? "shorthdr" : "");
5454 rc = readBSSListRid(ai, 0, &BSSList_rid);
5455 }
5456 *ptr = '\0';
5457 data->readlen = strlen( data->rbuffer );
5458 return 0;
5459}
5460
5461static int proc_close( struct inode *inode, struct file *file )
5462{
b4558ea9
JJ		 5463 struct proc_data *data = file->private_data;
5464
5465 if (data->on_close != NULL)
5466 data->on_close(inode, file);
5467 kfree(data->rbuffer);
5468 kfree(data->wbuffer);
5469 kfree(data);
1da177e4
LT		 5470 return 0;
5471}
5472
1da177e4
LT		 5473/* Since the card doesn't automatically switch to the right WEP mode,
5474 we will make it do it. If the card isn't associated, every secs we
5475 will switch WEP modes to see if that will help. If the card is
5476 associated we will check every minute to see if anything has
5477 changed. */
5478static void timer_func( struct net_device *dev ) {
faf3994a 5479 struct airo_info *apriv = dev->ml_priv;
1da177e4
LT		 5480
5481/* We don't have a link so try changing the authtype */
5482 readConfigRid(apriv, 0);
5483 disable_MAC(apriv, 0);
5484 switch(apriv->config.authType) {
5485 case AUTH_ENCRYPT:
5486/* So drop to OPEN */
5487 apriv->config.authType = AUTH_OPEN;
5488 break;
5489 case AUTH_SHAREDKEY:
5490 if (apriv->keyindex < auto_wep) {
5491 set_wep_key(apriv, apriv->keyindex, NULL, 0, 0, 0);
5492 apriv->config.authType = AUTH_SHAREDKEY;
5493 apriv->keyindex++;
5494 } else {
5495 /* Drop to ENCRYPT */
5496 apriv->keyindex = 0;
5497 set_wep_key(apriv, apriv->defindex, NULL, 0, 0, 0);
5498 apriv->config.authType = AUTH_ENCRYPT;
5499 }
5500 break;
5501 default: /* We'll escalate to SHAREDKEY */
5502 apriv->config.authType = AUTH_SHAREDKEY;
5503 }
5504 set_bit (FLAG_COMMIT, &apriv->flags);
5505 writeConfigRid(apriv, 0);
175ec1a1 5506 enable_MAC(apriv, 0);
1da177e4
LT		 5507 up(&apriv->sem);
5508
5509/* Schedule check to see if the change worked */
3c304956 5510 clear_bit(JOB_AUTOWEP, &apriv->jobs);
1da177e4
LT		 5511 apriv->expires = RUN_AT(HZ*3);
5512}
5513
1da177e4
LT		 5514#ifdef CONFIG_PCI
5515static int __devinit airo_pci_probe(struct pci_dev *pdev,
5516 const struct pci_device_id *pent)
5517{
5518 struct net_device *dev;
5519
5520 if (pci_enable_device(pdev))
5521 return -ENODEV;
5522 pci_set_master(pdev);
5523
5524 if (pdev->device == 0x5000 || pdev->device == 0xa504)
5525 dev = _init_airo_card(pdev->irq, pdev->resource[0].start, 0, pdev, &pdev->dev);
5526 else
5527 dev = _init_airo_card(pdev->irq, pdev->resource[2].start, 0, pdev, &pdev->dev);
777ec5e9
MS		 5528 if (!dev) {
5529 pci_disable_device(pdev);
1da177e4 5530 return -ENODEV;
777ec5e9 5531 }
1da177e4
LT		 5532
5533 pci_set_drvdata(pdev, dev);
5534 return 0;
5535}
5536
5537static void __devexit airo_pci_remove(struct pci_dev *pdev)
5538{
af5b5c9a
MS		 5539 struct net_device *dev = pci_get_drvdata(pdev);
5540
5541 airo_print_info(dev->name, "Unregistering...");
5542 stop_airo_card(dev, 1);
777ec5e9
MS		 5543 pci_disable_device(pdev);
5544 pci_set_drvdata(pdev, NULL);
1da177e4
LT		 5545}
5546
05adc3b7 5547static int airo_pci_suspend(struct pci_dev *pdev, pm_message_t state)
1da177e4
LT		 5548{
5549 struct net_device *dev = pci_get_drvdata(pdev);
faf3994a 5550 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 5551 Cmd cmd;
5552 Resp rsp;
5553
e292c737
PM		 5554 if (!ai->APList)
5555 ai->APList = kmalloc(sizeof(APListRid), GFP_KERNEL);
5556 if (!ai->APList)
1da177e4 5557 return -ENOMEM;
e292c737
PM		 5558 if (!ai->SSID)
5559 ai->SSID = kmalloc(sizeof(SsidRid), GFP_KERNEL);
5560 if (!ai->SSID)
1da177e4
LT		 5561 return -ENOMEM;
5562 readAPListRid(ai, ai->APList);
5563 readSsidRid(ai, ai->SSID);
5564 memset(&cmd, 0, sizeof(cmd));
5565 /* the lock will be released at the end of the resume callback */
5566 if (down_interruptible(&ai->sem))
5567 return -EAGAIN;
5568 disable_MAC(ai, 0);
5569 netif_device_detach(dev);
5570 ai->power = state;
e292c737 5571 cmd.cmd = HOSTSLEEP;
1da177e4
LT		 5572 issuecommand(ai, &cmd, &rsp);
5573
1cc68ae0 5574 pci_enable_wake(pdev, pci_choose_state(pdev, state), 1);
1da177e4 5575 pci_save_state(pdev);
1cc68ae0 5576 return pci_set_power_state(pdev, pci_choose_state(pdev, state));
1da177e4
LT		 5577}
5578
5579static int airo_pci_resume(struct pci_dev *pdev)
5580{
5581 struct net_device *dev = pci_get_drvdata(pdev);
faf3994a 5582 struct airo_info *ai = dev->ml_priv;
53232803 5583 pci_power_t prev_state = pdev->current_state;
1da177e4 5584
53232803 5585 pci_set_power_state(pdev, PCI_D0);
1da177e4 5586 pci_restore_state(pdev);
53232803 5587 pci_enable_wake(pdev, PCI_D0, 0);
1da177e4 5588
53232803 5589 if (prev_state != PCI_D1) {
1da177e4
LT		 5590 reset_card(dev, 0);
5591 mpi_init_descriptors(ai);
5592 setup_card(ai, dev->dev_addr, 0);
5593 clear_bit(FLAG_RADIO_OFF, &ai->flags);
5594 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
5595 } else {
5596 OUT4500(ai, EVACK, EV_AWAKEN);
5597 OUT4500(ai, EVACK, EV_AWAKEN);
5598 msleep(100);
5599 }
5600
e292c737 5601 set_bit(FLAG_COMMIT, &ai->flags);
1da177e4
LT		 5602 disable_MAC(ai, 0);
5603 msleep(200);
5604 if (ai->SSID) {
5605 writeSsidRid(ai, ai->SSID, 0);
5606 kfree(ai->SSID);
5607 ai->SSID = NULL;
5608 }
5609 if (ai->APList) {
5610 writeAPListRid(ai, ai->APList, 0);
5611 kfree(ai->APList);
5612 ai->APList = NULL;
5613 }
5614 writeConfigRid(ai, 0);
175ec1a1 5615 enable_MAC(ai, 0);
1cc68ae0 5616 ai->power = PMSG_ON;
1da177e4
LT		 5617 netif_device_attach(dev);
5618 netif_wake_queue(dev);
5619 enable_interrupts(ai);
5620 up(&ai->sem);
5621 return 0;
5622}
5623#endif
5624
5625static int __init airo_init_module( void )
5626{
de897881 5627 int i;
1da177e4 5628
928b4d8c 5629 airo_entry = create_proc_entry("driver/aironet",
1da177e4 5630 S_IFDIR | airo_perm,
928b4d8c 5631 NULL);
de897881
JG		 5632
5633 if (airo_entry) {
5634 airo_entry->uid = proc_uid;
5635 airo_entry->gid = proc_gid;
5636 }
1da177e4 5637
e292c737 5638 for (i = 0; i < 4 && io[i] && irq[i]; i++) {
934d8bf1
DW		 5639 airo_print_info("", "Trying to configure ISA adapter at irq=%d "
5640 "io=0x%x", irq[i], io[i] );
1da177e4 5641 if (init_airo_card( irq[i], io[i], 0, NULL ))
de897881 5642 /* do nothing */ ;
1da177e4
LT		 5643 }
5644
5645#ifdef CONFIG_PCI
934d8bf1 5646 airo_print_info("", "Probing for PCI adapters");
de897881 5647 i = pci_register_driver(&airo_driver);
934d8bf1 5648 airo_print_info("", "Finished probing for PCI adapters");
de897881
JG		 5649
5650 if (i) {
928b4d8c 5651 remove_proc_entry("driver/aironet", NULL);
de897881
JG		 5652 return i;
5653 }
1da177e4
LT		 5654#endif
5655
5656 /* Always exit with success, as we are a library module
5657 * as well as a driver module
5658 */
5659 return 0;
5660}
5661
5662static void __exit airo_cleanup_module( void )
5663{
af5b5c9a
MS		 5664 struct airo_info *ai;
5665 while(!list_empty(&airo_devices)) {
5666 ai = list_entry(airo_devices.next, struct airo_info, dev_list);
5667 airo_print_info(ai->dev->name, "Unregistering...");
5668 stop_airo_card(ai->dev, 1);
1da177e4
LT		 5669 }
5670#ifdef CONFIG_PCI
5671 pci_unregister_driver(&airo_driver);
5672#endif
928b4d8c 5673 remove_proc_entry("driver/aironet", NULL);
1da177e4
LT		 5674}
5675
1da177e4
LT		 5676/*
5677 * Initial Wireless Extension code for Aironet driver by :
5678 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 17 November 00
5679 * Conversion to new driver API by :
5680 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 26 March 02
5681 * Javier also did a good amount of work here, adding some new extensions
5682 * and fixing my code. Let's just say that without him this code just
5683 * would not work at all... - Jean II
5684 */
5685
41480af2
DW		 5686static u8 airo_rssi_to_dbm (tdsRssiEntry *rssi_rid, u8 rssi)
5687{
e292c737 5688 if (!rssi_rid)
41480af2
DW		 5689 return 0;
5690
5691 return (0x100 - rssi_rid[rssi].rssidBm);
5692}
5693
5694static u8 airo_dbm_to_pct (tdsRssiEntry *rssi_rid, u8 dbm)
5695{
5696 int i;
5697
e292c737 5698 if (!rssi_rid)
41480af2
DW		 5699 return 0;
5700
e292c737 5701 for (i = 0; i < 256; i++)
41480af2
DW		 5702 if (rssi_rid[i].rssidBm == dbm)
5703 return rssi_rid[i].rssipct;
5704
5705 return 0;
5706}
5707
5708
1da177e4
LT		 5709static int airo_get_quality (StatusRid *status_rid, CapabilityRid *cap_rid)
5710{
5711 int quality = 0;
329e2c00 5712 u16 sq;
1da177e4 5713
329e2c00 5714 if ((status_rid->mode & cpu_to_le16(0x3f)) != cpu_to_le16(0x3f))
56d81bd3
AV		 5715 return 0;
5716
5717 if (!(cap_rid->hardCap & cpu_to_le16(8)))
5718 return 0;
5719
329e2c00 5720 sq = le16_to_cpu(status_rid->signalQuality);
56d81bd3 5721 if (memcmp(cap_rid->prodName, "350", 3))
329e2c00 5722 if (sq > 0x20)
56d81bd3 5723 quality = 0;
1da177e4 5724 else
329e2c00 5725 quality = 0x20 - sq;
56d81bd3 5726 else
329e2c00 5727 if (sq > 0xb0)
56d81bd3 5728 quality = 0;
329e2c00 5729 else if (sq < 0x10)
56d81bd3
AV		 5730 quality = 0xa0;
5731 else
329e2c00 5732 quality = 0xb0 - sq;
1da177e4
LT		 5733 return quality;
5734}
5735
5736#define airo_get_max_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x20 : 0xa0)
5737#define airo_get_avg_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x10 : 0x50);
5738
5739/*------------------------------------------------------------------*/
5740/*
5741 * Wireless Handler : get protocol name
5742 */
5743static int airo_get_name(struct net_device *dev,
5744 struct iw_request_info *info,
5745 char *cwrq,
5746 char *extra)
5747{
5748 strcpy(cwrq, "IEEE 802.11-DS");
5749 return 0;
5750}
5751
5752/*------------------------------------------------------------------*/
5753/*
5754 * Wireless Handler : set frequency
5755 */
5756static int airo_set_freq(struct net_device *dev,
5757 struct iw_request_info *info,
5758 struct iw_freq *fwrq,
5759 char *extra)
5760{
faf3994a 5761 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 5762 int rc = -EINPROGRESS; /* Call commit handler */
5763
5764 /* If setting by frequency, convert to a channel */
9ee677c2 5765 if(fwrq->e == 1) {
1da177e4 5766 int f = fwrq->m / 100000;
9ee677c2 5767
1da177e4
LT		 5768 /* Hack to fall through... */
5769 fwrq->e = 0;
9ee677c2 5770 fwrq->m = ieee80211_freq_to_dsss_chan(f);
1da177e4
LT		 5771 }
5772 /* Setting by channel number */
5773 if((fwrq->m > 1000) || (fwrq->e > 0))
5774 rc = -EOPNOTSUPP;
5775 else {
5776 int channel = fwrq->m;
5777 /* We should do a better check than that,
5778 * based on the card capability !!! */
2610c733 5779 if((channel < 1) || (channel > 14)) {
934d8bf1
DW		 5780 airo_print_dbg(dev->name, "New channel value of %d is invalid!",
5781 fwrq->m);
1da177e4
LT		 5782 rc = -EINVAL;
5783 } else {
5784 readConfigRid(local, 1);
5785 /* Yes ! We can set it !!! */
3eb9b41f 5786 local->config.channelSet = cpu_to_le16(channel);
1da177e4
LT		 5787 set_bit (FLAG_COMMIT, &local->flags);
5788 }
5789 }
5790 return rc;
5791}
5792
5793/*------------------------------------------------------------------*/
5794/*
5795 * Wireless Handler : get frequency
5796 */
5797static int airo_get_freq(struct net_device *dev,
5798 struct iw_request_info *info,
5799 struct iw_freq *fwrq,
5800 char *extra)
5801{
faf3994a 5802 struct airo_info *local = dev->ml_priv;
1da177e4 5803 StatusRid status_rid; /* Card status info */
2610c733 5804 int ch;
1da177e4
LT		 5805
5806 readConfigRid(local, 1);
3eb9b41f
AV		 5807 if ((local->config.opmode & MODE_CFG_MASK) == MODE_STA_ESS)
5808 status_rid.channel = local->config.channelSet;
1da177e4
LT		 5809 else
5810 readStatusRid(local, &status_rid, 1);
5811
329e2c00 5812 ch = le16_to_cpu(status_rid.channel);
2610c733 5813 if((ch > 0) && (ch < 15)) {
9ee677c2 5814 fwrq->m = ieee80211_dsss_chan_to_freq(ch) * 100000;
1da177e4 5815 fwrq->e = 1;
2610c733
JA		 5816 } else {
5817 fwrq->m = ch;
5818 fwrq->e = 0;
1da177e4 5819 }
1da177e4
LT		 5820
5821 return 0;
5822}
5823
5824/*------------------------------------------------------------------*/
5825/*
5826 * Wireless Handler : set ESSID
5827 */
5828static int airo_set_essid(struct net_device *dev,
5829 struct iw_request_info *info,
5830 struct iw_point *dwrq,
5831 char *extra)
5832{
faf3994a 5833 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 5834 SsidRid SSID_rid; /* SSIDs */
5835
5836 /* Reload the list of current SSID */
5837 readSsidRid(local, &SSID_rid);
5838
5839 /* Check if we asked for `any' */
5840 if(dwrq->flags == 0) {
5841 /* Just send an empty SSID list */
5842 memset(&SSID_rid, 0, sizeof(SSID_rid));
5843 } else {
5844 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
5845
5846 /* Check the size of the string */
7f8544cc 5847 if(dwrq->length > IW_ESSID_MAX_SIZE) {
1da177e4
LT		 5848 return -E2BIG ;
5849 }
5850 /* Check if index is valid */
5851 if((index < 0) || (index >= 4)) {
5852 return -EINVAL;
5853 }
5854
5855 /* Set the SSID */
5856 memset(SSID_rid.ssids[index].ssid, 0,
5857 sizeof(SSID_rid.ssids[index].ssid));
5858 memcpy(SSID_rid.ssids[index].ssid, extra, dwrq->length);
0dd2212f 5859 SSID_rid.ssids[index].len = cpu_to_le16(dwrq->length);
1da177e4 5860 }
0dd2212f 5861 SSID_rid.len = cpu_to_le16(sizeof(SSID_rid));
1da177e4
LT		 5862 /* Write it to the card */
5863 disable_MAC(local, 1);
5864 writeSsidRid(local, &SSID_rid, 1);
175ec1a1 5865 enable_MAC(local, 1);
1da177e4
LT		 5866
5867 return 0;
5868}
5869
5870/*------------------------------------------------------------------*/
5871/*
5872 * Wireless Handler : get ESSID
5873 */
5874static int airo_get_essid(struct net_device *dev,
5875 struct iw_request_info *info,
5876 struct iw_point *dwrq,
5877 char *extra)
5878{
faf3994a 5879 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 5880 StatusRid status_rid; /* Card status info */
5881
5882 readStatusRid(local, &status_rid, 1);
5883
5884 /* Note : if dwrq->flags != 0, we should
5885 * get the relevant SSID from the SSID list... */
5886
5887 /* Get the current SSID */
329e2c00 5888 memcpy(extra, status_rid.SSID, le16_to_cpu(status_rid.SSIDlen));
1da177e4
LT		 5889 /* If none, we may want to get the one that was set */
5890
5891 /* Push it out ! */
329e2c00 5892 dwrq->length = le16_to_cpu(status_rid.SSIDlen);
1da177e4
LT		 5893 dwrq->flags = 1; /* active */
5894
5895 return 0;
5896}
5897
5898/*------------------------------------------------------------------*/
5899/*
5900 * Wireless Handler : set AP address
5901 */
5902static int airo_set_wap(struct net_device *dev,
5903 struct iw_request_info *info,
5904 struct sockaddr *awrq,
5905 char *extra)
5906{
faf3994a 5907 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 5908 Cmd cmd;
5909 Resp rsp;
5910 APListRid APList_rid;
4be757dd
DW		 5911 static const u8 any[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
5912 static const u8 off[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
1da177e4
LT		 5913
5914 if (awrq->sa_family != ARPHRD_ETHER)
5915 return -EINVAL;
4be757dd
DW		 5916 else if (!memcmp(any, awrq->sa_data, ETH_ALEN) ||
5917 !memcmp(off, awrq->sa_data, ETH_ALEN)) {
1da177e4
LT		 5918 memset(&cmd, 0, sizeof(cmd));
5919 cmd.cmd=CMD_LOSE_SYNC;
5920 if (down_interruptible(&local->sem))
5921 return -ERESTARTSYS;
5922 issuecommand(local, &cmd, &rsp);
5923 up(&local->sem);
5924 } else {
5925 memset(&APList_rid, 0, sizeof(APList_rid));
a749716e 5926 APList_rid.len = cpu_to_le16(sizeof(APList_rid));
1da177e4
LT		 5927 memcpy(APList_rid.ap[0], awrq->sa_data, ETH_ALEN);
5928 disable_MAC(local, 1);
5929 writeAPListRid(local, &APList_rid, 1);
175ec1a1 5930 enable_MAC(local, 1);
1da177e4
LT		 5931 }
5932 return 0;
5933}
5934
5935/*------------------------------------------------------------------*/
5936/*
5937 * Wireless Handler : get AP address
5938 */
5939static int airo_get_wap(struct net_device *dev,
5940 struct iw_request_info *info,
5941 struct sockaddr *awrq,
5942 char *extra)
5943{
faf3994a 5944 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 5945 StatusRid status_rid; /* Card status info */
5946
5947 readStatusRid(local, &status_rid, 1);
5948
5949 /* Tentative. This seems to work, wow, I'm lucky !!! */
5950 memcpy(awrq->sa_data, status_rid.bssid[0], ETH_ALEN);
5951 awrq->sa_family = ARPHRD_ETHER;
5952
5953 return 0;
5954}
5955
5956/*------------------------------------------------------------------*/
5957/*
5958 * Wireless Handler : set Nickname
5959 */
5960static int airo_set_nick(struct net_device *dev,
5961 struct iw_request_info *info,
5962 struct iw_point *dwrq,
5963 char *extra)
5964{
faf3994a 5965 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 5966
5967 /* Check the size of the string */
7f8544cc 5968 if(dwrq->length > 16) {
1da177e4
LT		 5969 return -E2BIG;
5970 }
5971 readConfigRid(local, 1);
5972 memset(local->config.nodeName, 0, sizeof(local->config.nodeName));
5973 memcpy(local->config.nodeName, extra, dwrq->length);
5974 set_bit (FLAG_COMMIT, &local->flags);
5975
5976 return -EINPROGRESS; /* Call commit handler */
5977}
5978
5979/*------------------------------------------------------------------*/
5980/*
5981 * Wireless Handler : get Nickname
5982 */
5983static int airo_get_nick(struct net_device *dev,
5984 struct iw_request_info *info,
5985 struct iw_point *dwrq,
5986 char *extra)
5987{
faf3994a 5988 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 5989
5990 readConfigRid(local, 1);
5991 strncpy(extra, local->config.nodeName, 16);
5992 extra[16] = '\0';
7f8544cc 5993 dwrq->length = strlen(extra);
1da177e4
LT		 5994
5995 return 0;
5996}
5997
5998/*------------------------------------------------------------------*/
5999/*
6000 * Wireless Handler : set Bit-Rate
6001 */
6002static int airo_set_rate(struct net_device *dev,
6003 struct iw_request_info *info,
6004 struct iw_param *vwrq,
6005 char *extra)
6006{
faf3994a 6007 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 6008 CapabilityRid cap_rid; /* Card capability info */
6009 u8 brate = 0;
6010 int i;
6011
6012 /* First : get a valid bit rate value */
6013 readCapabilityRid(local, &cap_rid, 1);
6014
6015 /* Which type of value ? */
6016 if((vwrq->value < 8) && (vwrq->value >= 0)) {
6017 /* Setting by rate index */
6018 /* Find value in the magic rate table */
6019 brate = cap_rid.supportedRates[vwrq->value];
6020 } else {
6021 /* Setting by frequency value */
6022 u8 normvalue = (u8) (vwrq->value/500000);
6023
6024 /* Check if rate is valid */
6025 for(i = 0 ; i < 8 ; i++) {
6026 if(normvalue == cap_rid.supportedRates[i]) {
6027 brate = normvalue;
6028 break;
6029 }
6030 }
6031 }
6032 /* -1 designed the max rate (mostly auto mode) */
6033 if(vwrq->value == -1) {
6034 /* Get the highest available rate */
6035 for(i = 0 ; i < 8 ; i++) {
6036 if(cap_rid.supportedRates[i] == 0)
6037 break;
6038 }
6039 if(i != 0)
6040 brate = cap_rid.supportedRates[i - 1];
6041 }
6042 /* Check that it is valid */
6043 if(brate == 0) {
6044 return -EINVAL;
6045 }
6046
6047 readConfigRid(local, 1);
6048 /* Now, check if we want a fixed or auto value */
6049 if(vwrq->fixed == 0) {
6050 /* Fill all the rates up to this max rate */
6051 memset(local->config.rates, 0, 8);
6052 for(i = 0 ; i < 8 ; i++) {
6053 local->config.rates[i] = cap_rid.supportedRates[i];
6054 if(local->config.rates[i] == brate)
6055 break;
6056 }
6057 } else {
6058 /* Fixed mode */
6059 /* One rate, fixed */
6060 memset(local->config.rates, 0, 8);
6061 local->config.rates[0] = brate;
6062 }
6063 set_bit (FLAG_COMMIT, &local->flags);
6064
6065 return -EINPROGRESS; /* Call commit handler */
6066}
6067
6068/*------------------------------------------------------------------*/
6069/*
6070 * Wireless Handler : get Bit-Rate
6071 */
6072static int airo_get_rate(struct net_device *dev,
6073 struct iw_request_info *info,
6074 struct iw_param *vwrq,
6075 char *extra)
6076{
faf3994a 6077 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 6078 StatusRid status_rid; /* Card status info */
6079
6080 readStatusRid(local, &status_rid, 1);
6081
329e2c00 6082 vwrq->value = le16_to_cpu(status_rid.currentXmitRate) * 500000;
1da177e4
LT		 6083 /* If more than one rate, set auto */
6084 readConfigRid(local, 1);
6085 vwrq->fixed = (local->config.rates[1] == 0);
6086
6087 return 0;
6088}
6089
6090/*------------------------------------------------------------------*/
6091/*
6092 * Wireless Handler : set RTS threshold
6093 */
6094static int airo_set_rts(struct net_device *dev,
6095 struct iw_request_info *info,
6096 struct iw_param *vwrq,
6097 char *extra)
6098{
faf3994a 6099 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 6100 int rthr = vwrq->value;
6101
6102 if(vwrq->disabled)
15db2763
DW		 6103 rthr = AIRO_DEF_MTU;
6104 if((rthr < 0) || (rthr > AIRO_DEF_MTU)) {
1da177e4
LT		 6105 return -EINVAL;
6106 }
6107 readConfigRid(local, 1);
3eb9b41f 6108 local->config.rtsThres = cpu_to_le16(rthr);
1da177e4
LT		 6109 set_bit (FLAG_COMMIT, &local->flags);
6110
6111 return -EINPROGRESS; /* Call commit handler */
6112}
6113
6114/*------------------------------------------------------------------*/
6115/*
6116 * Wireless Handler : get RTS threshold
6117 */
6118static int airo_get_rts(struct net_device *dev,
6119 struct iw_request_info *info,
6120 struct iw_param *vwrq,
6121 char *extra)
6122{
faf3994a 6123 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 6124
6125 readConfigRid(local, 1);
3eb9b41f 6126 vwrq->value = le16_to_cpu(local->config.rtsThres);
15db2763 6127 vwrq->disabled = (vwrq->value >= AIRO_DEF_MTU);
1da177e4
LT		 6128 vwrq->fixed = 1;
6129
6130 return 0;
6131}
6132
6133/*------------------------------------------------------------------*/
6134/*
6135 * Wireless Handler : set Fragmentation threshold
6136 */
6137static int airo_set_frag(struct net_device *dev,
6138 struct iw_request_info *info,
6139 struct iw_param *vwrq,
6140 char *extra)
6141{
faf3994a 6142 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 6143 int fthr = vwrq->value;
6144
6145 if(vwrq->disabled)
15db2763
DW		 6146 fthr = AIRO_DEF_MTU;
6147 if((fthr < 256) || (fthr > AIRO_DEF_MTU)) {
1da177e4
LT		 6148 return -EINVAL;
6149 }
6150 fthr &= ~0x1; /* Get an even value - is it really needed ??? */
6151 readConfigRid(local, 1);
3eb9b41f 6152 local->config.fragThresh = cpu_to_le16(fthr);
1da177e4
LT		 6153 set_bit (FLAG_COMMIT, &local->flags);
6154
6155 return -EINPROGRESS; /* Call commit handler */
6156}
6157
6158/*------------------------------------------------------------------*/
6159/*
6160 * Wireless Handler : get Fragmentation threshold
6161 */
6162static int airo_get_frag(struct net_device *dev,
6163 struct iw_request_info *info,
6164 struct iw_param *vwrq,
6165 char *extra)
6166{
faf3994a 6167 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 6168
6169 readConfigRid(local, 1);
3eb9b41f 6170 vwrq->value = le16_to_cpu(local->config.fragThresh);
15db2763 6171 vwrq->disabled = (vwrq->value >= AIRO_DEF_MTU);
1da177e4
LT		 6172 vwrq->fixed = 1;
6173
6174 return 0;
6175}
6176
6177/*------------------------------------------------------------------*/
6178/*
6179 * Wireless Handler : set Mode of Operation
6180 */
6181static int airo_set_mode(struct net_device *dev,
6182 struct iw_request_info *info,
6183 __u32 *uwrq,
6184 char *extra)
6185{
faf3994a 6186 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 6187 int reset = 0;
6188
6189 readConfigRid(local, 1);
3eb9b41f 6190 if (sniffing_mode(local))
1da177e4
LT		 6191 reset = 1;
6192
6193 switch(*uwrq) {
6194 case IW_MODE_ADHOC:
3eb9b41f 6195 local->config.opmode &= ~MODE_CFG_MASK;
1da177e4 6196 local->config.opmode |= MODE_STA_IBSS;
3eb9b41f 6197 local->config.rmode &= ~RXMODE_FULL_MASK;
1da177e4
LT		 6198 local->config.scanMode = SCANMODE_ACTIVE;
6199 clear_bit (FLAG_802_11, &local->flags);
6200 break;
6201 case IW_MODE_INFRA:
3eb9b41f 6202 local->config.opmode &= ~MODE_CFG_MASK;
1da177e4 6203 local->config.opmode |= MODE_STA_ESS;
3eb9b41f 6204 local->config.rmode &= ~RXMODE_FULL_MASK;
1da177e4
LT		 6205 local->config.scanMode = SCANMODE_ACTIVE;
6206 clear_bit (FLAG_802_11, &local->flags);
6207 break;
6208 case IW_MODE_MASTER:
3eb9b41f 6209 local->config.opmode &= ~MODE_CFG_MASK;
1da177e4 6210 local->config.opmode |= MODE_AP;
3eb9b41f 6211 local->config.rmode &= ~RXMODE_FULL_MASK;
1da177e4
LT		 6212 local->config.scanMode = SCANMODE_ACTIVE;
6213 clear_bit (FLAG_802_11, &local->flags);
6214 break;
6215 case IW_MODE_REPEAT:
3eb9b41f 6216 local->config.opmode &= ~MODE_CFG_MASK;
1da177e4 6217 local->config.opmode |= MODE_AP_RPTR;
3eb9b41f 6218 local->config.rmode &= ~RXMODE_FULL_MASK;
1da177e4
LT		 6219 local->config.scanMode = SCANMODE_ACTIVE;
6220 clear_bit (FLAG_802_11, &local->flags);
6221 break;
6222 case IW_MODE_MONITOR:
3eb9b41f 6223 local->config.opmode &= ~MODE_CFG_MASK;
1da177e4 6224 local->config.opmode |= MODE_STA_ESS;
3eb9b41f 6225 local->config.rmode &= ~RXMODE_FULL_MASK;
1da177e4
LT		 6226 local->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
6227 local->config.scanMode = SCANMODE_PASSIVE;
6228 set_bit (FLAG_802_11, &local->flags);
6229 break;
6230 default:
6231 return -EINVAL;
6232 }
6233 if (reset)
6234 set_bit (FLAG_RESET, &local->flags);
6235 set_bit (FLAG_COMMIT, &local->flags);
6236
6237 return -EINPROGRESS; /* Call commit handler */
6238}
6239
6240/*------------------------------------------------------------------*/
6241/*
6242 * Wireless Handler : get Mode of Operation
6243 */
6244static int airo_get_mode(struct net_device *dev,
6245 struct iw_request_info *info,
6246 __u32 *uwrq,
6247 char *extra)
6248{
faf3994a 6249 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 6250
6251 readConfigRid(local, 1);
6252 /* If not managed, assume it's ad-hoc */
3eb9b41f 6253 switch (local->config.opmode & MODE_CFG_MASK) {
1da177e4
LT		 6254 case MODE_STA_ESS:
6255 *uwrq = IW_MODE_INFRA;
6256 break;
6257 case MODE_AP:
6258 *uwrq = IW_MODE_MASTER;
6259 break;
6260 case MODE_AP_RPTR:
6261 *uwrq = IW_MODE_REPEAT;
6262 break;
6263 default:
6264 *uwrq = IW_MODE_ADHOC;
6265 }
6266
6267 return 0;
6268}
6269
56d81bd3
AV		 6270static inline int valid_index(CapabilityRid *p, int index)
6271{
6272 if (index < 0)
6273 return 0;
6274 return index < (p->softCap & cpu_to_le16(0x80) ? 4 : 1);
6275}
6276
1da177e4
LT		 6277/*------------------------------------------------------------------*/
6278/*
6279 * Wireless Handler : set Encryption Key
6280 */
6281static int airo_set_encode(struct net_device *dev,
6282 struct iw_request_info *info,
6283 struct iw_point *dwrq,
6284 char *extra)
6285{
faf3994a 6286 struct airo_info *local = dev->ml_priv;
1da177e4 6287 CapabilityRid cap_rid; /* Card capability info */
f89b2321 6288 int perm = ( dwrq->flags & IW_ENCODE_TEMP ? 0 : 1 );
3eb9b41f 6289 __le16 currentAuthType = local->config.authType;
1da177e4
LT		 6290
6291 /* Is WEP supported ? */
6292 readCapabilityRid(local, &cap_rid, 1);
6293 /* Older firmware doesn't support this...
56d81bd3 6294 if(!(cap_rid.softCap & cpu_to_le16(2))) {
1da177e4
LT		 6295 return -EOPNOTSUPP;
6296 } */
6297 readConfigRid(local, 1);
6298
6299 /* Basic checking: do we have a key to set ?
6300 * Note : with the new API, it's impossible to get a NULL pointer.
6301 * Therefore, we need to check a key size == 0 instead.
6302 * New version of iwconfig properly set the IW_ENCODE_NOKEY flag
6303 * when no key is present (only change flags), but older versions
6304 * don't do it. - Jean II */
6305 if (dwrq->length > 0) {
6306 wep_key_t key;
6307 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6308 int current_index = get_wep_key(local, 0xffff);
6309 /* Check the size of the key */
6310 if (dwrq->length > MAX_KEY_SIZE) {
6311 return -EINVAL;
6312 }
6313 /* Check the index (none -> use current) */
56d81bd3 6314 if (!valid_index(&cap_rid, index))
1da177e4
LT		 6315 index = current_index;
6316 /* Set the length */
6317 if (dwrq->length > MIN_KEY_SIZE)
6318 key.len = MAX_KEY_SIZE;
6319 else
6320 if (dwrq->length > 0)
6321 key.len = MIN_KEY_SIZE;
6322 else
6323 /* Disable the key */
6324 key.len = 0;
6325 /* Check if the key is not marked as invalid */
6326 if(!(dwrq->flags & IW_ENCODE_NOKEY)) {
6327 /* Cleanup */
6328 memset(key.key, 0, MAX_KEY_SIZE);
6329 /* Copy the key in the driver */
6330 memcpy(key.key, extra, dwrq->length);
6331 /* Send the key to the card */
f89b2321 6332 set_wep_key(local, index, key.key, key.len, perm, 1);
1da177e4
LT		 6333 }
6334 /* WE specify that if a valid key is set, encryption
6335 * should be enabled (user may turn it off later)
6336 * This is also how "iwconfig ethX key on" works */
6337 if((index == current_index) && (key.len > 0) &&
6338 (local->config.authType == AUTH_OPEN)) {
6339 local->config.authType = AUTH_ENCRYPT;
1da177e4
LT		 6340 }
6341 } else {
6342 /* Do we want to just set the transmit key index ? */
6343 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
56d81bd3 6344 if (valid_index(&cap_rid, index)) {
f89b2321 6345 set_wep_key(local, index, NULL, 0, perm, 1);
1da177e4
LT		 6346 } else
6347 /* Don't complain if only change the mode */
93a3b607 6348 if (!(dwrq->flags & IW_ENCODE_MODE))
1da177e4 6349 return -EINVAL;
1da177e4
LT		 6350 }
6351 /* Read the flags */
6352 if(dwrq->flags & IW_ENCODE_DISABLED)
6353 local->config.authType = AUTH_OPEN; // disable encryption
6354 if(dwrq->flags & IW_ENCODE_RESTRICTED)
6355 local->config.authType = AUTH_SHAREDKEY; // Only Both
6356 if(dwrq->flags & IW_ENCODE_OPEN)
6357 local->config.authType = AUTH_ENCRYPT; // Only Wep
6358 /* Commit the changes to flags if needed */
f89b2321 6359 if (local->config.authType != currentAuthType)
1da177e4
LT		 6360 set_bit (FLAG_COMMIT, &local->flags);
6361 return -EINPROGRESS; /* Call commit handler */
6362}
6363
6364/*------------------------------------------------------------------*/
6365/*
6366 * Wireless Handler : get Encryption Key
6367 */
6368static int airo_get_encode(struct net_device *dev,
6369 struct iw_request_info *info,
6370 struct iw_point *dwrq,
6371 char *extra)
6372{
faf3994a 6373 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 6374 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6375 CapabilityRid cap_rid; /* Card capability info */
6376
6377 /* Is it supported ? */
6378 readCapabilityRid(local, &cap_rid, 1);
56d81bd3 6379 if(!(cap_rid.softCap & cpu_to_le16(2))) {
1da177e4
LT		 6380 return -EOPNOTSUPP;
6381 }
6382 readConfigRid(local, 1);
6383 /* Check encryption mode */
6384 switch(local->config.authType) {
6385 case AUTH_ENCRYPT:
6386 dwrq->flags = IW_ENCODE_OPEN;
6387 break;
6388 case AUTH_SHAREDKEY:
6389 dwrq->flags = IW_ENCODE_RESTRICTED;
6390 break;
6391 default:
6392 case AUTH_OPEN:
6393 dwrq->flags = IW_ENCODE_DISABLED;
6394 break;
6395 }
6396 /* We can't return the key, so set the proper flag and return zero */
6397 dwrq->flags |= IW_ENCODE_NOKEY;
6398 memset(extra, 0, 16);
6399
6400 /* Which key do we want ? -1 -> tx index */
56d81bd3 6401 if (!valid_index(&cap_rid, index))
1da177e4
LT		 6402 index = get_wep_key(local, 0xffff);
6403 dwrq->flags |= index + 1;
6404 /* Copy the key to the user buffer */
6405 dwrq->length = get_wep_key(local, index);
6406 if (dwrq->length > 16) {
6407 dwrq->length=0;
6408 }
6409 return 0;
6410}
6411
4be757dd
DW		 6412/*------------------------------------------------------------------*/
6413/*
6414 * Wireless Handler : set extended Encryption parameters
6415 */
6416static int airo_set_encodeext(struct net_device *dev,
6417 struct iw_request_info *info,
6418 union iwreq_data *wrqu,
6419 char *extra)
6420{
faf3994a 6421 struct airo_info *local = dev->ml_priv;
4be757dd
DW		 6422 struct iw_point *encoding = &wrqu->encoding;
6423 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6424 CapabilityRid cap_rid; /* Card capability info */
6425 int perm = ( encoding->flags & IW_ENCODE_TEMP ? 0 : 1 );
3eb9b41f 6426 __le16 currentAuthType = local->config.authType;
22d8846e 6427 int idx, key_len, alg = ext->alg, set_key = 1;
4be757dd
DW		 6428 wep_key_t key;
6429
6430 /* Is WEP supported ? */
6431 readCapabilityRid(local, &cap_rid, 1);
6432 /* Older firmware doesn't support this...
56d81bd3 6433 if(!(cap_rid.softCap & cpu_to_le16(2))) {
4be757dd
DW		 6434 return -EOPNOTSUPP;
6435 } */
6436 readConfigRid(local, 1);
6437
6438 /* Determine and validate the key index */
6439 idx = encoding->flags & IW_ENCODE_INDEX;
6440 if (idx) {
56d81bd3 6441 if (!valid_index(&cap_rid, idx - 1))
4be757dd
DW		 6442 return -EINVAL;
6443 idx--;
6444 } else
6445 idx = get_wep_key(local, 0xffff);
6446
6447 if (encoding->flags & IW_ENCODE_DISABLED)
6448 alg = IW_ENCODE_ALG_NONE;
6449
4be757dd 6450 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
22d8846e
DW		 6451 /* Only set transmit key index here, actual
6452 * key is set below if needed.
6453 */
4be757dd 6454 set_wep_key(local, idx, NULL, 0, perm, 1);
22d8846e
DW		 6455 set_key = ext->key_len > 0 ? 1 : 0;
6456 }
6457
6458 if (set_key) {
4be757dd
DW		 6459 /* Set the requested key first */
6460 memset(key.key, 0, MAX_KEY_SIZE);
6461 switch (alg) {
6462 case IW_ENCODE_ALG_NONE:
6463 key.len = 0;
6464 break;
6465 case IW_ENCODE_ALG_WEP:
6466 if (ext->key_len > MIN_KEY_SIZE) {
6467 key.len = MAX_KEY_SIZE;
6468 } else if (ext->key_len > 0) {
6469 key.len = MIN_KEY_SIZE;
6470 } else {
6471 return -EINVAL;
6472 }
6473 key_len = min (ext->key_len, key.len);
6474 memcpy(key.key, ext->key, key_len);
6475 break;
6476 default:
6477 return -EINVAL;
6478 }
6479 /* Send the key to the card */
6480 set_wep_key(local, idx, key.key, key.len, perm, 1);
6481 }
6482
6483 /* Read the flags */
6484 if(encoding->flags & IW_ENCODE_DISABLED)
6485 local->config.authType = AUTH_OPEN; // disable encryption
6486 if(encoding->flags & IW_ENCODE_RESTRICTED)
6487 local->config.authType = AUTH_SHAREDKEY; // Only Both
6488 if(encoding->flags & IW_ENCODE_OPEN)
6489 local->config.authType = AUTH_ENCRYPT; // Only Wep
6490 /* Commit the changes to flags if needed */
6491 if (local->config.authType != currentAuthType)
6492 set_bit (FLAG_COMMIT, &local->flags);
6493
6494 return -EINPROGRESS;
6495}
6496
6497
6498/*------------------------------------------------------------------*/
6499/*
6500 * Wireless Handler : get extended Encryption parameters
6501 */
6502static int airo_get_encodeext(struct net_device *dev,
6503 struct iw_request_info *info,
6504 union iwreq_data *wrqu,
6505 char *extra)
6506{
faf3994a 6507 struct airo_info *local = dev->ml_priv;
4be757dd
DW		 6508 struct iw_point *encoding = &wrqu->encoding;
6509 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6510 CapabilityRid cap_rid; /* Card capability info */
6511 int idx, max_key_len;
6512
6513 /* Is it supported ? */
6514 readCapabilityRid(local, &cap_rid, 1);
56d81bd3 6515 if(!(cap_rid.softCap & cpu_to_le16(2))) {
4be757dd
DW		 6516 return -EOPNOTSUPP;
6517 }
6518 readConfigRid(local, 1);
6519
6520 max_key_len = encoding->length - sizeof(*ext);
6521 if (max_key_len < 0)
6522 return -EINVAL;
6523
6524 idx = encoding->flags & IW_ENCODE_INDEX;
6525 if (idx) {
56d81bd3 6526 if (!valid_index(&cap_rid, idx - 1))
4be757dd
DW		 6527 return -EINVAL;
6528 idx--;
6529 } else
6530 idx = get_wep_key(local, 0xffff);
6531
6532 encoding->flags = idx + 1;
6533 memset(ext, 0, sizeof(*ext));
6534
6535 /* Check encryption mode */
6536 switch(local->config.authType) {
6537 case AUTH_ENCRYPT:
6538 encoding->flags = IW_ENCODE_ALG_WEP | IW_ENCODE_ENABLED;
6539 break;
6540 case AUTH_SHAREDKEY:
6541 encoding->flags = IW_ENCODE_ALG_WEP | IW_ENCODE_ENABLED;
6542 break;
6543 default:
6544 case AUTH_OPEN:
6545 encoding->flags = IW_ENCODE_ALG_NONE | IW_ENCODE_DISABLED;
6546 break;
6547 }
6548 /* We can't return the key, so set the proper flag and return zero */
6549 encoding->flags |= IW_ENCODE_NOKEY;
6550 memset(extra, 0, 16);
6551
6552 /* Copy the key to the user buffer */
6553 ext->key_len = get_wep_key(local, idx);
6554 if (ext->key_len > 16) {
6555 ext->key_len=0;
6556 }
6557
6558 return 0;
6559}
6560
6561
6562/*------------------------------------------------------------------*/
6563/*
6564 * Wireless Handler : set extended authentication parameters
6565 */
6566static int airo_set_auth(struct net_device *dev,
6567 struct iw_request_info *info,
6568 union iwreq_data *wrqu, char *extra)
6569{
faf3994a 6570 struct airo_info *local = dev->ml_priv;
4be757dd 6571 struct iw_param *param = &wrqu->param;
3eb9b41f 6572 __le16 currentAuthType = local->config.authType;
4be757dd
DW		 6573
6574 switch (param->flags & IW_AUTH_INDEX) {
6575 case IW_AUTH_WPA_VERSION:
6576 case IW_AUTH_CIPHER_PAIRWISE:
6577 case IW_AUTH_CIPHER_GROUP:
6578 case IW_AUTH_KEY_MGMT:
6579 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6580 case IW_AUTH_PRIVACY_INVOKED:
6581 /*
6582 * airo does not use these parameters
6583 */
6584 break;
6585
6586 case IW_AUTH_DROP_UNENCRYPTED:
6587 if (param->value) {
6588 /* Only change auth type if unencrypted */
6589 if (currentAuthType == AUTH_OPEN)
6590 local->config.authType = AUTH_ENCRYPT;
6591 } else {
6592 local->config.authType = AUTH_OPEN;
6593 }
6594
6595 /* Commit the changes to flags if needed */
6596 if (local->config.authType != currentAuthType)
6597 set_bit (FLAG_COMMIT, &local->flags);
6598 break;
6599
6600 case IW_AUTH_80211_AUTH_ALG: {
6601 /* FIXME: What about AUTH_OPEN? This API seems to
6602 * disallow setting our auth to AUTH_OPEN.
6603 */
6604 if (param->value & IW_AUTH_ALG_SHARED_KEY) {
6605 local->config.authType = AUTH_SHAREDKEY;
6606 } else if (param->value & IW_AUTH_ALG_OPEN_SYSTEM) {
6607 local->config.authType = AUTH_ENCRYPT;
6608 } else
6609 return -EINVAL;
6610 break;
6611
6612 /* Commit the changes to flags if needed */
6613 if (local->config.authType != currentAuthType)
6614 set_bit (FLAG_COMMIT, &local->flags);
6615 }
6616
6617 case IW_AUTH_WPA_ENABLED:
6618 /* Silently accept disable of WPA */
6619 if (param->value > 0)
6620 return -EOPNOTSUPP;
6621 break;
6622
6623 default:
6624 return -EOPNOTSUPP;
6625 }
6626 return -EINPROGRESS;
6627}
6628
6629
6630/*------------------------------------------------------------------*/
6631/*
6632 * Wireless Handler : get extended authentication parameters
6633 */
6634static int airo_get_auth(struct net_device *dev,
6635 struct iw_request_info *info,
6636 union iwreq_data *wrqu, char *extra)
6637{
faf3994a 6638 struct airo_info *local = dev->ml_priv;
4be757dd 6639 struct iw_param *param = &wrqu->param;
3eb9b41f 6640 __le16 currentAuthType = local->config.authType;
4be757dd
DW		 6641
6642 switch (param->flags & IW_AUTH_INDEX) {
6643 case IW_AUTH_DROP_UNENCRYPTED:
6644 switch (currentAuthType) {
6645 case AUTH_SHAREDKEY:
6646 case AUTH_ENCRYPT:
6647 param->value = 1;
6648 break;
6649 default:
6650 param->value = 0;
6651 break;
6652 }
6653 break;
6654
6655 case IW_AUTH_80211_AUTH_ALG:
6656 switch (currentAuthType) {
6657 case AUTH_SHAREDKEY:
6658 param->value = IW_AUTH_ALG_SHARED_KEY;
6659 break;
6660 case AUTH_ENCRYPT:
6661 default:
6662 param->value = IW_AUTH_ALG_OPEN_SYSTEM;
6663 break;
6664 }
6665 break;
6666
6667 case IW_AUTH_WPA_ENABLED:
6668 param->value = 0;
6669 break;
6670
6671 default:
6672 return -EOPNOTSUPP;
6673 }
6674 return 0;
6675}
6676
6677
1da177e4
LT		 6678/*------------------------------------------------------------------*/
6679/*
6680 * Wireless Handler : set Tx-Power
6681 */
6682static int airo_set_txpow(struct net_device *dev,
6683 struct iw_request_info *info,
6684 struct iw_param *vwrq,
6685 char *extra)
6686{
faf3994a 6687 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 6688 CapabilityRid cap_rid; /* Card capability info */
6689 int i;
6690 int rc = -EINVAL;
3eb9b41f 6691 __le16 v = cpu_to_le16(vwrq->value);
1da177e4
LT		 6692
6693 readCapabilityRid(local, &cap_rid, 1);
6694
6695 if (vwrq->disabled) {
6696 set_bit (FLAG_RADIO_OFF, &local->flags);
6697 set_bit (FLAG_COMMIT, &local->flags);
6698 return -EINPROGRESS; /* Call commit handler */
6699 }
6700 if (vwrq->flags != IW_TXPOW_MWATT) {
6701 return -EINVAL;
6702 }
6703 clear_bit (FLAG_RADIO_OFF, &local->flags);
6704 for (i = 0; cap_rid.txPowerLevels[i] && (i < 8); i++)
3eb9b41f 6705 if (v == cap_rid.txPowerLevels[i]) {
1da177e4 6706 readConfigRid(local, 1);
3eb9b41f 6707 local->config.txPower = v;
1da177e4
LT		 6708 set_bit (FLAG_COMMIT, &local->flags);
6709 rc = -EINPROGRESS; /* Call commit handler */
6710 break;
6711 }
6712 return rc;
6713}
6714
6715/*------------------------------------------------------------------*/
6716/*
6717 * Wireless Handler : get Tx-Power
6718 */
6719static int airo_get_txpow(struct net_device *dev,
6720 struct iw_request_info *info,
6721 struct iw_param *vwrq,
6722 char *extra)
6723{
faf3994a 6724 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 6725
6726 readConfigRid(local, 1);
3eb9b41f 6727 vwrq->value = le16_to_cpu(local->config.txPower);
1da177e4
LT		 6728 vwrq->fixed = 1; /* No power control */
6729 vwrq->disabled = test_bit(FLAG_RADIO_OFF, &local->flags);
6730 vwrq->flags = IW_TXPOW_MWATT;
6731
6732 return 0;
6733}
6734
6735/*------------------------------------------------------------------*/
6736/*
6737 * Wireless Handler : set Retry limits
6738 */
6739static int airo_set_retry(struct net_device *dev,
6740 struct iw_request_info *info,
6741 struct iw_param *vwrq,
6742 char *extra)
6743{
faf3994a 6744 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 6745 int rc = -EINVAL;
6746
6747 if(vwrq->disabled) {
6748 return -EINVAL;
6749 }
6750 readConfigRid(local, 1);
6751 if(vwrq->flags & IW_RETRY_LIMIT) {
3eb9b41f 6752 __le16 v = cpu_to_le16(vwrq->value);
7f8544cc 6753 if(vwrq->flags & IW_RETRY_LONG)
3eb9b41f 6754 local->config.longRetryLimit = v;
7f8544cc 6755 else if (vwrq->flags & IW_RETRY_SHORT)
3eb9b41f 6756 local->config.shortRetryLimit = v;
1da177e4
LT		 6757 else {
6758 /* No modifier : set both */
3eb9b41f
AV		 6759 local->config.longRetryLimit = v;
6760 local->config.shortRetryLimit = v;
1da177e4
LT		 6761 }
6762 set_bit (FLAG_COMMIT, &local->flags);
6763 rc = -EINPROGRESS; /* Call commit handler */
6764 }
6765 if(vwrq->flags & IW_RETRY_LIFETIME) {
3eb9b41f 6766 local->config.txLifetime = cpu_to_le16(vwrq->value / 1024);
1da177e4
LT		 6767 set_bit (FLAG_COMMIT, &local->flags);
6768 rc = -EINPROGRESS; /* Call commit handler */
6769 }
6770 return rc;
6771}
6772
6773/*------------------------------------------------------------------*/
6774/*
6775 * Wireless Handler : get Retry limits
6776 */
6777static int airo_get_retry(struct net_device *dev,
6778 struct iw_request_info *info,
6779 struct iw_param *vwrq,
6780 char *extra)
6781{
faf3994a 6782 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 6783
6784 vwrq->disabled = 0; /* Can't be disabled */
6785
6786 readConfigRid(local, 1);
6787 /* Note : by default, display the min retry number */
6788 if((vwrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
6789 vwrq->flags = IW_RETRY_LIFETIME;
3eb9b41f 6790 vwrq->value = le16_to_cpu(local->config.txLifetime) * 1024;
7f8544cc
JT		 6791 } else if((vwrq->flags & IW_RETRY_LONG)) {
6792 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
3eb9b41f 6793 vwrq->value = le16_to_cpu(local->config.longRetryLimit);
1da177e4
LT		 6794 } else {
6795 vwrq->flags = IW_RETRY_LIMIT;
3eb9b41f
AV		 6796 vwrq->value = le16_to_cpu(local->config.shortRetryLimit);
6797 if(local->config.shortRetryLimit != local->config.longRetryLimit)
7f8544cc 6798 vwrq->flags |= IW_RETRY_SHORT;
1da177e4
LT		 6799 }
6800
6801 return 0;
6802}
6803
6804/*------------------------------------------------------------------*/
6805/*
6806 * Wireless Handler : get range info
6807 */
6808static int airo_get_range(struct net_device *dev,
6809 struct iw_request_info *info,
6810 struct iw_point *dwrq,
6811 char *extra)
6812{
faf3994a 6813 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 6814 struct iw_range *range = (struct iw_range *) extra;
6815 CapabilityRid cap_rid; /* Card capability info */
6816 int i;
6817 int k;
6818
6819 readCapabilityRid(local, &cap_rid, 1);
6820
6821 dwrq->length = sizeof(struct iw_range);
6822 memset(range, 0, sizeof(*range));
6823 range->min_nwid = 0x0000;
6824 range->max_nwid = 0x0000;
6825 range->num_channels = 14;
6826 /* Should be based on cap_rid.country to give only
6827 * what the current card support */
6828 k = 0;
6829 for(i = 0; i < 14; i++) {
6830 range->freq[k].i = i + 1; /* List index */
9ee677c2
DK		 6831 range->freq[k].m = ieee80211_dsss_chan_to_freq(i + 1) * 100000;
6832 range->freq[k++].e = 1; /* Values in MHz -> * 10^5 * 10 */
1da177e4
LT		 6833 }
6834 range->num_frequency = k;
6835
41480af2
DW		 6836 range->sensitivity = 65535;
6837
1da177e4 6838 /* Hum... Should put the right values there */
41480af2
DW		 6839 if (local->rssi)
6840 range->max_qual.qual = 100; /* % */
6841 else
6842 range->max_qual.qual = airo_get_max_quality(&cap_rid);
ce6623c3
JT		 6843 range->max_qual.level = 0x100 - 120; /* -120 dBm */
6844 range->max_qual.noise = 0x100 - 120; /* -120 dBm */
41480af2
DW		 6845
6846 /* Experimental measurements - boundary 11/5.5 Mb/s */
6847 /* Note : with or without the (local->rssi), results
6848 * are somewhat different. - Jean II */
6849 if (local->rssi) {
ce6623c3
JT		 6850 range->avg_qual.qual = 50; /* % */
6851 range->avg_qual.level = 0x100 - 70; /* -70 dBm */
41480af2
DW		 6852 } else {
6853 range->avg_qual.qual = airo_get_avg_quality(&cap_rid);
ce6623c3 6854 range->avg_qual.level = 0x100 - 80; /* -80 dBm */
41480af2 6855 }
ce6623c3 6856 range->avg_qual.noise = 0x100 - 85; /* -85 dBm */
1da177e4
LT		 6857
6858 for(i = 0 ; i < 8 ; i++) {
6859 range->bitrate[i] = cap_rid.supportedRates[i] * 500000;
6860 if(range->bitrate[i] == 0)
6861 break;
6862 }
6863 range->num_bitrates = i;
6864
6865 /* Set an indication of the max TCP throughput
6866 * in bit/s that we can expect using this interface.
6867 * May be use for QoS stuff... Jean II */
6868 if(i > 2)
6869 range->throughput = 5000 * 1000;
6870 else
6871 range->throughput = 1500 * 1000;
6872
6873 range->min_rts = 0;
15db2763 6874 range->max_rts = AIRO_DEF_MTU;
1da177e4 6875 range->min_frag = 256;
15db2763 6876 range->max_frag = AIRO_DEF_MTU;
1da177e4 6877
56d81bd3 6878 if(cap_rid.softCap & cpu_to_le16(2)) {
1da177e4
LT		 6879 // WEP: RC4 40 bits
6880 range->encoding_size[0] = 5;
6881 // RC4 ~128 bits
56d81bd3 6882 if (cap_rid.softCap & cpu_to_le16(0x100)) {
1da177e4
LT		 6883 range->encoding_size[1] = 13;
6884 range->num_encoding_sizes = 2;
6885 } else
6886 range->num_encoding_sizes = 1;
56d81bd3
AV		 6887 range->max_encoding_tokens =
6888 cap_rid.softCap & cpu_to_le16(0x80) ? 4 : 1;
1da177e4
LT		 6889 } else {
6890 range->num_encoding_sizes = 0;
6891 range->max_encoding_tokens = 0;
6892 }
6893 range->min_pmp = 0;
6894 range->max_pmp = 5000000; /* 5 secs */
6895 range->min_pmt = 0;
6896 range->max_pmt = 65535 * 1024; /* ??? */
6897 range->pmp_flags = IW_POWER_PERIOD;
6898 range->pmt_flags = IW_POWER_TIMEOUT;
6899 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
6900
6901 /* Transmit Power - values are in mW */
6902 for(i = 0 ; i < 8 ; i++) {
56d81bd3 6903 range->txpower[i] = le16_to_cpu(cap_rid.txPowerLevels[i]);
1da177e4
LT		 6904 if(range->txpower[i] == 0)
6905 break;
6906 }
6907 range->num_txpower = i;
6908 range->txpower_capa = IW_TXPOW_MWATT;
3c304956 6909 range->we_version_source = 19;
1da177e4
LT		 6910 range->we_version_compiled = WIRELESS_EXT;
6911 range->retry_capa = IW_RETRY_LIMIT | IW_RETRY_LIFETIME;
6912 range->retry_flags = IW_RETRY_LIMIT;
6913 range->r_time_flags = IW_RETRY_LIFETIME;
6914 range->min_retry = 1;
6915 range->max_retry = 65535;
6916 range->min_r_time = 1024;
6917 range->max_r_time = 65535 * 1024;
1da177e4
LT		 6918
6919 /* Event capability (kernel + driver) */
6920 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
6921 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
6922 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
6923 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
6924 range->event_capa[1] = IW_EVENT_CAPA_K_1;
6925 range->event_capa[4] = IW_EVENT_CAPA_MASK(IWEVTXDROP);
6926 return 0;
6927}
6928
6929/*------------------------------------------------------------------*/
6930/*
6931 * Wireless Handler : set Power Management
6932 */
6933static int airo_set_power(struct net_device *dev,
6934 struct iw_request_info *info,
6935 struct iw_param *vwrq,
6936 char *extra)
6937{
faf3994a 6938 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 6939
6940 readConfigRid(local, 1);
6941 if (vwrq->disabled) {
3eb9b41f 6942 if (sniffing_mode(local))
1da177e4 6943 return -EINVAL;
1da177e4 6944 local->config.powerSaveMode = POWERSAVE_CAM;
3eb9b41f 6945 local->config.rmode &= ~RXMODE_MASK;
1da177e4
LT		 6946 local->config.rmode |= RXMODE_BC_MC_ADDR;
6947 set_bit (FLAG_COMMIT, &local->flags);
6948 return -EINPROGRESS; /* Call commit handler */
6949 }
6950 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
3eb9b41f 6951 local->config.fastListenDelay = cpu_to_le16((vwrq->value + 500) / 1024);
1da177e4
LT		 6952 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6953 set_bit (FLAG_COMMIT, &local->flags);
6954 } else if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
3eb9b41f
AV		 6955 local->config.fastListenInterval =
6956 local->config.listenInterval =
6957 cpu_to_le16((vwrq->value + 500) / 1024);
1da177e4
LT		 6958 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6959 set_bit (FLAG_COMMIT, &local->flags);
6960 }
6961 switch (vwrq->flags & IW_POWER_MODE) {
6962 case IW_POWER_UNICAST_R:
3eb9b41f 6963 if (sniffing_mode(local))
1da177e4 6964 return -EINVAL;
3eb9b41f 6965 local->config.rmode &= ~RXMODE_MASK;
1da177e4
LT		 6966 local->config.rmode |= RXMODE_ADDR;
6967 set_bit (FLAG_COMMIT, &local->flags);
6968 break;
6969 case IW_POWER_ALL_R:
3eb9b41f 6970 if (sniffing_mode(local))
1da177e4 6971 return -EINVAL;
3eb9b41f 6972 local->config.rmode &= ~RXMODE_MASK;
1da177e4
LT		 6973 local->config.rmode |= RXMODE_BC_MC_ADDR;
6974 set_bit (FLAG_COMMIT, &local->flags);
6975 case IW_POWER_ON:
7f8544cc 6976 /* This is broken, fixme ;-) */
1da177e4
LT		 6977 break;
6978 default:
6979 return -EINVAL;
6980 }
6981 // Note : we may want to factor local->need_commit here
6982 // Note2 : may also want to factor RXMODE_RFMON test
6983 return -EINPROGRESS; /* Call commit handler */
6984}
6985
6986/*------------------------------------------------------------------*/
6987/*
6988 * Wireless Handler : get Power Management
6989 */
6990static int airo_get_power(struct net_device *dev,
6991 struct iw_request_info *info,
6992 struct iw_param *vwrq,
6993 char *extra)
6994{
faf3994a 6995 struct airo_info *local = dev->ml_priv;
3eb9b41f 6996 __le16 mode;
1da177e4
LT		 6997
6998 readConfigRid(local, 1);
6999 mode = local->config.powerSaveMode;
7000 if ((vwrq->disabled = (mode == POWERSAVE_CAM)))
7001 return 0;
7002 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
3eb9b41f 7003 vwrq->value = le16_to_cpu(local->config.fastListenDelay) * 1024;
1da177e4
LT		 7004 vwrq->flags = IW_POWER_TIMEOUT;
7005 } else {
3eb9b41f 7006 vwrq->value = le16_to_cpu(local->config.fastListenInterval) * 1024;
1da177e4
LT		 7007 vwrq->flags = IW_POWER_PERIOD;
7008 }
3eb9b41f 7009 if ((local->config.rmode & RXMODE_MASK) == RXMODE_ADDR)
1da177e4
LT		 7010 vwrq->flags |= IW_POWER_UNICAST_R;
7011 else
7012 vwrq->flags |= IW_POWER_ALL_R;
7013
7014 return 0;
7015}
7016
7017/*------------------------------------------------------------------*/
7018/*
7019 * Wireless Handler : set Sensitivity
7020 */
7021static int airo_set_sens(struct net_device *dev,
7022 struct iw_request_info *info,
7023 struct iw_param *vwrq,
7024 char *extra)
7025{
faf3994a 7026 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 7027
7028 readConfigRid(local, 1);
3eb9b41f
AV		 7029 local->config.rssiThreshold =
7030 cpu_to_le16(vwrq->disabled ? RSSI_DEFAULT : vwrq->value);
1da177e4
LT		 7031 set_bit (FLAG_COMMIT, &local->flags);
7032
7033 return -EINPROGRESS; /* Call commit handler */
7034}
7035
7036/*------------------------------------------------------------------*/
7037/*
7038 * Wireless Handler : get Sensitivity
7039 */
7040static int airo_get_sens(struct net_device *dev,
7041 struct iw_request_info *info,
7042 struct iw_param *vwrq,
7043 char *extra)
7044{
faf3994a 7045 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 7046
7047 readConfigRid(local, 1);
3eb9b41f 7048 vwrq->value = le16_to_cpu(local->config.rssiThreshold);
1da177e4
LT		 7049 vwrq->disabled = (vwrq->value == 0);
7050 vwrq->fixed = 1;
7051
7052 return 0;
7053}
7054
7055/*------------------------------------------------------------------*/
7056/*
7057 * Wireless Handler : get AP List
7058 * Note : this is deprecated in favor of IWSCAN
7059 */
7060static int airo_get_aplist(struct net_device *dev,
7061 struct iw_request_info *info,
7062 struct iw_point *dwrq,
7063 char *extra)
7064{
faf3994a 7065 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 7066 struct sockaddr *address = (struct sockaddr *) extra;
7067 struct iw_quality qual[IW_MAX_AP];
7068 BSSListRid BSSList;
7069 int i;
7070 int loseSync = capable(CAP_NET_ADMIN) ? 1: -1;
7071
7072 for (i = 0; i < IW_MAX_AP; i++) {
17e70491 7073 u16 dBm;
1da177e4
LT		 7074 if (readBSSListRid(local, loseSync, &BSSList))
7075 break;
7076 loseSync = 0;
7077 memcpy(address[i].sa_data, BSSList.bssid, ETH_ALEN);
7078 address[i].sa_family = ARPHRD_ETHER;
17e70491 7079 dBm = le16_to_cpu(BSSList.dBm);
41480af2 7080 if (local->rssi) {
17e70491
AV		 7081 qual[i].level = 0x100 - dBm;
7082 qual[i].qual = airo_dbm_to_pct(local->rssi, dBm);
ce6623c3
JT		 7083 qual[i].updated = IW_QUAL_QUAL_UPDATED
7084 | IW_QUAL_LEVEL_UPDATED
7085 | IW_QUAL_DBM;
41480af2 7086 } else {
17e70491 7087 qual[i].level = (dBm + 321) / 2;
41480af2 7088 qual[i].qual = 0;
ce6623c3
JT		 7089 qual[i].updated = IW_QUAL_QUAL_INVALID
7090 | IW_QUAL_LEVEL_UPDATED
7091 | IW_QUAL_DBM;
41480af2
DW		 7092 }
7093 qual[i].noise = local->wstats.qual.noise;
17e70491 7094 if (BSSList.index == cpu_to_le16(0xffff))
1da177e4
LT		 7095 break;
7096 }
7097 if (!i) {
7098 StatusRid status_rid; /* Card status info */
7099 readStatusRid(local, &status_rid, 1);
7100 for (i = 0;
7101 i < min(IW_MAX_AP, 4) &&
7102 (status_rid.bssid[i][0]
7103 & status_rid.bssid[i][1]
7104 & status_rid.bssid[i][2]
7105 & status_rid.bssid[i][3]
7106 & status_rid.bssid[i][4]
7107 & status_rid.bssid[i][5])!=0xff &&
7108 (status_rid.bssid[i][0]
7109 | status_rid.bssid[i][1]
7110 | status_rid.bssid[i][2]
7111 | status_rid.bssid[i][3]
7112 | status_rid.bssid[i][4]
7113 | status_rid.bssid[i][5]);
7114 i++) {
7115 memcpy(address[i].sa_data,
7116 status_rid.bssid[i], ETH_ALEN);
7117 address[i].sa_family = ARPHRD_ETHER;
7118 }
7119 } else {
7120 dwrq->flags = 1; /* Should be define'd */
7121 memcpy(extra + sizeof(struct sockaddr)*i,
7122 &qual, sizeof(struct iw_quality)*i);
7123 }
7124 dwrq->length = i;
7125
7126 return 0;
7127}
7128
7129/*------------------------------------------------------------------*/
7130/*
7131 * Wireless Handler : Initiate Scan
7132 */
7133static int airo_set_scan(struct net_device *dev,
7134 struct iw_request_info *info,
9930ccee 7135 struct iw_point *dwrq,
1da177e4
LT		 7136 char *extra)
7137{
faf3994a 7138 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 7139 Cmd cmd;
7140 Resp rsp;
9e75af30 7141 int wake = 0;
1da177e4
LT		 7142
7143 /* Note : you may have realised that, as this is a SET operation,
7144 * this is privileged and therefore a normal user can't
7145 * perform scanning.
7146 * This is not an error, while the device perform scanning,
7147 * traffic doesn't flow, so it's a perfect DoS...
7148 * Jean II */
7149 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
7150
9e75af30
DW		 7151 if (down_interruptible(&ai->sem))
7152 return -ERESTARTSYS;
7153
7154 /* If there's already a scan in progress, don't
7155 * trigger another one. */
7156 if (ai->scan_timeout > 0)
7157 goto out;
7158
1da177e4 7159 /* Initiate a scan command */
6fcdf565 7160 ai->scan_timeout = RUN_AT(3*HZ);
1da177e4
LT		 7161 memset(&cmd, 0, sizeof(cmd));
7162 cmd.cmd=CMD_LISTBSS;
1da177e4 7163 issuecommand(ai, &cmd, &rsp);
9e75af30 7164 wake = 1;
1da177e4 7165
9e75af30
DW		 7166out:
7167 up(&ai->sem);
7168 if (wake)
7169 wake_up_interruptible(&ai->thr_wait);
1da177e4
LT		 7170 return 0;
7171}
7172
7173/*------------------------------------------------------------------*/
7174/*
7175 * Translate scan data returned from the card to a card independent
7176 * format that the Wireless Tools will understand - Jean II
7177 */
7178static inline char *airo_translate_scan(struct net_device *dev,
ccc58057 7179 struct iw_request_info *info,
1da177e4
LT		 7180 char *current_ev,
7181 char *end_buf,
41480af2 7182 BSSListRid *bss)
1da177e4 7183{
faf3994a 7184 struct airo_info *ai = dev->ml_priv;
1da177e4 7185 struct iw_event iwe; /* Temporary buffer */
17e70491 7186 __le16 capabilities;
1da177e4
LT		 7187 char * current_val; /* For rates */
7188 int i;
3c304956 7189 char * buf;
851b3e5e 7190 u16 dBm;
1da177e4
LT		 7191
7192 /* First entry *MUST* be the AP MAC address */
7193 iwe.cmd = SIOCGIWAP;
7194 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
41480af2 7195 memcpy(iwe.u.ap_addr.sa_data, bss->bssid, ETH_ALEN);
ccc58057
DM		 7196 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
7197 &iwe, IW_EV_ADDR_LEN);
1da177e4
LT		 7198
7199 /* Other entries will be displayed in the order we give them */
7200
7201 /* Add the ESSID */
41480af2 7202 iwe.u.data.length = bss->ssidLen;
1da177e4
LT		 7203 if(iwe.u.data.length > 32)
7204 iwe.u.data.length = 32;
7205 iwe.cmd = SIOCGIWESSID;
7206 iwe.u.data.flags = 1;
ccc58057
DM		 7207 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
7208 &iwe, bss->ssid);
1da177e4
LT		 7209
7210 /* Add mode */
7211 iwe.cmd = SIOCGIWMODE;
17e70491 7212 capabilities = bss->cap;
1da177e4
LT		 7213 if(capabilities & (CAP_ESS | CAP_IBSS)) {
7214 if(capabilities & CAP_ESS)
7215 iwe.u.mode = IW_MODE_MASTER;
7216 else
7217 iwe.u.mode = IW_MODE_ADHOC;
ccc58057
DM		 7218 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
7219 &iwe, IW_EV_UINT_LEN);
1da177e4
LT		 7220 }
7221
7222 /* Add frequency */
7223 iwe.cmd = SIOCGIWFREQ;
41480af2 7224 iwe.u.freq.m = le16_to_cpu(bss->dsChannel);
9ee677c2 7225 iwe.u.freq.m = ieee80211_dsss_chan_to_freq(iwe.u.freq.m) * 100000;
1da177e4 7226 iwe.u.freq.e = 1;
ccc58057
DM		 7227 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
7228 &iwe, IW_EV_FREQ_LEN);
1da177e4 7229
851b3e5e
AV		 7230 dBm = le16_to_cpu(bss->dBm);
7231
1da177e4
LT		 7232 /* Add quality statistics */
7233 iwe.cmd = IWEVQUAL;
41480af2 7234 if (ai->rssi) {
851b3e5e
AV		 7235 iwe.u.qual.level = 0x100 - dBm;
7236 iwe.u.qual.qual = airo_dbm_to_pct(ai->rssi, dBm);
ce6623c3
JT		 7237 iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED
7238 | IW_QUAL_LEVEL_UPDATED
7239 | IW_QUAL_DBM;
41480af2 7240 } else {
851b3e5e 7241 iwe.u.qual.level = (dBm + 321) / 2;
41480af2 7242 iwe.u.qual.qual = 0;
bbeec90b 7243 iwe.u.qual.updated = IW_QUAL_QUAL_INVALID
ce6623c3
JT		 7244 | IW_QUAL_LEVEL_UPDATED
7245 | IW_QUAL_DBM;
41480af2
DW		 7246 }
7247 iwe.u.qual.noise = ai->wstats.qual.noise;
ccc58057
DM		 7248 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
7249 &iwe, IW_EV_QUAL_LEN);
1da177e4
LT		 7250
7251 /* Add encryption capability */
7252 iwe.cmd = SIOCGIWENCODE;
7253 if(capabilities & CAP_PRIVACY)
7254 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
7255 else
7256 iwe.u.data.flags = IW_ENCODE_DISABLED;
7257 iwe.u.data.length = 0;
ccc58057
DM		 7258 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
7259 &iwe, bss->ssid);
1da177e4
LT		 7260
7261 /* Rate : stuffing multiple values in a single event require a bit
7262 * more of magic - Jean II */
ccc58057 7263 current_val = current_ev + iwe_stream_lcp_len(info);
1da177e4
LT		 7264
7265 iwe.cmd = SIOCGIWRATE;
7266 /* Those two flags are ignored... */
7267 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
7268 /* Max 8 values */
7269 for(i = 0 ; i < 8 ; i++) {
7270 /* NULL terminated */
41480af2 7271 if(bss->rates[i] == 0)
1da177e4
LT		 7272 break;
7273 /* Bit rate given in 500 kb/s units (+ 0x80) */
41480af2 7274 iwe.u.bitrate.value = ((bss->rates[i] & 0x7f) * 500000);
1da177e4 7275 /* Add new value to event */
ccc58057
DM		 7276 current_val = iwe_stream_add_value(info, current_ev,
7277 current_val, end_buf,
7278 &iwe, IW_EV_PARAM_LEN);
1da177e4
LT		 7279 }
7280 /* Check if we added any event */
ccc58057 7281 if ((current_val - current_ev) > iwe_stream_lcp_len(info))
1da177e4
LT		 7282 current_ev = current_val;
7283
3c304956
DW		 7284 /* Beacon interval */
7285 buf = kmalloc(30, GFP_KERNEL);
7286 if (buf) {
7287 iwe.cmd = IWEVCUSTOM;
7288 sprintf(buf, "bcn_int=%d", bss->beaconInterval);
7289 iwe.u.data.length = strlen(buf);
ccc58057
DM		 7290 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
7291 &iwe, buf);
3c304956
DW		 7292 kfree(buf);
7293 }
7294
7295 /* Put WPA/RSN Information Elements into the event stream */
7296 if (test_bit(FLAG_WPA_CAPABLE, &ai->flags)) {
7297 unsigned int num_null_ies = 0;
7298 u16 length = sizeof (bss->extra.iep);
2c706002 7299 u8 *ie = (void *)&bss->extra.iep;
3c304956 7300
2c706002
JB		 7301 while ((length >= 2) && (num_null_ies < 2)) {
7302 if (2 + ie[1] > length) {
3c304956
DW		 7303 /* Invalid element, don't continue parsing IE */
7304 break;
7305 }
7306
2c706002
JB		 7307 switch (ie[0]) {
7308 case WLAN_EID_SSID:
3c304956
DW		 7309 /* Two zero-length SSID elements
7310 * mean we're done parsing elements */
2c706002 7311 if (!ie[1])
3c304956
DW		 7312 num_null_ies++;
7313 break;
7314
2c706002
JB		 7315 case WLAN_EID_GENERIC:
7316 if (ie[1] >= 4 &&
7317 ie[2] == 0x00 &&
7318 ie[3] == 0x50 &&
7319 ie[4] == 0xf2 &&
7320 ie[5] == 0x01) {
3c304956 7321 iwe.cmd = IWEVGENIE;
2c706002
JB		 7322 /* 64 is an arbitrary cut-off */
7323 iwe.u.data.length = min(ie[1] + 2,
7324 64);
ccc58057
DM		 7325 current_ev = iwe_stream_add_point(
7326 info, current_ev,
2c706002 7327 end_buf, &iwe, ie);
3c304956
DW		 7328 }
7329 break;
7330
2c706002 7331 case WLAN_EID_RSN:
3c304956 7332 iwe.cmd = IWEVGENIE;
2c706002
JB		 7333 /* 64 is an arbitrary cut-off */
7334 iwe.u.data.length = min(ie[1] + 2, 64);
ccc58057
DM		 7335 current_ev = iwe_stream_add_point(
7336 info, current_ev, end_buf,
2c706002 7337 &iwe, ie);
3c304956
DW		 7338 break;
7339
7340 default:
7341 break;
7342 }
7343
2c706002
JB		 7344 length -= 2 + ie[1];
7345 ie += 2 + ie[1];
3c304956
DW		 7346 }
7347 }
1da177e4
LT		 7348 return current_ev;
7349}
7350
7351/*------------------------------------------------------------------*/
7352/*
7353 * Wireless Handler : Read Scan Results
7354 */
7355static int airo_get_scan(struct net_device *dev,
7356 struct iw_request_info *info,
7357 struct iw_point *dwrq,
7358 char *extra)
7359{
faf3994a 7360 struct airo_info *ai = dev->ml_priv;
9e75af30
DW		 7361 BSSListElement *net;
7362 int err = 0;
1da177e4
LT		 7363 char *current_ev = extra;
7364
9e75af30
DW		 7365 /* If a scan is in-progress, return -EAGAIN */
7366 if (ai->scan_timeout > 0)
1da177e4 7367 return -EAGAIN;
1da177e4 7368
9e75af30
DW		 7369 if (down_interruptible(&ai->sem))
7370 return -EAGAIN;
1da177e4 7371
9e75af30 7372 list_for_each_entry (net, &ai->network_list, list) {
1da177e4 7373 /* Translate to WE format this entry */
ccc58057 7374 current_ev = airo_translate_scan(dev, info, current_ev,
1da177e4 7375 extra + dwrq->length,
9e75af30 7376 &net->bss);
1da177e4
LT		 7377
7378 /* Check if there is space for one more entry */
7379 if((extra + dwrq->length - current_ev) <= IW_EV_ADDR_LEN) {
7380 /* Ask user space to try again with a bigger buffer */
9e75af30
DW		 7381 err = -E2BIG;
7382 goto out;
1da177e4 7383 }
1da177e4 7384 }
9e75af30 7385
1da177e4
LT		 7386 /* Length of data */
7387 dwrq->length = (current_ev - extra);
7388 dwrq->flags = 0; /* todo */
7389
9e75af30
DW		 7390out:
7391 up(&ai->sem);
7392 return err;
1da177e4
LT		 7393}
7394
7395/*------------------------------------------------------------------*/
7396/*
7397 * Commit handler : called after a bunch of SET operations
7398 */
7399static int airo_config_commit(struct net_device *dev,
7400 struct iw_request_info *info, /* NULL */
7401 void *zwrq, /* NULL */
7402 char *extra) /* NULL */
7403{
faf3994a 7404 struct airo_info *local = dev->ml_priv;
1da177e4
LT		 7405
7406 if (!test_bit (FLAG_COMMIT, &local->flags))
7407 return 0;
7408
7409 /* Some of the "SET" function may have modified some of the
7410 * parameters. It's now time to commit them in the card */
7411 disable_MAC(local, 1);
7412 if (test_bit (FLAG_RESET, &local->flags)) {
7413 APListRid APList_rid;
7414 SsidRid SSID_rid;
7415
7416 readAPListRid(local, &APList_rid);
7417 readSsidRid(local, &SSID_rid);
7418 if (test_bit(FLAG_MPI,&local->flags))
7419 setup_card(local, dev->dev_addr, 1 );
7420 else
7421 reset_airo_card(dev);
7422 disable_MAC(local, 1);
7423 writeSsidRid(local, &SSID_rid, 1);
7424 writeAPListRid(local, &APList_rid, 1);
7425 }
7426 if (down_interruptible(&local->sem))
7427 return -ERESTARTSYS;
7428 writeConfigRid(local, 0);
175ec1a1 7429 enable_MAC(local, 0);
1da177e4
LT		 7430 if (test_bit (FLAG_RESET, &local->flags))
7431 airo_set_promisc(local);
7432 else
7433 up(&local->sem);
7434
7435 return 0;
7436}
7437
7438/*------------------------------------------------------------------*/
7439/*
7440 * Structures to export the Wireless Handlers
7441 */
7442
7443static const struct iw_priv_args airo_private_args[] = {
7444/*{ cmd, set_args, get_args, name } */
7445 { AIROIOCTL, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
7446 IW_PRIV_TYPE_BYTE | 2047, "airoioctl" },
7447 { AIROIDIFC, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
7448 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "airoidifc" },
7449};
7450
7451static const iw_handler airo_handler[] =
7452{
7453 (iw_handler) airo_config_commit, /* SIOCSIWCOMMIT */
7454 (iw_handler) airo_get_name, /* SIOCGIWNAME */
7455 (iw_handler) NULL, /* SIOCSIWNWID */
7456 (iw_handler) NULL, /* SIOCGIWNWID */
7457 (iw_handler) airo_set_freq, /* SIOCSIWFREQ */
7458 (iw_handler) airo_get_freq, /* SIOCGIWFREQ */
7459 (iw_handler) airo_set_mode, /* SIOCSIWMODE */
7460 (iw_handler) airo_get_mode, /* SIOCGIWMODE */
7461 (iw_handler) airo_set_sens, /* SIOCSIWSENS */
7462 (iw_handler) airo_get_sens, /* SIOCGIWSENS */
7463 (iw_handler) NULL, /* SIOCSIWRANGE */
7464 (iw_handler) airo_get_range, /* SIOCGIWRANGE */
7465 (iw_handler) NULL, /* SIOCSIWPRIV */
7466 (iw_handler) NULL, /* SIOCGIWPRIV */
7467 (iw_handler) NULL, /* SIOCSIWSTATS */
7468 (iw_handler) NULL, /* SIOCGIWSTATS */
7469 iw_handler_set_spy, /* SIOCSIWSPY */
7470 iw_handler_get_spy, /* SIOCGIWSPY */
7471 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
7472 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
7473 (iw_handler) airo_set_wap, /* SIOCSIWAP */
7474 (iw_handler) airo_get_wap, /* SIOCGIWAP */
7475 (iw_handler) NULL, /* -- hole -- */
7476 (iw_handler) airo_get_aplist, /* SIOCGIWAPLIST */
7477 (iw_handler) airo_set_scan, /* SIOCSIWSCAN */
7478 (iw_handler) airo_get_scan, /* SIOCGIWSCAN */
7479 (iw_handler) airo_set_essid, /* SIOCSIWESSID */
7480 (iw_handler) airo_get_essid, /* SIOCGIWESSID */
7481 (iw_handler) airo_set_nick, /* SIOCSIWNICKN */
7482 (iw_handler) airo_get_nick, /* SIOCGIWNICKN */
7483 (iw_handler) NULL, /* -- hole -- */
7484 (iw_handler) NULL, /* -- hole -- */
7485 (iw_handler) airo_set_rate, /* SIOCSIWRATE */
7486 (iw_handler) airo_get_rate, /* SIOCGIWRATE */
7487 (iw_handler) airo_set_rts, /* SIOCSIWRTS */
7488 (iw_handler) airo_get_rts, /* SIOCGIWRTS */
7489 (iw_handler) airo_set_frag, /* SIOCSIWFRAG */
7490 (iw_handler) airo_get_frag, /* SIOCGIWFRAG */
7491 (iw_handler) airo_set_txpow, /* SIOCSIWTXPOW */
7492 (iw_handler) airo_get_txpow, /* SIOCGIWTXPOW */
7493 (iw_handler) airo_set_retry, /* SIOCSIWRETRY */
7494 (iw_handler) airo_get_retry, /* SIOCGIWRETRY */
7495 (iw_handler) airo_set_encode, /* SIOCSIWENCODE */
7496 (iw_handler) airo_get_encode, /* SIOCGIWENCODE */
7497 (iw_handler) airo_set_power, /* SIOCSIWPOWER */
7498 (iw_handler) airo_get_power, /* SIOCGIWPOWER */
4be757dd
DW		 7499 (iw_handler) NULL, /* -- hole -- */
7500 (iw_handler) NULL, /* -- hole -- */
7501 (iw_handler) NULL, /* SIOCSIWGENIE */
7502 (iw_handler) NULL, /* SIOCGIWGENIE */
7503 (iw_handler) airo_set_auth, /* SIOCSIWAUTH */
7504 (iw_handler) airo_get_auth, /* SIOCGIWAUTH */
7505 (iw_handler) airo_set_encodeext, /* SIOCSIWENCODEEXT */
7506 (iw_handler) airo_get_encodeext, /* SIOCGIWENCODEEXT */
7507 (iw_handler) NULL, /* SIOCSIWPMKSA */
1da177e4
LT		 7508};
7509
7510/* Note : don't describe AIROIDIFC and AIROOLDIDIFC in here.
7511 * We want to force the use of the ioctl code, because those can't be
7512 * won't work the iw_handler code (because they simultaneously read
7513 * and write data and iw_handler can't do that).
7514 * Note that it's perfectly legal to read/write on a single ioctl command,
7515 * you just can't use iwpriv and need to force it via the ioctl handler.
7516 * Jean II */
7517static const iw_handler airo_private_handler[] =
7518{
7519 NULL, /* SIOCIWFIRSTPRIV */
7520};
7521
7522static const struct iw_handler_def airo_handler_def =
7523{
ff8ac609
DC		 7524 .num_standard = ARRAY_SIZE(airo_handler),
7525 .num_private = ARRAY_SIZE(airo_private_handler),
7526 .num_private_args = ARRAY_SIZE(airo_private_args),
1da177e4
LT		 7527 .standard = airo_handler,
7528 .private = airo_private_handler,
7529 .private_args = airo_private_args,
7530 .get_wireless_stats = airo_get_wireless_stats,
7531};
7532
1da177e4
LT		 7533/*
7534 * This defines the configuration part of the Wireless Extensions
7535 * Note : irq and spinlock protection will occur in the subroutines
7536 *
7537 * TODO :
7538 * o Check input value more carefully and fill correct values in range
7539 * o Test and shakeout the bugs (if any)
7540 *
7541 * Jean II
7542 *
7543 * Javier Achirica did a great job of merging code from the unnamed CISCO
7544 * developer that added support for flashing the card.
7545 */
7546static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
7547{
7548 int rc = 0;
faf3994a 7549 struct airo_info *ai = dev->ml_priv;
1da177e4 7550
ca078bae 7551 if (ai->power.event)
1da177e4
LT		 7552 return 0;
7553
7554 switch (cmd) {
7555#ifdef CISCO_EXT
7556 case AIROIDIFC:
7557#ifdef AIROOLDIDIFC
7558 case AIROOLDIDIFC:
7559#endif
7560 {
7561 int val = AIROMAGIC;
7562 aironet_ioctl com;
7563 if (copy_from_user(&com,rq->ifr_data,sizeof(com)))
7564 rc = -EFAULT;
7565 else if (copy_to_user(com.data,(char *)&val,sizeof(val)))
7566 rc = -EFAULT;
7567 }
7568 break;
7569
7570 case AIROIOCTL:
7571#ifdef AIROOLDIOCTL
7572 case AIROOLDIOCTL:
7573#endif
7574 /* Get the command struct and hand it off for evaluation by
7575 * the proper subfunction
7576 */
7577 {
7578 aironet_ioctl com;
7579 if (copy_from_user(&com,rq->ifr_data,sizeof(com))) {
7580 rc = -EFAULT;
7581 break;
7582 }
7583
7584 /* Separate R/W functions bracket legality here
7585 */
7586 if ( com.command == AIRORSWVERSION ) {
7587 if (copy_to_user(com.data, swversion, sizeof(swversion)))
7588 rc = -EFAULT;
7589 else
7590 rc = 0;
7591 }
7592 else if ( com.command <= AIRORRID)
7593 rc = readrids(dev,&com);
7594 else if ( com.command >= AIROPCAP && com.command <= (AIROPLEAPUSR+2) )
7595 rc = writerids(dev,&com);
7596 else if ( com.command >= AIROFLSHRST && com.command <= AIRORESTART )
7597 rc = flashcard(dev,&com);
7598 else
7599 rc = -EINVAL; /* Bad command in ioctl */
7600 }
7601 break;
7602#endif /* CISCO_EXT */
7603
7604 // All other calls are currently unsupported
7605 default:
7606 rc = -EOPNOTSUPP;
7607 }
7608 return rc;
7609}
7610
1da177e4
LT		 7611/*
7612 * Get the Wireless stats out of the driver
7613 * Note : irq and spinlock protection will occur in the subroutines
7614 *
7615 * TODO :
7616 * o Check if work in Ad-Hoc mode (otherwise, use SPY, as in wvlan_cs)
7617 *
7618 * Jean
7619 */
7620static void airo_read_wireless_stats(struct airo_info *local)
7621{
7622 StatusRid status_rid;
7623 StatsRid stats_rid;
7624 CapabilityRid cap_rid;
a23ace5f 7625 __le32 *vals = stats_rid.vals;
1da177e4
LT		 7626
7627 /* Get stats out of the card */
3c304956 7628 clear_bit(JOB_WSTATS, &local->jobs);
ca078bae 7629 if (local->power.event) {
1da177e4
LT		 7630 up(&local->sem);
7631 return;
7632 }
7633 readCapabilityRid(local, &cap_rid, 0);
7634 readStatusRid(local, &status_rid, 0);
7635 readStatsRid(local, &stats_rid, RID_STATS, 0);
7636 up(&local->sem);
7637
7638 /* The status */
329e2c00 7639 local->wstats.status = le16_to_cpu(status_rid.mode);
1da177e4 7640
41480af2
DW		 7641 /* Signal quality and co */
7642 if (local->rssi) {
329e2c00
AV		 7643 local->wstats.qual.level =
7644 airo_rssi_to_dbm(local->rssi,
7645 le16_to_cpu(status_rid.sigQuality));
41480af2 7646 /* normalizedSignalStrength appears to be a percentage */
329e2c00
AV		 7647 local->wstats.qual.qual =
7648 le16_to_cpu(status_rid.normalizedSignalStrength);
41480af2 7649 } else {
329e2c00
AV		 7650 local->wstats.qual.level =
7651 (le16_to_cpu(status_rid.normalizedSignalStrength) + 321) / 2;
41480af2
DW		 7652 local->wstats.qual.qual = airo_get_quality(&status_rid, &cap_rid);
7653 }
329e2c00 7654 if (le16_to_cpu(status_rid.len) >= 124) {
41480af2 7655 local->wstats.qual.noise = 0x100 - status_rid.noisedBm;
ce6623c3 7656 local->wstats.qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
1da177e4
LT		 7657 } else {
7658 local->wstats.qual.noise = 0;
ce6623c3 7659 local->wstats.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_INVALID | IW_QUAL_DBM;
1da177e4
LT		 7660 }
7661
7662 /* Packets discarded in the wireless adapter due to wireless
7663 * specific problems */
a23ace5f
AV		 7664 local->wstats.discard.nwid = le32_to_cpu(vals[56]) +
7665 le32_to_cpu(vals[57]) +
7666 le32_to_cpu(vals[58]); /* SSID Mismatch */
7667 local->wstats.discard.code = le32_to_cpu(vals[6]);/* RxWepErr */
7668 local->wstats.discard.fragment = le32_to_cpu(vals[30]);
7669 local->wstats.discard.retries = le32_to_cpu(vals[10]);
7670 local->wstats.discard.misc = le32_to_cpu(vals[1]) +
7671 le32_to_cpu(vals[32]);
7672 local->wstats.miss.beacon = le32_to_cpu(vals[34]);
1da177e4
LT		 7673}
7674
ff1d2767 7675static struct iw_statistics *airo_get_wireless_stats(struct net_device *dev)
1da177e4 7676{
faf3994a 7677 struct airo_info *local = dev->ml_priv;
1da177e4 7678
3c304956 7679 if (!test_bit(JOB_WSTATS, &local->jobs)) {
1da177e4
LT		 7680 /* Get stats out of the card if available */
7681 if (down_trylock(&local->sem) != 0) {
3c304956 7682 set_bit(JOB_WSTATS, &local->jobs);
1da177e4
LT		 7683 wake_up_interruptible(&local->thr_wait);
7684 } else
7685 airo_read_wireless_stats(local);
7686 }
7687
7688 return &local->wstats;
7689}
1da177e4
LT		 7690
7691#ifdef CISCO_EXT
7692/*
7693 * This just translates from driver IOCTL codes to the command codes to
7694 * feed to the radio's host interface. Things can be added/deleted
7695 * as needed. This represents the READ side of control I/O to
7696 * the card
7697 */
7698static int readrids(struct net_device *dev, aironet_ioctl *comp) {
7699 unsigned short ridcode;
7700 unsigned char *iobuf;
7701 int len;
faf3994a 7702 struct airo_info *ai = dev->ml_priv;
1da177e4
LT		 7703
7704 if (test_bit(FLAG_FLASHING, &ai->flags))
7705 return -EIO;
7706
7707 switch(comp->command)
7708 {
7709 case AIROGCAP: ridcode = RID_CAPABILITIES; break;
7710 case AIROGCFG: ridcode = RID_CONFIG;
7711 if (test_bit(FLAG_COMMIT, &ai->flags)) {
7712 disable_MAC (ai, 1);
7713 writeConfigRid (ai, 1);
175ec1a1 7714 enable_MAC(ai, 1);
1da177e4
LT		 7715 }
7716 break;
7717 case AIROGSLIST: ridcode = RID_SSID; break;
7718 case AIROGVLIST: ridcode = RID_APLIST; break;
7719 case AIROGDRVNAM: ridcode = RID_DRVNAME; break;
7720 case AIROGEHTENC: ridcode = RID_ETHERENCAP; break;
7721 case AIROGWEPKTMP: ridcode = RID_WEP_TEMP;
7722 /* Only super-user can read WEP keys */
7723 if (!capable(CAP_NET_ADMIN))
7724 return -EPERM;
7725 break;
7726 case AIROGWEPKNV: ridcode = RID_WEP_PERM;
7727 /* Only super-user can read WEP keys */
7728 if (!capable(CAP_NET_ADMIN))
7729 return -EPERM;
7730 break;
7731 case AIROGSTAT: ridcode = RID_STATUS; break;
7732 case AIROGSTATSD32: ridcode = RID_STATSDELTA; break;
7733 case AIROGSTATSC32: ridcode = RID_STATS; break;
1da177e4
LT		 7734 case AIROGMICSTATS:
7735 if (copy_to_user(comp->data, &ai->micstats,
7736 min((int)comp->len,(int)sizeof(ai->micstats))))
7737 return -EFAULT;
7738 return 0;
1da177e4
LT		 7739 case AIRORRID: ridcode = comp->ridnum; break;
7740 default:
7741 return -EINVAL;
7742 break;
7743 }
7744
7745 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7746 return -ENOMEM;
7747
7748 PC4500_readrid(ai,ridcode,iobuf,RIDSIZE, 1);
7749 /* get the count of bytes in the rid docs say 1st 2 bytes is it.
7750 * then return it to the user
7751 * 9/22/2000 Honor user given length
7752 */
7753 len = comp->len;
7754
7755 if (copy_to_user(comp->data, iobuf, min(len, (int)RIDSIZE))) {
7756 kfree (iobuf);
7757 return -EFAULT;
7758 }
7759 kfree (iobuf);
7760 return 0;
7761}
7762
7763/*
7764 * Danger Will Robinson write the rids here
7765 */
7766
7767static int writerids(struct net_device *dev, aironet_ioctl *comp) {
faf3994a 7768 struct airo_info *ai = dev->ml_priv;
1da177e4 7769 int ridcode;
1da177e4 7770 int enabled;
1da177e4
LT		 7771 static int (* writer)(struct airo_info *, u16 rid, const void *, int, int);
7772 unsigned char *iobuf;
7773
7774 /* Only super-user can write RIDs */
7775 if (!capable(CAP_NET_ADMIN))
7776 return -EPERM;
7777
7778 if (test_bit(FLAG_FLASHING, &ai->flags))
7779 return -EIO;
7780
7781 ridcode = 0;
7782 writer = do_writerid;
7783
7784 switch(comp->command)
7785 {
7786 case AIROPSIDS: ridcode = RID_SSID; break;
7787 case AIROPCAP: ridcode = RID_CAPABILITIES; break;
7788 case AIROPAPLIST: ridcode = RID_APLIST; break;
7789 case AIROPCFG: ai->config.len = 0;
7790 clear_bit(FLAG_COMMIT, &ai->flags);
7791 ridcode = RID_CONFIG; break;
7792 case AIROPWEPKEYNV: ridcode = RID_WEP_PERM; break;
7793 case AIROPLEAPUSR: ridcode = RID_LEAPUSERNAME; break;
7794 case AIROPLEAPPWD: ridcode = RID_LEAPPASSWORD; break;
7795 case AIROPWEPKEY: ridcode = RID_WEP_TEMP; writer = PC4500_writerid;
7796 break;
7797 case AIROPLEAPUSR+1: ridcode = 0xFF2A; break;
7798 case AIROPLEAPUSR+2: ridcode = 0xFF2B; break;
7799
7800 /* this is not really a rid but a command given to the card
7801 * same with MAC off
7802 */
7803 case AIROPMACON:
175ec1a1 7804 if (enable_MAC(ai, 1) != 0)
1da177e4
LT		 7805 return -EIO;
7806 return 0;
7807
7808 /*
7809 * Evidently this code in the airo driver does not get a symbol
7810 * as disable_MAC. it's probably so short the compiler does not gen one.
7811 */
7812 case AIROPMACOFF:
7813 disable_MAC(ai, 1);
7814 return 0;
7815
7816 /* This command merely clears the counts does not actually store any data
7817 * only reads rid. But as it changes the cards state, I put it in the
7818 * writerid routines.
7819 */
7820 case AIROPSTCLR:
7821 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7822 return -ENOMEM;
7823
7824 PC4500_readrid(ai,RID_STATSDELTACLEAR,iobuf,RIDSIZE, 1);
7825
1da177e4
LT		 7826 enabled = ai->micstats.enabled;
7827 memset(&ai->micstats,0,sizeof(ai->micstats));
7828 ai->micstats.enabled = enabled;
1da177e4
LT		 7829
7830 if (copy_to_user(comp->data, iobuf,
7831 min((int)comp->len, (int)RIDSIZE))) {
7832 kfree (iobuf);
7833 return -EFAULT;
7834 }
7835 kfree (iobuf);
7836 return 0;
7837
7838 default:
7839 return -EOPNOTSUPP; /* Blarg! */
7840 }
7841 if(comp->len > RIDSIZE)
7842 return -EINVAL;
7843
7844 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7845 return -ENOMEM;
7846
7847 if (copy_from_user(iobuf,comp->data,comp->len)) {
7848 kfree (iobuf);
7849 return -EFAULT;
7850 }
7851
7852 if (comp->command == AIROPCFG) {
7853 ConfigRid *cfg = (ConfigRid *)iobuf;
7854
7855 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags))
3eb9b41f 7856 cfg->opmode |= MODE_MIC;
1da177e4 7857
3eb9b41f 7858 if ((cfg->opmode & MODE_CFG_MASK) == MODE_STA_IBSS)
1da177e4
LT		 7859 set_bit (FLAG_ADHOC, &ai->flags);
7860 else
7861 clear_bit (FLAG_ADHOC, &ai->flags);
7862 }
7863
7864 if((*writer)(ai, ridcode, iobuf,comp->len,1)) {
7865 kfree (iobuf);
7866 return -EIO;
7867 }
7868 kfree (iobuf);
7869 return 0;
7870}
7871
7872/*****************************************************************************
7873 * Ancillary flash / mod functions much black magic lurkes here *
7874 *****************************************************************************
7875 */
7876
7877/*
7878 * Flash command switch table
7879 */
7880
ff1d2767 7881static int flashcard(struct net_device *dev, aironet_ioctl *comp) {
1da177e4 7882 int z;
1da177e4
LT		 7883
7884 /* Only super-user can modify flash */
7885 if (!capable(CAP_NET_ADMIN))
7886 return -EPERM;
7887
7888 switch(comp->command)
7889 {
7890 case AIROFLSHRST:
faf3994a 7891 return cmdreset((struct airo_info *)dev->ml_priv);
1da177e4
LT		 7892
7893 case AIROFLSHSTFL:
faf3994a
WC		 7894 if (!AIRO_FLASH(dev) &&
7895 (AIRO_FLASH(dev) = kmalloc(FLASHSIZE, GFP_KERNEL)) == NULL)
1da177e4 7896 return -ENOMEM;
faf3994a 7897 return setflashmode((struct airo_info *)dev->ml_priv);
1da177e4
LT		 7898
7899 case AIROFLSHGCHR: /* Get char from aux */
7900 if(comp->len != sizeof(int))
7901 return -EINVAL;
7902 if (copy_from_user(&z,comp->data,comp->len))
7903 return -EFAULT;
faf3994a 7904 return flashgchar((struct airo_info *)dev->ml_priv, z, 8000);
1da177e4
LT		 7905
7906 case AIROFLSHPCHR: /* Send char to card. */
7907 if(comp->len != sizeof(int))
7908 return -EINVAL;
7909 if (copy_from_user(&z,comp->data,comp->len))
7910 return -EFAULT;
faf3994a 7911 return flashpchar((struct airo_info *)dev->ml_priv, z, 8000);
1da177e4
LT		 7912
7913 case AIROFLPUTBUF: /* Send 32k to card */
faf3994a 7914 if (!AIRO_FLASH(dev))
1da177e4
LT		 7915 return -ENOMEM;
7916 if(comp->len > FLASHSIZE)
7917 return -EINVAL;
faf3994a 7918 if (copy_from_user(AIRO_FLASH(dev), comp->data, comp->len))
1da177e4
LT		 7919 return -EFAULT;
7920
faf3994a 7921 flashputbuf((struct airo_info *)dev->ml_priv);
1da177e4
LT		 7922 return 0;
7923
7924 case AIRORESTART:
faf3994a 7925 if (flashrestart((struct airo_info *)dev->ml_priv, dev))
1da177e4
LT		 7926 return -EIO;
7927 return 0;
7928 }
7929 return -EINVAL;
7930}
7931
7932#define FLASH_COMMAND 0x7e7e
7933
7934/*
7935 * STEP 1)
7936 * Disable MAC and do soft reset on
7937 * card.
7938 */
7939
ff1d2767 7940static int cmdreset(struct airo_info *ai) {
1da177e4
LT		 7941 disable_MAC(ai, 1);
7942
7943 if(!waitbusy (ai)){
934d8bf1 7944 airo_print_info(ai->dev->name, "Waitbusy hang before RESET");
1da177e4
LT		 7945 return -EBUSY;
7946 }
7947
7948 OUT4500(ai,COMMAND,CMD_SOFTRESET);
7949
7950 ssleep(1); /* WAS 600 12/7/00 */
7951
7952 if(!waitbusy (ai)){
934d8bf1 7953 airo_print_info(ai->dev->name, "Waitbusy hang AFTER RESET");
1da177e4
LT		 7954 return -EBUSY;
7955 }
7956 return 0;
7957}
7958
7959/* STEP 2)
7960 * Put the card in legendary flash
7961 * mode
7962 */
7963
ff1d2767 7964static int setflashmode (struct airo_info *ai) {
1da177e4
LT		 7965 set_bit (FLAG_FLASHING, &ai->flags);
7966
7967 OUT4500(ai, SWS0, FLASH_COMMAND);
7968 OUT4500(ai, SWS1, FLASH_COMMAND);
7969 if (probe) {
7970 OUT4500(ai, SWS0, FLASH_COMMAND);
7971 OUT4500(ai, COMMAND,0x10);
7972 } else {
7973 OUT4500(ai, SWS2, FLASH_COMMAND);
7974 OUT4500(ai, SWS3, FLASH_COMMAND);
7975 OUT4500(ai, COMMAND,0);
7976 }
7977 msleep(500); /* 500ms delay */
7978
7979 if(!waitbusy(ai)) {
7980 clear_bit (FLAG_FLASHING, &ai->flags);
934d8bf1 7981 airo_print_info(ai->dev->name, "Waitbusy hang after setflash mode");
1da177e4
LT		 7982 return -EIO;
7983 }
7984 return 0;
7985}
7986
7987/* Put character to SWS0 wait for dwelltime
7988 * x 50us for echo .
7989 */
7990
ff1d2767 7991static int flashpchar(struct airo_info *ai,int byte,int dwelltime) {
1da177e4
LT		 7992 int echo;
7993 int waittime;
7994
7995 byte |= 0x8000;
7996
7997 if(dwelltime == 0 )
7998 dwelltime = 200;
7999
8000 waittime=dwelltime;
8001
8002 /* Wait for busy bit d15 to go false indicating buffer empty */
8003 while ((IN4500 (ai, SWS0) & 0x8000) && waittime > 0) {
8004 udelay (50);
8005 waittime -= 50;
8006 }
8007
8008 /* timeout for busy clear wait */
8009 if(waittime <= 0 ){
934d8bf1 8010 airo_print_info(ai->dev->name, "flash putchar busywait timeout!");
1da177e4
LT		 8011 return -EBUSY;
8012 }
8013
8014 /* Port is clear now write byte and wait for it to echo back */
8015 do {
8016 OUT4500(ai,SWS0,byte);
8017 udelay(50);
8018 dwelltime -= 50;
8019 echo = IN4500(ai,SWS1);
8020 } while (dwelltime >= 0 && echo != byte);
8021
8022 OUT4500(ai,SWS1,0);
8023
8024 return (echo == byte) ? 0 : -EIO;
8025}
8026
8027/*
8028 * Get a character from the card matching matchbyte
8029 * Step 3)
8030 */
ff1d2767 8031static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime){
1da177e4
LT		 8032 int rchar;
8033 unsigned char rbyte=0;
8034
8035 do {
8036 rchar = IN4500(ai,SWS1);
8037
8038 if(dwelltime && !(0x8000 & rchar)){
8039 dwelltime -= 10;
8040 mdelay(10);
8041 continue;
8042 }
8043 rbyte = 0xff & rchar;
8044
8045 if( (rbyte == matchbyte) && (0x8000 & rchar) ){
8046 OUT4500(ai,SWS1,0);
8047 return 0;
8048 }
8049 if( rbyte == 0x81 || rbyte == 0x82 || rbyte == 0x83 || rbyte == 0x1a || 0xffff == rchar)
8050 break;
8051 OUT4500(ai,SWS1,0);
8052
8053 }while(dwelltime > 0);
8054 return -EIO;
8055}
8056
8057/*
8058 * Transfer 32k of firmware data from user buffer to our buffer and
8059 * send to the card
8060 */
8061
ff1d2767 8062static int flashputbuf(struct airo_info *ai){
1da177e4
LT		 8063 int nwords;
8064
8065 /* Write stuff */
8066 if (test_bit(FLAG_MPI,&ai->flags))
8067 memcpy_toio(ai->pciaux + 0x8000, ai->flash, FLASHSIZE);
8068 else {
8069 OUT4500(ai,AUXPAGE,0x100);
8070 OUT4500(ai,AUXOFF,0);
8071
8072 for(nwords=0;nwords != FLASHSIZE / 2;nwords++){
8073 OUT4500(ai,AUXDATA,ai->flash[nwords] & 0xffff);
8074 }
8075 }
8076 OUT4500(ai,SWS0,0x8000);
8077
8078 return 0;
8079}
8080
8081/*
8082 *
8083 */
ff1d2767 8084static int flashrestart(struct airo_info *ai,struct net_device *dev){
1da177e4
LT		 8085 int i,status;
8086
8087 ssleep(1); /* Added 12/7/00 */
8088 clear_bit (FLAG_FLASHING, &ai->flags);
8089 if (test_bit(FLAG_MPI, &ai->flags)) {
8090 status = mpi_init_descriptors(ai);
8091 if (status != SUCCESS)
8092 return status;
8093 }
8094 status = setup_card(ai, dev->dev_addr, 1);
8095
8096 if (!test_bit(FLAG_MPI,&ai->flags))
8097 for( i = 0; i < MAX_FIDS; i++ ) {
8098 ai->fids[i] = transmit_allocate
15db2763 8099 ( ai, AIRO_DEF_MTU, i >= MAX_FIDS / 2 );
1da177e4
LT		 8100 }
8101
8102 ssleep(1); /* Added 12/7/00 */
8103 return status;
8104}
8105#endif /* CISCO_EXT */
8106
8107/*
8108 This program is free software; you can redistribute it and/or
8109 modify it under the terms of the GNU General Public License
8110 as published by the Free Software Foundation; either version 2
8111 of the License, or (at your option) any later version.
8112
8113 This program is distributed in the hope that it will be useful,
8114 but WITHOUT ANY WARRANTY; without even the implied warranty of
8115 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
8116 GNU General Public License for more details.
8117
8118 In addition:
8119
8120 Redistribution and use in source and binary forms, with or without
8121 modification, are permitted provided that the following conditions
8122 are met:
8123
8124 1. Redistributions of source code must retain the above copyright
8125 notice, this list of conditions and the following disclaimer.
8126 2. Redistributions in binary form must reproduce the above copyright
8127 notice, this list of conditions and the following disclaimer in the
8128 documentation and/or other materials provided with the distribution.
8129 3. The name of the author may not be used to endorse or promote
8130 products derived from this software without specific prior written
8131 permission.
8132
8133 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
8134 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
8135 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
8136 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
8137 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
8138 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
8139 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
8140 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
8141 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
8142 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
8143 POSSIBILITY OF SUCH DAMAGE.
8144*/
8145
8146module_init(airo_init_module);
8147module_exit(airo_cleanup_module);
Ubuntu Artful kernel mirror