git.oblomov.eu Git - linux-2.6/blob - drivers/net/wireless/airo.c

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