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