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