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