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