]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/net/wireless/airo.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/agpgart
[mirror_ubuntu-artful-kernel.git] / drivers / net / wireless / airo.c
1 /*======================================================================
2
3 Aironet driver for 4500 and 4800 series cards
4
5 This code is released under both the GPL version 2 and BSD licenses.
6 Either license may be used. The respective licenses are found at
7 the end of this file.
8
9 This code was developed by Benjamin Reed <breed@users.sourceforge.net>
10 including portions of which come from the Aironet PC4500
11 Developer's Reference Manual and used with permission. Copyright
12 (C) 1999 Benjamin Reed. All Rights Reserved. Permission to use
13 code in the Developer's manual was granted for this driver by
14 Aironet. Major code contributions were received from Javier Achirica
15 <achirica@users.sourceforge.net> and Jean Tourrilhes <jt@hpl.hp.com>.
16 Code was also integrated from the Cisco Aironet driver for Linux.
17 Support for MPI350 cards was added by Fabrice Bellet
18 <fabrice@bellet.info>.
19
20 ======================================================================*/
21
22 #include <linux/config.h>
23 #include <linux/init.h>
24
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/proc_fs.h>
28 #include <linux/smp_lock.h>
29
30 #include <linux/sched.h>
31 #include <linux/ptrace.h>
32 #include <linux/slab.h>
33 #include <linux/string.h>
34 #include <linux/timer.h>
35 #include <linux/interrupt.h>
36 #include <linux/in.h>
37 #include <linux/bitops.h>
38 #include <linux/scatterlist.h>
39 #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
50 #include "airo.h"
51
52 #ifdef CONFIG_PCI
53 static 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 };
63 MODULE_DEVICE_TABLE(pci, card_ids);
64
65 static int airo_pci_probe(struct pci_dev *, const struct pci_device_id *);
66 static void airo_pci_remove(struct pci_dev *);
67 static int airo_pci_suspend(struct pci_dev *pdev, pm_message_t state);
68 static int airo_pci_resume(struct pci_dev *pdev);
69
70 static 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
108 static 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
219 static int rates[8];
220 static int basic_rate;
221 static char *ssids[3];
222
223 static int io[4];
224 static int irq[4];
225
226 static
227 int maxencrypt /* = 0 */; /* The highest rate that the card can encrypt at.
228 0 means no limit. For old cards this was 4 */
229
230 static int auto_wep /* = 0 */; /* If set, it tries to figure out the wep mode */
231 static 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. */
233 static int adhoc;
234
235 static int probe = 1;
236
237 static int proc_uid /* = 0 */;
238
239 static int proc_gid /* = 0 */;
240
241 static int airo_perm = 0555;
242
243 static int proc_perm = 0644;
244
245 MODULE_AUTHOR("Benjamin Reed");
246 MODULE_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.");
249 MODULE_LICENSE("Dual BSD/GPL");
250 MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340/350");
251 module_param_array(io, int, NULL, 0);
252 module_param_array(irq, int, NULL, 0);
253 module_param(basic_rate, int, 0);
254 module_param_array(rates, int, NULL, 0);
255 module_param_array(ssids, charp, NULL, 0);
256 module_param(auto_wep, int, 0);
257 MODULE_PARM_DESC(auto_wep, "If non-zero, the driver will keep looping through \
258 the authentication options until an association is made. The value of \
259 auto_wep is number of the wep keys to check. A value of 2 will try using \
260 the key at index 0 and index 1.");
261 module_param(aux_bap, int, 0);
262 MODULE_PARM_DESC(aux_bap, "If non-zero, the driver will switch into a mode \
263 than seems to work better for older cards with some older buses. Before \
264 switching it checks that the switch is needed.");
265 module_param(maxencrypt, int, 0);
266 MODULE_PARM_DESC(maxencrypt, "The maximum speed that the card can do \
267 encryption. Units are in 512kbs. Zero (default) means there is no limit. \
268 Older cards used to be limited to 2mbs (4).");
269 module_param(adhoc, int, 0);
270 MODULE_PARM_DESC(adhoc, "If non-zero, the card will start in adhoc mode.");
271 module_param(probe, int, 0);
272 MODULE_PARM_DESC(probe, "If zero, the driver won't start the card.");
273
274 module_param(proc_uid, int, 0);
275 MODULE_PARM_DESC(proc_uid, "The uid that the /proc files will belong to.");
276 module_param(proc_gid, int, 0);
277 MODULE_PARM_DESC(proc_gid, "The gid that the /proc files will belong to.");
278 module_param(airo_perm, int, 0);
279 MODULE_PARM_DESC(airo_perm, "The permission bits of /proc/[driver/]aironet.");
280 module_param(proc_perm, int, 0);
281 MODULE_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!!! */
286 static 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
478 typedef struct {
479 u16 cmd;
480 u16 parm0;
481 u16 parm1;
482 u16 parm2;
483 } Cmd;
484
485 typedef 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 */
503 typedef 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 */
512 typedef struct {
513 u16 len;
514 u8 ssid[32];
515 } Ssid;
516
517 typedef struct {
518 u16 len;
519 Ssid ssids[3];
520 } SsidRid;
521
522 typedef 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
530 typedef 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
650 typedef 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
708 typedef struct {
709 u16 len;
710 u16 spacer;
711 u32 vals[100];
712 } StatsRid;
713
714
715 typedef struct {
716 u16 len;
717 u8 ap[4][ETH_ALEN];
718 } APListRid;
719
720 typedef 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
749 typedef 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];
760 u16 dBm;
761 #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
779 typedef struct {
780 u8 rssipct;
781 u8 rssidBm;
782 } tdsRssiEntry;
783
784 typedef struct {
785 u16 len;
786 tdsRssiEntry x[256];
787 } tdsRssiRid;
788
789 typedef struct {
790 u16 len;
791 u16 state;
792 u16 multicastValid;
793 u8 multicast[16];
794 u16 unicastValid;
795 u8 unicast[16];
796 } MICRid;
797
798 typedef 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
815 typedef 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
899 typedef 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
906 static char swversion[] = "2.1";
907 #endif /* CISCO_EXT */
908
909 #define NUM_MODULES 2
910 #define MIC_MSGLEN_MAX 2400
911 #define EMMH32_MSGLEN_MAX MIC_MSGLEN_MAX
912
913 typedef 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
924 typedef 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
934 typedef 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
943 typedef struct {
944 miccntx mCtx; // Multicast context
945 miccntx uCtx; // Unicast context
946 } mic_module;
947
948 typedef 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
955 typedef 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
963 typedef 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 */
974 typedef 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 */
986 typedef 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 */
998 typedef 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
1006 typedef 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
1026 typedef 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
1037 typedef struct {
1038 TxCtlHdr ctlhdr;
1039 u16 fill1;
1040 u16 fill2;
1041 WifiHdr wifihdr;
1042 u16 gaplen;
1043 u16 status;
1044 } WifiCtlHdr;
1045
1046 static WifiCtlHdr wifictlhdr8023 = {
1047 .ctlhdr = {
1048 .ctl = HOST_DONT_RLSE,
1049 }
1050 };
1051
1052 // Frequency list (map channels to frequencies)
1053 static 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
1059 typedef 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) */
1071 static const struct iw_handler_def airo_handler_def;
1072
1073 static const char version[] = "airo.c 0.6 (Ben Reed & Javier Achirica)";
1074
1075 struct airo_info;
1076
1077 static int get_dec_u16( char *buffer, int *start, int limit );
1078 static void OUT4500( struct airo_info *, u16 register, u16 value );
1079 static unsigned short IN4500( struct airo_info *, u16 register );
1080 static u16 setup_card(struct airo_info*, u8 *mac, int lock);
1081 static int enable_MAC( struct airo_info *ai, Resp *rsp, int lock );
1082 static void disable_MAC(struct airo_info *ai, int lock);
1083 static void enable_interrupts(struct airo_info*);
1084 static void disable_interrupts(struct airo_info*);
1085 static u16 issuecommand(struct airo_info*, Cmd *pCmd, Resp *pRsp);
1086 static int bap_setup(struct airo_info*, u16 rid, u16 offset, int whichbap);
1087 static int aux_bap_read(struct airo_info*, u16 *pu16Dst, int bytelen,
1088 int whichbap);
1089 static int fast_bap_read(struct airo_info*, u16 *pu16Dst, int bytelen,
1090 int whichbap);
1091 static int bap_write(struct airo_info*, const u16 *pu16Src, int bytelen,
1092 int whichbap);
1093 static int PC4500_accessrid(struct airo_info*, u16 rid, u16 accmd);
1094 static int PC4500_readrid(struct airo_info*, u16 rid, void *pBuf, int len, int lock);
1095 static int PC4500_writerid(struct airo_info*, u16 rid, const void
1096 *pBuf, int len, int lock);
1097 static int do_writerid( struct airo_info*, u16 rid, const void *rid_data,
1098 int len, int dummy );
1099 static u16 transmit_allocate(struct airo_info*, int lenPayload, int raw);
1100 static int transmit_802_3_packet(struct airo_info*, int len, char *pPacket);
1101 static int transmit_802_11_packet(struct airo_info*, int len, char *pPacket);
1102
1103 static int mpi_send_packet (struct net_device *dev);
1104 static void mpi_unmap_card(struct pci_dev *pci);
1105 static void mpi_receive_802_3(struct airo_info *ai);
1106 static void mpi_receive_802_11(struct airo_info *ai);
1107 static int waitbusy (struct airo_info *ai);
1108
1109 static irqreturn_t airo_interrupt( int irq, void* dev_id, struct pt_regs
1110 *regs);
1111 static int airo_thread(void *data);
1112 static void timer_func( struct net_device *dev );
1113 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
1114 static struct iw_statistics *airo_get_wireless_stats (struct net_device *dev);
1115 static void airo_read_wireless_stats (struct airo_info *local);
1116 #ifdef CISCO_EXT
1117 static int readrids(struct net_device *dev, aironet_ioctl *comp);
1118 static int writerids(struct net_device *dev, aironet_ioctl *comp);
1119 static int flashcard(struct net_device *dev, aironet_ioctl *comp);
1120 #endif /* CISCO_EXT */
1121 #ifdef MICSUPPORT
1122 static void micinit(struct airo_info *ai);
1123 static int micsetup(struct airo_info *ai);
1124 static int encapsulate(struct airo_info *ai, etherHead *pPacket, MICBuffer *buffer, int len);
1125 static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *pPacket, u16 payLen);
1126
1127 static u8 airo_rssi_to_dbm (tdsRssiEntry *rssi_rid, u8 rssi);
1128 static u8 airo_dbm_to_pct (tdsRssiEntry *rssi_rid, u8 dbm);
1129
1130 #include <linux/crypto.h>
1131 #endif
1132
1133 struct 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;
1189 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;
1193 #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;
1209 pm_message_t power;
1210 SsidRid *SSID;
1211 APListRid *APList;
1212 #define PCI_SHARED_LEN 2*MPI_MAX_FIDS*PKTSIZE+RIDSIZE
1213 char proc_name[IFNAMSIZ];
1214 };
1215
1216 static 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
1221 static int setup_proc_entry( struct net_device *dev,
1222 struct airo_info *apriv );
1223 static int takedown_proc_entry( struct net_device *dev,
1224 struct airo_info *apriv );
1225
1226 static int cmdreset(struct airo_info *ai);
1227 static int setflashmode (struct airo_info *ai);
1228 static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime);
1229 static int flashputbuf(struct airo_info *ai);
1230 static int flashrestart(struct airo_info *ai,struct net_device *dev);
1231
1232 #ifdef MICSUPPORT
1233 /***********************************************************************
1234 * MIC ROUTINES *
1235 ***********************************************************************
1236 */
1237
1238 static int RxSeqValid (struct airo_info *ai,miccntx *context,int mcast,u32 micSeq);
1239 static void MoveWindow(miccntx *context, u32 micSeq);
1240 static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct crypto_tfm *);
1241 static void emmh32_init(emmh32_context *context);
1242 static void emmh32_update(emmh32_context *context, u8 *pOctets, int len);
1243 static void emmh32_final(emmh32_context *context, u8 digest[4]);
1244 static int flashpchar(struct airo_info *ai,int byte,int dwelltime);
1245
1246 /* micinit - Initialize mic seed */
1247
1248 static 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
1304 static int micsetup(struct airo_info *ai) {
1305 int i;
1306
1307 if (ai->tfm == NULL)
1308 ai->tfm = crypto_alloc_tfm("aes", CRYPTO_TFM_REQ_MAY_SLEEP);
1309
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
1322 static char micsnap[] = {0xAA,0xAA,0x03,0x00,0x40,0x96,0x00,0x02};
1323
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
1340 static 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
1375 typedef 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
1396 static 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
1500 static 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
1548 static 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
1574 static unsigned char aes_counter[16];
1575
1576 /* expand the key to fill the MMH coefficient array */
1577 static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct crypto_tfm *tfm)
1578 {
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);
1596 sg_set_buf(sg, plain, 16);
1597 crypto_cipher_encrypt(tfm, sg, sg, 16);
1598 cipher = kmap(sg->page) + sg->offset;
1599 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 */
1607 static void emmh32_init(emmh32_context *context)
1608 {
1609 /* prepare for new mic calculation */
1610 context->accum = 0;
1611 context->position = 0;
1612 }
1613
1614 /* add some bytes to the mic calculation */
1615 static void emmh32_update(emmh32_context *context, u8 *pOctets, int len)
1616 {
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 */
1654 static u32 mask32[4] = { 0x00000000L, 0xFF000000L, 0xFFFF0000L, 0xFFFFFF00L };
1655
1656 /* calculate the mic */
1657 static void emmh32_final(emmh32_context *context, u8 digest[4])
1658 {
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
1691 static 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);
1721 list->dBm = le16_to_cpu(list->dBm);
1722 return rc;
1723 }
1724
1725 static 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... */
1736 static 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
1754 static 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 }
1764 static 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 }
1776 static 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 }
1805 static 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 }
1816 static 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 }
1849 static 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 }
1862 static 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 }
1867 static 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 }
1873 static 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 }
1885 static 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
1894 static 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
1921 static 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
1962 static 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
2045 static void get_tx_error(struct airo_info *ai, s32 fid)
2046 {
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
2096 static 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
2122 static 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
2161 static 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
2187 static 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
2232 static 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);
2237 if (ai->power.event) {
2238 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
2260 static struct net_device_stats *airo_get_stats(struct net_device *dev)
2261 {
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
2276 static 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
2288 static 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
2305 static 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
2323 static 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
2332 static 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
2352 static void del_airo_dev( struct net_device *dev );
2353
2354 void 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 */
2379 if (test_bit(FLAG_MPI, &ai->flags) && !skb_queue_empty(&ai->txq)) {
2380 struct sk_buff *skb = NULL;
2381 for (;(skb = skb_dequeue(&ai->txq));)
2382 dev_kfree_skb(skb);
2383 }
2384
2385 kfree(ai->flash);
2386 kfree(ai->rssi);
2387 kfree(ai->APList);
2388 kfree(ai->SSID);
2389 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
2404 crypto_free_tfm(ai->tfm);
2405 #endif
2406 del_airo_dev( dev );
2407 free_netdev( dev );
2408 }
2409
2410 EXPORT_SYMBOL(stop_airo_card);
2411
2412 static int add_airo_dev( struct net_device *dev );
2413
2414 static int wll_header_parse(struct sk_buff *skb, unsigned char *haddr)
2415 {
2416 memcpy(haddr, skb->mac.raw + 10, ETH_ALEN);
2417 return ETH_ALEN;
2418 }
2419
2420 static 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 */
2438 static 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 */
2515 static 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;
2521 dma_addr_t busaddroff;
2522 unsigned char *vpackoff;
2523 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 */
2565 busaddroff = ai->shared_dma;
2566 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;
2574 ai->rxfids[i].rx_desc.host_addr = busaddroff;
2575 ai->rxfids[i].rx_desc.valid = 1;
2576 ai->rxfids[i].rx_desc.len = PKTSIZE;
2577 ai->rxfids[i].rx_desc.rdy = 0;
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;
2589 ai->txfids[i].tx_desc.host_addr = busaddroff;
2590 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;
2602 ai->config_desc.rid_desc.host_addr = busaddroff;
2603 ai->ridbus = busaddroff;
2604 ai->config_desc.rid_desc.rid = 0;
2605 ai->config_desc.rid_desc.len = RIDSIZE;
2606 ai->config_desc.rid_desc.valid = 1;
2607 pciaddroff += sizeof(Rid);
2608 busaddroff += RIDSIZE;
2609 vpackoff += RIDSIZE;
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
2630 static 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;
2642 dev->wireless_handlers = &airo_handler_def;
2643 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
2658 static 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;
2668 dev->wireless_data = ethdev->wireless_data;
2669 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
2678 static int reset_card( struct net_device *dev , int lock) {
2679 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
2693 static struct net_device *_init_airo_card( unsigned short irq, int port,
2694 int is_pcmcia, struct pci_dev *pci,
2695 struct device *dmdev )
2696 {
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;
2746 dev->wireless_handlers = &airo_handler_def;
2747 ai->wireless_data.spy_data = &ai->spy_data;
2748 dev->wireless_data = &ai->wireless_data;
2749 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
2815 err_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 }
2822 err_out_res:
2823 if (!is_pcmcia)
2824 release_region( dev->base_addr, 64 );
2825 err_out_irq:
2826 free_irq(dev->irq, dev);
2827 err_out_unlink:
2828 del_airo_dev(dev);
2829 err_out_thr:
2830 set_bit(JOB_DIE, &ai->flags);
2831 kill_proc(ai->thr_pid, SIGTERM, 1);
2832 wait_for_completion(&ai->thr_exited);
2833 err_out_free:
2834 free_netdev(dev);
2835 return NULL;
2836 }
2837
2838 struct 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
2844 EXPORT_SYMBOL(init_airo_card);
2845
2846 static 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
2856 int 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
2881 EXPORT_SYMBOL(reset_airo_card);
2882
2883 static 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
2900 static 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 */
2913 try_to_freeze();
2914
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
2957 if (ai->power.event || test_bit(FLAG_FLASHING, &ai->flags)) {
2958 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
2984 static 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)) {
3218 badmic:
3219 dev_kfree_skb_irq (skb);
3220 #else
3221 if (0) {
3222 #endif
3223 badrx:
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;
3244 wstats.noise = apriv->wstats.qual.noise;
3245 wstats.updated = IW_QUAL_LEVEL_UPDATED
3246 | IW_QUAL_QUAL_UPDATED
3247 | IW_QUAL_DBM;
3248 /* 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 }
3268 exitrx:
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);
3282 if (!skb_queue_empty(&apriv->txq)) {
3283 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 }
3321 exittx:
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 */
3343 static 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
3354 static 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
3368 static 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
3401 static 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
3418 static void enable_interrupts( struct airo_info *ai ) {
3419 /* Enable the interrupts */
3420 OUT4500( ai, EVINTEN, STATUS_INTS );
3421 }
3422
3423 static void disable_interrupts( struct airo_info *ai ) {
3424 OUT4500( ai, EVINTEN, 0 );
3425 }
3426
3427 static 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)) {
3469 badmic:
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 }
3496 badrx:
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
3505 void 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;
3590 wstats.noise = ai->wstats.qual.noise;
3591 wstats.updated = IW_QUAL_QUAL_UPDATED
3592 | IW_QUAL_LEVEL_UPDATED
3593 | IW_QUAL_DBM;
3594 /* 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 );
3605 badrx:
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
3614 static 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 ) );
3626 kfree (ai->flash);
3627 ai->flash = NULL;
3628
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
3664 kfree(ai->APList);
3665 ai->APList = NULL;
3666 kfree(ai->SSID);
3667 ai->SSID = NULL;
3668 // 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)
3678 memcpy(ai->rssi, (u8*)&rssi_rid + 2, 512); /* Skip RID length member */
3679 }
3680 else {
3681 kfree(ai->rssi);
3682 ai->rssi = NULL;
3683 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
3773 static 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! */
3827 static 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 */
3865 static 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 */
3879 static 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 */
3916 static 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 */
3928 static 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
3940 static 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. */
3959 static 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 }
4016 done:
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 */
4024 static 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
4040 if (test_bit(FLAG_ENABLED, &ai->flags))
4041 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 }
4090 done:
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. */
4098 static 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
4147 done:
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. */
4156 static 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
4202 static 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
4266 static ssize_t proc_read( struct file *file,
4267 char __user *buffer,
4268 size_t len,
4269 loff_t *offset);
4270
4271 static ssize_t proc_write( struct file *file,
4272 const char __user *buffer,
4273 size_t len,
4274 loff_t *offset );
4275 static int proc_close( struct inode *inode, struct file *file );
4276
4277 static int proc_stats_open( struct inode *inode, struct file *file );
4278 static int proc_statsdelta_open( struct inode *inode, struct file *file );
4279 static int proc_status_open( struct inode *inode, struct file *file );
4280 static int proc_SSID_open( struct inode *inode, struct file *file );
4281 static int proc_APList_open( struct inode *inode, struct file *file );
4282 static int proc_BSSList_open( struct inode *inode, struct file *file );
4283 static int proc_config_open( struct inode *inode, struct file *file );
4284 static int proc_wepkey_open( struct inode *inode, struct file *file );
4285
4286 static struct file_operations proc_statsdelta_ops = {
4287 .read = proc_read,
4288 .open = proc_statsdelta_open,
4289 .release = proc_close
4290 };
4291
4292 static struct file_operations proc_stats_ops = {
4293 .read = proc_read,
4294 .open = proc_stats_open,
4295 .release = proc_close
4296 };
4297
4298 static struct file_operations proc_status_ops = {
4299 .read = proc_read,
4300 .open = proc_status_open,
4301 .release = proc_close
4302 };
4303
4304 static 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
4311 static 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
4318 static 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
4325 static 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
4332 static 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
4339 static struct proc_dir_entry *airo_entry;
4340
4341 struct 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
4355 static 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
4450 static 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 */
4477 static 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 */
4504 static 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
4529 static 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
4538 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4539 return -ENOMEM;
4540 memset(file->private_data, 0, sizeof(struct proc_data));
4541 data = (struct proc_data *)file->private_data;
4542 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4543 kfree (file->private_data);
4544 return -ENOMEM;
4545 }
4546
4547 readStatusRid(apriv, &status_rid, 1);
4548 readCapabilityRid(apriv, &cap_rid, 1);
4549
4550 i = sprintf(data->rbuffer, "Status: %s%s%s%s%s%s%s%s%s\n",
4551 status_rid.mode & 1 ? "CFG ": "",
4552 status_rid.mode & 2 ? "ACT ": "",
4553 status_rid.mode & 0x10 ? "SYN ": "",
4554 status_rid.mode & 0x20 ? "LNK ": "",
4555 status_rid.mode & 0x40 ? "LEAP ": "",
4556 status_rid.mode & 0x80 ? "PRIV ": "",
4557 status_rid.mode & 0x100 ? "KEY ": "",
4558 status_rid.mode & 0x200 ? "WEP ": "",
4559 status_rid.mode & 0x8000 ? "ERR ": "");
4560 sprintf( data->rbuffer+i, "Mode: %x\n"
4561 "Signal Strength: %d\n"
4562 "Signal Quality: %d\n"
4563 "SSID: %-.*s\n"
4564 "AP: %-.16s\n"
4565 "Freq: %d\n"
4566 "BitRate: %dmbs\n"
4567 "Driver Version: %s\n"
4568 "Device: %s\nManufacturer: %s\nFirmware Version: %s\n"
4569 "Radio type: %x\nCountry: %x\nHardware Version: %x\n"
4570 "Software Version: %x\nSoftware Subversion: %x\n"
4571 "Boot block version: %x\n",
4572 (int)status_rid.mode,
4573 (int)status_rid.normalizedSignalStrength,
4574 (int)status_rid.signalQuality,
4575 (int)status_rid.SSIDlen,
4576 status_rid.SSID,
4577 status_rid.apName,
4578 (int)status_rid.channel,
4579 (int)status_rid.currentXmitRate/2,
4580 version,
4581 cap_rid.prodName,
4582 cap_rid.manName,
4583 cap_rid.prodVer,
4584 cap_rid.radioType,
4585 cap_rid.country,
4586 cap_rid.hardVer,
4587 (int)cap_rid.softVer,
4588 (int)cap_rid.softSubVer,
4589 (int)cap_rid.bootBlockVer );
4590 data->readlen = strlen( data->rbuffer );
4591 return 0;
4592 }
4593
4594 static int proc_stats_rid_open(struct inode*, struct file*, u16);
4595 static int proc_statsdelta_open( struct inode *inode,
4596 struct file *file ) {
4597 if (file->f_mode&FMODE_WRITE) {
4598 return proc_stats_rid_open(inode, file, RID_STATSDELTACLEAR);
4599 }
4600 return proc_stats_rid_open(inode, file, RID_STATSDELTA);
4601 }
4602
4603 static int proc_stats_open( struct inode *inode, struct file *file ) {
4604 return proc_stats_rid_open(inode, file, RID_STATS);
4605 }
4606
4607 static int proc_stats_rid_open( struct inode *inode,
4608 struct file *file,
4609 u16 rid ) {
4610 struct proc_data *data;
4611 struct proc_dir_entry *dp = PDE(inode);
4612 struct net_device *dev = dp->data;
4613 struct airo_info *apriv = dev->priv;
4614 StatsRid stats;
4615 int i, j;
4616 u32 *vals = stats.vals;
4617
4618 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4619 return -ENOMEM;
4620 memset(file->private_data, 0, sizeof(struct proc_data));
4621 data = (struct proc_data *)file->private_data;
4622 if ((data->rbuffer = kmalloc( 4096, GFP_KERNEL )) == NULL) {
4623 kfree (file->private_data);
4624 return -ENOMEM;
4625 }
4626
4627 readStatsRid(apriv, &stats, rid, 1);
4628
4629 j = 0;
4630 for(i=0; statsLabels[i]!=(char *)-1 &&
4631 i*4<stats.len; i++){
4632 if (!statsLabels[i]) continue;
4633 if (j+strlen(statsLabels[i])+16>4096) {
4634 printk(KERN_WARNING
4635 "airo: Potentially disasterous buffer overflow averted!\n");
4636 break;
4637 }
4638 j+=sprintf(data->rbuffer+j, "%s: %u\n", statsLabels[i], vals[i]);
4639 }
4640 if (i*4>=stats.len){
4641 printk(KERN_WARNING
4642 "airo: Got a short rid\n");
4643 }
4644 data->readlen = j;
4645 return 0;
4646 }
4647
4648 static int get_dec_u16( char *buffer, int *start, int limit ) {
4649 u16 value;
4650 int valid = 0;
4651 for( value = 0; buffer[*start] >= '0' &&
4652 buffer[*start] <= '9' &&
4653 *start < limit; (*start)++ ) {
4654 valid = 1;
4655 value *= 10;
4656 value += buffer[*start] - '0';
4657 }
4658 if ( !valid ) return -1;
4659 return value;
4660 }
4661
4662 static int airo_config_commit(struct net_device *dev,
4663 struct iw_request_info *info, void *zwrq,
4664 char *extra);
4665
4666 static void proc_config_on_close( struct inode *inode, struct file *file ) {
4667 struct proc_data *data = file->private_data;
4668 struct proc_dir_entry *dp = PDE(inode);
4669 struct net_device *dev = dp->data;
4670 struct airo_info *ai = dev->priv;
4671 char *line;
4672
4673 if ( !data->writelen ) return;
4674
4675 readConfigRid(ai, 1);
4676 set_bit (FLAG_COMMIT, &ai->flags);
4677
4678 line = data->wbuffer;
4679 while( line[0] ) {
4680 /*** Mode processing */
4681 if ( !strncmp( line, "Mode: ", 6 ) ) {
4682 line += 6;
4683 if ((ai->config.rmode & 0xff) >= RXMODE_RFMON)
4684 set_bit (FLAG_RESET, &ai->flags);
4685 ai->config.rmode &= 0xfe00;
4686 clear_bit (FLAG_802_11, &ai->flags);
4687 ai->config.opmode &= 0xFF00;
4688 ai->config.scanMode = SCANMODE_ACTIVE;
4689 if ( line[0] == 'a' ) {
4690 ai->config.opmode |= 0;
4691 } else {
4692 ai->config.opmode |= 1;
4693 if ( line[0] == 'r' ) {
4694 ai->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
4695 ai->config.scanMode = SCANMODE_PASSIVE;
4696 set_bit (FLAG_802_11, &ai->flags);
4697 } else if ( line[0] == 'y' ) {
4698 ai->config.rmode |= RXMODE_RFMON_ANYBSS | RXMODE_DISABLE_802_3_HEADER;
4699 ai->config.scanMode = SCANMODE_PASSIVE;
4700 set_bit (FLAG_802_11, &ai->flags);
4701 } else if ( line[0] == 'l' )
4702 ai->config.rmode |= RXMODE_LANMON;
4703 }
4704 set_bit (FLAG_COMMIT, &ai->flags);
4705 }
4706
4707 /*** Radio status */
4708 else if (!strncmp(line,"Radio: ", 7)) {
4709 line += 7;
4710 if (!strncmp(line,"off",3)) {
4711 set_bit (FLAG_RADIO_OFF, &ai->flags);
4712 } else {
4713 clear_bit (FLAG_RADIO_OFF, &ai->flags);
4714 }
4715 }
4716 /*** NodeName processing */
4717 else if ( !strncmp( line, "NodeName: ", 10 ) ) {
4718 int j;
4719
4720 line += 10;
4721 memset( ai->config.nodeName, 0, 16 );
4722 /* Do the name, assume a space between the mode and node name */
4723 for( j = 0; j < 16 && line[j] != '\n'; j++ ) {
4724 ai->config.nodeName[j] = line[j];
4725 }
4726 set_bit (FLAG_COMMIT, &ai->flags);
4727 }
4728
4729 /*** PowerMode processing */
4730 else if ( !strncmp( line, "PowerMode: ", 11 ) ) {
4731 line += 11;
4732 if ( !strncmp( line, "PSPCAM", 6 ) ) {
4733 ai->config.powerSaveMode = POWERSAVE_PSPCAM;
4734 set_bit (FLAG_COMMIT, &ai->flags);
4735 } else if ( !strncmp( line, "PSP", 3 ) ) {
4736 ai->config.powerSaveMode = POWERSAVE_PSP;
4737 set_bit (FLAG_COMMIT, &ai->flags);
4738 } else {
4739 ai->config.powerSaveMode = POWERSAVE_CAM;
4740 set_bit (FLAG_COMMIT, &ai->flags);
4741 }
4742 } else if ( !strncmp( line, "DataRates: ", 11 ) ) {
4743 int v, i = 0, k = 0; /* i is index into line,
4744 k is index to rates */
4745
4746 line += 11;
4747 while((v = get_dec_u16(line, &i, 3))!=-1) {
4748 ai->config.rates[k++] = (u8)v;
4749 line += i + 1;
4750 i = 0;
4751 }
4752 set_bit (FLAG_COMMIT, &ai->flags);
4753 } else if ( !strncmp( line, "Channel: ", 9 ) ) {
4754 int v, i = 0;
4755 line += 9;
4756 v = get_dec_u16(line, &i, i+3);
4757 if ( v != -1 ) {
4758 ai->config.channelSet = (u16)v;
4759 set_bit (FLAG_COMMIT, &ai->flags);
4760 }
4761 } else if ( !strncmp( line, "XmitPower: ", 11 ) ) {
4762 int v, i = 0;
4763 line += 11;
4764 v = get_dec_u16(line, &i, i+3);
4765 if ( v != -1 ) {
4766 ai->config.txPower = (u16)v;
4767 set_bit (FLAG_COMMIT, &ai->flags);
4768 }
4769 } else if ( !strncmp( line, "WEP: ", 5 ) ) {
4770 line += 5;
4771 switch( line[0] ) {
4772 case 's':
4773 ai->config.authType = (u16)AUTH_SHAREDKEY;
4774 break;
4775 case 'e':
4776 ai->config.authType = (u16)AUTH_ENCRYPT;
4777 break;
4778 default:
4779 ai->config.authType = (u16)AUTH_OPEN;
4780 break;
4781 }
4782 set_bit (FLAG_COMMIT, &ai->flags);
4783 } else if ( !strncmp( line, "LongRetryLimit: ", 16 ) ) {
4784 int v, i = 0;
4785
4786 line += 16;
4787 v = get_dec_u16(line, &i, 3);
4788 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4789 ai->config.longRetryLimit = (u16)v;
4790 set_bit (FLAG_COMMIT, &ai->flags);
4791 } else if ( !strncmp( line, "ShortRetryLimit: ", 17 ) ) {
4792 int v, i = 0;
4793
4794 line += 17;
4795 v = get_dec_u16(line, &i, 3);
4796 v = (v<0) ? 0 : ((v>255) ? 255 : v);
4797 ai->config.shortRetryLimit = (u16)v;
4798 set_bit (FLAG_COMMIT, &ai->flags);
4799 } else if ( !strncmp( line, "RTSThreshold: ", 14 ) ) {
4800 int v, i = 0;
4801
4802 line += 14;
4803 v = get_dec_u16(line, &i, 4);
4804 v = (v<0) ? 0 : ((v>2312) ? 2312 : v);
4805 ai->config.rtsThres = (u16)v;
4806 set_bit (FLAG_COMMIT, &ai->flags);
4807 } else if ( !strncmp( line, "TXMSDULifetime: ", 16 ) ) {
4808 int v, i = 0;
4809
4810 line += 16;
4811 v = get_dec_u16(line, &i, 5);
4812 v = (v<0) ? 0 : v;
4813 ai->config.txLifetime = (u16)v;
4814 set_bit (FLAG_COMMIT, &ai->flags);
4815 } else if ( !strncmp( line, "RXMSDULifetime: ", 16 ) ) {
4816 int v, i = 0;
4817
4818 line += 16;
4819 v = get_dec_u16(line, &i, 5);
4820 v = (v<0) ? 0 : v;
4821 ai->config.rxLifetime = (u16)v;
4822 set_bit (FLAG_COMMIT, &ai->flags);
4823 } else if ( !strncmp( line, "TXDiversity: ", 13 ) ) {
4824 ai->config.txDiversity =
4825 (line[13]=='l') ? 1 :
4826 ((line[13]=='r')? 2: 3);
4827 set_bit (FLAG_COMMIT, &ai->flags);
4828 } else if ( !strncmp( line, "RXDiversity: ", 13 ) ) {
4829 ai->config.rxDiversity =
4830 (line[13]=='l') ? 1 :
4831 ((line[13]=='r')? 2: 3);
4832 set_bit (FLAG_COMMIT, &ai->flags);
4833 } else if ( !strncmp( line, "FragThreshold: ", 15 ) ) {
4834 int v, i = 0;
4835
4836 line += 15;
4837 v = get_dec_u16(line, &i, 4);
4838 v = (v<256) ? 256 : ((v>2312) ? 2312 : v);
4839 v = v & 0xfffe; /* Make sure its even */
4840 ai->config.fragThresh = (u16)v;
4841 set_bit (FLAG_COMMIT, &ai->flags);
4842 } else if (!strncmp(line, "Modulation: ", 12)) {
4843 line += 12;
4844 switch(*line) {
4845 case 'd': ai->config.modulation=MOD_DEFAULT; set_bit(FLAG_COMMIT, &ai->flags); break;
4846 case 'c': ai->config.modulation=MOD_CCK; set_bit(FLAG_COMMIT, &ai->flags); break;
4847 case 'm': ai->config.modulation=MOD_MOK; set_bit(FLAG_COMMIT, &ai->flags); break;
4848 default:
4849 printk( KERN_WARNING "airo: Unknown modulation\n" );
4850 }
4851 } else if (!strncmp(line, "Preamble: ", 10)) {
4852 line += 10;
4853 switch(*line) {
4854 case 'a': ai->config.preamble=PREAMBLE_AUTO; set_bit(FLAG_COMMIT, &ai->flags); break;
4855 case 'l': ai->config.preamble=PREAMBLE_LONG; set_bit(FLAG_COMMIT, &ai->flags); break;
4856 case 's': ai->config.preamble=PREAMBLE_SHORT; set_bit(FLAG_COMMIT, &ai->flags); break;
4857 default: printk(KERN_WARNING "airo: Unknown preamble\n");
4858 }
4859 } else {
4860 printk( KERN_WARNING "Couldn't figure out %s\n", line );
4861 }
4862 while( line[0] && line[0] != '\n' ) line++;
4863 if ( line[0] ) line++;
4864 }
4865 airo_config_commit(dev, NULL, NULL, NULL);
4866 }
4867
4868 static char *get_rmode(u16 mode) {
4869 switch(mode&0xff) {
4870 case RXMODE_RFMON: return "rfmon";
4871 case RXMODE_RFMON_ANYBSS: return "yna (any) bss rfmon";
4872 case RXMODE_LANMON: return "lanmon";
4873 }
4874 return "ESS";
4875 }
4876
4877 static int proc_config_open( struct inode *inode, struct file *file ) {
4878 struct proc_data *data;
4879 struct proc_dir_entry *dp = PDE(inode);
4880 struct net_device *dev = dp->data;
4881 struct airo_info *ai = dev->priv;
4882 int i;
4883
4884 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4885 return -ENOMEM;
4886 memset(file->private_data, 0, sizeof(struct proc_data));
4887 data = (struct proc_data *)file->private_data;
4888 if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4889 kfree (file->private_data);
4890 return -ENOMEM;
4891 }
4892 if ((data->wbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4893 kfree (data->rbuffer);
4894 kfree (file->private_data);
4895 return -ENOMEM;
4896 }
4897 memset( data->wbuffer, 0, 2048 );
4898 data->maxwritelen = 2048;
4899 data->on_close = proc_config_on_close;
4900
4901 readConfigRid(ai, 1);
4902
4903 i = sprintf( data->rbuffer,
4904 "Mode: %s\n"
4905 "Radio: %s\n"
4906 "NodeName: %-16s\n"
4907 "PowerMode: %s\n"
4908 "DataRates: %d %d %d %d %d %d %d %d\n"
4909 "Channel: %d\n"
4910 "XmitPower: %d\n",
4911 (ai->config.opmode & 0xFF) == 0 ? "adhoc" :
4912 (ai->config.opmode & 0xFF) == 1 ? get_rmode(ai->config.rmode):
4913 (ai->config.opmode & 0xFF) == 2 ? "AP" :
4914 (ai->config.opmode & 0xFF) == 3 ? "AP RPTR" : "Error",
4915 test_bit(FLAG_RADIO_OFF, &ai->flags) ? "off" : "on",
4916 ai->config.nodeName,
4917 ai->config.powerSaveMode == 0 ? "CAM" :
4918 ai->config.powerSaveMode == 1 ? "PSP" :
4919 ai->config.powerSaveMode == 2 ? "PSPCAM" : "Error",
4920 (int)ai->config.rates[0],
4921 (int)ai->config.rates[1],
4922 (int)ai->config.rates[2],
4923 (int)ai->config.rates[3],
4924 (int)ai->config.rates[4],
4925 (int)ai->config.rates[5],
4926 (int)ai->config.rates[6],
4927 (int)ai->config.rates[7],
4928 (int)ai->config.channelSet,
4929 (int)ai->config.txPower
4930 );
4931 sprintf( data->rbuffer + i,
4932 "LongRetryLimit: %d\n"
4933 "ShortRetryLimit: %d\n"
4934 "RTSThreshold: %d\n"
4935 "TXMSDULifetime: %d\n"
4936 "RXMSDULifetime: %d\n"
4937 "TXDiversity: %s\n"
4938 "RXDiversity: %s\n"
4939 "FragThreshold: %d\n"
4940 "WEP: %s\n"
4941 "Modulation: %s\n"
4942 "Preamble: %s\n",
4943 (int)ai->config.longRetryLimit,
4944 (int)ai->config.shortRetryLimit,
4945 (int)ai->config.rtsThres,
4946 (int)ai->config.txLifetime,
4947 (int)ai->config.rxLifetime,
4948 ai->config.txDiversity == 1 ? "left" :
4949 ai->config.txDiversity == 2 ? "right" : "both",
4950 ai->config.rxDiversity == 1 ? "left" :
4951 ai->config.rxDiversity == 2 ? "right" : "both",
4952 (int)ai->config.fragThresh,
4953 ai->config.authType == AUTH_ENCRYPT ? "encrypt" :
4954 ai->config.authType == AUTH_SHAREDKEY ? "shared" : "open",
4955 ai->config.modulation == 0 ? "default" :
4956 ai->config.modulation == MOD_CCK ? "cck" :
4957 ai->config.modulation == MOD_MOK ? "mok" : "error",
4958 ai->config.preamble == PREAMBLE_AUTO ? "auto" :
4959 ai->config.preamble == PREAMBLE_LONG ? "long" :
4960 ai->config.preamble == PREAMBLE_SHORT ? "short" : "error"
4961 );
4962 data->readlen = strlen( data->rbuffer );
4963 return 0;
4964 }
4965
4966 static void proc_SSID_on_close( struct inode *inode, struct file *file ) {
4967 struct proc_data *data = (struct proc_data *)file->private_data;
4968 struct proc_dir_entry *dp = PDE(inode);
4969 struct net_device *dev = dp->data;
4970 struct airo_info *ai = dev->priv;
4971 SsidRid SSID_rid;
4972 Resp rsp;
4973 int i;
4974 int offset = 0;
4975
4976 if ( !data->writelen ) return;
4977
4978 memset( &SSID_rid, 0, sizeof( SSID_rid ) );
4979
4980 for( i = 0; i < 3; i++ ) {
4981 int j;
4982 for( j = 0; j+offset < data->writelen && j < 32 &&
4983 data->wbuffer[offset+j] != '\n'; j++ ) {
4984 SSID_rid.ssids[i].ssid[j] = data->wbuffer[offset+j];
4985 }
4986 if ( j == 0 ) break;
4987 SSID_rid.ssids[i].len = j;
4988 offset += j;
4989 while( data->wbuffer[offset] != '\n' &&
4990 offset < data->writelen ) offset++;
4991 offset++;
4992 }
4993 if (i)
4994 SSID_rid.len = sizeof(SSID_rid);
4995 disable_MAC(ai, 1);
4996 writeSsidRid(ai, &SSID_rid, 1);
4997 enable_MAC(ai, &rsp, 1);
4998 }
4999
5000 static inline u8 hexVal(char c) {
5001 if (c>='0' && c<='9') return c -= '0';
5002 if (c>='a' && c<='f') return c -= 'a'-10;
5003 if (c>='A' && c<='F') return c -= 'A'-10;
5004 return 0;
5005 }
5006
5007 static void proc_APList_on_close( struct inode *inode, struct file *file ) {
5008 struct proc_data *data = (struct proc_data *)file->private_data;
5009 struct proc_dir_entry *dp = PDE(inode);
5010 struct net_device *dev = dp->data;
5011 struct airo_info *ai = dev->priv;
5012 APListRid APList_rid;
5013 Resp rsp;
5014 int i;
5015
5016 if ( !data->writelen ) return;
5017
5018 memset( &APList_rid, 0, sizeof(APList_rid) );
5019 APList_rid.len = sizeof(APList_rid);
5020
5021 for( i = 0; i < 4 && data->writelen >= (i+1)*6*3; i++ ) {
5022 int j;
5023 for( j = 0; j < 6*3 && data->wbuffer[j+i*6*3]; j++ ) {
5024 switch(j%3) {
5025 case 0:
5026 APList_rid.ap[i][j/3]=
5027 hexVal(data->wbuffer[j+i*6*3])<<4;
5028 break;
5029 case 1:
5030 APList_rid.ap[i][j/3]|=
5031 hexVal(data->wbuffer[j+i*6*3]);
5032 break;
5033 }
5034 }
5035 }
5036 disable_MAC(ai, 1);
5037 writeAPListRid(ai, &APList_rid, 1);
5038 enable_MAC(ai, &rsp, 1);
5039 }
5040
5041 /* This function wraps PC4500_writerid with a MAC disable */
5042 static int do_writerid( struct airo_info *ai, u16 rid, const void *rid_data,
5043 int len, int dummy ) {
5044 int rc;
5045 Resp rsp;
5046
5047 disable_MAC(ai, 1);
5048 rc = PC4500_writerid(ai, rid, rid_data, len, 1);
5049 enable_MAC(ai, &rsp, 1);
5050 return rc;
5051 }
5052
5053 /* Returns the length of the key at the index. If index == 0xffff
5054 * the index of the transmit key is returned. If the key doesn't exist,
5055 * -1 will be returned.
5056 */
5057 static int get_wep_key(struct airo_info *ai, u16 index) {
5058 WepKeyRid wkr;
5059 int rc;
5060 u16 lastindex;
5061
5062 rc = readWepKeyRid(ai, &wkr, 1, 1);
5063 if (rc == SUCCESS) do {
5064 lastindex = wkr.kindex;
5065 if (wkr.kindex == index) {
5066 if (index == 0xffff) {
5067 return wkr.mac[0];
5068 }
5069 return wkr.klen;
5070 }
5071 readWepKeyRid(ai, &wkr, 0, 1);
5072 } while(lastindex != wkr.kindex);
5073 return -1;
5074 }
5075
5076 static int set_wep_key(struct airo_info *ai, u16 index,
5077 const char *key, u16 keylen, int perm, int lock ) {
5078 static const unsigned char macaddr[ETH_ALEN] = { 0x01, 0, 0, 0, 0, 0 };
5079 WepKeyRid wkr;
5080 Resp rsp;
5081
5082 memset(&wkr, 0, sizeof(wkr));
5083 if (keylen == 0) {
5084 // We are selecting which key to use
5085 wkr.len = sizeof(wkr);
5086 wkr.kindex = 0xffff;
5087 wkr.mac[0] = (char)index;
5088 if (perm) printk(KERN_INFO "Setting transmit key to %d\n", index);
5089 if (perm) ai->defindex = (char)index;
5090 } else {
5091 // We are actually setting the key
5092 wkr.len = sizeof(wkr);
5093 wkr.kindex = index;
5094 wkr.klen = keylen;
5095 memcpy( wkr.key, key, keylen );
5096 memcpy( wkr.mac, macaddr, ETH_ALEN );
5097 printk(KERN_INFO "Setting key %d\n", index);
5098 }
5099
5100 disable_MAC(ai, lock);
5101 writeWepKeyRid(ai, &wkr, perm, lock);
5102 enable_MAC(ai, &rsp, lock);
5103 return 0;
5104 }
5105
5106 static void proc_wepkey_on_close( struct inode *inode, struct file *file ) {
5107 struct proc_data *data;
5108 struct proc_dir_entry *dp = PDE(inode);
5109 struct net_device *dev = dp->data;
5110 struct airo_info *ai = dev->priv;
5111 int i;
5112 char key[16];
5113 u16 index = 0;
5114 int j = 0;
5115
5116 memset(key, 0, sizeof(key));
5117
5118 data = (struct proc_data *)file->private_data;
5119 if ( !data->writelen ) return;
5120
5121 if (data->wbuffer[0] >= '0' && data->wbuffer[0] <= '3' &&
5122 (data->wbuffer[1] == ' ' || data->wbuffer[1] == '\n')) {
5123 index = data->wbuffer[0] - '0';
5124 if (data->wbuffer[1] == '\n') {
5125 set_wep_key(ai, index, NULL, 0, 1, 1);
5126 return;
5127 }
5128 j = 2;
5129 } else {
5130 printk(KERN_ERR "airo: WepKey passed invalid key index\n");
5131 return;
5132 }
5133
5134 for( i = 0; i < 16*3 && data->wbuffer[i+j]; i++ ) {
5135 switch(i%3) {
5136 case 0:
5137 key[i/3] = hexVal(data->wbuffer[i+j])<<4;
5138 break;
5139 case 1:
5140 key[i/3] |= hexVal(data->wbuffer[i+j]);
5141 break;
5142 }
5143 }
5144 set_wep_key(ai, index, key, i/3, 1, 1);
5145 }
5146
5147 static int proc_wepkey_open( struct inode *inode, struct file *file ) {
5148 struct proc_data *data;
5149 struct proc_dir_entry *dp = PDE(inode);
5150 struct net_device *dev = dp->data;
5151 struct airo_info *ai = dev->priv;
5152 char *ptr;
5153 WepKeyRid wkr;
5154 u16 lastindex;
5155 int j=0;
5156 int rc;
5157
5158 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5159 return -ENOMEM;
5160 memset(file->private_data, 0, sizeof(struct proc_data));
5161 memset(&wkr, 0, sizeof(wkr));
5162 data = (struct proc_data *)file->private_data;
5163 if ((data->rbuffer = kmalloc( 180, GFP_KERNEL )) == NULL) {
5164 kfree (file->private_data);
5165 return -ENOMEM;
5166 }
5167 memset(data->rbuffer, 0, 180);
5168 data->writelen = 0;
5169 data->maxwritelen = 80;
5170 if ((data->wbuffer = kmalloc( 80, GFP_KERNEL )) == NULL) {
5171 kfree (data->rbuffer);
5172 kfree (file->private_data);
5173 return -ENOMEM;
5174 }
5175 memset( data->wbuffer, 0, 80 );
5176 data->on_close = proc_wepkey_on_close;
5177
5178 ptr = data->rbuffer;
5179 strcpy(ptr, "No wep keys\n");
5180 rc = readWepKeyRid(ai, &wkr, 1, 1);
5181 if (rc == SUCCESS) do {
5182 lastindex = wkr.kindex;
5183 if (wkr.kindex == 0xffff) {
5184 j += sprintf(ptr+j, "Tx key = %d\n",
5185 (int)wkr.mac[0]);
5186 } else {
5187 j += sprintf(ptr+j, "Key %d set with length = %d\n",
5188 (int)wkr.kindex, (int)wkr.klen);
5189 }
5190 readWepKeyRid(ai, &wkr, 0, 1);
5191 } while((lastindex != wkr.kindex) && (j < 180-30));
5192
5193 data->readlen = strlen( data->rbuffer );
5194 return 0;
5195 }
5196
5197 static int proc_SSID_open( struct inode *inode, struct file *file ) {
5198 struct proc_data *data;
5199 struct proc_dir_entry *dp = PDE(inode);
5200 struct net_device *dev = dp->data;
5201 struct airo_info *ai = dev->priv;
5202 int i;
5203 char *ptr;
5204 SsidRid SSID_rid;
5205
5206 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5207 return -ENOMEM;
5208 memset(file->private_data, 0, sizeof(struct proc_data));
5209 data = (struct proc_data *)file->private_data;
5210 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5211 kfree (file->private_data);
5212 return -ENOMEM;
5213 }
5214 data->writelen = 0;
5215 data->maxwritelen = 33*3;
5216 if ((data->wbuffer = kmalloc( 33*3, GFP_KERNEL )) == NULL) {
5217 kfree (data->rbuffer);
5218 kfree (file->private_data);
5219 return -ENOMEM;
5220 }
5221 memset( data->wbuffer, 0, 33*3 );
5222 data->on_close = proc_SSID_on_close;
5223
5224 readSsidRid(ai, &SSID_rid);
5225 ptr = data->rbuffer;
5226 for( i = 0; i < 3; i++ ) {
5227 int j;
5228 if ( !SSID_rid.ssids[i].len ) break;
5229 for( j = 0; j < 32 &&
5230 j < SSID_rid.ssids[i].len &&
5231 SSID_rid.ssids[i].ssid[j]; j++ ) {
5232 *ptr++ = SSID_rid.ssids[i].ssid[j];
5233 }
5234 *ptr++ = '\n';
5235 }
5236 *ptr = '\0';
5237 data->readlen = strlen( data->rbuffer );
5238 return 0;
5239 }
5240
5241 static int proc_APList_open( struct inode *inode, struct file *file ) {
5242 struct proc_data *data;
5243 struct proc_dir_entry *dp = PDE(inode);
5244 struct net_device *dev = dp->data;
5245 struct airo_info *ai = dev->priv;
5246 int i;
5247 char *ptr;
5248 APListRid APList_rid;
5249
5250 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5251 return -ENOMEM;
5252 memset(file->private_data, 0, sizeof(struct proc_data));
5253 data = (struct proc_data *)file->private_data;
5254 if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5255 kfree (file->private_data);
5256 return -ENOMEM;
5257 }
5258 data->writelen = 0;
5259 data->maxwritelen = 4*6*3;
5260 if ((data->wbuffer = kmalloc( data->maxwritelen, GFP_KERNEL )) == NULL) {
5261 kfree (data->rbuffer);
5262 kfree (file->private_data);
5263 return -ENOMEM;
5264 }
5265 memset( data->wbuffer, 0, data->maxwritelen );
5266 data->on_close = proc_APList_on_close;
5267
5268 readAPListRid(ai, &APList_rid);
5269 ptr = data->rbuffer;
5270 for( i = 0; i < 4; i++ ) {
5271 // We end when we find a zero MAC
5272 if ( !*(int*)APList_rid.ap[i] &&
5273 !*(int*)&APList_rid.ap[i][2]) break;
5274 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x\n",
5275 (int)APList_rid.ap[i][0],
5276 (int)APList_rid.ap[i][1],
5277 (int)APList_rid.ap[i][2],
5278 (int)APList_rid.ap[i][3],
5279 (int)APList_rid.ap[i][4],
5280 (int)APList_rid.ap[i][5]);
5281 }
5282 if (i==0) ptr += sprintf(ptr, "Not using specific APs\n");
5283
5284 *ptr = '\0';
5285 data->readlen = strlen( data->rbuffer );
5286 return 0;
5287 }
5288
5289 static int proc_BSSList_open( struct inode *inode, struct file *file ) {
5290 struct proc_data *data;
5291 struct proc_dir_entry *dp = PDE(inode);
5292 struct net_device *dev = dp->data;
5293 struct airo_info *ai = dev->priv;
5294 char *ptr;
5295 BSSListRid BSSList_rid;
5296 int rc;
5297 /* If doLoseSync is not 1, we won't do a Lose Sync */
5298 int doLoseSync = -1;
5299
5300 if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5301 return -ENOMEM;
5302 memset(file->private_data, 0, sizeof(struct proc_data));
5303 data = (struct proc_data *)file->private_data;
5304 if ((data->rbuffer = kmalloc( 1024, GFP_KERNEL )) == NULL) {
5305 kfree (file->private_data);
5306 return -ENOMEM;
5307 }
5308 data->writelen = 0;
5309 data->maxwritelen = 0;
5310 data->wbuffer = NULL;
5311 data->on_close = NULL;
5312
5313 if (file->f_mode & FMODE_WRITE) {
5314 if (!(file->f_mode & FMODE_READ)) {
5315 Cmd cmd;
5316 Resp rsp;
5317
5318 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
5319 memset(&cmd, 0, sizeof(cmd));
5320 cmd.cmd=CMD_LISTBSS;
5321 if (down_interruptible(&ai->sem))
5322 return -ERESTARTSYS;
5323 issuecommand(ai, &cmd, &rsp);
5324 up(&ai->sem);
5325 data->readlen = 0;
5326 return 0;
5327 }
5328 doLoseSync = 1;
5329 }
5330 ptr = data->rbuffer;
5331 /* There is a race condition here if there are concurrent opens.
5332 Since it is a rare condition, we'll just live with it, otherwise
5333 we have to add a spin lock... */
5334 rc = readBSSListRid(ai, doLoseSync, &BSSList_rid);
5335 while(rc == 0 && BSSList_rid.index != 0xffff) {
5336 ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x %*s rssi = %d",
5337 (int)BSSList_rid.bssid[0],
5338 (int)BSSList_rid.bssid[1],
5339 (int)BSSList_rid.bssid[2],
5340 (int)BSSList_rid.bssid[3],
5341 (int)BSSList_rid.bssid[4],
5342 (int)BSSList_rid.bssid[5],
5343 (int)BSSList_rid.ssidLen,
5344 BSSList_rid.ssid,
5345 (int)BSSList_rid.dBm);
5346 ptr += sprintf(ptr, " channel = %d %s %s %s %s\n",
5347 (int)BSSList_rid.dsChannel,
5348 BSSList_rid.cap & CAP_ESS ? "ESS" : "",
5349 BSSList_rid.cap & CAP_IBSS ? "adhoc" : "",
5350 BSSList_rid.cap & CAP_PRIVACY ? "wep" : "",
5351 BSSList_rid.cap & CAP_SHORTHDR ? "shorthdr" : "");
5352 rc = readBSSListRid(ai, 0, &BSSList_rid);
5353 }
5354 *ptr = '\0';
5355 data->readlen = strlen( data->rbuffer );
5356 return 0;
5357 }
5358
5359 static int proc_close( struct inode *inode, struct file *file )
5360 {
5361 struct proc_data *data = file->private_data;
5362
5363 if (data->on_close != NULL)
5364 data->on_close(inode, file);
5365 kfree(data->rbuffer);
5366 kfree(data->wbuffer);
5367 kfree(data);
5368 return 0;
5369 }
5370
5371 static struct net_device_list {
5372 struct net_device *dev;
5373 struct net_device_list *next;
5374 } *airo_devices;
5375
5376 /* Since the card doesn't automatically switch to the right WEP mode,
5377 we will make it do it. If the card isn't associated, every secs we
5378 will switch WEP modes to see if that will help. If the card is
5379 associated we will check every minute to see if anything has
5380 changed. */
5381 static void timer_func( struct net_device *dev ) {
5382 struct airo_info *apriv = dev->priv;
5383 Resp rsp;
5384
5385 /* We don't have a link so try changing the authtype */
5386 readConfigRid(apriv, 0);
5387 disable_MAC(apriv, 0);
5388 switch(apriv->config.authType) {
5389 case AUTH_ENCRYPT:
5390 /* So drop to OPEN */
5391 apriv->config.authType = AUTH_OPEN;
5392 break;
5393 case AUTH_SHAREDKEY:
5394 if (apriv->keyindex < auto_wep) {
5395 set_wep_key(apriv, apriv->keyindex, NULL, 0, 0, 0);
5396 apriv->config.authType = AUTH_SHAREDKEY;
5397 apriv->keyindex++;
5398 } else {
5399 /* Drop to ENCRYPT */
5400 apriv->keyindex = 0;
5401 set_wep_key(apriv, apriv->defindex, NULL, 0, 0, 0);
5402 apriv->config.authType = AUTH_ENCRYPT;
5403 }
5404 break;
5405 default: /* We'll escalate to SHAREDKEY */
5406 apriv->config.authType = AUTH_SHAREDKEY;
5407 }
5408 set_bit (FLAG_COMMIT, &apriv->flags);
5409 writeConfigRid(apriv, 0);
5410 enable_MAC(apriv, &rsp, 0);
5411 up(&apriv->sem);
5412
5413 /* Schedule check to see if the change worked */
5414 clear_bit(JOB_AUTOWEP, &apriv->flags);
5415 apriv->expires = RUN_AT(HZ*3);
5416 }
5417
5418 static int add_airo_dev( struct net_device *dev ) {
5419 struct net_device_list *node = kmalloc( sizeof( *node ), GFP_KERNEL );
5420 if ( !node )
5421 return -ENOMEM;
5422
5423 node->dev = dev;
5424 node->next = airo_devices;
5425 airo_devices = node;
5426
5427 return 0;
5428 }
5429
5430 static void del_airo_dev( struct net_device *dev ) {
5431 struct net_device_list **p = &airo_devices;
5432 while( *p && ( (*p)->dev != dev ) )
5433 p = &(*p)->next;
5434 if ( *p && (*p)->dev == dev )
5435 *p = (*p)->next;
5436 }
5437
5438 #ifdef CONFIG_PCI
5439 static int __devinit airo_pci_probe(struct pci_dev *pdev,
5440 const struct pci_device_id *pent)
5441 {
5442 struct net_device *dev;
5443
5444 if (pci_enable_device(pdev))
5445 return -ENODEV;
5446 pci_set_master(pdev);
5447
5448 if (pdev->device == 0x5000 || pdev->device == 0xa504)
5449 dev = _init_airo_card(pdev->irq, pdev->resource[0].start, 0, pdev, &pdev->dev);
5450 else
5451 dev = _init_airo_card(pdev->irq, pdev->resource[2].start, 0, pdev, &pdev->dev);
5452 if (!dev)
5453 return -ENODEV;
5454
5455 pci_set_drvdata(pdev, dev);
5456 return 0;
5457 }
5458
5459 static void __devexit airo_pci_remove(struct pci_dev *pdev)
5460 {
5461 }
5462
5463 static int airo_pci_suspend(struct pci_dev *pdev, pm_message_t state)
5464 {
5465 struct net_device *dev = pci_get_drvdata(pdev);
5466 struct airo_info *ai = dev->priv;
5467 Cmd cmd;
5468 Resp rsp;
5469
5470 if ((ai->APList == NULL) &&
5471 (ai->APList = kmalloc(sizeof(APListRid), GFP_KERNEL)) == NULL)
5472 return -ENOMEM;
5473 if ((ai->SSID == NULL) &&
5474 (ai->SSID = kmalloc(sizeof(SsidRid), GFP_KERNEL)) == NULL)
5475 return -ENOMEM;
5476 readAPListRid(ai, ai->APList);
5477 readSsidRid(ai, ai->SSID);
5478 memset(&cmd, 0, sizeof(cmd));
5479 /* the lock will be released at the end of the resume callback */
5480 if (down_interruptible(&ai->sem))
5481 return -EAGAIN;
5482 disable_MAC(ai, 0);
5483 netif_device_detach(dev);
5484 ai->power = state;
5485 cmd.cmd=HOSTSLEEP;
5486 issuecommand(ai, &cmd, &rsp);
5487
5488 pci_enable_wake(pdev, pci_choose_state(pdev, state), 1);
5489 pci_save_state(pdev);
5490 return pci_set_power_state(pdev, pci_choose_state(pdev, state));
5491 }
5492
5493 static int airo_pci_resume(struct pci_dev *pdev)
5494 {
5495 struct net_device *dev = pci_get_drvdata(pdev);
5496 struct airo_info *ai = dev->priv;
5497 Resp rsp;
5498 pci_power_t prev_state = pdev->current_state;
5499
5500 pci_set_power_state(pdev, PCI_D0);
5501 pci_restore_state(pdev);
5502 pci_enable_wake(pdev, PCI_D0, 0);
5503
5504 if (prev_state != PCI_D1) {
5505 reset_card(dev, 0);
5506 mpi_init_descriptors(ai);
5507 setup_card(ai, dev->dev_addr, 0);
5508 clear_bit(FLAG_RADIO_OFF, &ai->flags);
5509 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
5510 } else {
5511 OUT4500(ai, EVACK, EV_AWAKEN);
5512 OUT4500(ai, EVACK, EV_AWAKEN);
5513 msleep(100);
5514 }
5515
5516 set_bit (FLAG_COMMIT, &ai->flags);
5517 disable_MAC(ai, 0);
5518 msleep(200);
5519 if (ai->SSID) {
5520 writeSsidRid(ai, ai->SSID, 0);
5521 kfree(ai->SSID);
5522 ai->SSID = NULL;
5523 }
5524 if (ai->APList) {
5525 writeAPListRid(ai, ai->APList, 0);
5526 kfree(ai->APList);
5527 ai->APList = NULL;
5528 }
5529 writeConfigRid(ai, 0);
5530 enable_MAC(ai, &rsp, 0);
5531 ai->power = PMSG_ON;
5532 netif_device_attach(dev);
5533 netif_wake_queue(dev);
5534 enable_interrupts(ai);
5535 up(&ai->sem);
5536 return 0;
5537 }
5538 #endif
5539
5540 static int __init airo_init_module( void )
5541 {
5542 int i, have_isa_dev = 0;
5543
5544 airo_entry = create_proc_entry("aironet",
5545 S_IFDIR | airo_perm,
5546 proc_root_driver);
5547 airo_entry->uid = proc_uid;
5548 airo_entry->gid = proc_gid;
5549
5550 for( i = 0; i < 4 && io[i] && irq[i]; i++ ) {
5551 printk( KERN_INFO
5552 "airo: Trying to configure ISA adapter at irq=%d io=0x%x\n",
5553 irq[i], io[i] );
5554 if (init_airo_card( irq[i], io[i], 0, NULL ))
5555 have_isa_dev = 1;
5556 }
5557
5558 #ifdef CONFIG_PCI
5559 printk( KERN_INFO "airo: Probing for PCI adapters\n" );
5560 pci_register_driver(&airo_driver);
5561 printk( KERN_INFO "airo: Finished probing for PCI adapters\n" );
5562 #endif
5563
5564 /* Always exit with success, as we are a library module
5565 * as well as a driver module
5566 */
5567 return 0;
5568 }
5569
5570 static void __exit airo_cleanup_module( void )
5571 {
5572 while( airo_devices ) {
5573 printk( KERN_INFO "airo: Unregistering %s\n", airo_devices->dev->name );
5574 stop_airo_card( airo_devices->dev, 1 );
5575 }
5576 #ifdef CONFIG_PCI
5577 pci_unregister_driver(&airo_driver);
5578 #endif
5579 remove_proc_entry("aironet", proc_root_driver);
5580 }
5581
5582 /*
5583 * Initial Wireless Extension code for Aironet driver by :
5584 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 17 November 00
5585 * Conversion to new driver API by :
5586 * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 26 March 02
5587 * Javier also did a good amount of work here, adding some new extensions
5588 * and fixing my code. Let's just say that without him this code just
5589 * would not work at all... - Jean II
5590 */
5591
5592 static u8 airo_rssi_to_dbm (tdsRssiEntry *rssi_rid, u8 rssi)
5593 {
5594 if( !rssi_rid )
5595 return 0;
5596
5597 return (0x100 - rssi_rid[rssi].rssidBm);
5598 }
5599
5600 static u8 airo_dbm_to_pct (tdsRssiEntry *rssi_rid, u8 dbm)
5601 {
5602 int i;
5603
5604 if( !rssi_rid )
5605 return 0;
5606
5607 for( i = 0; i < 256; i++ )
5608 if (rssi_rid[i].rssidBm == dbm)
5609 return rssi_rid[i].rssipct;
5610
5611 return 0;
5612 }
5613
5614
5615 static int airo_get_quality (StatusRid *status_rid, CapabilityRid *cap_rid)
5616 {
5617 int quality = 0;
5618
5619 if ((status_rid->mode & 0x3f) == 0x3f && (cap_rid->hardCap & 8)) {
5620 if (memcmp(cap_rid->prodName, "350", 3))
5621 if (status_rid->signalQuality > 0x20)
5622 quality = 0;
5623 else
5624 quality = 0x20 - status_rid->signalQuality;
5625 else
5626 if (status_rid->signalQuality > 0xb0)
5627 quality = 0;
5628 else if (status_rid->signalQuality < 0x10)
5629 quality = 0xa0;
5630 else
5631 quality = 0xb0 - status_rid->signalQuality;
5632 }
5633 return quality;
5634 }
5635
5636 #define airo_get_max_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x20 : 0xa0)
5637 #define airo_get_avg_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x10 : 0x50);
5638
5639 /*------------------------------------------------------------------*/
5640 /*
5641 * Wireless Handler : get protocol name
5642 */
5643 static int airo_get_name(struct net_device *dev,
5644 struct iw_request_info *info,
5645 char *cwrq,
5646 char *extra)
5647 {
5648 strcpy(cwrq, "IEEE 802.11-DS");
5649 return 0;
5650 }
5651
5652 /*------------------------------------------------------------------*/
5653 /*
5654 * Wireless Handler : set frequency
5655 */
5656 static int airo_set_freq(struct net_device *dev,
5657 struct iw_request_info *info,
5658 struct iw_freq *fwrq,
5659 char *extra)
5660 {
5661 struct airo_info *local = dev->priv;
5662 int rc = -EINPROGRESS; /* Call commit handler */
5663
5664 /* If setting by frequency, convert to a channel */
5665 if((fwrq->e == 1) &&
5666 (fwrq->m >= (int) 2.412e8) &&
5667 (fwrq->m <= (int) 2.487e8)) {
5668 int f = fwrq->m / 100000;
5669 int c = 0;
5670 while((c < 14) && (f != frequency_list[c]))
5671 c++;
5672 /* Hack to fall through... */
5673 fwrq->e = 0;
5674 fwrq->m = c + 1;
5675 }
5676 /* Setting by channel number */
5677 if((fwrq->m > 1000) || (fwrq->e > 0))
5678 rc = -EOPNOTSUPP;
5679 else {
5680 int channel = fwrq->m;
5681 /* We should do a better check than that,
5682 * based on the card capability !!! */
5683 if((channel < 1) || (channel > 16)) {
5684 printk(KERN_DEBUG "%s: New channel value of %d is invalid!\n", dev->name, fwrq->m);
5685 rc = -EINVAL;
5686 } else {
5687 readConfigRid(local, 1);
5688 /* Yes ! We can set it !!! */
5689 local->config.channelSet = (u16)(channel - 1);
5690 set_bit (FLAG_COMMIT, &local->flags);
5691 }
5692 }
5693 return rc;
5694 }
5695
5696 /*------------------------------------------------------------------*/
5697 /*
5698 * Wireless Handler : get frequency
5699 */
5700 static int airo_get_freq(struct net_device *dev,
5701 struct iw_request_info *info,
5702 struct iw_freq *fwrq,
5703 char *extra)
5704 {
5705 struct airo_info *local = dev->priv;
5706 StatusRid status_rid; /* Card status info */
5707
5708 readConfigRid(local, 1);
5709 if ((local->config.opmode & 0xFF) == MODE_STA_ESS)
5710 status_rid.channel = local->config.channelSet;
5711 else
5712 readStatusRid(local, &status_rid, 1);
5713
5714 #ifdef WEXT_USECHANNELS
5715 fwrq->m = ((int)status_rid.channel) + 1;
5716 fwrq->e = 0;
5717 #else
5718 {
5719 int f = (int)status_rid.channel;
5720 fwrq->m = frequency_list[f] * 100000;
5721 fwrq->e = 1;
5722 }
5723 #endif
5724
5725 return 0;
5726 }
5727
5728 /*------------------------------------------------------------------*/
5729 /*
5730 * Wireless Handler : set ESSID
5731 */
5732 static int airo_set_essid(struct net_device *dev,
5733 struct iw_request_info *info,
5734 struct iw_point *dwrq,
5735 char *extra)
5736 {
5737 struct airo_info *local = dev->priv;
5738 Resp rsp;
5739 SsidRid SSID_rid; /* SSIDs */
5740
5741 /* Reload the list of current SSID */
5742 readSsidRid(local, &SSID_rid);
5743
5744 /* Check if we asked for `any' */
5745 if(dwrq->flags == 0) {
5746 /* Just send an empty SSID list */
5747 memset(&SSID_rid, 0, sizeof(SSID_rid));
5748 } else {
5749 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
5750
5751 /* Check the size of the string */
5752 if(dwrq->length > IW_ESSID_MAX_SIZE+1) {
5753 return -E2BIG ;
5754 }
5755 /* Check if index is valid */
5756 if((index < 0) || (index >= 4)) {
5757 return -EINVAL;
5758 }
5759
5760 /* Set the SSID */
5761 memset(SSID_rid.ssids[index].ssid, 0,
5762 sizeof(SSID_rid.ssids[index].ssid));
5763 memcpy(SSID_rid.ssids[index].ssid, extra, dwrq->length);
5764 SSID_rid.ssids[index].len = dwrq->length - 1;
5765 }
5766 SSID_rid.len = sizeof(SSID_rid);
5767 /* Write it to the card */
5768 disable_MAC(local, 1);
5769 writeSsidRid(local, &SSID_rid, 1);
5770 enable_MAC(local, &rsp, 1);
5771
5772 return 0;
5773 }
5774
5775 /*------------------------------------------------------------------*/
5776 /*
5777 * Wireless Handler : get ESSID
5778 */
5779 static int airo_get_essid(struct net_device *dev,
5780 struct iw_request_info *info,
5781 struct iw_point *dwrq,
5782 char *extra)
5783 {
5784 struct airo_info *local = dev->priv;
5785 StatusRid status_rid; /* Card status info */
5786
5787 readStatusRid(local, &status_rid, 1);
5788
5789 /* Note : if dwrq->flags != 0, we should
5790 * get the relevant SSID from the SSID list... */
5791
5792 /* Get the current SSID */
5793 memcpy(extra, status_rid.SSID, status_rid.SSIDlen);
5794 extra[status_rid.SSIDlen] = '\0';
5795 /* If none, we may want to get the one that was set */
5796
5797 /* Push it out ! */
5798 dwrq->length = status_rid.SSIDlen + 1;
5799 dwrq->flags = 1; /* active */
5800
5801 return 0;
5802 }
5803
5804 /*------------------------------------------------------------------*/
5805 /*
5806 * Wireless Handler : set AP address
5807 */
5808 static int airo_set_wap(struct net_device *dev,
5809 struct iw_request_info *info,
5810 struct sockaddr *awrq,
5811 char *extra)
5812 {
5813 struct airo_info *local = dev->priv;
5814 Cmd cmd;
5815 Resp rsp;
5816 APListRid APList_rid;
5817 static const unsigned char bcast[ETH_ALEN] = { 255, 255, 255, 255, 255, 255 };
5818
5819 if (awrq->sa_family != ARPHRD_ETHER)
5820 return -EINVAL;
5821 else if (!memcmp(bcast, awrq->sa_data, ETH_ALEN)) {
5822 memset(&cmd, 0, sizeof(cmd));
5823 cmd.cmd=CMD_LOSE_SYNC;
5824 if (down_interruptible(&local->sem))
5825 return -ERESTARTSYS;
5826 issuecommand(local, &cmd, &rsp);
5827 up(&local->sem);
5828 } else {
5829 memset(&APList_rid, 0, sizeof(APList_rid));
5830 APList_rid.len = sizeof(APList_rid);
5831 memcpy(APList_rid.ap[0], awrq->sa_data, ETH_ALEN);
5832 disable_MAC(local, 1);
5833 writeAPListRid(local, &APList_rid, 1);
5834 enable_MAC(local, &rsp, 1);
5835 }
5836 return 0;
5837 }
5838
5839 /*------------------------------------------------------------------*/
5840 /*
5841 * Wireless Handler : get AP address
5842 */
5843 static int airo_get_wap(struct net_device *dev,
5844 struct iw_request_info *info,
5845 struct sockaddr *awrq,
5846 char *extra)
5847 {
5848 struct airo_info *local = dev->priv;
5849 StatusRid status_rid; /* Card status info */
5850
5851 readStatusRid(local, &status_rid, 1);
5852
5853 /* Tentative. This seems to work, wow, I'm lucky !!! */
5854 memcpy(awrq->sa_data, status_rid.bssid[0], ETH_ALEN);
5855 awrq->sa_family = ARPHRD_ETHER;
5856
5857 return 0;
5858 }
5859
5860 /*------------------------------------------------------------------*/
5861 /*
5862 * Wireless Handler : set Nickname
5863 */
5864 static int airo_set_nick(struct net_device *dev,
5865 struct iw_request_info *info,
5866 struct iw_point *dwrq,
5867 char *extra)
5868 {
5869 struct airo_info *local = dev->priv;
5870
5871 /* Check the size of the string */
5872 if(dwrq->length > 16 + 1) {
5873 return -E2BIG;
5874 }
5875 readConfigRid(local, 1);
5876 memset(local->config.nodeName, 0, sizeof(local->config.nodeName));
5877 memcpy(local->config.nodeName, extra, dwrq->length);
5878 set_bit (FLAG_COMMIT, &local->flags);
5879
5880 return -EINPROGRESS; /* Call commit handler */
5881 }
5882
5883 /*------------------------------------------------------------------*/
5884 /*
5885 * Wireless Handler : get Nickname
5886 */
5887 static int airo_get_nick(struct net_device *dev,
5888 struct iw_request_info *info,
5889 struct iw_point *dwrq,
5890 char *extra)
5891 {
5892 struct airo_info *local = dev->priv;
5893
5894 readConfigRid(local, 1);
5895 strncpy(extra, local->config.nodeName, 16);
5896 extra[16] = '\0';
5897 dwrq->length = strlen(extra) + 1;
5898
5899 return 0;
5900 }
5901
5902 /*------------------------------------------------------------------*/
5903 /*
5904 * Wireless Handler : set Bit-Rate
5905 */
5906 static int airo_set_rate(struct net_device *dev,
5907 struct iw_request_info *info,
5908 struct iw_param *vwrq,
5909 char *extra)
5910 {
5911 struct airo_info *local = dev->priv;
5912 CapabilityRid cap_rid; /* Card capability info */
5913 u8 brate = 0;
5914 int i;
5915
5916 /* First : get a valid bit rate value */
5917 readCapabilityRid(local, &cap_rid, 1);
5918
5919 /* Which type of value ? */
5920 if((vwrq->value < 8) && (vwrq->value >= 0)) {
5921 /* Setting by rate index */
5922 /* Find value in the magic rate table */
5923 brate = cap_rid.supportedRates[vwrq->value];
5924 } else {
5925 /* Setting by frequency value */
5926 u8 normvalue = (u8) (vwrq->value/500000);
5927
5928 /* Check if rate is valid */
5929 for(i = 0 ; i < 8 ; i++) {
5930 if(normvalue == cap_rid.supportedRates[i]) {
5931 brate = normvalue;
5932 break;
5933 }
5934 }
5935 }
5936 /* -1 designed the max rate (mostly auto mode) */
5937 if(vwrq->value == -1) {
5938 /* Get the highest available rate */
5939 for(i = 0 ; i < 8 ; i++) {
5940 if(cap_rid.supportedRates[i] == 0)
5941 break;
5942 }
5943 if(i != 0)
5944 brate = cap_rid.supportedRates[i - 1];
5945 }
5946 /* Check that it is valid */
5947 if(brate == 0) {
5948 return -EINVAL;
5949 }
5950
5951 readConfigRid(local, 1);
5952 /* Now, check if we want a fixed or auto value */
5953 if(vwrq->fixed == 0) {
5954 /* Fill all the rates up to this max rate */
5955 memset(local->config.rates, 0, 8);
5956 for(i = 0 ; i < 8 ; i++) {
5957 local->config.rates[i] = cap_rid.supportedRates[i];
5958 if(local->config.rates[i] == brate)
5959 break;
5960 }
5961 } else {
5962 /* Fixed mode */
5963 /* One rate, fixed */
5964 memset(local->config.rates, 0, 8);
5965 local->config.rates[0] = brate;
5966 }
5967 set_bit (FLAG_COMMIT, &local->flags);
5968
5969 return -EINPROGRESS; /* Call commit handler */
5970 }
5971
5972 /*------------------------------------------------------------------*/
5973 /*
5974 * Wireless Handler : get Bit-Rate
5975 */
5976 static int airo_get_rate(struct net_device *dev,
5977 struct iw_request_info *info,
5978 struct iw_param *vwrq,
5979 char *extra)
5980 {
5981 struct airo_info *local = dev->priv;
5982 StatusRid status_rid; /* Card status info */
5983
5984 readStatusRid(local, &status_rid, 1);
5985
5986 vwrq->value = status_rid.currentXmitRate * 500000;
5987 /* If more than one rate, set auto */
5988 readConfigRid(local, 1);
5989 vwrq->fixed = (local->config.rates[1] == 0);
5990
5991 return 0;
5992 }
5993
5994 /*------------------------------------------------------------------*/
5995 /*
5996 * Wireless Handler : set RTS threshold
5997 */
5998 static int airo_set_rts(struct net_device *dev,
5999 struct iw_request_info *info,
6000 struct iw_param *vwrq,
6001 char *extra)
6002 {
6003 struct airo_info *local = dev->priv;
6004 int rthr = vwrq->value;
6005
6006 if(vwrq->disabled)
6007 rthr = 2312;
6008 if((rthr < 0) || (rthr > 2312)) {
6009 return -EINVAL;
6010 }
6011 readConfigRid(local, 1);
6012 local->config.rtsThres = rthr;
6013 set_bit (FLAG_COMMIT, &local->flags);
6014
6015 return -EINPROGRESS; /* Call commit handler */
6016 }
6017
6018 /*------------------------------------------------------------------*/
6019 /*
6020 * Wireless Handler : get RTS threshold
6021 */
6022 static int airo_get_rts(struct net_device *dev,
6023 struct iw_request_info *info,
6024 struct iw_param *vwrq,
6025 char *extra)
6026 {
6027 struct airo_info *local = dev->priv;
6028
6029 readConfigRid(local, 1);
6030 vwrq->value = local->config.rtsThres;
6031 vwrq->disabled = (vwrq->value >= 2312);
6032 vwrq->fixed = 1;
6033
6034 return 0;
6035 }
6036
6037 /*------------------------------------------------------------------*/
6038 /*
6039 * Wireless Handler : set Fragmentation threshold
6040 */
6041 static int airo_set_frag(struct net_device *dev,
6042 struct iw_request_info *info,
6043 struct iw_param *vwrq,
6044 char *extra)
6045 {
6046 struct airo_info *local = dev->priv;
6047 int fthr = vwrq->value;
6048
6049 if(vwrq->disabled)
6050 fthr = 2312;
6051 if((fthr < 256) || (fthr > 2312)) {
6052 return -EINVAL;
6053 }
6054 fthr &= ~0x1; /* Get an even value - is it really needed ??? */
6055 readConfigRid(local, 1);
6056 local->config.fragThresh = (u16)fthr;
6057 set_bit (FLAG_COMMIT, &local->flags);
6058
6059 return -EINPROGRESS; /* Call commit handler */
6060 }
6061
6062 /*------------------------------------------------------------------*/
6063 /*
6064 * Wireless Handler : get Fragmentation threshold
6065 */
6066 static int airo_get_frag(struct net_device *dev,
6067 struct iw_request_info *info,
6068 struct iw_param *vwrq,
6069 char *extra)
6070 {
6071 struct airo_info *local = dev->priv;
6072
6073 readConfigRid(local, 1);
6074 vwrq->value = local->config.fragThresh;
6075 vwrq->disabled = (vwrq->value >= 2312);
6076 vwrq->fixed = 1;
6077
6078 return 0;
6079 }
6080
6081 /*------------------------------------------------------------------*/
6082 /*
6083 * Wireless Handler : set Mode of Operation
6084 */
6085 static int airo_set_mode(struct net_device *dev,
6086 struct iw_request_info *info,
6087 __u32 *uwrq,
6088 char *extra)
6089 {
6090 struct airo_info *local = dev->priv;
6091 int reset = 0;
6092
6093 readConfigRid(local, 1);
6094 if ((local->config.rmode & 0xff) >= RXMODE_RFMON)
6095 reset = 1;
6096
6097 switch(*uwrq) {
6098 case IW_MODE_ADHOC:
6099 local->config.opmode &= 0xFF00;
6100 local->config.opmode |= MODE_STA_IBSS;
6101 local->config.rmode &= 0xfe00;
6102 local->config.scanMode = SCANMODE_ACTIVE;
6103 clear_bit (FLAG_802_11, &local->flags);
6104 break;
6105 case IW_MODE_INFRA:
6106 local->config.opmode &= 0xFF00;
6107 local->config.opmode |= MODE_STA_ESS;
6108 local->config.rmode &= 0xfe00;
6109 local->config.scanMode = SCANMODE_ACTIVE;
6110 clear_bit (FLAG_802_11, &local->flags);
6111 break;
6112 case IW_MODE_MASTER:
6113 local->config.opmode &= 0xFF00;
6114 local->config.opmode |= MODE_AP;
6115 local->config.rmode &= 0xfe00;
6116 local->config.scanMode = SCANMODE_ACTIVE;
6117 clear_bit (FLAG_802_11, &local->flags);
6118 break;
6119 case IW_MODE_REPEAT:
6120 local->config.opmode &= 0xFF00;
6121 local->config.opmode |= MODE_AP_RPTR;
6122 local->config.rmode &= 0xfe00;
6123 local->config.scanMode = SCANMODE_ACTIVE;
6124 clear_bit (FLAG_802_11, &local->flags);
6125 break;
6126 case IW_MODE_MONITOR:
6127 local->config.opmode &= 0xFF00;
6128 local->config.opmode |= MODE_STA_ESS;
6129 local->config.rmode &= 0xfe00;
6130 local->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
6131 local->config.scanMode = SCANMODE_PASSIVE;
6132 set_bit (FLAG_802_11, &local->flags);
6133 break;
6134 default:
6135 return -EINVAL;
6136 }
6137 if (reset)
6138 set_bit (FLAG_RESET, &local->flags);
6139 set_bit (FLAG_COMMIT, &local->flags);
6140
6141 return -EINPROGRESS; /* Call commit handler */
6142 }
6143
6144 /*------------------------------------------------------------------*/
6145 /*
6146 * Wireless Handler : get Mode of Operation
6147 */
6148 static int airo_get_mode(struct net_device *dev,
6149 struct iw_request_info *info,
6150 __u32 *uwrq,
6151 char *extra)
6152 {
6153 struct airo_info *local = dev->priv;
6154
6155 readConfigRid(local, 1);
6156 /* If not managed, assume it's ad-hoc */
6157 switch (local->config.opmode & 0xFF) {
6158 case MODE_STA_ESS:
6159 *uwrq = IW_MODE_INFRA;
6160 break;
6161 case MODE_AP:
6162 *uwrq = IW_MODE_MASTER;
6163 break;
6164 case MODE_AP_RPTR:
6165 *uwrq = IW_MODE_REPEAT;
6166 break;
6167 default:
6168 *uwrq = IW_MODE_ADHOC;
6169 }
6170
6171 return 0;
6172 }
6173
6174 /*------------------------------------------------------------------*/
6175 /*
6176 * Wireless Handler : set Encryption Key
6177 */
6178 static int airo_set_encode(struct net_device *dev,
6179 struct iw_request_info *info,
6180 struct iw_point *dwrq,
6181 char *extra)
6182 {
6183 struct airo_info *local = dev->priv;
6184 CapabilityRid cap_rid; /* Card capability info */
6185
6186 /* Is WEP supported ? */
6187 readCapabilityRid(local, &cap_rid, 1);
6188 /* Older firmware doesn't support this...
6189 if(!(cap_rid.softCap & 2)) {
6190 return -EOPNOTSUPP;
6191 } */
6192 readConfigRid(local, 1);
6193
6194 /* Basic checking: do we have a key to set ?
6195 * Note : with the new API, it's impossible to get a NULL pointer.
6196 * Therefore, we need to check a key size == 0 instead.
6197 * New version of iwconfig properly set the IW_ENCODE_NOKEY flag
6198 * when no key is present (only change flags), but older versions
6199 * don't do it. - Jean II */
6200 if (dwrq->length > 0) {
6201 wep_key_t key;
6202 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6203 int current_index = get_wep_key(local, 0xffff);
6204 /* Check the size of the key */
6205 if (dwrq->length > MAX_KEY_SIZE) {
6206 return -EINVAL;
6207 }
6208 /* Check the index (none -> use current) */
6209 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4:1)))
6210 index = current_index;
6211 /* Set the length */
6212 if (dwrq->length > MIN_KEY_SIZE)
6213 key.len = MAX_KEY_SIZE;
6214 else
6215 if (dwrq->length > 0)
6216 key.len = MIN_KEY_SIZE;
6217 else
6218 /* Disable the key */
6219 key.len = 0;
6220 /* Check if the key is not marked as invalid */
6221 if(!(dwrq->flags & IW_ENCODE_NOKEY)) {
6222 /* Cleanup */
6223 memset(key.key, 0, MAX_KEY_SIZE);
6224 /* Copy the key in the driver */
6225 memcpy(key.key, extra, dwrq->length);
6226 /* Send the key to the card */
6227 set_wep_key(local, index, key.key, key.len, 1, 1);
6228 }
6229 /* WE specify that if a valid key is set, encryption
6230 * should be enabled (user may turn it off later)
6231 * This is also how "iwconfig ethX key on" works */
6232 if((index == current_index) && (key.len > 0) &&
6233 (local->config.authType == AUTH_OPEN)) {
6234 local->config.authType = AUTH_ENCRYPT;
6235 set_bit (FLAG_COMMIT, &local->flags);
6236 }
6237 } else {
6238 /* Do we want to just set the transmit key index ? */
6239 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6240 if ((index >= 0) && (index < ((cap_rid.softCap & 0x80)?4:1))) {
6241 set_wep_key(local, index, NULL, 0, 1, 1);
6242 } else
6243 /* Don't complain if only change the mode */
6244 if(!dwrq->flags & IW_ENCODE_MODE) {
6245 return -EINVAL;
6246 }
6247 }
6248 /* Read the flags */
6249 if(dwrq->flags & IW_ENCODE_DISABLED)
6250 local->config.authType = AUTH_OPEN; // disable encryption
6251 if(dwrq->flags & IW_ENCODE_RESTRICTED)
6252 local->config.authType = AUTH_SHAREDKEY; // Only Both
6253 if(dwrq->flags & IW_ENCODE_OPEN)
6254 local->config.authType = AUTH_ENCRYPT; // Only Wep
6255 /* Commit the changes to flags if needed */
6256 if(dwrq->flags & IW_ENCODE_MODE)
6257 set_bit (FLAG_COMMIT, &local->flags);
6258 return -EINPROGRESS; /* Call commit handler */
6259 }
6260
6261 /*------------------------------------------------------------------*/
6262 /*
6263 * Wireless Handler : get Encryption Key
6264 */
6265 static int airo_get_encode(struct net_device *dev,
6266 struct iw_request_info *info,
6267 struct iw_point *dwrq,
6268 char *extra)
6269 {
6270 struct airo_info *local = dev->priv;
6271 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6272 CapabilityRid cap_rid; /* Card capability info */
6273
6274 /* Is it supported ? */
6275 readCapabilityRid(local, &cap_rid, 1);
6276 if(!(cap_rid.softCap & 2)) {
6277 return -EOPNOTSUPP;
6278 }
6279 readConfigRid(local, 1);
6280 /* Check encryption mode */
6281 switch(local->config.authType) {
6282 case AUTH_ENCRYPT:
6283 dwrq->flags = IW_ENCODE_OPEN;
6284 break;
6285 case AUTH_SHAREDKEY:
6286 dwrq->flags = IW_ENCODE_RESTRICTED;
6287 break;
6288 default:
6289 case AUTH_OPEN:
6290 dwrq->flags = IW_ENCODE_DISABLED;
6291 break;
6292 }
6293 /* We can't return the key, so set the proper flag and return zero */
6294 dwrq->flags |= IW_ENCODE_NOKEY;
6295 memset(extra, 0, 16);
6296
6297 /* Which key do we want ? -1 -> tx index */
6298 if ((index < 0) || (index >= ((cap_rid.softCap & 0x80) ? 4 : 1)))
6299 index = get_wep_key(local, 0xffff);
6300 dwrq->flags |= index + 1;
6301 /* Copy the key to the user buffer */
6302 dwrq->length = get_wep_key(local, index);
6303 if (dwrq->length > 16) {
6304 dwrq->length=0;
6305 }
6306 return 0;
6307 }
6308
6309 /*------------------------------------------------------------------*/
6310 /*
6311 * Wireless Handler : set Tx-Power
6312 */
6313 static int airo_set_txpow(struct net_device *dev,
6314 struct iw_request_info *info,
6315 struct iw_param *vwrq,
6316 char *extra)
6317 {
6318 struct airo_info *local = dev->priv;
6319 CapabilityRid cap_rid; /* Card capability info */
6320 int i;
6321 int rc = -EINVAL;
6322
6323 readCapabilityRid(local, &cap_rid, 1);
6324
6325 if (vwrq->disabled) {
6326 set_bit (FLAG_RADIO_OFF, &local->flags);
6327 set_bit (FLAG_COMMIT, &local->flags);
6328 return -EINPROGRESS; /* Call commit handler */
6329 }
6330 if (vwrq->flags != IW_TXPOW_MWATT) {
6331 return -EINVAL;
6332 }
6333 clear_bit (FLAG_RADIO_OFF, &local->flags);
6334 for (i = 0; cap_rid.txPowerLevels[i] && (i < 8); i++)
6335 if ((vwrq->value==cap_rid.txPowerLevels[i])) {
6336 readConfigRid(local, 1);
6337 local->config.txPower = vwrq->value;
6338 set_bit (FLAG_COMMIT, &local->flags);
6339 rc = -EINPROGRESS; /* Call commit handler */
6340 break;
6341 }
6342 return rc;
6343 }
6344
6345 /*------------------------------------------------------------------*/
6346 /*
6347 * Wireless Handler : get Tx-Power
6348 */
6349 static int airo_get_txpow(struct net_device *dev,
6350 struct iw_request_info *info,
6351 struct iw_param *vwrq,
6352 char *extra)
6353 {
6354 struct airo_info *local = dev->priv;
6355
6356 readConfigRid(local, 1);
6357 vwrq->value = local->config.txPower;
6358 vwrq->fixed = 1; /* No power control */
6359 vwrq->disabled = test_bit(FLAG_RADIO_OFF, &local->flags);
6360 vwrq->flags = IW_TXPOW_MWATT;
6361
6362 return 0;
6363 }
6364
6365 /*------------------------------------------------------------------*/
6366 /*
6367 * Wireless Handler : set Retry limits
6368 */
6369 static int airo_set_retry(struct net_device *dev,
6370 struct iw_request_info *info,
6371 struct iw_param *vwrq,
6372 char *extra)
6373 {
6374 struct airo_info *local = dev->priv;
6375 int rc = -EINVAL;
6376
6377 if(vwrq->disabled) {
6378 return -EINVAL;
6379 }
6380 readConfigRid(local, 1);
6381 if(vwrq->flags & IW_RETRY_LIMIT) {
6382 if(vwrq->flags & IW_RETRY_MAX)
6383 local->config.longRetryLimit = vwrq->value;
6384 else if (vwrq->flags & IW_RETRY_MIN)
6385 local->config.shortRetryLimit = vwrq->value;
6386 else {
6387 /* No modifier : set both */
6388 local->config.longRetryLimit = vwrq->value;
6389 local->config.shortRetryLimit = vwrq->value;
6390 }
6391 set_bit (FLAG_COMMIT, &local->flags);
6392 rc = -EINPROGRESS; /* Call commit handler */
6393 }
6394 if(vwrq->flags & IW_RETRY_LIFETIME) {
6395 local->config.txLifetime = vwrq->value / 1024;
6396 set_bit (FLAG_COMMIT, &local->flags);
6397 rc = -EINPROGRESS; /* Call commit handler */
6398 }
6399 return rc;
6400 }
6401
6402 /*------------------------------------------------------------------*/
6403 /*
6404 * Wireless Handler : get Retry limits
6405 */
6406 static int airo_get_retry(struct net_device *dev,
6407 struct iw_request_info *info,
6408 struct iw_param *vwrq,
6409 char *extra)
6410 {
6411 struct airo_info *local = dev->priv;
6412
6413 vwrq->disabled = 0; /* Can't be disabled */
6414
6415 readConfigRid(local, 1);
6416 /* Note : by default, display the min retry number */
6417 if((vwrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
6418 vwrq->flags = IW_RETRY_LIFETIME;
6419 vwrq->value = (int)local->config.txLifetime * 1024;
6420 } else if((vwrq->flags & IW_RETRY_MAX)) {
6421 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
6422 vwrq->value = (int)local->config.longRetryLimit;
6423 } else {
6424 vwrq->flags = IW_RETRY_LIMIT;
6425 vwrq->value = (int)local->config.shortRetryLimit;
6426 if((int)local->config.shortRetryLimit != (int)local->config.longRetryLimit)
6427 vwrq->flags |= IW_RETRY_MIN;
6428 }
6429
6430 return 0;
6431 }
6432
6433 /*------------------------------------------------------------------*/
6434 /*
6435 * Wireless Handler : get range info
6436 */
6437 static int airo_get_range(struct net_device *dev,
6438 struct iw_request_info *info,
6439 struct iw_point *dwrq,
6440 char *extra)
6441 {
6442 struct airo_info *local = dev->priv;
6443 struct iw_range *range = (struct iw_range *) extra;
6444 CapabilityRid cap_rid; /* Card capability info */
6445 int i;
6446 int k;
6447
6448 readCapabilityRid(local, &cap_rid, 1);
6449
6450 dwrq->length = sizeof(struct iw_range);
6451 memset(range, 0, sizeof(*range));
6452 range->min_nwid = 0x0000;
6453 range->max_nwid = 0x0000;
6454 range->num_channels = 14;
6455 /* Should be based on cap_rid.country to give only
6456 * what the current card support */
6457 k = 0;
6458 for(i = 0; i < 14; i++) {
6459 range->freq[k].i = i + 1; /* List index */
6460 range->freq[k].m = frequency_list[i] * 100000;
6461 range->freq[k++].e = 1; /* Values in table in MHz -> * 10^5 * 10 */
6462 }
6463 range->num_frequency = k;
6464
6465 range->sensitivity = 65535;
6466
6467 /* Hum... Should put the right values there */
6468 if (local->rssi)
6469 range->max_qual.qual = 100; /* % */
6470 else
6471 range->max_qual.qual = airo_get_max_quality(&cap_rid);
6472 range->max_qual.level = 0x100 - 120; /* -120 dBm */
6473 range->max_qual.noise = 0x100 - 120; /* -120 dBm */
6474
6475 /* Experimental measurements - boundary 11/5.5 Mb/s */
6476 /* Note : with or without the (local->rssi), results
6477 * are somewhat different. - Jean II */
6478 if (local->rssi) {
6479 range->avg_qual.qual = 50; /* % */
6480 range->avg_qual.level = 0x100 - 70; /* -70 dBm */
6481 } else {
6482 range->avg_qual.qual = airo_get_avg_quality(&cap_rid);
6483 range->avg_qual.level = 0x100 - 80; /* -80 dBm */
6484 }
6485 range->avg_qual.noise = 0x100 - 85; /* -85 dBm */
6486
6487 for(i = 0 ; i < 8 ; i++) {
6488 range->bitrate[i] = cap_rid.supportedRates[i] * 500000;
6489 if(range->bitrate[i] == 0)
6490 break;
6491 }
6492 range->num_bitrates = i;
6493
6494 /* Set an indication of the max TCP throughput
6495 * in bit/s that we can expect using this interface.
6496 * May be use for QoS stuff... Jean II */
6497 if(i > 2)
6498 range->throughput = 5000 * 1000;
6499 else
6500 range->throughput = 1500 * 1000;
6501
6502 range->min_rts = 0;
6503 range->max_rts = 2312;
6504 range->min_frag = 256;
6505 range->max_frag = 2312;
6506
6507 if(cap_rid.softCap & 2) {
6508 // WEP: RC4 40 bits
6509 range->encoding_size[0] = 5;
6510 // RC4 ~128 bits
6511 if (cap_rid.softCap & 0x100) {
6512 range->encoding_size[1] = 13;
6513 range->num_encoding_sizes = 2;
6514 } else
6515 range->num_encoding_sizes = 1;
6516 range->max_encoding_tokens = (cap_rid.softCap & 0x80) ? 4 : 1;
6517 } else {
6518 range->num_encoding_sizes = 0;
6519 range->max_encoding_tokens = 0;
6520 }
6521 range->min_pmp = 0;
6522 range->max_pmp = 5000000; /* 5 secs */
6523 range->min_pmt = 0;
6524 range->max_pmt = 65535 * 1024; /* ??? */
6525 range->pmp_flags = IW_POWER_PERIOD;
6526 range->pmt_flags = IW_POWER_TIMEOUT;
6527 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
6528
6529 /* Transmit Power - values are in mW */
6530 for(i = 0 ; i < 8 ; i++) {
6531 range->txpower[i] = cap_rid.txPowerLevels[i];
6532 if(range->txpower[i] == 0)
6533 break;
6534 }
6535 range->num_txpower = i;
6536 range->txpower_capa = IW_TXPOW_MWATT;
6537 range->we_version_source = 12;
6538 range->we_version_compiled = WIRELESS_EXT;
6539 range->retry_capa = IW_RETRY_LIMIT | IW_RETRY_LIFETIME;
6540 range->retry_flags = IW_RETRY_LIMIT;
6541 range->r_time_flags = IW_RETRY_LIFETIME;
6542 range->min_retry = 1;
6543 range->max_retry = 65535;
6544 range->min_r_time = 1024;
6545 range->max_r_time = 65535 * 1024;
6546
6547 /* Event capability (kernel + driver) */
6548 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
6549 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
6550 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
6551 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
6552 range->event_capa[1] = IW_EVENT_CAPA_K_1;
6553 range->event_capa[4] = IW_EVENT_CAPA_MASK(IWEVTXDROP);
6554 return 0;
6555 }
6556
6557 /*------------------------------------------------------------------*/
6558 /*
6559 * Wireless Handler : set Power Management
6560 */
6561 static int airo_set_power(struct net_device *dev,
6562 struct iw_request_info *info,
6563 struct iw_param *vwrq,
6564 char *extra)
6565 {
6566 struct airo_info *local = dev->priv;
6567
6568 readConfigRid(local, 1);
6569 if (vwrq->disabled) {
6570 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6571 return -EINVAL;
6572 }
6573 local->config.powerSaveMode = POWERSAVE_CAM;
6574 local->config.rmode &= 0xFF00;
6575 local->config.rmode |= RXMODE_BC_MC_ADDR;
6576 set_bit (FLAG_COMMIT, &local->flags);
6577 return -EINPROGRESS; /* Call commit handler */
6578 }
6579 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
6580 local->config.fastListenDelay = (vwrq->value + 500) / 1024;
6581 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6582 set_bit (FLAG_COMMIT, &local->flags);
6583 } else if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
6584 local->config.fastListenInterval = local->config.listenInterval = (vwrq->value + 500) / 1024;
6585 local->config.powerSaveMode = POWERSAVE_PSPCAM;
6586 set_bit (FLAG_COMMIT, &local->flags);
6587 }
6588 switch (vwrq->flags & IW_POWER_MODE) {
6589 case IW_POWER_UNICAST_R:
6590 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6591 return -EINVAL;
6592 }
6593 local->config.rmode &= 0xFF00;
6594 local->config.rmode |= RXMODE_ADDR;
6595 set_bit (FLAG_COMMIT, &local->flags);
6596 break;
6597 case IW_POWER_ALL_R:
6598 if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) {
6599 return -EINVAL;
6600 }
6601 local->config.rmode &= 0xFF00;
6602 local->config.rmode |= RXMODE_BC_MC_ADDR;
6603 set_bit (FLAG_COMMIT, &local->flags);
6604 case IW_POWER_ON:
6605 break;
6606 default:
6607 return -EINVAL;
6608 }
6609 // Note : we may want to factor local->need_commit here
6610 // Note2 : may also want to factor RXMODE_RFMON test
6611 return -EINPROGRESS; /* Call commit handler */
6612 }
6613
6614 /*------------------------------------------------------------------*/
6615 /*
6616 * Wireless Handler : get Power Management
6617 */
6618 static int airo_get_power(struct net_device *dev,
6619 struct iw_request_info *info,
6620 struct iw_param *vwrq,
6621 char *extra)
6622 {
6623 struct airo_info *local = dev->priv;
6624 int mode;
6625
6626 readConfigRid(local, 1);
6627 mode = local->config.powerSaveMode;
6628 if ((vwrq->disabled = (mode == POWERSAVE_CAM)))
6629 return 0;
6630 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
6631 vwrq->value = (int)local->config.fastListenDelay * 1024;
6632 vwrq->flags = IW_POWER_TIMEOUT;
6633 } else {
6634 vwrq->value = (int)local->config.fastListenInterval * 1024;
6635 vwrq->flags = IW_POWER_PERIOD;
6636 }
6637 if ((local->config.rmode & 0xFF) == RXMODE_ADDR)
6638 vwrq->flags |= IW_POWER_UNICAST_R;
6639 else
6640 vwrq->flags |= IW_POWER_ALL_R;
6641
6642 return 0;
6643 }
6644
6645 /*------------------------------------------------------------------*/
6646 /*
6647 * Wireless Handler : set Sensitivity
6648 */
6649 static int airo_set_sens(struct net_device *dev,
6650 struct iw_request_info *info,
6651 struct iw_param *vwrq,
6652 char *extra)
6653 {
6654 struct airo_info *local = dev->priv;
6655
6656 readConfigRid(local, 1);
6657 local->config.rssiThreshold = vwrq->disabled ? RSSI_DEFAULT : vwrq->value;
6658 set_bit (FLAG_COMMIT, &local->flags);
6659
6660 return -EINPROGRESS; /* Call commit handler */
6661 }
6662
6663 /*------------------------------------------------------------------*/
6664 /*
6665 * Wireless Handler : get Sensitivity
6666 */
6667 static int airo_get_sens(struct net_device *dev,
6668 struct iw_request_info *info,
6669 struct iw_param *vwrq,
6670 char *extra)
6671 {
6672 struct airo_info *local = dev->priv;
6673
6674 readConfigRid(local, 1);
6675 vwrq->value = local->config.rssiThreshold;
6676 vwrq->disabled = (vwrq->value == 0);
6677 vwrq->fixed = 1;
6678
6679 return 0;
6680 }
6681
6682 /*------------------------------------------------------------------*/
6683 /*
6684 * Wireless Handler : get AP List
6685 * Note : this is deprecated in favor of IWSCAN
6686 */
6687 static int airo_get_aplist(struct net_device *dev,
6688 struct iw_request_info *info,
6689 struct iw_point *dwrq,
6690 char *extra)
6691 {
6692 struct airo_info *local = dev->priv;
6693 struct sockaddr *address = (struct sockaddr *) extra;
6694 struct iw_quality qual[IW_MAX_AP];
6695 BSSListRid BSSList;
6696 int i;
6697 int loseSync = capable(CAP_NET_ADMIN) ? 1: -1;
6698
6699 for (i = 0; i < IW_MAX_AP; i++) {
6700 if (readBSSListRid(local, loseSync, &BSSList))
6701 break;
6702 loseSync = 0;
6703 memcpy(address[i].sa_data, BSSList.bssid, ETH_ALEN);
6704 address[i].sa_family = ARPHRD_ETHER;
6705 if (local->rssi) {
6706 qual[i].level = 0x100 - BSSList.dBm;
6707 qual[i].qual = airo_dbm_to_pct( local->rssi, BSSList.dBm );
6708 qual[i].updated = IW_QUAL_QUAL_UPDATED
6709 | IW_QUAL_LEVEL_UPDATED
6710 | IW_QUAL_DBM;
6711 } else {
6712 qual[i].level = (BSSList.dBm + 321) / 2;
6713 qual[i].qual = 0;
6714 qual[i].updated = IW_QUAL_QUAL_INVALID
6715 | IW_QUAL_LEVEL_UPDATED
6716 | IW_QUAL_DBM;
6717 }
6718 qual[i].noise = local->wstats.qual.noise;
6719 if (BSSList.index == 0xffff)
6720 break;
6721 }
6722 if (!i) {
6723 StatusRid status_rid; /* Card status info */
6724 readStatusRid(local, &status_rid, 1);
6725 for (i = 0;
6726 i < min(IW_MAX_AP, 4) &&
6727 (status_rid.bssid[i][0]
6728 & status_rid.bssid[i][1]
6729 & status_rid.bssid[i][2]
6730 & status_rid.bssid[i][3]
6731 & status_rid.bssid[i][4]
6732 & status_rid.bssid[i][5])!=0xff &&
6733 (status_rid.bssid[i][0]
6734 | status_rid.bssid[i][1]
6735 | status_rid.bssid[i][2]
6736 | status_rid.bssid[i][3]
6737 | status_rid.bssid[i][4]
6738 | status_rid.bssid[i][5]);
6739 i++) {
6740 memcpy(address[i].sa_data,
6741 status_rid.bssid[i], ETH_ALEN);
6742 address[i].sa_family = ARPHRD_ETHER;
6743 }
6744 } else {
6745 dwrq->flags = 1; /* Should be define'd */
6746 memcpy(extra + sizeof(struct sockaddr)*i,
6747 &qual, sizeof(struct iw_quality)*i);
6748 }
6749 dwrq->length = i;
6750
6751 return 0;
6752 }
6753
6754 /*------------------------------------------------------------------*/
6755 /*
6756 * Wireless Handler : Initiate Scan
6757 */
6758 static int airo_set_scan(struct net_device *dev,
6759 struct iw_request_info *info,
6760 struct iw_param *vwrq,
6761 char *extra)
6762 {
6763 struct airo_info *ai = dev->priv;
6764 Cmd cmd;
6765 Resp rsp;
6766
6767 /* Note : you may have realised that, as this is a SET operation,
6768 * this is privileged and therefore a normal user can't
6769 * perform scanning.
6770 * This is not an error, while the device perform scanning,
6771 * traffic doesn't flow, so it's a perfect DoS...
6772 * Jean II */
6773 if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
6774
6775 /* Initiate a scan command */
6776 memset(&cmd, 0, sizeof(cmd));
6777 cmd.cmd=CMD_LISTBSS;
6778 if (down_interruptible(&ai->sem))
6779 return -ERESTARTSYS;
6780 issuecommand(ai, &cmd, &rsp);
6781 ai->scan_timestamp = jiffies;
6782 up(&ai->sem);
6783
6784 /* At this point, just return to the user. */
6785
6786 return 0;
6787 }
6788
6789 /*------------------------------------------------------------------*/
6790 /*
6791 * Translate scan data returned from the card to a card independent
6792 * format that the Wireless Tools will understand - Jean II
6793 */
6794 static inline char *airo_translate_scan(struct net_device *dev,
6795 char *current_ev,
6796 char *end_buf,
6797 BSSListRid *bss)
6798 {
6799 struct airo_info *ai = dev->priv;
6800 struct iw_event iwe; /* Temporary buffer */
6801 u16 capabilities;
6802 char * current_val; /* For rates */
6803 int i;
6804
6805 /* First entry *MUST* be the AP MAC address */
6806 iwe.cmd = SIOCGIWAP;
6807 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
6808 memcpy(iwe.u.ap_addr.sa_data, bss->bssid, ETH_ALEN);
6809 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_ADDR_LEN);
6810
6811 /* Other entries will be displayed in the order we give them */
6812
6813 /* Add the ESSID */
6814 iwe.u.data.length = bss->ssidLen;
6815 if(iwe.u.data.length > 32)
6816 iwe.u.data.length = 32;
6817 iwe.cmd = SIOCGIWESSID;
6818 iwe.u.data.flags = 1;
6819 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, bss->ssid);
6820
6821 /* Add mode */
6822 iwe.cmd = SIOCGIWMODE;
6823 capabilities = le16_to_cpu(bss->cap);
6824 if(capabilities & (CAP_ESS | CAP_IBSS)) {
6825 if(capabilities & CAP_ESS)
6826 iwe.u.mode = IW_MODE_MASTER;
6827 else
6828 iwe.u.mode = IW_MODE_ADHOC;
6829 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_UINT_LEN);
6830 }
6831
6832 /* Add frequency */
6833 iwe.cmd = SIOCGIWFREQ;
6834 iwe.u.freq.m = le16_to_cpu(bss->dsChannel);
6835 /* iwe.u.freq.m containt the channel (starting 1), our
6836 * frequency_list array start at index 0...
6837 */
6838 iwe.u.freq.m = frequency_list[iwe.u.freq.m - 1] * 100000;
6839 iwe.u.freq.e = 1;
6840 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_FREQ_LEN);
6841
6842 /* Add quality statistics */
6843 iwe.cmd = IWEVQUAL;
6844 if (ai->rssi) {
6845 iwe.u.qual.level = 0x100 - bss->dBm;
6846 iwe.u.qual.qual = airo_dbm_to_pct( ai->rssi, bss->dBm );
6847 iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED
6848 | IW_QUAL_LEVEL_UPDATED
6849 | IW_QUAL_DBM;
6850 } else {
6851 iwe.u.qual.level = (bss->dBm + 321) / 2;
6852 iwe.u.qual.qual = 0;
6853 iwe.u.qual.updated = IW_QUAL_QUAL_INVALID
6854 | IW_QUAL_LEVEL_UPDATED
6855 | IW_QUAL_DBM;
6856 }
6857 iwe.u.qual.noise = ai->wstats.qual.noise;
6858 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
6859
6860 /* Add encryption capability */
6861 iwe.cmd = SIOCGIWENCODE;
6862 if(capabilities & CAP_PRIVACY)
6863 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
6864 else
6865 iwe.u.data.flags = IW_ENCODE_DISABLED;
6866 iwe.u.data.length = 0;
6867 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, bss->ssid);
6868
6869 /* Rate : stuffing multiple values in a single event require a bit
6870 * more of magic - Jean II */
6871 current_val = current_ev + IW_EV_LCP_LEN;
6872
6873 iwe.cmd = SIOCGIWRATE;
6874 /* Those two flags are ignored... */
6875 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
6876 /* Max 8 values */
6877 for(i = 0 ; i < 8 ; i++) {
6878 /* NULL terminated */
6879 if(bss->rates[i] == 0)
6880 break;
6881 /* Bit rate given in 500 kb/s units (+ 0x80) */
6882 iwe.u.bitrate.value = ((bss->rates[i] & 0x7f) * 500000);
6883 /* Add new value to event */
6884 current_val = iwe_stream_add_value(current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
6885 }
6886 /* Check if we added any event */
6887 if((current_val - current_ev) > IW_EV_LCP_LEN)
6888 current_ev = current_val;
6889
6890 /* The other data in the scan result are not really
6891 * interesting, so for now drop it - Jean II */
6892 return current_ev;
6893 }
6894
6895 /*------------------------------------------------------------------*/
6896 /*
6897 * Wireless Handler : Read Scan Results
6898 */
6899 static int airo_get_scan(struct net_device *dev,
6900 struct iw_request_info *info,
6901 struct iw_point *dwrq,
6902 char *extra)
6903 {
6904 struct airo_info *ai = dev->priv;
6905 BSSListRid BSSList;
6906 int rc;
6907 char *current_ev = extra;
6908
6909 /* When we are associated again, the scan has surely finished.
6910 * Just in case, let's make sure enough time has elapsed since
6911 * we started the scan. - Javier */
6912 if(ai->scan_timestamp && time_before(jiffies,ai->scan_timestamp+3*HZ)) {
6913 /* Important note : we don't want to block the caller
6914 * until results are ready for various reasons.
6915 * First, managing wait queues is complex and racy
6916 * (there may be multiple simultaneous callers).
6917 * Second, we grab some rtnetlink lock before comming
6918 * here (in dev_ioctl()).
6919 * Third, the caller can wait on the Wireless Event
6920 * - Jean II */
6921 return -EAGAIN;
6922 }
6923 ai->scan_timestamp = 0;
6924
6925 /* There's only a race with proc_BSSList_open(), but its
6926 * consequences are begnign. So I don't bother fixing it - Javier */
6927
6928 /* Try to read the first entry of the scan result */
6929 rc = PC4500_readrid(ai, RID_BSSLISTFIRST, &BSSList, sizeof(BSSList), 1);
6930 if((rc) || (BSSList.index == 0xffff)) {
6931 /* Client error, no scan results...
6932 * The caller need to restart the scan. */
6933 return -ENODATA;
6934 }
6935
6936 /* Read and parse all entries */
6937 while((!rc) && (BSSList.index != 0xffff)) {
6938 /* Translate to WE format this entry */
6939 current_ev = airo_translate_scan(dev, current_ev,
6940 extra + dwrq->length,
6941 &BSSList);
6942
6943 /* Check if there is space for one more entry */
6944 if((extra + dwrq->length - current_ev) <= IW_EV_ADDR_LEN) {
6945 /* Ask user space to try again with a bigger buffer */
6946 return -E2BIG;
6947 }
6948
6949 /* Read next entry */
6950 rc = PC4500_readrid(ai, RID_BSSLISTNEXT,
6951 &BSSList, sizeof(BSSList), 1);
6952 }
6953 /* Length of data */
6954 dwrq->length = (current_ev - extra);
6955 dwrq->flags = 0; /* todo */
6956
6957 return 0;
6958 }
6959
6960 /*------------------------------------------------------------------*/
6961 /*
6962 * Commit handler : called after a bunch of SET operations
6963 */
6964 static int airo_config_commit(struct net_device *dev,
6965 struct iw_request_info *info, /* NULL */
6966 void *zwrq, /* NULL */
6967 char *extra) /* NULL */
6968 {
6969 struct airo_info *local = dev->priv;
6970 Resp rsp;
6971
6972 if (!test_bit (FLAG_COMMIT, &local->flags))
6973 return 0;
6974
6975 /* Some of the "SET" function may have modified some of the
6976 * parameters. It's now time to commit them in the card */
6977 disable_MAC(local, 1);
6978 if (test_bit (FLAG_RESET, &local->flags)) {
6979 APListRid APList_rid;
6980 SsidRid SSID_rid;
6981
6982 readAPListRid(local, &APList_rid);
6983 readSsidRid(local, &SSID_rid);
6984 if (test_bit(FLAG_MPI,&local->flags))
6985 setup_card(local, dev->dev_addr, 1 );
6986 else
6987 reset_airo_card(dev);
6988 disable_MAC(local, 1);
6989 writeSsidRid(local, &SSID_rid, 1);
6990 writeAPListRid(local, &APList_rid, 1);
6991 }
6992 if (down_interruptible(&local->sem))
6993 return -ERESTARTSYS;
6994 writeConfigRid(local, 0);
6995 enable_MAC(local, &rsp, 0);
6996 if (test_bit (FLAG_RESET, &local->flags))
6997 airo_set_promisc(local);
6998 else
6999 up(&local->sem);
7000
7001 return 0;
7002 }
7003
7004 /*------------------------------------------------------------------*/
7005 /*
7006 * Structures to export the Wireless Handlers
7007 */
7008
7009 static const struct iw_priv_args airo_private_args[] = {
7010 /*{ cmd, set_args, get_args, name } */
7011 { AIROIOCTL, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
7012 IW_PRIV_TYPE_BYTE | 2047, "airoioctl" },
7013 { AIROIDIFC, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
7014 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "airoidifc" },
7015 };
7016
7017 static const iw_handler airo_handler[] =
7018 {
7019 (iw_handler) airo_config_commit, /* SIOCSIWCOMMIT */
7020 (iw_handler) airo_get_name, /* SIOCGIWNAME */
7021 (iw_handler) NULL, /* SIOCSIWNWID */
7022 (iw_handler) NULL, /* SIOCGIWNWID */
7023 (iw_handler) airo_set_freq, /* SIOCSIWFREQ */
7024 (iw_handler) airo_get_freq, /* SIOCGIWFREQ */
7025 (iw_handler) airo_set_mode, /* SIOCSIWMODE */
7026 (iw_handler) airo_get_mode, /* SIOCGIWMODE */
7027 (iw_handler) airo_set_sens, /* SIOCSIWSENS */
7028 (iw_handler) airo_get_sens, /* SIOCGIWSENS */
7029 (iw_handler) NULL, /* SIOCSIWRANGE */
7030 (iw_handler) airo_get_range, /* SIOCGIWRANGE */
7031 (iw_handler) NULL, /* SIOCSIWPRIV */
7032 (iw_handler) NULL, /* SIOCGIWPRIV */
7033 (iw_handler) NULL, /* SIOCSIWSTATS */
7034 (iw_handler) NULL, /* SIOCGIWSTATS */
7035 iw_handler_set_spy, /* SIOCSIWSPY */
7036 iw_handler_get_spy, /* SIOCGIWSPY */
7037 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
7038 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
7039 (iw_handler) airo_set_wap, /* SIOCSIWAP */
7040 (iw_handler) airo_get_wap, /* SIOCGIWAP */
7041 (iw_handler) NULL, /* -- hole -- */
7042 (iw_handler) airo_get_aplist, /* SIOCGIWAPLIST */
7043 (iw_handler) airo_set_scan, /* SIOCSIWSCAN */
7044 (iw_handler) airo_get_scan, /* SIOCGIWSCAN */
7045 (iw_handler) airo_set_essid, /* SIOCSIWESSID */
7046 (iw_handler) airo_get_essid, /* SIOCGIWESSID */
7047 (iw_handler) airo_set_nick, /* SIOCSIWNICKN */
7048 (iw_handler) airo_get_nick, /* SIOCGIWNICKN */
7049 (iw_handler) NULL, /* -- hole -- */
7050 (iw_handler) NULL, /* -- hole -- */
7051 (iw_handler) airo_set_rate, /* SIOCSIWRATE */
7052 (iw_handler) airo_get_rate, /* SIOCGIWRATE */
7053 (iw_handler) airo_set_rts, /* SIOCSIWRTS */
7054 (iw_handler) airo_get_rts, /* SIOCGIWRTS */
7055 (iw_handler) airo_set_frag, /* SIOCSIWFRAG */
7056 (iw_handler) airo_get_frag, /* SIOCGIWFRAG */
7057 (iw_handler) airo_set_txpow, /* SIOCSIWTXPOW */
7058 (iw_handler) airo_get_txpow, /* SIOCGIWTXPOW */
7059 (iw_handler) airo_set_retry, /* SIOCSIWRETRY */
7060 (iw_handler) airo_get_retry, /* SIOCGIWRETRY */
7061 (iw_handler) airo_set_encode, /* SIOCSIWENCODE */
7062 (iw_handler) airo_get_encode, /* SIOCGIWENCODE */
7063 (iw_handler) airo_set_power, /* SIOCSIWPOWER */
7064 (iw_handler) airo_get_power, /* SIOCGIWPOWER */
7065 };
7066
7067 /* Note : don't describe AIROIDIFC and AIROOLDIDIFC in here.
7068 * We want to force the use of the ioctl code, because those can't be
7069 * won't work the iw_handler code (because they simultaneously read
7070 * and write data and iw_handler can't do that).
7071 * Note that it's perfectly legal to read/write on a single ioctl command,
7072 * you just can't use iwpriv and need to force it via the ioctl handler.
7073 * Jean II */
7074 static const iw_handler airo_private_handler[] =
7075 {
7076 NULL, /* SIOCIWFIRSTPRIV */
7077 };
7078
7079 static const struct iw_handler_def airo_handler_def =
7080 {
7081 .num_standard = sizeof(airo_handler)/sizeof(iw_handler),
7082 .num_private = sizeof(airo_private_handler)/sizeof(iw_handler),
7083 .num_private_args = sizeof(airo_private_args)/sizeof(struct iw_priv_args),
7084 .standard = airo_handler,
7085 .private = airo_private_handler,
7086 .private_args = airo_private_args,
7087 .get_wireless_stats = airo_get_wireless_stats,
7088 };
7089
7090 /*
7091 * This defines the configuration part of the Wireless Extensions
7092 * Note : irq and spinlock protection will occur in the subroutines
7093 *
7094 * TODO :
7095 * o Check input value more carefully and fill correct values in range
7096 * o Test and shakeout the bugs (if any)
7097 *
7098 * Jean II
7099 *
7100 * Javier Achirica did a great job of merging code from the unnamed CISCO
7101 * developer that added support for flashing the card.
7102 */
7103 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
7104 {
7105 int rc = 0;
7106 struct airo_info *ai = (struct airo_info *)dev->priv;
7107
7108 if (ai->power.event)
7109 return 0;
7110
7111 switch (cmd) {
7112 #ifdef CISCO_EXT
7113 case AIROIDIFC:
7114 #ifdef AIROOLDIDIFC
7115 case AIROOLDIDIFC:
7116 #endif
7117 {
7118 int val = AIROMAGIC;
7119 aironet_ioctl com;
7120 if (copy_from_user(&com,rq->ifr_data,sizeof(com)))
7121 rc = -EFAULT;
7122 else if (copy_to_user(com.data,(char *)&val,sizeof(val)))
7123 rc = -EFAULT;
7124 }
7125 break;
7126
7127 case AIROIOCTL:
7128 #ifdef AIROOLDIOCTL
7129 case AIROOLDIOCTL:
7130 #endif
7131 /* Get the command struct and hand it off for evaluation by
7132 * the proper subfunction
7133 */
7134 {
7135 aironet_ioctl com;
7136 if (copy_from_user(&com,rq->ifr_data,sizeof(com))) {
7137 rc = -EFAULT;
7138 break;
7139 }
7140
7141 /* Separate R/W functions bracket legality here
7142 */
7143 if ( com.command == AIRORSWVERSION ) {
7144 if (copy_to_user(com.data, swversion, sizeof(swversion)))
7145 rc = -EFAULT;
7146 else
7147 rc = 0;
7148 }
7149 else if ( com.command <= AIRORRID)
7150 rc = readrids(dev,&com);
7151 else if ( com.command >= AIROPCAP && com.command <= (AIROPLEAPUSR+2) )
7152 rc = writerids(dev,&com);
7153 else if ( com.command >= AIROFLSHRST && com.command <= AIRORESTART )
7154 rc = flashcard(dev,&com);
7155 else
7156 rc = -EINVAL; /* Bad command in ioctl */
7157 }
7158 break;
7159 #endif /* CISCO_EXT */
7160
7161 // All other calls are currently unsupported
7162 default:
7163 rc = -EOPNOTSUPP;
7164 }
7165 return rc;
7166 }
7167
7168 /*
7169 * Get the Wireless stats out of the driver
7170 * Note : irq and spinlock protection will occur in the subroutines
7171 *
7172 * TODO :
7173 * o Check if work in Ad-Hoc mode (otherwise, use SPY, as in wvlan_cs)
7174 *
7175 * Jean
7176 */
7177 static void airo_read_wireless_stats(struct airo_info *local)
7178 {
7179 StatusRid status_rid;
7180 StatsRid stats_rid;
7181 CapabilityRid cap_rid;
7182 u32 *vals = stats_rid.vals;
7183
7184 /* Get stats out of the card */
7185 clear_bit(JOB_WSTATS, &local->flags);
7186 if (local->power.event) {
7187 up(&local->sem);
7188 return;
7189 }
7190 readCapabilityRid(local, &cap_rid, 0);
7191 readStatusRid(local, &status_rid, 0);
7192 readStatsRid(local, &stats_rid, RID_STATS, 0);
7193 up(&local->sem);
7194
7195 /* The status */
7196 local->wstats.status = status_rid.mode;
7197
7198 /* Signal quality and co */
7199 if (local->rssi) {
7200 local->wstats.qual.level = airo_rssi_to_dbm( local->rssi, status_rid.sigQuality );
7201 /* normalizedSignalStrength appears to be a percentage */
7202 local->wstats.qual.qual = status_rid.normalizedSignalStrength;
7203 } else {
7204 local->wstats.qual.level = (status_rid.normalizedSignalStrength + 321) / 2;
7205 local->wstats.qual.qual = airo_get_quality(&status_rid, &cap_rid);
7206 }
7207 if (status_rid.len >= 124) {
7208 local->wstats.qual.noise = 0x100 - status_rid.noisedBm;
7209 local->wstats.qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
7210 } else {
7211 local->wstats.qual.noise = 0;
7212 local->wstats.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_INVALID | IW_QUAL_DBM;
7213 }
7214
7215 /* Packets discarded in the wireless adapter due to wireless
7216 * specific problems */
7217 local->wstats.discard.nwid = vals[56] + vals[57] + vals[58];/* SSID Mismatch */
7218 local->wstats.discard.code = vals[6];/* RxWepErr */
7219 local->wstats.discard.fragment = vals[30];
7220 local->wstats.discard.retries = vals[10];
7221 local->wstats.discard.misc = vals[1] + vals[32];
7222 local->wstats.miss.beacon = vals[34];
7223 }
7224
7225 static struct iw_statistics *airo_get_wireless_stats(struct net_device *dev)
7226 {
7227 struct airo_info *local = dev->priv;
7228
7229 if (!test_bit(JOB_WSTATS, &local->flags)) {
7230 /* Get stats out of the card if available */
7231 if (down_trylock(&local->sem) != 0) {
7232 set_bit(JOB_WSTATS, &local->flags);
7233 wake_up_interruptible(&local->thr_wait);
7234 } else
7235 airo_read_wireless_stats(local);
7236 }
7237
7238 return &local->wstats;
7239 }
7240
7241 #ifdef CISCO_EXT
7242 /*
7243 * This just translates from driver IOCTL codes to the command codes to
7244 * feed to the radio's host interface. Things can be added/deleted
7245 * as needed. This represents the READ side of control I/O to
7246 * the card
7247 */
7248 static int readrids(struct net_device *dev, aironet_ioctl *comp) {
7249 unsigned short ridcode;
7250 unsigned char *iobuf;
7251 int len;
7252 struct airo_info *ai = dev->priv;
7253 Resp rsp;
7254
7255 if (test_bit(FLAG_FLASHING, &ai->flags))
7256 return -EIO;
7257
7258 switch(comp->command)
7259 {
7260 case AIROGCAP: ridcode = RID_CAPABILITIES; break;
7261 case AIROGCFG: ridcode = RID_CONFIG;
7262 if (test_bit(FLAG_COMMIT, &ai->flags)) {
7263 disable_MAC (ai, 1);
7264 writeConfigRid (ai, 1);
7265 enable_MAC (ai, &rsp, 1);
7266 }
7267 break;
7268 case AIROGSLIST: ridcode = RID_SSID; break;
7269 case AIROGVLIST: ridcode = RID_APLIST; break;
7270 case AIROGDRVNAM: ridcode = RID_DRVNAME; break;
7271 case AIROGEHTENC: ridcode = RID_ETHERENCAP; break;
7272 case AIROGWEPKTMP: ridcode = RID_WEP_TEMP;
7273 /* Only super-user can read WEP keys */
7274 if (!capable(CAP_NET_ADMIN))
7275 return -EPERM;
7276 break;
7277 case AIROGWEPKNV: ridcode = RID_WEP_PERM;
7278 /* Only super-user can read WEP keys */
7279 if (!capable(CAP_NET_ADMIN))
7280 return -EPERM;
7281 break;
7282 case AIROGSTAT: ridcode = RID_STATUS; break;
7283 case AIROGSTATSD32: ridcode = RID_STATSDELTA; break;
7284 case AIROGSTATSC32: ridcode = RID_STATS; break;
7285 #ifdef MICSUPPORT
7286 case AIROGMICSTATS:
7287 if (copy_to_user(comp->data, &ai->micstats,
7288 min((int)comp->len,(int)sizeof(ai->micstats))))
7289 return -EFAULT;
7290 return 0;
7291 #endif
7292 case AIRORRID: ridcode = comp->ridnum; break;
7293 default:
7294 return -EINVAL;
7295 break;
7296 }
7297
7298 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7299 return -ENOMEM;
7300
7301 PC4500_readrid(ai,ridcode,iobuf,RIDSIZE, 1);
7302 /* get the count of bytes in the rid docs say 1st 2 bytes is it.
7303 * then return it to the user
7304 * 9/22/2000 Honor user given length
7305 */
7306 len = comp->len;
7307
7308 if (copy_to_user(comp->data, iobuf, min(len, (int)RIDSIZE))) {
7309 kfree (iobuf);
7310 return -EFAULT;
7311 }
7312 kfree (iobuf);
7313 return 0;
7314 }
7315
7316 /*
7317 * Danger Will Robinson write the rids here
7318 */
7319
7320 static int writerids(struct net_device *dev, aironet_ioctl *comp) {
7321 struct airo_info *ai = dev->priv;
7322 int ridcode;
7323 #ifdef MICSUPPORT
7324 int enabled;
7325 #endif
7326 Resp rsp;
7327 static int (* writer)(struct airo_info *, u16 rid, const void *, int, int);
7328 unsigned char *iobuf;
7329
7330 /* Only super-user can write RIDs */
7331 if (!capable(CAP_NET_ADMIN))
7332 return -EPERM;
7333
7334 if (test_bit(FLAG_FLASHING, &ai->flags))
7335 return -EIO;
7336
7337 ridcode = 0;
7338 writer = do_writerid;
7339
7340 switch(comp->command)
7341 {
7342 case AIROPSIDS: ridcode = RID_SSID; break;
7343 case AIROPCAP: ridcode = RID_CAPABILITIES; break;
7344 case AIROPAPLIST: ridcode = RID_APLIST; break;
7345 case AIROPCFG: ai->config.len = 0;
7346 clear_bit(FLAG_COMMIT, &ai->flags);
7347 ridcode = RID_CONFIG; break;
7348 case AIROPWEPKEYNV: ridcode = RID_WEP_PERM; break;
7349 case AIROPLEAPUSR: ridcode = RID_LEAPUSERNAME; break;
7350 case AIROPLEAPPWD: ridcode = RID_LEAPPASSWORD; break;
7351 case AIROPWEPKEY: ridcode = RID_WEP_TEMP; writer = PC4500_writerid;
7352 break;
7353 case AIROPLEAPUSR+1: ridcode = 0xFF2A; break;
7354 case AIROPLEAPUSR+2: ridcode = 0xFF2B; break;
7355
7356 /* this is not really a rid but a command given to the card
7357 * same with MAC off
7358 */
7359 case AIROPMACON:
7360 if (enable_MAC(ai, &rsp, 1) != 0)
7361 return -EIO;
7362 return 0;
7363
7364 /*
7365 * Evidently this code in the airo driver does not get a symbol
7366 * as disable_MAC. it's probably so short the compiler does not gen one.
7367 */
7368 case AIROPMACOFF:
7369 disable_MAC(ai, 1);
7370 return 0;
7371
7372 /* This command merely clears the counts does not actually store any data
7373 * only reads rid. But as it changes the cards state, I put it in the
7374 * writerid routines.
7375 */
7376 case AIROPSTCLR:
7377 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7378 return -ENOMEM;
7379
7380 PC4500_readrid(ai,RID_STATSDELTACLEAR,iobuf,RIDSIZE, 1);
7381
7382 #ifdef MICSUPPORT
7383 enabled = ai->micstats.enabled;
7384 memset(&ai->micstats,0,sizeof(ai->micstats));
7385 ai->micstats.enabled = enabled;
7386 #endif
7387
7388 if (copy_to_user(comp->data, iobuf,
7389 min((int)comp->len, (int)RIDSIZE))) {
7390 kfree (iobuf);
7391 return -EFAULT;
7392 }
7393 kfree (iobuf);
7394 return 0;
7395
7396 default:
7397 return -EOPNOTSUPP; /* Blarg! */
7398 }
7399 if(comp->len > RIDSIZE)
7400 return -EINVAL;
7401
7402 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7403 return -ENOMEM;
7404
7405 if (copy_from_user(iobuf,comp->data,comp->len)) {
7406 kfree (iobuf);
7407 return -EFAULT;
7408 }
7409
7410 if (comp->command == AIROPCFG) {
7411 ConfigRid *cfg = (ConfigRid *)iobuf;
7412
7413 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags))
7414 cfg->opmode |= MODE_MIC;
7415
7416 if ((cfg->opmode & 0xFF) == MODE_STA_IBSS)
7417 set_bit (FLAG_ADHOC, &ai->flags);
7418 else
7419 clear_bit (FLAG_ADHOC, &ai->flags);
7420 }
7421
7422 if((*writer)(ai, ridcode, iobuf,comp->len,1)) {
7423 kfree (iobuf);
7424 return -EIO;
7425 }
7426 kfree (iobuf);
7427 return 0;
7428 }
7429
7430 /*****************************************************************************
7431 * Ancillary flash / mod functions much black magic lurkes here *
7432 *****************************************************************************
7433 */
7434
7435 /*
7436 * Flash command switch table
7437 */
7438
7439 static int flashcard(struct net_device *dev, aironet_ioctl *comp) {
7440 int z;
7441
7442 /* Only super-user can modify flash */
7443 if (!capable(CAP_NET_ADMIN))
7444 return -EPERM;
7445
7446 switch(comp->command)
7447 {
7448 case AIROFLSHRST:
7449 return cmdreset((struct airo_info *)dev->priv);
7450
7451 case AIROFLSHSTFL:
7452 if (!((struct airo_info *)dev->priv)->flash &&
7453 (((struct airo_info *)dev->priv)->flash = kmalloc (FLASHSIZE, GFP_KERNEL)) == NULL)
7454 return -ENOMEM;
7455 return setflashmode((struct airo_info *)dev->priv);
7456
7457 case AIROFLSHGCHR: /* Get char from aux */
7458 if(comp->len != sizeof(int))
7459 return -EINVAL;
7460 if (copy_from_user(&z,comp->data,comp->len))
7461 return -EFAULT;
7462 return flashgchar((struct airo_info *)dev->priv,z,8000);
7463
7464 case AIROFLSHPCHR: /* Send char to card. */
7465 if(comp->len != sizeof(int))
7466 return -EINVAL;
7467 if (copy_from_user(&z,comp->data,comp->len))
7468 return -EFAULT;
7469 return flashpchar((struct airo_info *)dev->priv,z,8000);
7470
7471 case AIROFLPUTBUF: /* Send 32k to card */
7472 if (!((struct airo_info *)dev->priv)->flash)
7473 return -ENOMEM;
7474 if(comp->len > FLASHSIZE)
7475 return -EINVAL;
7476 if(copy_from_user(((struct airo_info *)dev->priv)->flash,comp->data,comp->len))
7477 return -EFAULT;
7478
7479 flashputbuf((struct airo_info *)dev->priv);
7480 return 0;
7481
7482 case AIRORESTART:
7483 if(flashrestart((struct airo_info *)dev->priv,dev))
7484 return -EIO;
7485 return 0;
7486 }
7487 return -EINVAL;
7488 }
7489
7490 #define FLASH_COMMAND 0x7e7e
7491
7492 /*
7493 * STEP 1)
7494 * Disable MAC and do soft reset on
7495 * card.
7496 */
7497
7498 static int cmdreset(struct airo_info *ai) {
7499 disable_MAC(ai, 1);
7500
7501 if(!waitbusy (ai)){
7502 printk(KERN_INFO "Waitbusy hang before RESET\n");
7503 return -EBUSY;
7504 }
7505
7506 OUT4500(ai,COMMAND,CMD_SOFTRESET);
7507
7508 ssleep(1); /* WAS 600 12/7/00 */
7509
7510 if(!waitbusy (ai)){
7511 printk(KERN_INFO "Waitbusy hang AFTER RESET\n");
7512 return -EBUSY;
7513 }
7514 return 0;
7515 }
7516
7517 /* STEP 2)
7518 * Put the card in legendary flash
7519 * mode
7520 */
7521
7522 static int setflashmode (struct airo_info *ai) {
7523 set_bit (FLAG_FLASHING, &ai->flags);
7524
7525 OUT4500(ai, SWS0, FLASH_COMMAND);
7526 OUT4500(ai, SWS1, FLASH_COMMAND);
7527 if (probe) {
7528 OUT4500(ai, SWS0, FLASH_COMMAND);
7529 OUT4500(ai, COMMAND,0x10);
7530 } else {
7531 OUT4500(ai, SWS2, FLASH_COMMAND);
7532 OUT4500(ai, SWS3, FLASH_COMMAND);
7533 OUT4500(ai, COMMAND,0);
7534 }
7535 msleep(500); /* 500ms delay */
7536
7537 if(!waitbusy(ai)) {
7538 clear_bit (FLAG_FLASHING, &ai->flags);
7539 printk(KERN_INFO "Waitbusy hang after setflash mode\n");
7540 return -EIO;
7541 }
7542 return 0;
7543 }
7544
7545 /* Put character to SWS0 wait for dwelltime
7546 * x 50us for echo .
7547 */
7548
7549 static int flashpchar(struct airo_info *ai,int byte,int dwelltime) {
7550 int echo;
7551 int waittime;
7552
7553 byte |= 0x8000;
7554
7555 if(dwelltime == 0 )
7556 dwelltime = 200;
7557
7558 waittime=dwelltime;
7559
7560 /* Wait for busy bit d15 to go false indicating buffer empty */
7561 while ((IN4500 (ai, SWS0) & 0x8000) && waittime > 0) {
7562 udelay (50);
7563 waittime -= 50;
7564 }
7565
7566 /* timeout for busy clear wait */
7567 if(waittime <= 0 ){
7568 printk(KERN_INFO "flash putchar busywait timeout! \n");
7569 return -EBUSY;
7570 }
7571
7572 /* Port is clear now write byte and wait for it to echo back */
7573 do {
7574 OUT4500(ai,SWS0,byte);
7575 udelay(50);
7576 dwelltime -= 50;
7577 echo = IN4500(ai,SWS1);
7578 } while (dwelltime >= 0 && echo != byte);
7579
7580 OUT4500(ai,SWS1,0);
7581
7582 return (echo == byte) ? 0 : -EIO;
7583 }
7584
7585 /*
7586 * Get a character from the card matching matchbyte
7587 * Step 3)
7588 */
7589 static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime){
7590 int rchar;
7591 unsigned char rbyte=0;
7592
7593 do {
7594 rchar = IN4500(ai,SWS1);
7595
7596 if(dwelltime && !(0x8000 & rchar)){
7597 dwelltime -= 10;
7598 mdelay(10);
7599 continue;
7600 }
7601 rbyte = 0xff & rchar;
7602
7603 if( (rbyte == matchbyte) && (0x8000 & rchar) ){
7604 OUT4500(ai,SWS1,0);
7605 return 0;
7606 }
7607 if( rbyte == 0x81 || rbyte == 0x82 || rbyte == 0x83 || rbyte == 0x1a || 0xffff == rchar)
7608 break;
7609 OUT4500(ai,SWS1,0);
7610
7611 }while(dwelltime > 0);
7612 return -EIO;
7613 }
7614
7615 /*
7616 * Transfer 32k of firmware data from user buffer to our buffer and
7617 * send to the card
7618 */
7619
7620 static int flashputbuf(struct airo_info *ai){
7621 int nwords;
7622
7623 /* Write stuff */
7624 if (test_bit(FLAG_MPI,&ai->flags))
7625 memcpy_toio(ai->pciaux + 0x8000, ai->flash, FLASHSIZE);
7626 else {
7627 OUT4500(ai,AUXPAGE,0x100);
7628 OUT4500(ai,AUXOFF,0);
7629
7630 for(nwords=0;nwords != FLASHSIZE / 2;nwords++){
7631 OUT4500(ai,AUXDATA,ai->flash[nwords] & 0xffff);
7632 }
7633 }
7634 OUT4500(ai,SWS0,0x8000);
7635
7636 return 0;
7637 }
7638
7639 /*
7640 *
7641 */
7642 static int flashrestart(struct airo_info *ai,struct net_device *dev){
7643 int i,status;
7644
7645 ssleep(1); /* Added 12/7/00 */
7646 clear_bit (FLAG_FLASHING, &ai->flags);
7647 if (test_bit(FLAG_MPI, &ai->flags)) {
7648 status = mpi_init_descriptors(ai);
7649 if (status != SUCCESS)
7650 return status;
7651 }
7652 status = setup_card(ai, dev->dev_addr, 1);
7653
7654 if (!test_bit(FLAG_MPI,&ai->flags))
7655 for( i = 0; i < MAX_FIDS; i++ ) {
7656 ai->fids[i] = transmit_allocate
7657 ( ai, 2312, i >= MAX_FIDS / 2 );
7658 }
7659
7660 ssleep(1); /* Added 12/7/00 */
7661 return status;
7662 }
7663 #endif /* CISCO_EXT */
7664
7665 /*
7666 This program is free software; you can redistribute it and/or
7667 modify it under the terms of the GNU General Public License
7668 as published by the Free Software Foundation; either version 2
7669 of the License, or (at your option) any later version.
7670
7671 This program is distributed in the hope that it will be useful,
7672 but WITHOUT ANY WARRANTY; without even the implied warranty of
7673 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
7674 GNU General Public License for more details.
7675
7676 In addition:
7677
7678 Redistribution and use in source and binary forms, with or without
7679 modification, are permitted provided that the following conditions
7680 are met:
7681
7682 1. Redistributions of source code must retain the above copyright
7683 notice, this list of conditions and the following disclaimer.
7684 2. Redistributions in binary form must reproduce the above copyright
7685 notice, this list of conditions and the following disclaimer in the
7686 documentation and/or other materials provided with the distribution.
7687 3. The name of the author may not be used to endorse or promote
7688 products derived from this software without specific prior written
7689 permission.
7690
7691 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
7692 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
7693 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
7694 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
7695 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
7696 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
7697 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
7698 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
7699 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
7700 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
7701 POSSIBILITY OF SUCH DAMAGE.
7702 */
7703
7704 module_init(airo_init_module);
7705 module_exit(airo_cleanup_module);
Ubuntu Artful kernel mirror