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