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_array(io, int, NULL, 0);
 250 module_param_array(irq, int, 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 int airo_change_mtu(struct net_device *dev, int new_mtu)
2345 {
2346         if ((new_mtu < 68) || (new_mtu > 2400))
2347                 return -EINVAL;
2348         dev->mtu = new_mtu;
2349         return 0;
2350 }
2351
2352 static LIST_HEAD(airo_devices);
2353
2354 static void add_airo_dev(struct airo_info *ai)
2355 {
2356         /* Upper layers already keep track of PCI devices,
2357          * so we only need to remember our non-PCI cards. */
2358         if (!ai->pci)
2359                 list_add_tail(&ai->dev_list, &airo_devices);
2360 }
2361
2362 static void del_airo_dev(struct airo_info *ai)
2363 {
2364         if (!ai->pci)
2365                 list_del(&ai->dev_list);
2366 }
2367
2368 static int airo_close(struct net_device *dev) {
2369         struct airo_info *ai = dev->ml_priv;
2370
2371         netif_stop_queue(dev);
2372
2373         if (ai->wifidev != dev) {
2374 #ifdef POWER_ON_DOWN
2375                 /* Shut power to the card. The idea is that the user can save
2376                  * power when he doesn't need the card with "ifconfig down".
2377                  * That's the method that is most friendly towards the network
2378                  * stack (i.e. the network stack won't try to broadcast
2379                  * anything on the interface and routes are gone. Jean II */
2380                 set_bit(FLAG_RADIO_DOWN, &ai->flags);
2381                 disable_MAC(ai, 1);
2382 #endif
2383                 disable_interrupts( ai );
2384
2385                 free_irq(dev->irq, dev);
2386
2387                 set_bit(JOB_DIE, &ai->jobs);
2388                 kthread_stop(ai->airo_thread_task);
2389         }
2390         return 0;
2391 }
2392
2393 void stop_airo_card( struct net_device *dev, int freeres )
2394 {
2395         struct airo_info *ai = dev->ml_priv;
2396
2397         set_bit(FLAG_RADIO_DOWN, &ai->flags);
2398         disable_MAC(ai, 1);
2399         disable_interrupts(ai);
2400         takedown_proc_entry( dev, ai );
2401         if (test_bit(FLAG_REGISTERED, &ai->flags)) {
2402                 unregister_netdev( dev );
2403                 if (ai->wifidev) {
2404                         unregister_netdev(ai->wifidev);
2405                         free_netdev(ai->wifidev);
2406                         ai->wifidev = NULL;
2407                 }
2408                 clear_bit(FLAG_REGISTERED, &ai->flags);
2409         }
2410         /*
2411          * Clean out tx queue
2412          */
2413         if (test_bit(FLAG_MPI, &ai->flags) && !skb_queue_empty(&ai->txq)) {
2414                 struct sk_buff *skb = NULL;
2415                 for (;(skb = skb_dequeue(&ai->txq));)
2416                         dev_kfree_skb(skb);
2417         }
2418
2419         airo_networks_free (ai);
2420
2421         kfree(ai->flash);
2422         kfree(ai->rssi);
2423         kfree(ai->SSID);
2424         if (freeres) {
2425                 /* PCMCIA frees this stuff, so only for PCI and ISA */
2426                 release_region( dev->base_addr, 64 );
2427                 if (test_bit(FLAG_MPI, &ai->flags)) {
2428                         if (ai->pci)
2429                                 mpi_unmap_card(ai->pci);
2430                         if (ai->pcimem)
2431                                 iounmap(ai->pcimem);
2432                         if (ai->pciaux)
2433                                 iounmap(ai->pciaux);
2434                         pci_free_consistent(ai->pci, PCI_SHARED_LEN,
2435                                 ai->shared, ai->shared_dma);
2436                 }
2437         }
2438         crypto_free_cipher(ai->tfm);
2439         del_airo_dev(ai);
2440         free_netdev( dev );
2441 }
2442
2443 EXPORT_SYMBOL(stop_airo_card);
2444
2445 static int wll_header_parse(const struct sk_buff *skb, unsigned char *haddr)
2446 {
2447         memcpy(haddr, skb_mac_header(skb) + 10, ETH_ALEN);
2448         return ETH_ALEN;
2449 }
2450
2451 static void mpi_unmap_card(struct pci_dev *pci)
2452 {
2453         unsigned long mem_start = pci_resource_start(pci, 1);
2454         unsigned long mem_len = pci_resource_len(pci, 1);
2455         unsigned long aux_start = pci_resource_start(pci, 2);
2456         unsigned long aux_len = AUXMEMSIZE;
2457
2458         release_mem_region(aux_start, aux_len);
2459         release_mem_region(mem_start, mem_len);
2460 }
2461
2462 /*************************************************************
2463  *  This routine assumes that descriptors have been setup .
2464  *  Run at insmod time or after reset  when the decriptors
2465  *  have been initialized . Returns 0 if all is well nz
2466  *  otherwise . Does not allocate memory but sets up card
2467  *  using previously allocated descriptors.
2468  */
2469 static int mpi_init_descriptors (struct airo_info *ai)
2470 {
2471         Cmd cmd;
2472         Resp rsp;
2473         int i;
2474         int rc = SUCCESS;
2475
2476         /* Alloc  card RX descriptors */
2477         netif_stop_queue(ai->dev);
2478
2479         memset(&rsp,0,sizeof(rsp));
2480         memset(&cmd,0,sizeof(cmd));
2481
2482         cmd.cmd = CMD_ALLOCATEAUX;
2483         cmd.parm0 = FID_RX;
2484         cmd.parm1 = (ai->rxfids[0].card_ram_off - ai->pciaux);
2485         cmd.parm2 = MPI_MAX_FIDS;
2486         rc=issuecommand(ai, &cmd, &rsp);
2487         if (rc != SUCCESS) {
2488                 airo_print_err(ai->dev->name, "Couldn't allocate RX FID");
2489                 return rc;
2490         }
2491
2492         for (i=0; i<MPI_MAX_FIDS; i++) {
2493                 memcpy_toio(ai->rxfids[i].card_ram_off,
2494                         &ai->rxfids[i].rx_desc, sizeof(RxFid));
2495         }
2496
2497         /* Alloc card TX descriptors */
2498
2499         memset(&rsp,0,sizeof(rsp));
2500         memset(&cmd,0,sizeof(cmd));
2501
2502         cmd.cmd = CMD_ALLOCATEAUX;
2503         cmd.parm0 = FID_TX;
2504         cmd.parm1 = (ai->txfids[0].card_ram_off - ai->pciaux);
2505         cmd.parm2 = MPI_MAX_FIDS;
2506
2507         for (i=0; i<MPI_MAX_FIDS; i++) {
2508                 ai->txfids[i].tx_desc.valid = 1;
2509                 memcpy_toio(ai->txfids[i].card_ram_off,
2510                         &ai->txfids[i].tx_desc, sizeof(TxFid));
2511         }
2512         ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2513
2514         rc=issuecommand(ai, &cmd, &rsp);
2515         if (rc != SUCCESS) {
2516                 airo_print_err(ai->dev->name, "Couldn't allocate TX FID");
2517                 return rc;
2518         }
2519
2520         /* Alloc card Rid descriptor */
2521         memset(&rsp,0,sizeof(rsp));
2522         memset(&cmd,0,sizeof(cmd));
2523
2524         cmd.cmd = CMD_ALLOCATEAUX;
2525         cmd.parm0 = RID_RW;
2526         cmd.parm1 = (ai->config_desc.card_ram_off - ai->pciaux);
2527         cmd.parm2 = 1; /* Magic number... */
2528         rc=issuecommand(ai, &cmd, &rsp);
2529         if (rc != SUCCESS) {
2530                 airo_print_err(ai->dev->name, "Couldn't allocate RID");
2531                 return rc;
2532         }
2533
2534         memcpy_toio(ai->config_desc.card_ram_off,
2535                 &ai->config_desc.rid_desc, sizeof(Rid));
2536
2537         return rc;
2538 }
2539
2540 /*
2541  * We are setting up three things here:
2542  * 1) Map AUX memory for descriptors: Rid, TxFid, or RxFid.
2543  * 2) Map PCI memory for issuing commands.
2544  * 3) Allocate memory (shared) to send and receive ethernet frames.
2545  */
2546 static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci)
2547 {
2548         unsigned long mem_start, mem_len, aux_start, aux_len;
2549         int rc = -1;
2550         int i;
2551         dma_addr_t busaddroff;
2552         unsigned char *vpackoff;
2553         unsigned char __iomem *pciaddroff;
2554
2555         mem_start = pci_resource_start(pci, 1);
2556         mem_len = pci_resource_len(pci, 1);
2557         aux_start = pci_resource_start(pci, 2);
2558         aux_len = AUXMEMSIZE;
2559
2560         if (!request_mem_region(mem_start, mem_len, DRV_NAME)) {
2561                 airo_print_err("", "Couldn't get region %x[%x]",
2562                         (int)mem_start, (int)mem_len);
2563                 goto out;
2564         }
2565         if (!request_mem_region(aux_start, aux_len, DRV_NAME)) {
2566                 airo_print_err("", "Couldn't get region %x[%x]",
2567                         (int)aux_start, (int)aux_len);
2568                 goto free_region1;
2569         }
2570
2571         ai->pcimem = ioremap(mem_start, mem_len);
2572         if (!ai->pcimem) {
2573                 airo_print_err("", "Couldn't map region %x[%x]",
2574                         (int)mem_start, (int)mem_len);
2575                 goto free_region2;
2576         }
2577         ai->pciaux = ioremap(aux_start, aux_len);
2578         if (!ai->pciaux) {
2579                 airo_print_err("", "Couldn't map region %x[%x]",
2580                         (int)aux_start, (int)aux_len);
2581                 goto free_memmap;
2582         }
2583
2584         /* Reserve PKTSIZE for each fid and 2K for the Rids */
2585         ai->shared = pci_alloc_consistent(pci, PCI_SHARED_LEN, &ai->shared_dma);
2586         if (!ai->shared) {
2587                 airo_print_err("", "Couldn't alloc_consistent %d",
2588                         PCI_SHARED_LEN);
2589                 goto free_auxmap;
2590         }
2591
2592         /*
2593          * Setup descriptor RX, TX, CONFIG
2594          */
2595         busaddroff = ai->shared_dma;
2596         pciaddroff = ai->pciaux + AUX_OFFSET;
2597         vpackoff   = ai->shared;
2598
2599         /* RX descriptor setup */
2600         for(i = 0; i < MPI_MAX_FIDS; i++) {
2601                 ai->rxfids[i].pending = 0;
2602                 ai->rxfids[i].card_ram_off = pciaddroff;
2603                 ai->rxfids[i].virtual_host_addr = vpackoff;
2604                 ai->rxfids[i].rx_desc.host_addr = busaddroff;
2605                 ai->rxfids[i].rx_desc.valid = 1;
2606                 ai->rxfids[i].rx_desc.len = PKTSIZE;
2607                 ai->rxfids[i].rx_desc.rdy = 0;
2608
2609                 pciaddroff += sizeof(RxFid);
2610                 busaddroff += PKTSIZE;
2611                 vpackoff   += PKTSIZE;
2612         }
2613
2614         /* TX descriptor setup */
2615         for(i = 0; i < MPI_MAX_FIDS; i++) {
2616                 ai->txfids[i].card_ram_off = pciaddroff;
2617                 ai->txfids[i].virtual_host_addr = vpackoff;
2618                 ai->txfids[i].tx_desc.valid = 1;
2619                 ai->txfids[i].tx_desc.host_addr = busaddroff;
2620                 memcpy(ai->txfids[i].virtual_host_addr,
2621                         &wifictlhdr8023, sizeof(wifictlhdr8023));
2622
2623                 pciaddroff += sizeof(TxFid);
2624                 busaddroff += PKTSIZE;
2625                 vpackoff   += PKTSIZE;
2626         }
2627         ai->txfids[i-1].tx_desc.eoc = 1; /* Last descriptor has EOC set */
2628
2629         /* Rid descriptor setup */
2630         ai->config_desc.card_ram_off = pciaddroff;
2631         ai->config_desc.virtual_host_addr = vpackoff;
2632         ai->config_desc.rid_desc.host_addr = busaddroff;
2633         ai->ridbus = busaddroff;
2634         ai->config_desc.rid_desc.rid = 0;
2635         ai->config_desc.rid_desc.len = RIDSIZE;
2636         ai->config_desc.rid_desc.valid = 1;
2637         pciaddroff += sizeof(Rid);
2638         busaddroff += RIDSIZE;
2639         vpackoff   += RIDSIZE;
2640
2641         /* Tell card about descriptors */
2642         if (mpi_init_descriptors (ai) != SUCCESS)
2643                 goto free_shared;
2644
2645         return 0;
2646  free_shared:
2647         pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2648  free_auxmap:
2649         iounmap(ai->pciaux);
2650  free_memmap:
2651         iounmap(ai->pcimem);
2652  free_region2:
2653         release_mem_region(aux_start, aux_len);
2654  free_region1:
2655         release_mem_region(mem_start, mem_len);
2656  out:
2657         return rc;
2658 }
2659
2660 static const struct header_ops airo_header_ops = {
2661         .parse = wll_header_parse,
2662 };
2663
2664 static const struct net_device_ops airo11_netdev_ops = {
2665         .ndo_open               = airo_open,
2666         .ndo_stop               = airo_close,
2667         .ndo_start_xmit         = airo_start_xmit11,
2668         .ndo_get_stats          = airo_get_stats,
2669         .ndo_set_mac_address    = airo_set_mac_address,
2670         .ndo_do_ioctl           = airo_ioctl,
2671         .ndo_change_mtu         = airo_change_mtu,
2672 };
2673
2674 static void wifi_setup(struct net_device *dev)
2675 {
2676         dev->netdev_ops = &airo11_netdev_ops;
2677         dev->header_ops = &airo_header_ops;
2678         dev->wireless_handlers = &airo_handler_def;
2679
2680         dev->type               = ARPHRD_IEEE80211;
2681         dev->hard_header_len    = ETH_HLEN;
2682         dev->mtu                = AIRO_DEF_MTU;
2683         dev->addr_len           = ETH_ALEN;
2684         dev->tx_queue_len       = 100;
2685
2686         eth_broadcast_addr(dev->broadcast);
2687
2688         dev->flags              = IFF_BROADCAST|IFF_MULTICAST;
2689 }
2690
2691 static struct net_device *init_wifidev(struct airo_info *ai,
2692                                         struct net_device *ethdev)
2693 {
2694         int err;
2695         struct net_device *dev = alloc_netdev(0, "wifi%d", NET_NAME_UNKNOWN,
2696                                               wifi_setup);
2697         if (!dev)
2698                 return NULL;
2699         dev->ml_priv = ethdev->ml_priv;
2700         dev->irq = ethdev->irq;
2701         dev->base_addr = ethdev->base_addr;
2702         dev->wireless_data = ethdev->wireless_data;
2703         SET_NETDEV_DEV(dev, ethdev->dev.parent);
2704         eth_hw_addr_inherit(dev, ethdev);
2705         err = register_netdev(dev);
2706         if (err<0) {
2707                 free_netdev(dev);
2708                 return NULL;
2709         }
2710         return dev;
2711 }
2712
2713 static int reset_card( struct net_device *dev , int lock) {
2714         struct airo_info *ai = dev->ml_priv;
2715
2716         if (lock && down_interruptible(&ai->sem))
2717                 return -1;
2718         waitbusy (ai);
2719         OUT4500(ai,COMMAND,CMD_SOFTRESET);
2720         msleep(200);
2721         waitbusy (ai);
2722         msleep(200);
2723         if (lock)
2724                 up(&ai->sem);
2725         return 0;
2726 }
2727
2728 #define AIRO_MAX_NETWORK_COUNT  64
2729 static int airo_networks_allocate(struct airo_info *ai)
2730 {
2731         if (ai->networks)
2732                 return 0;
2733
2734         ai->networks = kcalloc(AIRO_MAX_NETWORK_COUNT, sizeof(BSSListElement),
2735                                GFP_KERNEL);
2736         if (!ai->networks) {
2737                 airo_print_warn("", "Out of memory allocating beacons");
2738                 return -ENOMEM;
2739         }
2740
2741         return 0;
2742 }
2743
2744 static void airo_networks_free(struct airo_info *ai)
2745 {
2746         kfree(ai->networks);
2747         ai->networks = NULL;
2748 }
2749
2750 static void airo_networks_initialize(struct airo_info *ai)
2751 {
2752         int i;
2753
2754         INIT_LIST_HEAD(&ai->network_free_list);
2755         INIT_LIST_HEAD(&ai->network_list);
2756         for (i = 0; i < AIRO_MAX_NETWORK_COUNT; i++)
2757                 list_add_tail(&ai->networks[i].list,
2758                               &ai->network_free_list);
2759 }
2760
2761 static const struct net_device_ops airo_netdev_ops = {
2762         .ndo_open               = airo_open,
2763         .ndo_stop               = airo_close,
2764         .ndo_start_xmit         = airo_start_xmit,
2765         .ndo_get_stats          = airo_get_stats,
2766         .ndo_set_rx_mode        = airo_set_multicast_list,
2767         .ndo_set_mac_address    = airo_set_mac_address,
2768         .ndo_do_ioctl           = airo_ioctl,
2769         .ndo_change_mtu         = airo_change_mtu,
2770         .ndo_validate_addr      = eth_validate_addr,
2771 };
2772
2773 static const struct net_device_ops mpi_netdev_ops = {
2774         .ndo_open               = airo_open,
2775         .ndo_stop               = airo_close,
2776         .ndo_start_xmit         = mpi_start_xmit,
2777         .ndo_get_stats          = airo_get_stats,
2778         .ndo_set_rx_mode        = airo_set_multicast_list,
2779         .ndo_set_mac_address    = airo_set_mac_address,
2780         .ndo_do_ioctl           = airo_ioctl,
2781         .ndo_change_mtu         = airo_change_mtu,
2782         .ndo_validate_addr      = eth_validate_addr,
2783 };
2784
2785
2786 static struct net_device *_init_airo_card( unsigned short irq, int port,
2787                                            int is_pcmcia, struct pci_dev *pci,
2788                                            struct device *dmdev )
2789 {
2790         struct net_device *dev;
2791         struct airo_info *ai;
2792         int i, rc;
2793         CapabilityRid cap_rid;
2794
2795         /* Create the network device object. */
2796         dev = alloc_netdev(sizeof(*ai), "", NET_NAME_UNKNOWN, ether_setup);
2797         if (!dev) {
2798                 airo_print_err("", "Couldn't alloc_etherdev");
2799                 return NULL;
2800         }
2801
2802         ai = dev->ml_priv = netdev_priv(dev);
2803         ai->wifidev = NULL;
2804         ai->flags = 1 << FLAG_RADIO_DOWN;
2805         ai->jobs = 0;
2806         ai->dev = dev;
2807         if (pci && (pci->device == 0x5000 || pci->device == 0xa504)) {
2808                 airo_print_dbg("", "Found an MPI350 card");
2809                 set_bit(FLAG_MPI, &ai->flags);
2810         }
2811         spin_lock_init(&ai->aux_lock);
2812         sema_init(&ai->sem, 1);
2813         ai->config.len = 0;
2814         ai->pci = pci;
2815         init_waitqueue_head (&ai->thr_wait);
2816         ai->tfm = NULL;
2817         add_airo_dev(ai);
2818         ai->APList.len = cpu_to_le16(sizeof(struct APListRid));
2819
2820         if (airo_networks_allocate (ai))
2821                 goto err_out_free;
2822         airo_networks_initialize (ai);
2823
2824         skb_queue_head_init (&ai->txq);
2825
2826         /* The Airo-specific entries in the device structure. */
2827         if (test_bit(FLAG_MPI,&ai->flags))
2828                 dev->netdev_ops = &mpi_netdev_ops;
2829         else
2830                 dev->netdev_ops = &airo_netdev_ops;
2831         dev->wireless_handlers = &airo_handler_def;
2832         ai->wireless_data.spy_data = &ai->spy_data;
2833         dev->wireless_data = &ai->wireless_data;
2834         dev->irq = irq;
2835         dev->base_addr = port;
2836         dev->priv_flags &= ~IFF_TX_SKB_SHARING;
2837
2838         SET_NETDEV_DEV(dev, dmdev);
2839
2840         reset_card (dev, 1);
2841         msleep(400);
2842
2843         if (!is_pcmcia) {
2844                 if (!request_region(dev->base_addr, 64, DRV_NAME)) {
2845                         rc = -EBUSY;
2846                         airo_print_err(dev->name, "Couldn't request region");
2847                         goto err_out_nets;
2848                 }
2849         }
2850
2851         if (test_bit(FLAG_MPI,&ai->flags)) {
2852                 if (mpi_map_card(ai, pci)) {
2853                         airo_print_err("", "Could not map memory");
2854                         goto err_out_res;
2855                 }
2856         }
2857
2858         if (probe) {
2859                 if (setup_card(ai, dev->dev_addr, 1) != SUCCESS) {
2860                         airo_print_err(dev->name, "MAC could not be enabled" );
2861                         rc = -EIO;
2862                         goto err_out_map;
2863                 }
2864         } else if (!test_bit(FLAG_MPI,&ai->flags)) {
2865                 ai->bap_read = fast_bap_read;
2866                 set_bit(FLAG_FLASHING, &ai->flags);
2867         }
2868
2869         strcpy(dev->name, "eth%d");
2870         rc = register_netdev(dev);
2871         if (rc) {
2872                 airo_print_err(dev->name, "Couldn't register_netdev");
2873                 goto err_out_map;
2874         }
2875         ai->wifidev = init_wifidev(ai, dev);
2876         if (!ai->wifidev)
2877                 goto err_out_reg;
2878
2879         rc = readCapabilityRid(ai, &cap_rid, 1);
2880         if (rc != SUCCESS) {
2881                 rc = -EIO;
2882                 goto err_out_wifi;
2883         }
2884         /* WEP capability discovery */
2885         ai->wep_capable = (cap_rid.softCap & cpu_to_le16(0x02)) ? 1 : 0;
2886         ai->max_wep_idx = (cap_rid.softCap & cpu_to_le16(0x80)) ? 3 : 0;
2887
2888         airo_print_info(dev->name, "Firmware version %x.%x.%02d",
2889                         ((le16_to_cpu(cap_rid.softVer) >> 8) & 0xF),
2890                         (le16_to_cpu(cap_rid.softVer) & 0xFF),
2891                         le16_to_cpu(cap_rid.softSubVer));
2892
2893         /* Test for WPA support */
2894         /* Only firmware versions 5.30.17 or better can do WPA */
2895         if (le16_to_cpu(cap_rid.softVer) > 0x530
2896          || (le16_to_cpu(cap_rid.softVer) == 0x530
2897               && le16_to_cpu(cap_rid.softSubVer) >= 17)) {
2898                 airo_print_info(ai->dev->name, "WPA supported.");
2899
2900                 set_bit(FLAG_WPA_CAPABLE, &ai->flags);
2901                 ai->bssListFirst = RID_WPA_BSSLISTFIRST;
2902                 ai->bssListNext = RID_WPA_BSSLISTNEXT;
2903                 ai->bssListRidLen = sizeof(BSSListRid);
2904         } else {
2905                 airo_print_info(ai->dev->name, "WPA unsupported with firmware "
2906                         "versions older than 5.30.17.");
2907
2908                 ai->bssListFirst = RID_BSSLISTFIRST;
2909                 ai->bssListNext = RID_BSSLISTNEXT;
2910                 ai->bssListRidLen = sizeof(BSSListRid) - sizeof(BSSListRidExtra);
2911         }
2912
2913         set_bit(FLAG_REGISTERED,&ai->flags);
2914         airo_print_info(dev->name, "MAC enabled %pM", dev->dev_addr);
2915
2916         /* Allocate the transmit buffers */
2917         if (probe && !test_bit(FLAG_MPI,&ai->flags))
2918                 for( i = 0; i < MAX_FIDS; i++ )
2919                         ai->fids[i] = transmit_allocate(ai,AIRO_DEF_MTU,i>=MAX_FIDS/2);
2920
2921         if (setup_proc_entry(dev, dev->ml_priv) < 0)
2922                 goto err_out_wifi;
2923
2924         return dev;
2925
2926 err_out_wifi:
2927         unregister_netdev(ai->wifidev);
2928         free_netdev(ai->wifidev);
2929 err_out_reg:
2930         unregister_netdev(dev);
2931 err_out_map:
2932         if (test_bit(FLAG_MPI,&ai->flags) && pci) {
2933                 pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
2934                 iounmap(ai->pciaux);
2935                 iounmap(ai->pcimem);
2936                 mpi_unmap_card(ai->pci);
2937         }
2938 err_out_res:
2939         if (!is_pcmcia)
2940                 release_region( dev->base_addr, 64 );
2941 err_out_nets:
2942         airo_networks_free(ai);
2943 err_out_free:
2944         del_airo_dev(ai);
2945         free_netdev(dev);
2946         return NULL;
2947 }
2948
2949 struct net_device *init_airo_card( unsigned short irq, int port, int is_pcmcia,
2950                                   struct device *dmdev)
2951 {
2952         return _init_airo_card ( irq, port, is_pcmcia, NULL, dmdev);
2953 }
2954
2955 EXPORT_SYMBOL(init_airo_card);
2956
2957 static int waitbusy (struct airo_info *ai) {
2958         int delay = 0;
2959         while ((IN4500(ai, COMMAND) & COMMAND_BUSY) && (delay < 10000)) {
2960                 udelay (10);
2961                 if ((++delay % 20) == 0)
2962                         OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
2963         }
2964         return delay < 10000;
2965 }
2966
2967 int reset_airo_card( struct net_device *dev )
2968 {
2969         int i;
2970         struct airo_info *ai = dev->ml_priv;
2971
2972         if (reset_card (dev, 1))
2973                 return -1;
2974
2975         if ( setup_card(ai, dev->dev_addr, 1 ) != SUCCESS ) {
2976                 airo_print_err(dev->name, "MAC could not be enabled");
2977                 return -1;
2978         }
2979         airo_print_info(dev->name, "MAC enabled %pM", dev->dev_addr);
2980         /* Allocate the transmit buffers if needed */
2981         if (!test_bit(FLAG_MPI,&ai->flags))
2982                 for( i = 0; i < MAX_FIDS; i++ )
2983                         ai->fids[i] = transmit_allocate (ai,AIRO_DEF_MTU,i>=MAX_FIDS/2);
2984
2985         enable_interrupts( ai );
2986         netif_wake_queue(dev);
2987         return 0;
2988 }
2989
2990 EXPORT_SYMBOL(reset_airo_card);
2991
2992 static void airo_send_event(struct net_device *dev) {
2993         struct airo_info *ai = dev->ml_priv;
2994         union iwreq_data wrqu;
2995         StatusRid status_rid;
2996
2997         clear_bit(JOB_EVENT, &ai->jobs);
2998         PC4500_readrid(ai, RID_STATUS, &status_rid, sizeof(status_rid), 0);
2999         up(&ai->sem);
3000         wrqu.data.length = 0;
3001         wrqu.data.flags = 0;
3002         memcpy(wrqu.ap_addr.sa_data, status_rid.bssid[0], ETH_ALEN);
3003         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
3004
3005         /* Send event to user space */
3006         wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
3007 }
3008
3009 static void airo_process_scan_results (struct airo_info *ai) {
3010         union iwreq_data        wrqu;
3011         BSSListRid bss;
3012         int rc;
3013         BSSListElement * loop_net;
3014         BSSListElement * tmp_net;
3015
3016         /* Blow away current list of scan results */
3017         list_for_each_entry_safe (loop_net, tmp_net, &ai->network_list, list) {
3018                 list_move_tail (&loop_net->list, &ai->network_free_list);
3019                 /* Don't blow away ->list, just BSS data */
3020                 memset (loop_net, 0, sizeof (loop_net->bss));
3021         }
3022
3023         /* Try to read the first entry of the scan result */
3024         rc = PC4500_readrid(ai, ai->bssListFirst, &bss, ai->bssListRidLen, 0);
3025         if((rc) || (bss.index == cpu_to_le16(0xffff))) {
3026                 /* No scan results */
3027                 goto out;
3028         }
3029
3030         /* Read and parse all entries */
3031         tmp_net = NULL;
3032         while((!rc) && (bss.index != cpu_to_le16(0xffff))) {
3033                 /* Grab a network off the free list */
3034                 if (!list_empty(&ai->network_free_list)) {
3035                         tmp_net = list_entry(ai->network_free_list.next,
3036                                             BSSListElement, list);
3037                         list_del(ai->network_free_list.next);
3038                 }
3039
3040                 if (tmp_net != NULL) {
3041                         memcpy(tmp_net, &bss, sizeof(tmp_net->bss));
3042                         list_add_tail(&tmp_net->list, &ai->network_list);
3043                         tmp_net = NULL;
3044                 }
3045
3046                 /* Read next entry */
3047                 rc = PC4500_readrid(ai, ai->bssListNext,
3048                                     &bss, ai->bssListRidLen, 0);
3049         }
3050
3051 out:
3052         /* write APList back (we cleared it in airo_set_scan) */
3053         disable_MAC(ai, 2);
3054         writeAPListRid(ai, &ai->APList, 0);
3055         enable_MAC(ai, 0);
3056
3057         ai->scan_timeout = 0;
3058         clear_bit(JOB_SCAN_RESULTS, &ai->jobs);
3059         up(&ai->sem);
3060
3061         /* Send an empty event to user space.
3062          * We don't send the received data on
3063          * the event because it would require
3064          * us to do complex transcoding, and
3065          * we want to minimise the work done in
3066          * the irq handler. Use a request to
3067          * extract the data - Jean II */
3068         wrqu.data.length = 0;
3069         wrqu.data.flags = 0;
3070         wireless_send_event(ai->dev, SIOCGIWSCAN, &wrqu, NULL);
3071 }
3072
3073 static int airo_thread(void *data) {
3074         struct net_device *dev = data;
3075         struct airo_info *ai = dev->ml_priv;
3076         int locked;
3077
3078         set_freezable();
3079         while(1) {
3080                 /* make swsusp happy with our thread */
3081                 try_to_freeze();
3082
3083                 if (test_bit(JOB_DIE, &ai->jobs))
3084                         break;
3085
3086                 if (ai->jobs) {
3087                         locked = down_interruptible(&ai->sem);
3088                 } else {
3089                         wait_queue_t wait;
3090
3091                         init_waitqueue_entry(&wait, current);
3092                         add_wait_queue(&ai->thr_wait, &wait);
3093                         for (;;) {
3094                                 set_current_state(TASK_INTERRUPTIBLE);
3095                                 if (ai->jobs)
3096                                         break;
3097                                 if (ai->expires || ai->scan_timeout) {
3098                                         if (ai->scan_timeout &&
3099                                                         time_after_eq(jiffies,ai->scan_timeout)){
3100                                                 set_bit(JOB_SCAN_RESULTS, &ai->jobs);
3101                                                 break;
3102                                         } else if (ai->expires &&
3103                                                         time_after_eq(jiffies,ai->expires)){
3104                                                 set_bit(JOB_AUTOWEP, &ai->jobs);
3105                                                 break;
3106                                         }
3107                                         if (!kthread_should_stop() &&
3108                                             !freezing(current)) {
3109                                                 unsigned long wake_at;
3110                                                 if (!ai->expires || !ai->scan_timeout) {
3111                                                         wake_at = max(ai->expires,
3112                                                                 ai->scan_timeout);
3113                                                 } else {
3114                                                         wake_at = min(ai->expires,
3115                                                                 ai->scan_timeout);
3116                                                 }
3117                                                 schedule_timeout(wake_at - jiffies);
3118                                                 continue;
3119                                         }
3120                                 } else if (!kthread_should_stop() &&
3121                                            !freezing(current)) {
3122                                         schedule();
3123                                         continue;
3124                                 }
3125                                 break;
3126                         }
3127                         current->state = TASK_RUNNING;
3128                         remove_wait_queue(&ai->thr_wait, &wait);
3129                         locked = 1;
3130                 }
3131
3132                 if (locked)
3133                         continue;
3134
3135                 if (test_bit(JOB_DIE, &ai->jobs)) {
3136                         up(&ai->sem);
3137                         break;
3138                 }
3139
3140                 if (ai->power.event || test_bit(FLAG_FLASHING, &ai->flags)) {
3141                         up(&ai->sem);
3142                         continue;
3143                 }
3144
3145                 if (test_bit(JOB_XMIT, &ai->jobs))
3146                         airo_end_xmit(dev);
3147                 else if (test_bit(JOB_XMIT11, &ai->jobs))
3148                         airo_end_xmit11(dev);
3149                 else if (test_bit(JOB_STATS, &ai->jobs))
3150                         airo_read_stats(dev);
3151                 else if (test_bit(JOB_WSTATS, &ai->jobs))
3152                         airo_read_wireless_stats(ai);
3153                 else if (test_bit(JOB_PROMISC, &ai->jobs))
3154                         airo_set_promisc(ai);
3155                 else if (test_bit(JOB_MIC, &ai->jobs))
3156                         micinit(ai);
3157                 else if (test_bit(JOB_EVENT, &ai->jobs))
3158                         airo_send_event(dev);
3159                 else if (test_bit(JOB_AUTOWEP, &ai->jobs))
3160                         timer_func(dev);
3161                 else if (test_bit(JOB_SCAN_RESULTS, &ai->jobs))
3162                         airo_process_scan_results(ai);
3163                 else  /* Shouldn't get here, but we make sure to unlock */
3164                         up(&ai->sem);
3165         }
3166
3167         return 0;
3168 }
3169
3170 static int header_len(__le16 ctl)
3171 {
3172         u16 fc = le16_to_cpu(ctl);
3173         switch (fc & 0xc) {
3174         case 4:
3175                 if ((fc & 0xe0) == 0xc0)
3176                         return 10;      /* one-address control packet */
3177                 return 16;      /* two-address control packet */
3178         case 8:
3179                 if ((fc & 0x300) == 0x300)
3180                         return 30;      /* WDS packet */
3181         }
3182         return 24;
3183 }
3184
3185 static void airo_handle_cisco_mic(struct airo_info *ai)
3186 {
3187         if (test_bit(FLAG_MIC_CAPABLE, &ai->flags)) {
3188                 set_bit(JOB_MIC, &ai->jobs);
3189                 wake_up_interruptible(&ai->thr_wait);
3190         }
3191 }
3192
3193 /* Airo Status codes */
3194 #define STAT_NOBEACON   0x8000 /* Loss of sync - missed beacons */
3195 #define STAT_MAXRETRIES 0x8001 /* Loss of sync - max retries */
3196 #define STAT_MAXARL     0x8002 /* Loss of sync - average retry level exceeded*/
3197 #define STAT_FORCELOSS  0x8003 /* Loss of sync - host request */
3198 #define STAT_TSFSYNC    0x8004 /* Loss of sync - TSF synchronization */
3199 #define STAT_DEAUTH     0x8100 /* low byte is 802.11 reason code */
3200 #define STAT_DISASSOC   0x8200 /* low byte is 802.11 reason code */
3201 #define STAT_ASSOC_FAIL 0x8400 /* low byte is 802.11 reason code */
3202 #define STAT_AUTH_FAIL  0x0300 /* low byte is 802.11 reason code */
3203 #define STAT_ASSOC      0x0400 /* Associated */
3204 #define STAT_REASSOC    0x0600 /* Reassociated?  Only on firmware >= 5.30.17 */
3205
3206 static void airo_print_status(const char *devname, u16 status)
3207 {
3208         u8 reason = status & 0xFF;
3209
3210         switch (status & 0xFF00) {
3211         case STAT_NOBEACON:
3212                 switch (status) {
3213                 case STAT_NOBEACON:
3214                         airo_print_dbg(devname, "link lost (missed beacons)");
3215                         break;
3216                 case STAT_MAXRETRIES:
3217                 case STAT_MAXARL:
3218                         airo_print_dbg(devname, "link lost (max retries)");
3219                         break;
3220                 case STAT_FORCELOSS:
3221                         airo_print_dbg(devname, "link lost (local choice)");
3222                         break;
3223                 case STAT_TSFSYNC:
3224                         airo_print_dbg(devname, "link lost (TSF sync lost)");
3225                         break;
3226                 default:
3227                         airo_print_dbg(devname, "unknown status %x\n", status);
3228                         break;
3229                 }
3230                 break;
3231         case STAT_DEAUTH:
3232                 airo_print_dbg(devname, "deauthenticated (reason: %d)", reason);
3233                 break;
3234         case STAT_DISASSOC:
3235                 airo_print_dbg(devname, "disassociated (reason: %d)", reason);
3236                 break;
3237         case STAT_ASSOC_FAIL:
3238                 airo_print_dbg(devname, "association failed (reason: %d)",
3239                                reason);
3240                 break;
3241         case STAT_AUTH_FAIL:
3242                 airo_print_dbg(devname, "authentication failed (reason: %d)",
3243                                reason);
3244                 break;
3245         case STAT_ASSOC:
3246         case STAT_REASSOC:
3247                 break;
3248         default:
3249                 airo_print_dbg(devname, "unknown status %x\n", status);
3250                 break;
3251         }
3252 }
3253
3254 static void airo_handle_link(struct airo_info *ai)
3255 {
3256         union iwreq_data wrqu;
3257         int scan_forceloss = 0;
3258         u16 status;
3259
3260         /* Get new status and acknowledge the link change */
3261         status = le16_to_cpu(IN4500(ai, LINKSTAT));
3262         OUT4500(ai, EVACK, EV_LINK);
3263
3264         if ((status == STAT_FORCELOSS) && (ai->scan_timeout > 0))
3265                 scan_forceloss = 1;
3266
3267         airo_print_status(ai->dev->name, status);
3268
3269         if ((status == STAT_ASSOC) || (status == STAT_REASSOC)) {
3270                 if (auto_wep)
3271                         ai->expires = 0;
3272                 if (ai->list_bss_task)
3273                         wake_up_process(ai->list_bss_task);
3274                 set_bit(FLAG_UPDATE_UNI, &ai->flags);
3275                 set_bit(FLAG_UPDATE_MULTI, &ai->flags);
3276
3277                 if (down_trylock(&ai->sem) != 0) {
3278                         set_bit(JOB_EVENT, &ai->jobs);
3279                         wake_up_interruptible(&ai->thr_wait);
3280                 } else
3281                         airo_send_event(ai->dev);
3282                 netif_carrier_on(ai->dev);
3283         } else if (!scan_forceloss) {
3284                 if (auto_wep && !ai->expires) {
3285                         ai->expires = RUN_AT(3*HZ);
3286                         wake_up_interruptible(&ai->thr_wait);
3287                 }
3288
3289                 /* Send event to user space */
3290                 eth_zero_addr(wrqu.ap_addr.sa_data);
3291                 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
3292                 wireless_send_event(ai->dev, SIOCGIWAP, &wrqu, NULL);
3293                 netif_carrier_off(ai->dev);
3294         } else {
3295                 netif_carrier_off(ai->dev);
3296         }
3297 }
3298
3299 static void airo_handle_rx(struct airo_info *ai)
3300 {
3301         struct sk_buff *skb = NULL;
3302         __le16 fc, v, *buffer, tmpbuf[4];
3303         u16 len, hdrlen = 0, gap, fid;
3304         struct rx_hdr hdr;
3305         int success = 0;
3306
3307         if (test_bit(FLAG_MPI, &ai->flags)) {
3308                 if (test_bit(FLAG_802_11, &ai->flags))
3309                         mpi_receive_802_11(ai);
3310                 else
3311                         mpi_receive_802_3(ai);
3312                 OUT4500(ai, EVACK, EV_RX);
3313                 return;
3314         }
3315
3316         fid = IN4500(ai, RXFID);
3317
3318         /* Get the packet length */
3319         if (test_bit(FLAG_802_11, &ai->flags)) {
3320                 bap_setup (ai, fid, 4, BAP0);
3321                 bap_read (ai, (__le16*)&hdr, sizeof(hdr), BAP0);
3322                 /* Bad CRC. Ignore packet */
3323                 if (le16_to_cpu(hdr.status) & 2)
3324                         hdr.len = 0;
3325                 if (ai->wifidev == NULL)
3326                         hdr.len = 0;
3327         } else {
3328                 bap_setup(ai, fid, 0x36, BAP0);
3329                 bap_read(ai, &hdr.len, 2, BAP0);
3330         }
3331         len = le16_to_cpu(hdr.len);
3332
3333         if (len > AIRO_DEF_MTU) {
3334                 airo_print_err(ai->dev->name, "Bad size %d", len);
3335                 goto done;
3336         }
3337         if (len == 0)
3338                 goto done;
3339
3340         if (test_bit(FLAG_802_11, &ai->flags)) {
3341                 bap_read(ai, &fc, sizeof (fc), BAP0);
3342                 hdrlen = header_len(fc);
3343         } else
3344                 hdrlen = ETH_ALEN * 2;
3345
3346         skb = dev_alloc_skb(len + hdrlen + 2 + 2);
3347         if (!skb) {
3348                 ai->dev->stats.rx_dropped++;
3349                 goto done;
3350         }
3351
3352         skb_reserve(skb, 2); /* This way the IP header is aligned */
3353         buffer = (__le16 *) skb_put(skb, len + hdrlen);
3354         if (test_bit(FLAG_802_11, &ai->flags)) {
3355                 buffer[0] = fc;
3356                 bap_read(ai, buffer + 1, hdrlen - 2, BAP0);
3357                 if (hdrlen == 24)
3358                         bap_read(ai, tmpbuf, 6, BAP0);
3359
3360                 bap_read(ai, &v, sizeof(v), BAP0);
3361                 gap = le16_to_cpu(v);
3362                 if (gap) {
3363                         if (gap <= 8) {
3364                                 bap_read(ai, tmpbuf, gap, BAP0);
3365                         } else {
3366                                 airo_print_err(ai->dev->name, "gaplen too "
3367                                         "big. Problems will follow...");
3368                         }
3369                 }
3370                 bap_read(ai, buffer + hdrlen/2, len, BAP0);
3371         } else {
3372                 MICBuffer micbuf;
3373
3374                 bap_read(ai, buffer, ETH_ALEN * 2, BAP0);
3375                 if (ai->micstats.enabled) {
3376                         bap_read(ai, (__le16 *) &micbuf, sizeof (micbuf), BAP0);
3377                         if (ntohs(micbuf.typelen) > 0x05DC)
3378                                 bap_setup(ai, fid, 0x44, BAP0);
3379                         else {
3380                                 if (len <= sizeof (micbuf)) {
3381                                         dev_kfree_skb_irq(skb);
3382                                         goto done;
3383                                 }
3384
3385                                 len -= sizeof(micbuf);
3386                                 skb_trim(skb, len + hdrlen);
3387                         }
3388                 }
3389
3390                 bap_read(ai, buffer + ETH_ALEN, len, BAP0);
3391                 if (decapsulate(ai, &micbuf, (etherHead*) buffer, len))
3392                         dev_kfree_skb_irq (skb);
3393                 else
3394                         success = 1;
3395         }
3396
3397 #ifdef WIRELESS_SPY
3398         if (success && (ai->spy_data.spy_number > 0)) {
3399                 char *sa;
3400                 struct iw_quality wstats;
3401
3402                 /* Prepare spy data : addr + qual */
3403                 if (!test_bit(FLAG_802_11, &ai->flags)) {
3404                         sa = (char *) buffer + 6;
3405                         bap_setup(ai, fid, 8, BAP0);
3406                         bap_read(ai, (__le16 *) hdr.rssi, 2, BAP0);
3407                 } else
3408                         sa = (char *) buffer + 10;
3409                 wstats.qual = hdr.rssi[0];
3410                 if (ai->rssi)
3411                         wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3412                 else
3413                         wstats.level = (hdr.rssi[1] + 321) / 2;
3414                 wstats.noise = ai->wstats.qual.noise;
3415                 wstats.updated =  IW_QUAL_LEVEL_UPDATED
3416                                 | IW_QUAL_QUAL_UPDATED
3417                                 | IW_QUAL_DBM;
3418                 /* Update spy records */
3419                 wireless_spy_update(ai->dev, sa, &wstats);
3420         }
3421 #endif /* WIRELESS_SPY */
3422
3423 done:
3424         OUT4500(ai, EVACK, EV_RX);
3425
3426         if (success) {
3427                 if (test_bit(FLAG_802_11, &ai->flags)) {
3428                         skb_reset_mac_header(skb);
3429                         skb->pkt_type = PACKET_OTHERHOST;
3430                         skb->dev = ai->wifidev;
3431                         skb->protocol = htons(ETH_P_802_2);
3432                 } else
3433                         skb->protocol = eth_type_trans(skb, ai->dev);
3434                 skb->ip_summed = CHECKSUM_NONE;
3435
3436                 netif_rx(skb);
3437         }
3438 }
3439
3440 static void airo_handle_tx(struct airo_info *ai, u16 status)
3441 {
3442         int i, len = 0, index = -1;
3443         u16 fid;
3444
3445         if (test_bit(FLAG_MPI, &ai->flags)) {
3446                 unsigned long flags;
3447
3448                 if (status & EV_TXEXC)
3449                         get_tx_error(ai, -1);
3450
3451                 spin_lock_irqsave(&ai->aux_lock, flags);
3452                 if (!skb_queue_empty(&ai->txq)) {
3453                         spin_unlock_irqrestore(&ai->aux_lock,flags);
3454                         mpi_send_packet(ai->dev);
3455                 } else {
3456                         clear_bit(FLAG_PENDING_XMIT, &ai->flags);
3457                         spin_unlock_irqrestore(&ai->aux_lock,flags);
3458                         netif_wake_queue(ai->dev);
3459                 }
3460                 OUT4500(ai, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3461                 return;
3462         }
3463
3464         fid = IN4500(ai, TXCOMPLFID);
3465
3466         for(i = 0; i < MAX_FIDS; i++) {
3467                 if ((ai->fids[i] & 0xffff) == fid) {
3468                         len = ai->fids[i] >> 16;
3469                         index = i;
3470                 }
3471         }
3472
3473         if (index != -1) {
3474                 if (status & EV_TXEXC)
3475                         get_tx_error(ai, index);
3476
3477                 OUT4500(ai, EVACK, status & (EV_TX | EV_TXEXC));
3478
3479                 /* Set up to be used again */
3480                 ai->fids[index] &= 0xffff;
3481                 if (index < MAX_FIDS / 2) {
3482                         if (!test_bit(FLAG_PENDING_XMIT, &ai->flags))
3483                                 netif_wake_queue(ai->dev);
3484                 } else {
3485                         if (!test_bit(FLAG_PENDING_XMIT11, &ai->flags))
3486                                 netif_wake_queue(ai->wifidev);
3487                 }
3488         } else {
3489                 OUT4500(ai, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
3490                 airo_print_err(ai->dev->name, "Unallocated FID was used to xmit");
3491         }
3492 }
3493
3494 static irqreturn_t airo_interrupt(int irq, void *dev_id)
3495 {
3496         struct net_device *dev = dev_id;
3497         u16 status, savedInterrupts = 0;
3498         struct airo_info *ai = dev->ml_priv;
3499         int handled = 0;
3500
3501         if (!netif_device_present(dev))
3502                 return IRQ_NONE;
3503
3504         for (;;) {
3505                 status = IN4500(ai, EVSTAT);
3506                 if (!(status & STATUS_INTS) || (status == 0xffff))
3507                         break;
3508
3509                 handled = 1;
3510
3511                 if (status & EV_AWAKE) {
3512                         OUT4500(ai, EVACK, EV_AWAKE);
3513                         OUT4500(ai, EVACK, EV_AWAKE);
3514                 }
3515
3516                 if (!savedInterrupts) {
3517                         savedInterrupts = IN4500(ai, EVINTEN);
3518                         OUT4500(ai, EVINTEN, 0);
3519                 }
3520
3521                 if (status & EV_MIC) {
3522                         OUT4500(ai, EVACK, EV_MIC);
3523                         airo_handle_cisco_mic(ai);
3524                 }
3525
3526                 if (status & EV_LINK) {
3527                         /* Link status changed */
3528                         airo_handle_link(ai);
3529                 }
3530
3531                 /* Check to see if there is something to receive */
3532                 if (status & EV_RX)
3533                         airo_handle_rx(ai);
3534
3535                 /* Check to see if a packet has been transmitted */
3536                 if (status & (EV_TX | EV_TXCPY | EV_TXEXC))
3537                         airo_handle_tx(ai, status);
3538
3539                 if ( status & ~STATUS_INTS & ~IGNORE_INTS ) {
3540                         airo_print_warn(ai->dev->name, "Got weird status %x",
3541                                 status & ~STATUS_INTS & ~IGNORE_INTS );
3542                 }
3543         }
3544
3545         if (savedInterrupts)
3546                 OUT4500(ai, EVINTEN, savedInterrupts);
3547
3548         return IRQ_RETVAL(handled);
3549 }
3550
3551 /*
3552  *  Routines to talk to the card
3553  */
3554
3555 /*
3556  *  This was originally written for the 4500, hence the name
3557  *  NOTE:  If use with 8bit mode and SMP bad things will happen!
3558  *         Why would some one do 8 bit IO in an SMP machine?!?
3559  */
3560 static void OUT4500( struct airo_info *ai, u16 reg, u16 val ) {
3561         if (test_bit(FLAG_MPI,&ai->flags))
3562                 reg <<= 1;
3563         if ( !do8bitIO )
3564                 outw( val, ai->dev->base_addr + reg );
3565         else {
3566                 outb( val & 0xff, ai->dev->base_addr + reg );
3567                 outb( val >> 8, ai->dev->base_addr + reg + 1 );
3568         }
3569 }
3570
3571 static u16 IN4500( struct airo_info *ai, u16 reg ) {
3572         unsigned short rc;
3573
3574         if (test_bit(FLAG_MPI,&ai->flags))
3575                 reg <<= 1;
3576         if ( !do8bitIO )
3577                 rc = inw( ai->dev->base_addr + reg );
3578         else {
3579                 rc = inb( ai->dev->base_addr + reg );
3580                 rc += ((int)inb( ai->dev->base_addr + reg + 1 )) << 8;
3581         }
3582         return rc;
3583 }
3584
3585 static int enable_MAC(struct airo_info *ai, int lock)
3586 {
3587         int rc;
3588         Cmd cmd;
3589         Resp rsp;
3590
3591         /* FLAG_RADIO_OFF : Radio disabled via /proc or Wireless Extensions
3592          * FLAG_RADIO_DOWN : Radio disabled via "ifconfig ethX down"
3593          * Note : we could try to use !netif_running(dev) in enable_MAC()
3594          * instead of this flag, but I don't trust it *within* the
3595          * open/close functions, and testing both flags together is
3596          * "cheaper" - Jean II */
3597         if (ai->flags & FLAG_RADIO_MASK) return SUCCESS;
3598
3599         if (lock && down_interruptible(&ai->sem))
3600                 return -ERESTARTSYS;
3601
3602         if (!test_bit(FLAG_ENABLED, &ai->flags)) {
3603                 memset(&cmd, 0, sizeof(cmd));
3604                 cmd.cmd = MAC_ENABLE;
3605                 rc = issuecommand(ai, &cmd, &rsp);
3606                 if (rc == SUCCESS)
3607                         set_bit(FLAG_ENABLED, &ai->flags);
3608         } else
3609                 rc = SUCCESS;
3610
3611         if (lock)
3612             up(&ai->sem);
3613
3614         if (rc)
3615                 airo_print_err(ai->dev->name, "Cannot enable MAC");
3616         else if ((rsp.status & 0xFF00) != 0) {
3617                 airo_print_err(ai->dev->name, "Bad MAC enable reason=%x, "
3618                         "rid=%x, offset=%d", rsp.rsp0, rsp.rsp1, rsp.rsp2);
3619                 rc = ERROR;
3620         }
3621         return rc;
3622 }
3623
3624 static void disable_MAC( struct airo_info *ai, int lock ) {
3625         Cmd cmd;
3626         Resp rsp;
3627
3628         if (lock == 1 && down_interruptible(&ai->sem))
3629                 return;
3630
3631         if (test_bit(FLAG_ENABLED, &ai->flags)) {
3632                 if (lock != 2) /* lock == 2 means don't disable carrier */
3633                         netif_carrier_off(ai->dev);
3634                 memset(&cmd, 0, sizeof(cmd));
3635                 cmd.cmd = MAC_DISABLE; // disable in case already enabled
3636                 issuecommand(ai, &cmd, &rsp);
3637                 clear_bit(FLAG_ENABLED, &ai->flags);
3638         }
3639         if (lock == 1)
3640                 up(&ai->sem);
3641 }
3642
3643 static void enable_interrupts( struct airo_info *ai ) {
3644         /* Enable the interrupts */
3645         OUT4500( ai, EVINTEN, STATUS_INTS );
3646 }
3647
3648 static void disable_interrupts( struct airo_info *ai ) {
3649         OUT4500( ai, EVINTEN, 0 );
3650 }
3651
3652 static void mpi_receive_802_3(struct airo_info *ai)
3653 {
3654         RxFid rxd;
3655         int len = 0;
3656         struct sk_buff *skb;
3657         char *buffer;
3658         int off = 0;
3659         MICBuffer micbuf;
3660
3661         memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3662         /* Make sure we got something */
3663         if (rxd.rdy && rxd.valid == 0) {
3664                 len = rxd.len + 12;
3665                 if (len < 12 || len > 2048)
3666                         goto badrx;
3667
3668                 skb = dev_alloc_skb(len);
3669                 if (!skb) {
3670                         ai->dev->stats.rx_dropped++;
3671                         goto badrx;
3672                 }
3673                 buffer = skb_put(skb,len);
3674                 memcpy(buffer, ai->rxfids[0].virtual_host_addr, ETH_ALEN * 2);
3675                 if (ai->micstats.enabled) {
3676                         memcpy(&micbuf,
3677                                 ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2,
3678                                 sizeof(micbuf));
3679                         if (ntohs(micbuf.typelen) <= 0x05DC) {
3680                                 if (len <= sizeof(micbuf) + ETH_ALEN * 2)
3681                                         goto badmic;
3682
3683                                 off = sizeof(micbuf);
3684                                 skb_trim (skb, len - off);
3685                         }
3686                 }
3687                 memcpy(buffer + ETH_ALEN * 2,
3688                         ai->rxfids[0].virtual_host_addr + ETH_ALEN * 2 + off,
3689                         len - ETH_ALEN * 2 - off);
3690                 if (decapsulate (ai, &micbuf, (etherHead*)buffer, len - off - ETH_ALEN * 2)) {
3691 badmic:
3692                         dev_kfree_skb_irq (skb);
3693                         goto badrx;
3694                 }
3695 #ifdef WIRELESS_SPY
3696                 if (ai->spy_data.spy_number > 0) {
3697                         char *sa;
3698                         struct iw_quality wstats;
3699                         /* Prepare spy data : addr + qual */
3700                         sa = buffer + ETH_ALEN;
3701                         wstats.qual = 0; /* XXX Where do I get that info from ??? */
3702                         wstats.level = 0;
3703                         wstats.updated = 0;
3704                         /* Update spy records */
3705                         wireless_spy_update(ai->dev, sa, &wstats);
3706                 }
3707 #endif /* WIRELESS_SPY */
3708
3709                 skb->ip_summed = CHECKSUM_NONE;
3710                 skb->protocol = eth_type_trans(skb, ai->dev);
3711                 netif_rx(skb);
3712         }
3713 badrx:
3714         if (rxd.valid == 0) {
3715                 rxd.valid = 1;
3716                 rxd.rdy = 0;
3717                 rxd.len = PKTSIZE;
3718                 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3719         }
3720 }
3721
3722 static void mpi_receive_802_11(struct airo_info *ai)
3723 {
3724         RxFid rxd;
3725         struct sk_buff *skb = NULL;
3726         u16 len, hdrlen = 0;
3727         __le16 fc;
3728         struct rx_hdr hdr;
3729         u16 gap;
3730         u16 *buffer;
3731         char *ptr = ai->rxfids[0].virtual_host_addr + 4;
3732
3733         memcpy_fromio(&rxd, ai->rxfids[0].card_ram_off, sizeof(rxd));
3734         memcpy ((char *)&hdr, ptr, sizeof(hdr));
3735         ptr += sizeof(hdr);
3736         /* Bad CRC. Ignore packet */
3737         if (le16_to_cpu(hdr.status) & 2)
3738                 hdr.len = 0;
3739         if (ai->wifidev == NULL)
3740                 hdr.len = 0;
3741         len = le16_to_cpu(hdr.len);
3742         if (len > AIRO_DEF_MTU) {
3743                 airo_print_err(ai->dev->name, "Bad size %d", len);
3744                 goto badrx;
3745         }
3746         if (len == 0)
3747                 goto badrx;
3748
3749         fc = get_unaligned((__le16 *)ptr);
3750         hdrlen = header_len(fc);
3751
3752         skb = dev_alloc_skb( len + hdrlen + 2 );
3753         if ( !skb ) {
3754                 ai->dev->stats.rx_dropped++;
3755                 goto badrx;
3756         }
3757         buffer = (u16*)skb_put (skb, len + hdrlen);
3758         memcpy ((char *)buffer, ptr, hdrlen);
3759         ptr += hdrlen;
3760         if (hdrlen == 24)
3761                 ptr += 6;
3762         gap = get_unaligned_le16(ptr);
3763         ptr += sizeof(__le16);
3764         if (gap) {
3765                 if (gap <= 8)
3766                         ptr += gap;
3767                 else
3768                         airo_print_err(ai->dev->name,
3769                             "gaplen too big. Problems will follow...");
3770         }
3771         memcpy ((char *)buffer + hdrlen, ptr, len);
3772         ptr += len;
3773 #ifdef IW_WIRELESS_SPY    /* defined in iw_handler.h */
3774         if (ai->spy_data.spy_number > 0) {
3775                 char *sa;
3776                 struct iw_quality wstats;
3777                 /* Prepare spy data : addr + qual */
3778                 sa = (char*)buffer + 10;
3779                 wstats.qual = hdr.rssi[0];
3780                 if (ai->rssi)
3781                         wstats.level = 0x100 - ai->rssi[hdr.rssi[1]].rssidBm;
3782                 else
3783                         wstats.level = (hdr.rssi[1] + 321) / 2;
3784                 wstats.noise = ai->wstats.qual.noise;
3785                 wstats.updated = IW_QUAL_QUAL_UPDATED
3786                         | IW_QUAL_LEVEL_UPDATED
3787                         | IW_QUAL_DBM;
3788                 /* Update spy records */
3789                 wireless_spy_update(ai->dev, sa, &wstats);
3790         }
3791 #endif /* IW_WIRELESS_SPY */
3792         skb_reset_mac_header(skb);
3793         skb->pkt_type = PACKET_OTHERHOST;
3794         skb->dev = ai->wifidev;
3795         skb->protocol = htons(ETH_P_802_2);
3796         skb->ip_summed = CHECKSUM_NONE;
3797         netif_rx( skb );
3798
3799 badrx:
3800         if (rxd.valid == 0) {
3801                 rxd.valid = 1;
3802                 rxd.rdy = 0;
3803                 rxd.len = PKTSIZE;
3804                 memcpy_toio(ai->rxfids[0].card_ram_off, &rxd, sizeof(rxd));
3805         }
3806 }
3807
3808 static inline void set_auth_type(struct airo_info *local, int auth_type)
3809 {
3810         local->config.authType = auth_type;
3811         /* Cache the last auth type used (of AUTH_OPEN and AUTH_ENCRYPT).
3812          * Used by airo_set_auth()
3813          */
3814         if (auth_type == AUTH_OPEN || auth_type == AUTH_ENCRYPT)
3815                 local->last_auth = auth_type;
3816 }
3817
3818 static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
3819 {
3820         Cmd cmd;
3821         Resp rsp;
3822         int status;
3823         SsidRid mySsid;
3824         __le16 lastindex;
3825         WepKeyRid wkr;
3826         int rc;
3827
3828         memset( &mySsid, 0, sizeof( mySsid ) );
3829         kfree (ai->flash);
3830         ai->flash = NULL;
3831
3832         /* The NOP is the first step in getting the card going */
3833         cmd.cmd = NOP;
3834         cmd.parm0 = cmd.parm1 = cmd.parm2 = 0;
3835         if (lock && down_interruptible(&ai->sem))
3836                 return ERROR;
3837         if ( issuecommand( ai, &cmd, &rsp ) != SUCCESS ) {
3838                 if (lock)
3839                         up(&ai->sem);
3840                 return ERROR;
3841         }
3842         disable_MAC( ai, 0);
3843
3844         // Let's figure out if we need to use the AUX port
3845         if (!test_bit(FLAG_MPI,&ai->flags)) {
3846                 cmd.cmd = CMD_ENABLEAUX;
3847                 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
3848                         if (lock)
3849                                 up(&ai->sem);
3850                         airo_print_err(ai->dev->name, "Error checking for AUX port");
3851                         return ERROR;
3852                 }
3853                 if (!aux_bap || rsp.status & 0xff00) {
3854                         ai->bap_read = fast_bap_read;
3855                         airo_print_dbg(ai->dev->name, "Doing fast bap_reads");
3856                 } else {
3857                         ai->bap_read = aux_bap_read;
3858                         airo_print_dbg(ai->dev->name, "Doing AUX bap_reads");
3859                 }
3860         }
3861         if (lock)
3862                 up(&ai->sem);
3863         if (ai->config.len == 0) {
3864                 int i;
3865                 tdsRssiRid rssi_rid;
3866                 CapabilityRid cap_rid;
3867
3868                 kfree(ai->SSID);
3869                 ai->SSID = NULL;
3870                 // general configuration (read/modify/write)
3871                 status = readConfigRid(ai, lock);
3872                 if ( status != SUCCESS ) return ERROR;
3873
3874                 status = readCapabilityRid(ai, &cap_rid, lock);
3875                 if ( status != SUCCESS ) return ERROR;
3876
3877                 status = PC4500_readrid(ai,RID_RSSI,&rssi_rid,sizeof(rssi_rid),lock);
3878                 if ( status == SUCCESS ) {
3879                         if (ai->rssi || (ai->rssi = kmalloc(512, GFP_KERNEL)) != NULL)
3880                                 memcpy(ai->rssi, (u8*)&rssi_rid + 2, 512); /* Skip RID length member */
3881                 }
3882                 else {
3883                         kfree(ai->rssi);
3884                         ai->rssi = NULL;
3885                         if (cap_rid.softCap & cpu_to_le16(8))
3886                                 ai->config.rmode |= RXMODE_NORMALIZED_RSSI;
3887                         else
3888                                 airo_print_warn(ai->dev->name, "unknown received signal "
3889                                                 "level scale");
3890                 }
3891                 ai->config.opmode = adhoc ? MODE_STA_IBSS : MODE_STA_ESS;
3892                 set_auth_type(ai, AUTH_OPEN);
3893                 ai->config.modulation = MOD_CCK;
3894
3895                 if (le16_to_cpu(cap_rid.len) >= sizeof(cap_rid) &&
3896                     (cap_rid.extSoftCap & cpu_to_le16(1)) &&
3897                     micsetup(ai) == SUCCESS) {
3898                         ai->config.opmode |= MODE_MIC;
3899                         set_bit(FLAG_MIC_CAPABLE, &ai->flags);
3900                 }
3901
3902                 /* Save off the MAC */
3903                 for( i = 0; i < ETH_ALEN; i++ ) {
3904                         mac[i] = ai->config.macAddr[i];
3905                 }
3906
3907                 /* Check to see if there are any insmod configured
3908                    rates to add */
3909                 if ( rates[0] ) {
3910                         memset(ai->config.rates,0,sizeof(ai->config.rates));
3911                         for( i = 0; i < 8 && rates[i]; i++ ) {
3912                                 ai->config.rates[i] = rates[i];
3913                         }
3914                 }
3915                 set_bit (FLAG_COMMIT, &ai->flags);
3916         }
3917
3918         /* Setup the SSIDs if present */
3919         if ( ssids[0] ) {
3920                 int i;
3921                 for( i = 0; i < 3 && ssids[i]; i++ ) {
3922                         size_t len = strlen(ssids[i]);
3923                         if (len > 32)
3924                                 len = 32;
3925                         mySsid.ssids[i].len = cpu_to_le16(len);
3926                         memcpy(mySsid.ssids[i].ssid, ssids[i], len);
3927                 }
3928                 mySsid.len = cpu_to_le16(sizeof(mySsid));
3929         }
3930
3931         status = writeConfigRid(ai, lock);
3932         if ( status != SUCCESS ) return ERROR;
3933
3934         /* Set up the SSID list */
3935         if ( ssids[0] ) {
3936                 status = writeSsidRid(ai, &mySsid, lock);
3937                 if ( status != SUCCESS ) return ERROR;
3938         }
3939
3940         status = enable_MAC(ai, lock);
3941         if (status != SUCCESS)
3942                 return ERROR;
3943
3944         /* Grab the initial wep key, we gotta save it for auto_wep */
3945         rc = readWepKeyRid(ai, &wkr, 1, lock);
3946         if (rc == SUCCESS) do {
3947                 lastindex = wkr.kindex;
3948                 if (wkr.kindex == cpu_to_le16(0xffff)) {
3949                         ai->defindex = wkr.mac[0];
3950                 }
3951                 rc = readWepKeyRid(ai, &wkr, 0, lock);
3952         } while(lastindex != wkr.kindex);
3953
3954         try_auto_wep(ai);
3955
3956         return SUCCESS;
3957 }
3958
3959 static u16 issuecommand(struct airo_info *ai, Cmd *pCmd, Resp *pRsp) {
3960         // Im really paranoid about letting it run forever!
3961         int max_tries = 600000;
3962
3963         if (IN4500(ai, EVSTAT) & EV_CMD)
3964                 OUT4500(ai, EVACK, EV_CMD);
3965
3966         OUT4500(ai, PARAM0, pCmd->parm0);
3967         OUT4500(ai, PARAM1, pCmd->parm1);
3968         OUT4500(ai, PARAM2, pCmd->parm2);
3969         OUT4500(ai, COMMAND, pCmd->cmd);
3970
3971         while (max_tries-- && (IN4500(ai, EVSTAT) & EV_CMD) == 0) {
3972                 if ((IN4500(ai, COMMAND)) == pCmd->cmd)
3973                         // PC4500 didn't notice command, try again
3974                         OUT4500(ai, COMMAND, pCmd->cmd);
3975                 if (!in_atomic() && (max_tries & 255) == 0)
3976                         schedule();
3977         }
3978
3979         if ( max_tries == -1 ) {
3980                 airo_print_err(ai->dev->name,
3981                         "Max tries exceeded when issuing command");
3982                 if (IN4500(ai, COMMAND) & COMMAND_BUSY)
3983                         OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
3984                 return ERROR;
3985         }
3986
3987         // command completed
3988         pRsp->status = IN4500(ai, STATUS);
3989         pRsp->rsp0 = IN4500(ai, RESP0);
3990         pRsp->rsp1 = IN4500(ai, RESP1);
3991         pRsp->rsp2 = IN4500(ai, RESP2);
3992         if ((pRsp->status & 0xff00)!=0 && pCmd->cmd != CMD_SOFTRESET)
3993                 airo_print_err(ai->dev->name,
3994                         "cmd:%x status:%x rsp0:%x rsp1:%x rsp2:%x",
3995                         pCmd->cmd, pRsp->status, pRsp->rsp0, pRsp->rsp1,
3996                         pRsp->rsp2);
3997
3998         // clear stuck command busy if necessary
3999         if (IN4500(ai, COMMAND) & COMMAND_BUSY) {
4000                 OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
4001         }
4002         // acknowledge processing the status/response
4003         OUT4500(ai, EVACK, EV_CMD);
4004
4005         return SUCCESS;
4006 }
4007
4008 /* Sets up the bap to start exchange data.  whichbap should
4009  * be one of the BAP0 or BAP1 defines.  Locks should be held before
4010  * calling! */
4011 static int bap_setup(struct airo_info *ai, u16 rid, u16 offset, int whichbap )
4012 {
4013         int timeout = 50;
4014         int max_tries = 3;
4015
4016         OUT4500(ai, SELECT0+whichbap, rid);
4017         OUT4500(ai, OFFSET0+whichbap, offset);
4018         while (1) {
4019                 int status = IN4500(ai, OFFSET0+whichbap);
4020                 if (status & BAP_BUSY) {
4021                         /* This isn't really a timeout, but its kinda
4022                            close */
4023                         if (timeout--) {
4024                                 continue;
4025                         }
4026                 } else if ( status & BAP_ERR ) {
4027                         /* invalid rid or offset */
4028                         airo_print_err(ai->dev->name, "BAP error %x %d",
4029                                 status, whichbap );
4030                         return ERROR;
4031                 } else if (status & BAP_DONE) { // success
4032                         return SUCCESS;
4033                 }
4034                 if ( !(max_tries--) ) {
4035                         airo_print_err(ai->dev->name,
4036                                 "BAP setup error too many retries\n");
4037                         return ERROR;
4038                 }
4039                 // -- PC4500 missed it, try again
4040                 OUT4500(ai, SELECT0+whichbap, rid);
4041                 OUT4500(ai, OFFSET0+whichbap, offset);
4042                 timeout = 50;
4043         }
4044 }
4045
4046 /* should only be called by aux_bap_read.  This aux function and the
4047    following use concepts not documented in the developers guide.  I
4048    got them from a patch given to my by Aironet */
4049 static u16 aux_setup(struct airo_info *ai, u16 page,
4050                      u16 offset, u16 *len)
4051 {
4052         u16 next;
4053
4054         OUT4500(ai, AUXPAGE, page);
4055         OUT4500(ai, AUXOFF, 0);
4056         next = IN4500(ai, AUXDATA);
4057         *len = IN4500(ai, AUXDATA)&0xff;
4058         if (offset != 4) OUT4500(ai, AUXOFF, offset);
4059         return next;
4060 }
4061
4062 /* requires call to bap_setup() first */
4063 static int aux_bap_read(struct airo_info *ai, __le16 *pu16Dst,
4064                         int bytelen, int whichbap)
4065 {
4066         u16 len;
4067         u16 page;
4068         u16 offset;
4069         u16 next;
4070         int words;
4071         int i;
4072         unsigned long flags;
4073
4074         spin_lock_irqsave(&ai->aux_lock, flags);
4075         page = IN4500(ai, SWS0+whichbap);
4076         offset = IN4500(ai, SWS2+whichbap);
4077         next = aux_setup(ai, page, offset, &len);
4078         words = (bytelen+1)>>1;
4079
4080         for (i=0; i<words;) {
4081                 int count;
4082                 count = (len>>1) < (words-i) ? (len>>1) : (words-i);
4083                 if ( !do8bitIO )
4084                         insw( ai->dev->base_addr+DATA0+whichbap,
4085                               pu16Dst+i,count );
4086                 else
4087                         insb( ai->dev->base_addr+DATA0+whichbap,
4088                               pu16Dst+i, count << 1 );
4089                 i += count;
4090                 if (i<words) {
4091                         next = aux_setup(ai, next, 4, &len);
4092                 }
4093         }
4094         spin_unlock_irqrestore(&ai->aux_lock, flags);
4095         return SUCCESS;
4096 }
4097
4098
4099 /* requires call to bap_setup() first */
4100 static int fast_bap_read(struct airo_info *ai, __le16 *pu16Dst,
4101                          int bytelen, int whichbap)
4102 {
4103         bytelen = (bytelen + 1) & (~1); // round up to even value
4104         if ( !do8bitIO )
4105                 insw( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen>>1 );
4106         else
4107                 insb( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen );
4108         return SUCCESS;
4109 }
4110
4111 /* requires call to bap_setup() first */
4112 static int bap_write(struct airo_info *ai, const __le16 *pu16Src,
4113                      int bytelen, int whichbap)
4114 {
4115         bytelen = (bytelen + 1) & (~1); // round up to even value
4116         if ( !do8bitIO )
4117                 outsw( ai->dev->base_addr+DATA0+whichbap,
4118                        pu16Src, bytelen>>1 );
4119         else
4120                 outsb( ai->dev->base_addr+DATA0+whichbap, pu16Src, bytelen );
4121         return SUCCESS;
4122 }
4123
4124 static int PC4500_accessrid(struct airo_info *ai, u16 rid, u16 accmd)
4125 {
4126         Cmd cmd; /* for issuing commands */
4127         Resp rsp; /* response from commands */
4128         u16 status;
4129
4130         memset(&cmd, 0, sizeof(cmd));
4131         cmd.cmd = accmd;
4132         cmd.parm0 = rid;
4133         status = issuecommand(ai, &cmd, &rsp);
4134         if (status != 0) return status;
4135         if ( (rsp.status & 0x7F00) != 0) {
4136                 return (accmd << 8) + (rsp.rsp0 & 0xFF);
4137         }
4138         return 0;
4139 }
4140
4141 /*  Note, that we are using BAP1 which is also used by transmit, so
4142  *  we must get a lock. */
4143 static int PC4500_readrid(struct airo_info *ai, u16 rid, void *pBuf, int len, int lock)
4144 {
4145         u16 status;
4146         int rc = SUCCESS;
4147
4148         if (lock) {
4149                 if (down_interruptible(&ai->sem))
4150                         return ERROR;
4151         }
4152         if (test_bit(FLAG_MPI,&ai->flags)) {
4153                 Cmd cmd;
4154                 Resp rsp;
4155
4156                 memset(&cmd, 0, sizeof(cmd));
4157                 memset(&rsp, 0, sizeof(rsp));
4158                 ai->config_desc.rid_desc.valid = 1;
4159                 ai->config_desc.rid_desc.len = RIDSIZE;
4160                 ai->config_desc.rid_desc.rid = 0;
4161                 ai->config_desc.rid_desc.host_addr = ai->ridbus;
4162
4163                 cmd.cmd = CMD_ACCESS;
4164                 cmd.parm0 = rid;
4165
4166                 memcpy_toio(ai->config_desc.card_ram_off,
4167                         &ai->config_desc.rid_desc, sizeof(Rid));
4168
4169                 rc = issuecommand(ai, &cmd, &rsp);
4170
4171                 if (rsp.status & 0x7f00)
4172                         rc = rsp.rsp0;
4173                 if (!rc)
4174                         memcpy(pBuf, ai->config_desc.virtual_host_addr, len);
4175                 goto done;
4176         } else {
4177                 if ((status = PC4500_accessrid(ai, rid, CMD_ACCESS))!=SUCCESS) {
4178                         rc = status;
4179                         goto done;
4180                 }
4181                 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4182                         rc = ERROR;
4183                         goto done;
4184                 }
4185                 // read the rid length field
4186                 bap_read(ai, pBuf, 2, BAP1);
4187                 // length for remaining part of rid
4188                 len = min(len, (int)le16_to_cpu(*(__le16*)pBuf)) - 2;
4189
4190                 if ( len <= 2 ) {
4191                         airo_print_err(ai->dev->name,
4192                                 "Rid %x has a length of %d which is too short",
4193                                 (int)rid, (int)len );
4194                         rc = ERROR;
4195                         goto done;
4196                 }
4197                 // read remainder of the rid
4198                 rc = bap_read(ai, ((__le16*)pBuf)+1, len, BAP1);
4199         }
4200 done:
4201         if (lock)
4202                 up(&ai->sem);
4203         return rc;
4204 }
4205
4206 /*  Note, that we are using BAP1 which is also used by transmit, so
4207  *  make sure this isn't called when a transmit is happening */
4208 static int PC4500_writerid(struct airo_info *ai, u16 rid,
4209                            const void *pBuf, int len, int lock)
4210 {
4211         u16 status;
4212         int rc = SUCCESS;
4213
4214         *(__le16*)pBuf = cpu_to_le16((u16)len);
4215
4216         if (lock) {
4217                 if (down_interruptible(&ai->sem))
4218                         return ERROR;
4219         }
4220         if (test_bit(FLAG_MPI,&ai->flags)) {
4221                 Cmd cmd;
4222                 Resp rsp;
4223
4224                 if (test_bit(FLAG_ENABLED, &ai->flags) && (RID_WEP_TEMP != rid))
4225                         airo_print_err(ai->dev->name,
4226                                 "%s: MAC should be disabled (rid=%04x)",
4227                                 __func__, rid);
4228                 memset(&cmd, 0, sizeof(cmd));
4229                 memset(&rsp, 0, sizeof(rsp));
4230
4231                 ai->config_desc.rid_desc.valid = 1;
4232                 ai->config_desc.rid_desc.len = *((u16 *)pBuf);
4233                 ai->config_desc.rid_desc.rid = 0;
4234
4235                 cmd.cmd = CMD_WRITERID;
4236                 cmd.parm0 = rid;
4237
4238                 memcpy_toio(ai->config_desc.card_ram_off,
4239                         &ai->config_desc.rid_desc, sizeof(Rid));
4240
4241                 if (len < 4 || len > 2047) {
4242                         airo_print_err(ai->dev->name, "%s: len=%d", __func__, len);
4243                         rc = -1;
4244                 } else {
4245                         memcpy(ai->config_desc.virtual_host_addr,
4246                                 pBuf, len);
4247
4248                         rc = issuecommand(ai, &cmd, &rsp);
4249                         if ((rc & 0xff00) != 0) {
4250                                 airo_print_err(ai->dev->name, "%s: Write rid Error %d",
4251                                                 __func__, rc);
4252                                 airo_print_err(ai->dev->name, "%s: Cmd=%04x",
4253                                                 __func__, cmd.cmd);
4254                         }
4255
4256                         if ((rsp.status & 0x7f00))
4257                                 rc = rsp.rsp0;
4258                 }
4259         } else {
4260                 // --- first access so that we can write the rid data
4261                 if ( (status = PC4500_accessrid(ai, rid, CMD_ACCESS)) != 0) {
4262                         rc = status;
4263                         goto done;
4264                 }
4265                 // --- now write the rid data
4266                 if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
4267                         rc = ERROR;
4268                         goto done;
4269                 }
4270                 bap_write(ai, pBuf, len, BAP1);
4271                 // ---now commit the rid data
4272                 rc = PC4500_accessrid(ai, rid, 0x100|CMD_ACCESS);
4273         }
4274 done:
4275         if (lock)
4276                 up(&ai->sem);
4277         return rc;
4278 }
4279
4280 /* Allocates a FID to be used for transmitting packets.  We only use
4281    one for now. */
4282 static u16 transmit_allocate(struct airo_info *ai, int lenPayload, int raw)
4283 {
4284         unsigned int loop = 3000;
4285         Cmd cmd;
4286         Resp rsp;
4287         u16 txFid;
4288         __le16 txControl;
4289
4290         cmd.cmd = CMD_ALLOCATETX;
4291         cmd.parm0 = lenPayload;
4292         if (down_interruptible(&ai->sem))
4293                 return ERROR;
4294         if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
4295                 txFid = ERROR;
4296                 goto done;
4297         }
4298         if ( (rsp.status & 0xFF00) != 0) {
4299                 txFid = ERROR;
4300                 goto done;
4301         }
4302         /* wait for the allocate event/indication
4303          * It makes me kind of nervous that this can just sit here and spin,
4304          * but in practice it only loops like four times. */
4305         while (((IN4500(ai, EVSTAT) & EV_ALLOC) == 0) && --loop);
4306         if (!loop) {
4307                 txFid = ERROR;
4308                 goto done;
4309         }
4310
4311         // get the allocated fid and acknowledge
4312         txFid = IN4500(ai, TXALLOCFID);
4313         OUT4500(ai, EVACK, EV_ALLOC);
4314
4315         /*  The CARD is pretty cool since it converts the ethernet packet
4316          *  into 802.11.  Also note that we don't release the FID since we
4317          *  will be using the same one over and over again. */
4318         /*  We only have to setup the control once since we are not
4319          *  releasing the fid. */
4320         if (raw)
4321                 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_11
4322                         | TXCTL_ETHERNET | TXCTL_NORELEASE);
4323         else
4324                 txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_3
4325                         | TXCTL_ETHERNET | TXCTL_NORELEASE);
4326         if (bap_setup(ai, txFid, 0x0008, BAP1) != SUCCESS)
4327                 txFid = ERROR;
4328         else
4329                 bap_write(ai, &txControl, sizeof(txControl), BAP1);
4330
4331 done:
4332         up(&ai->sem);
4333
4334         return txFid;
4335 }
4336
4337 /* In general BAP1 is dedicated to transmiting packets.  However,
4338    since we need a BAP when accessing RIDs, we also use BAP1 for that.
4339    Make sure the BAP1 spinlock is held when this is called. */
4340 static int transmit_802_3_packet(struct airo_info *ai, int len, char *pPacket)
4341 {
4342         __le16 payloadLen;
4343         Cmd cmd;
4344         Resp rsp;
4345         int miclen = 0;
4346         u16 txFid = len;
4347         MICBuffer pMic;
4348
4349         len >>= 16;
4350
4351         if (len <= ETH_ALEN * 2) {
4352                 airo_print_warn(ai->dev->name, "Short packet %d", len);
4353                 return ERROR;
4354         }
4355         len -= ETH_ALEN * 2;
4356
4357         if (test_bit(FLAG_MIC_CAPABLE, &ai->flags) && ai->micstats.enabled &&
4358             (ntohs(((__be16 *)pPacket)[6]) != 0x888E)) {
4359                 if (encapsulate(ai,(etherHead *)pPacket,&pMic,len) != SUCCESS)
4360                         return ERROR;
4361                 miclen = sizeof(pMic);
4362         }
4363         // packet is destination[6], source[6], payload[len-12]
4364         // write the payload length and dst/src/payload
4365         if (bap_setup(ai, txFid, 0x0036, BAP1) != SUCCESS) return ERROR;
4366         /* The hardware addresses aren't counted as part of the payload, so
4367          * we have to subtract the 12 bytes for the addresses off */
4368         payloadLen = cpu_to_le16(len + miclen);
4369         bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4370         bap_write(ai, (__le16*)pPacket, sizeof(etherHead), BAP1);
4371         if (miclen)
4372                 bap_write(ai, (__le16*)&pMic, miclen, BAP1);
4373         bap_write(ai, (__le16*)(pPacket + sizeof(etherHead)), len, BAP1);
4374         // issue the transmit command
4375         memset( &cmd, 0, sizeof( cmd ) );
4376         cmd.cmd = CMD_TRANSMIT;
4377         cmd.parm0 = txFid;
4378         if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4379         if ( (rsp.status & 0xFF00) != 0) return ERROR;
4380         return SUCCESS;
4381 }
4382
4383 static int transmit_802_11_packet(struct airo_info *ai, int len, char *pPacket)
4384 {
4385         __le16 fc, payloadLen;
4386         Cmd cmd;
4387         Resp rsp;
4388         int hdrlen;
4389         static u8 tail[(30-10) + 2 + 6] = {[30-10] = 6};
4390         /* padding of header to full size + le16 gaplen (6) + gaplen bytes */
4391         u16 txFid = len;
4392         len >>= 16;
4393
4394         fc = *(__le16*)pPacket;
4395         hdrlen = header_len(fc);
4396
4397         if (len < hdrlen) {
4398                 airo_print_warn(ai->dev->name, "Short packet %d", len);
4399                 return ERROR;
4400         }
4401
4402         /* packet is 802.11 header +  payload
4403          * write the payload length and dst/src/payload */
4404         if (bap_setup(ai, txFid, 6, BAP1) != SUCCESS) return ERROR;
4405         /* The 802.11 header aren't counted as part of the payload, so
4406          * we have to subtract the header bytes off */
4407         payloadLen = cpu_to_le16(len-hdrlen);
4408         bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
4409         if (bap_setup(ai, txFid, 0x0014, BAP1) != SUCCESS) return ERROR;
4410         bap_write(ai, (__le16 *)pPacket, hdrlen, BAP1);
4411         bap_write(ai, (__le16 *)(tail + (hdrlen - 10)), 38 - hdrlen, BAP1);
4412
4413         bap_write(ai, (__le16 *)(pPacket + hdrlen), len - hdrlen, BAP1);
4414         // issue the transmit command
4415         memset( &cmd, 0, sizeof( cmd ) );
4416         cmd.cmd = CMD_TRANSMIT;
4417         cmd.parm0 = txFid;
4418         if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
4419         if ( (rsp.status & 0xFF00) != 0) return ERROR;
4420         return SUCCESS;
4421 }
4422
4423 /*
4424  *  This is the proc_fs routines.  It is a bit messier than I would
4425  *  like!  Feel free to clean it up!
4426  */
4427
4428 static ssize_t proc_read( struct file *file,
4429                           char __user *buffer,
4430                           size_t len,
4431                           loff_t *offset);
4432
4433 static ssize_t proc_write( struct file *file,
4434                            const char __user *buffer,
4435                            size_t len,
4436                            loff_t *offset );
4437 static int proc_close( struct inode *inode, struct file *file );
4438
4439 static int proc_stats_open( struct inode *inode, struct file *file );
4440 static int proc_statsdelta_open( struct inode *inode, struct file *file );
4441 static int proc_status_open( struct inode *inode, struct file *file );
4442 static int proc_SSID_open( struct inode *inode, struct file *file );
4443 static int proc_APList_open( struct inode *inode, struct file *file );
4444 static int proc_BSSList_open( struct inode *inode, struct file *file );
4445 static int proc_config_open( struct inode *inode, struct file *file );
4446 static int proc_wepkey_open( struct inode *inode, struct file *file );
4447
4448 static const struct file_operations proc_statsdelta_ops = {
4449         .owner          = THIS_MODULE,
4450         .read           = proc_read,
4451         .open           = proc_statsdelta_open,
4452         .release        = proc_close,
4453         .llseek         = default_llseek,
4454 };
4455
4456 static const struct file_operations proc_stats_ops = {
4457         .owner          = THIS_MODULE,
4458         .read           = proc_read,
4459         .open           = proc_stats_open,
4460         .release        = proc_close,
4461         .llseek         = default_llseek,
4462 };
4463
4464 static const struct file_operations proc_status_ops = {
4465         .owner          = THIS_MODULE,
4466         .read           = proc_read,
4467         .open           = proc_status_open,
4468         .release        = proc_close,
4469         .llseek         = default_llseek,
4470 };
4471
4472 static const struct file_operations proc_SSID_ops = {
4473         .owner          = THIS_MODULE,
4474         .read           = proc_read,
4475         .write          = proc_write,
4476         .open           = proc_SSID_open,
4477         .release        = proc_close,
4478         .llseek         = default_llseek,
4479 };
4480
4481 static const struct file_operations proc_BSSList_ops = {
4482         .owner          = THIS_MODULE,
4483         .read           = proc_read,
4484         .write          = proc_write,
4485         .open           = proc_BSSList_open,
4486         .release        = proc_close,
4487         .llseek         = default_llseek,
4488 };
4489
4490 static const struct file_operations proc_APList_ops = {
4491         .owner          = THIS_MODULE,
4492         .read           = proc_read,
4493         .write          = proc_write,
4494         .open           = proc_APList_open,
4495         .release        = proc_close,
4496         .llseek         = default_llseek,
4497 };
4498
4499 static const struct file_operations proc_config_ops = {
4500         .owner          = THIS_MODULE,
4501         .read           = proc_read,
4502         .write          = proc_write,
4503         .open           = proc_config_open,
4504         .release        = proc_close,
4505         .llseek         = default_llseek,
4506 };
4507
4508 static const struct file_operations proc_wepkey_ops = {
4509         .owner          = THIS_MODULE,
4510         .read           = proc_read,
4511         .write          = proc_write,
4512         .open           = proc_wepkey_open,
4513         .release        = proc_close,
4514         .llseek         = default_llseek,
4515 };
4516
4517 static struct proc_dir_entry *airo_entry;
4518
4519 struct proc_data {
4520         int release_buffer;
4521         int readlen;
4522         char *rbuffer;
4523         int writelen;
4524         int maxwritelen;
4525         char *wbuffer;
4526         void (*on_close) (struct inode *, struct file *);
4527 };
4528
4529 static int setup_proc_entry( struct net_device *dev,
4530                              struct airo_info *apriv ) {
4531         struct proc_dir_entry *entry;
4532
4533         /* First setup the device directory */
4534         strcpy(apriv->proc_name,dev->name);
4535         apriv->proc_entry = proc_mkdir_mode(apriv->proc_name, airo_perm,
4536                                             airo_entry);
4537         if (!apriv->proc_entry)
4538                 return -ENOMEM;
4539         proc_set_user(apriv->proc_entry, proc_kuid, proc_kgid);
4540
4541         /* Setup the StatsDelta */
4542         entry = proc_create_data("StatsDelta", S_IRUGO & proc_perm,
4543                                  apriv->proc_entry, &proc_statsdelta_ops, dev);
4544         if (!entry)
4545                 goto fail;
4546         proc_set_user(entry, proc_kuid, proc_kgid);
4547
4548         /* Setup the Stats */
4549         entry = proc_create_data("Stats", S_IRUGO & proc_perm,
4550                                  apriv->proc_entry, &proc_stats_ops, dev);
4551         if (!entry)
4552                 goto fail;
4553         proc_set_user(entry, proc_kuid, proc_kgid);
4554
4555         /* Setup the Status */
4556         entry = proc_create_data("Status", S_IRUGO & proc_perm,
4557                                  apriv->proc_entry, &proc_status_ops, dev);
4558         if (!entry)
4559                 goto fail;
4560         proc_set_user(entry, proc_kuid, proc_kgid);
4561
4562         /* Setup the Config */
4563         entry = proc_create_data("Config", proc_perm,
4564                                  apriv->proc_entry, &proc_config_ops, dev);
4565         if (!entry)
4566                 goto fail;
4567         proc_set_user(entry, proc_kuid, proc_kgid);
4568
4569         /* Setup the SSID */
4570         entry = proc_create_data("SSID", proc_perm,
4571                                  apriv->proc_entry, &proc_SSID_ops, dev);
4572         if (!entry)
4573                 goto fail;
4574         proc_set_user(entry, proc_kuid, proc_kgid);
4575
4576         /* Setup the APList */
4577         entry = proc_create_data("APList", proc_perm,
4578                                  apriv->proc_entry, &proc_APList_ops, dev);
4579         if (!entry)
4580                 goto fail;
4581         proc_set_user(entry, proc_kuid, proc_kgid);
4582
4583         /* Setup the BSSList */
4584         entry = proc_create_data("BSSList", proc_perm,
4585                                  apriv->proc_entry, &proc_BSSList_ops, dev);
4586         if (!entry)
4587                 goto fail;
4588         proc_set_user(entry, proc_kuid, proc_kgid);
4589
4590         /* Setup the WepKey */
4591         entry = proc_create_data("WepKey", proc_perm,
4592                                  apriv->proc_entry, &proc_wepkey_ops, dev);
4593         if (!entry)
4594                 goto fail;
4595         proc_set_user(entry, proc_kuid, proc_kgid);
4596         return 0;
4597
4598 fail:
4599         remove_proc_subtree(apriv->proc_name, airo_entry);
4600         return -ENOMEM;
4601 }
4602
4603 static int takedown_proc_entry( struct net_device *dev,
4604                                 struct airo_info *apriv )
4605 {
4606         remove_proc_subtree(apriv->proc_name, airo_entry);
4607         return 0;
4608 }
4609
4610 /*
4611  *  What we want from the proc_fs is to be able to efficiently read
4612  *  and write the configuration.  To do this, we want to read the
4613  *  configuration when the file is opened and write it when the file is
4614  *  closed.  So basically we allocate a read buffer at open and fill it
4615  *  with data, and allocate a write buffer and read it at close.
4616  */
4617
4618 /*
4619  *  The read routine is generic, it relies on the preallocated rbuffer
4620  *  to supply the data.
4621  */
4622 static ssize_t proc_read( struct file *file,
4623                           char __user *buffer,
4624                           size_t len,
4625                           loff_t *offset )
4626 {
4627         struct proc_data *priv = file->private_data;
4628
4629         if (!priv->rbuffer)
4630                 return -EINVAL;
4631
4632         return simple_read_from_buffer(buffer, len, offset, priv->rbuffer,
4633                                         priv->readlen);
4634 }
4635
4636 /*
4637  *  The write routine is generic, it fills in a preallocated rbuffer
4638  *  to supply the data.
4639  */
4640 static ssize_t proc_write( struct file *file,
4641                            const char __user *buffer,
4642                            size_t len,
4643                            loff_t *offset )
4644 {
4645         ssize_t ret;
4646         struct proc_data *priv = file->private_data;
4647
4648         if (!priv->wbuffer)
4649                 return -EINVAL;
4650
4651         ret = simple_write_to_buffer(priv->wbuffer, priv->maxwritelen, offset,
4652                                         buffer, len);
4653         if (ret > 0)
4654                 priv->writelen = max_t(int, priv->writelen, *offset);
4655
4656         return ret;
4657 }
4658
4659 static int proc_status_open(struct inode *inode, struct file *file)
4660 {
4661         struct proc_data *data;
4662         struct net_device *dev = PDE_DATA(inode);
4663         struct airo_info *apriv = dev->ml_priv;
4664         CapabilityRid cap_rid;
4665         StatusRid status_rid;
4666         u16 mode;
4667         int i;
4668
4669         if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4670                 return -ENOMEM;
4671         data = file->private_data;
4672         if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
4673                 kfree (file->private_data);
4674                 return -ENOMEM;
4675         }
4676
4677         readStatusRid(apriv, &status_rid, 1);
4678         readCapabilityRid(apriv, &cap_rid, 1);
4679
4680         mode = le16_to_cpu(status_rid.mode);
4681
4682         i = sprintf(data->rbuffer, "Status: %s%s%s%s%s%s%s%s%s\n",
4683                     mode & 1 ? "CFG ": "",
4684                     mode & 2 ? "ACT ": "",
4685                     mode & 0x10 ? "SYN ": "",
4686                     mode & 0x20 ? "LNK ": "",
4687                     mode & 0x40 ? "LEAP ": "",
4688                     mode & 0x80 ? "PRIV ": "",
4689                     mode & 0x100 ? "KEY ": "",
4690                     mode & 0x200 ? "WEP ": "",
4691                     mode & 0x8000 ? "ERR ": "");
4692         sprintf( data->rbuffer+i, "Mode: %x\n"
4693                  "Signal Strength: %d\n"
4694                  "Signal Quality: %d\n"
4695                  "SSID: %-.*s\n"
4696                  "AP: %-.16s\n"
4697                  "Freq: %d\n"
4698                  "BitRate: %dmbs\n"
4699                  "Driver Version: %s\n"
4700                  "Device: %s\nManufacturer: %s\nFirmware Version: %s\n"
4701                  "Radio type: %x\nCountry: %x\nHardware Version: %x\n"
4702                  "Software Version: %x\nSoftware Subversion: %x\n"
4703                  "Boot block version: %x\n",
4704                  le16_to_cpu(status_rid.mode),
4705                  le16_to_cpu(status_rid.normalizedSignalStrength),
4706                  le16_to_cpu(status_rid.signalQuality),
4707                  le16_to_cpu(status_rid.SSIDlen),
4708                  status_rid.SSID,
4709                  status_rid.apName,
4710                  le16_to_cpu(status_rid.channel),
4711                  le16_to_cpu(status_rid.currentXmitRate) / 2,
4712                  version,
4713                  cap_rid.prodName,
4714                  cap_rid.manName,
4715                  cap_rid.prodVer,
4716                  le16_to_cpu(cap_rid.radioType),
4717                  le16_to_cpu(cap_rid.country),
4718                  le16_to_cpu(cap_rid.hardVer),
4719                  le16_to_cpu(cap_rid.softVer),
4720                  le16_to_cpu(cap_rid.softSubVer),
4721                  le16_to_cpu(cap_rid.bootBlockVer));
4722         data->readlen = strlen( data->rbuffer );
4723         return 0;
4724 }
4725
4726 static int proc_stats_rid_open(struct inode*, struct file*, u16);
4727 static int proc_statsdelta_open( struct inode *inode,
4728                                  struct file *file ) {
4729         if (file->f_mode&FMODE_WRITE) {
4730                 return proc_stats_rid_open(inode, file, RID_STATSDELTACLEAR);
4731         }
4732         return proc_stats_rid_open(inode, file, RID_STATSDELTA);
4733 }
4734
4735 static int proc_stats_open( struct inode *inode, struct file *file ) {
4736         return proc_stats_rid_open(inode, file, RID_STATS);
4737 }
4738
4739 static int proc_stats_rid_open( struct inode *inode,
4740                                 struct file *file,
4741                                 u16 rid )
4742 {
4743         struct proc_data *data;
4744         struct net_device *dev = PDE_DATA(inode);
4745         struct airo_info *apriv = dev->ml_priv;
4746         StatsRid stats;
4747         int i, j;
4748         __le32 *vals = stats.vals;
4749         int len;
4750
4751         if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
4752                 return -ENOMEM;
4753         data = file->private_data;
4754         if ((data->rbuffer = kmalloc( 4096, GFP_KERNEL )) == NULL) {
4755                 kfree (file->private_data);
4756                 return -ENOMEM;
4757         }
4758
4759         readStatsRid(apriv, &stats, rid, 1);
4760         len = le16_to_cpu(stats.len);
4761
4762         j = 0;
4763         for(i=0; statsLabels[i]!=(char *)-1 && i*4<len; i++) {
4764                 if (!statsLabels[i]) continue;
4765                 if (j+strlen(statsLabels[i])+16>4096) {
4766                         airo_print_warn(apriv->dev->name,
4767                                "Potentially disastrous buffer overflow averted!");
4768                         break;
4769                 }
4770                 j+=sprintf(data->rbuffer+j, "%s: %u\n", statsLabels[i],
4771                                 le32_to_cpu(vals[i]));
4772         }
4773         if (i*4 >= len) {
4774                 airo_print_warn(apriv->dev->name, "Got a short rid");
4775         }
4776         data->readlen = j;
4777         return 0;
4778 }
4779
4780 static int get_dec_u16( char *buffer, int *start, int limit ) {
4781         u16 value;
4782         int valid = 0;
4783         for (value = 0; *start < limit && buffer[*start] >= '0' &&
4784                         buffer[*start] <= '9'; (*start)++) {
4785                 valid = 1;
4786                 value *= 10;
4787                 value += buffer[*start] - '0';
4788         }
4789         if ( !valid ) return -1;
4790         return value;
4791 }
4792
4793 static int airo_config_commit(struct net_device *dev,
4794                               struct iw_request_info *info, void *zwrq,
4795                               char *extra);
4796
4797 static inline int sniffing_mode(struct airo_info *ai)
4798 {
4799         return (le16_to_cpu(ai->config.rmode) & le16_to_cpu(RXMODE_MASK)) >=
4800                 le16_to_cpu(RXMODE_RFMON);
4801 }
4802
4803 static void proc_config_on_close(struct inode *inode, struct file *file)
4804 {
4805         struct proc_data *data = file->private_data;
4806         struct net_device *dev = PDE_DATA(inode);
4807         struct airo_info *ai = dev->ml_priv;
4808         char *line;
4809
4810         if ( !data->writelen ) return;
4811
4812         readConfigRid(ai, 1);
4813         set_bit (FLAG_COMMIT, &ai->flags);
4814
4815         line = data->wbuffer;
4816         while( line[0] ) {
4817 /*** Mode processing */
4818                 if ( !strncmp( line, "Mode: ", 6 ) ) {
4819                         line += 6;
4820                         if (sniffing_mode(ai))
4821                                 set_bit (FLAG_RESET, &ai->flags);
4822                         ai->config.rmode &= ~RXMODE_FULL_MASK;
4823                         clear_bit (FLAG_802_11, &ai->flags);
4824                         ai->config.opmode &= ~MODE_CFG_MASK;
4825                         ai->config.scanMode = SCANMODE_ACTIVE;
4826                         if ( line[0] == 'a' ) {
4827                                 ai->config.opmode |= MODE_STA_IBSS;
4828                         } else {
4829                                 ai->config.opmode |= MODE_STA_ESS;
4830                                 if ( line[0] == 'r' ) {
4831                                         ai->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
4832                                         ai->config.scanMode = SCANMODE_PASSIVE;
4833                                         set_bit (FLAG_802_11, &ai->flags);
4834                                 } else if ( line[0] == 'y' ) {
4835                                         ai->config.rmode |= RXMODE_RFMON_ANYBSS | RXMODE_DISABLE_802_3_HEADER;
4836                                         ai->config.scanMode = SCANMODE_PASSIVE;
4837                                         set_bit (FLAG_802_11, &ai->flags);
4838                                 } else if ( line[0] == 'l' )
4839                                         ai->config.rmode |= RXMODE_LANMON;
4840                         }
4841                         set_bit (FLAG_COMMIT, &ai->flags);
4842                 }
4843
4844 /*** Radio status */
4845                 else if (!strncmp(line,"Radio: ", 7)) {
4846                         line += 7;
4847                         if (!strncmp(line,"off",3)) {
4848                                 set_bit (FLAG_RADIO_OFF, &ai->flags);
4849                         } else {
4850                                 clear_bit (FLAG_RADIO_OFF, &ai->flags);
4851                         }
4852                 }
4853 /*** NodeName processing */
4854                 else if ( !strncmp( line, "NodeName: ", 10 ) ) {
4855                         int j;
4856
4857                         line += 10;
4858                         memset( ai->config.nodeName, 0, 16 );
4859 /* Do the name, assume a space between the mode and node name */
4860                         for( j = 0; j < 16 && line[j] != '\n'; j++ ) {
4861                                 ai->config.nodeName[j] = line[j];
4862                         }
4863                         set_bit (FLAG_COMMIT, &ai->flags);
4864                 }
4865
4866 /*** PowerMode processing */
4867                 else if ( !strncmp( line, "PowerMode: ", 11 ) ) {
4868                         line += 11;
4869                         if ( !strncmp( line, "PSPCAM", 6 ) ) {
4870                                 ai->config.powerSaveMode = POWERSAVE_PSPCAM;
4871                                 set_bit (FLAG_COMMIT, &ai->flags);
4872                         } else if ( !strncmp( line, "PSP", 3 ) ) {
4873                                 ai->config.powerSaveMode = POWERSAVE_PSP;
4874                                 set_bit (FLAG_COMMIT, &ai->flags);
4875                         } else {
4876                                 ai->config.powerSaveMode = POWERSAVE_CAM;
4877                                 set_bit (FLAG_COMMIT, &ai->flags);
4878                         }
4879                 } else if ( !strncmp( line, "DataRates: ", 11 ) ) {
4880                         int v, i = 0, k = 0; /* i is index into line,
4881                                                 k is index to rates */
4882
4883                         line += 11;
4884                         while((v = get_dec_u16(line, &i, 3))!=-1) {
4885                                 ai->config.rates[k++] = (u8)v;
4886                                 line += i + 1;
4887                                 i = 0;
4888                         }
4889                         set_bit (FLAG_COMMIT, &ai->flags);
4890                 } else if ( !strncmp( line, "Channel: ", 9 ) ) {
4891                         int v, i = 0;
4892                         line += 9;
4893                         v = get_dec_u16(line, &i, i+3);
4894                         if ( v != -1 ) {
4895                                 ai->config.channelSet = cpu_to_le16(v);
4896                                 set_bit (FLAG_COMMIT, &ai->flags);
4897                         }
4898                 } else if ( !strncmp( line, "XmitPower: ", 11 ) ) {
4899                         int v, i = 0;
4900                         line += 11;
4901                         v = get_dec_u16(line, &i, i+3);
4902                         if ( v != -1 ) {
4903                                 ai->config.txPower = cpu_to_le16(v);
4904                                 set_bit (FLAG_COMMIT, &ai->flags);
4905                         }
4906                 } else if ( !strncmp( line, "WEP: ", 5 ) ) {
4907                         line += 5;
4908                         switch( line[0] ) {
4909                         case 's':
4910                                 set_auth_type(ai, AUTH_SHAREDKEY);
4911                                 break;
4912                         case 'e':
4913                                 set_auth_type(ai, AUTH_ENCRYPT);
4914                                 break;
4915                         default:
4916                                 set_auth_type(ai, AUTH_OPEN);
4917                                 break;
4918                         }
4919                         set_bit (FLAG_COMMIT, &ai->flags);
4920                 } else if ( !strncmp( line, "LongRetryLimit: ", 16 ) ) {
4921                         int v, i = 0;
4922
4923                         line += 16;
4924                         v = get_dec_u16(line, &i, 3);
4925                         v = (v<0) ? 0 : ((v>255) ? 255 : v);
4926                         ai->config.longRetryLimit = cpu_to_le16(v);
4927                         set_bit (FLAG_COMMIT, &ai->flags);
4928                 } else if ( !strncmp( line, "ShortRetryLimit: ", 17 ) ) {
4929                         int v, i = 0;
4930
4931                         line += 17;
4932                         v = get_dec_u16(line, &i, 3);
4933                         v = (v<0) ? 0 : ((v>255) ? 255 : v);
4934                         ai->config.shortRetryLimit = cpu_to_le16(v);
4935                         set_bit (FLAG_COMMIT, &ai->flags);
4936                 } else if ( !strncmp( line, "RTSThreshold: ", 14 ) ) {
4937                         int v, i = 0;
4938
4939                         line += 14;
4940                         v = get_dec_u16(line, &i, 4);
4941                         v = (v<0) ? 0 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v);
4942                         ai->config.rtsThres = cpu_to_le16(v);
4943                         set_bit (FLAG_COMMIT, &ai->flags);
4944                 } else if ( !strncmp( line, "TXMSDULifetime: ", 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.txLifetime = cpu_to_le16(v);
4951                         set_bit (FLAG_COMMIT, &ai->flags);
4952                 } else if ( !strncmp( line, "RXMSDULifetime: ", 16 ) ) {
4953                         int v, i = 0;
4954
4955                         line += 16;
4956                         v = get_dec_u16(line, &i, 5);
4957                         v = (v<0) ? 0 : v;
4958                         ai->config.rxLifetime = cpu_to_le16(v);
4959                         set_bit (FLAG_COMMIT, &ai->flags);
4960                 } else if ( !strncmp( line, "TXDiversity: ", 13 ) ) {
4961                         ai->config.txDiversity =
4962                                 (line[13]=='l') ? 1 :
4963                                 ((line[13]=='r')? 2: 3);
4964                         set_bit (FLAG_COMMIT, &ai->flags);
4965                 } else if ( !strncmp( line, "RXDiversity: ", 13 ) ) {
4966                         ai->config.rxDiversity =
4967                                 (line[13]=='l') ? 1 :
4968                                 ((line[13]=='r')? 2: 3);
4969                         set_bit (FLAG_COMMIT, &ai->flags);
4970                 } else if ( !strncmp( line, "FragThreshold: ", 15 ) ) {
4971                         int v, i = 0;
4972
4973                         line += 15;
4974                         v = get_dec_u16(line, &i, 4);
4975                         v = (v<256) ? 256 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v);
4976                         v = v & 0xfffe; /* Make sure its even */
4977                         ai->config.fragThresh = cpu_to_le16(v);
4978                         set_bit (FLAG_COMMIT, &ai->flags);
4979                 } else if (!strncmp(line, "Modulation: ", 12)) {
4980                         line += 12;
4981                         switch(*line) {
4982                         case 'd':  ai->config.modulation=MOD_DEFAULT; set_bit(FLAG_COMMIT, &ai->flags); break;
4983                         case 'c':  ai->config.modulation=MOD_CCK; set_bit(FLAG_COMMIT, &ai->flags); break;
4984                         case 'm':  ai->config.modulation=MOD_MOK; set_bit(FLAG_COMMIT, &ai->flags); break;
4985                         default: airo_print_warn(ai->dev->name, "Unknown modulation");
4986                         }
4987                 } else if (!strncmp(line, "Preamble: ", 10)) {
4988                         line += 10;
4989                         switch(*line) {
4990                         case 'a': ai->config.preamble=PREAMBLE_AUTO; set_bit(FLAG_COMMIT, &ai->flags); break;
4991                         case 'l': ai->config.preamble=PREAMBLE_LONG; set_bit(FLAG_COMMIT, &ai->flags); break;
4992                         case 's': ai->config.preamble=PREAMBLE_SHORT; set_bit(FLAG_COMMIT, &ai->flags); break;
4993                         default: airo_print_warn(ai->dev->name, "Unknown preamble");
4994                         }
4995                 } else {
4996                         airo_print_warn(ai->dev->name, "Couldn't figure out %s", line);
4997                 }
4998                 while( line[0] && line[0] != '\n' ) line++;
4999                 if ( line[0] ) line++;
5000         }
5001         airo_config_commit(dev, NULL, NULL, NULL);
5002 }
5003
5004 static const char *get_rmode(__le16 mode)
5005 {
5006         switch(mode & RXMODE_MASK) {
5007         case RXMODE_RFMON:  return "rfmon";
5008         case RXMODE_RFMON_ANYBSS:  return "yna (any) bss rfmon";
5009         case RXMODE_LANMON:  return "lanmon";
5010         }
5011         return "ESS";
5012 }
5013
5014 static int proc_config_open(struct inode *inode, struct file *file)
5015 {
5016         struct proc_data *data;
5017         struct net_device *dev = PDE_DATA(inode);
5018         struct airo_info *ai = dev->ml_priv;
5019         int i;
5020         __le16 mode;
5021
5022         if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5023                 return -ENOMEM;
5024         data = file->private_data;
5025         if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
5026                 kfree (file->private_data);
5027                 return -ENOMEM;
5028         }
5029         if ((data->wbuffer = kzalloc( 2048, GFP_KERNEL )) == NULL) {
5030                 kfree (data->rbuffer);
5031                 kfree (file->private_data);
5032                 return -ENOMEM;
5033         }
5034         data->maxwritelen = 2048;
5035         data->on_close = proc_config_on_close;
5036
5037         readConfigRid(ai, 1);
5038
5039         mode = ai->config.opmode & MODE_CFG_MASK;
5040         i = sprintf( data->rbuffer,
5041                      "Mode: %s\n"
5042                      "Radio: %s\n"
5043                      "NodeName: %-16s\n"
5044                      "PowerMode: %s\n"
5045                      "DataRates: %d %d %d %d %d %d %d %d\n"
5046                      "Channel: %d\n"
5047                      "XmitPower: %d\n",
5048                      mode == MODE_STA_IBSS ? "adhoc" :
5049                      mode == MODE_STA_ESS ? get_rmode(ai->config.rmode):
5050                      mode == MODE_AP ? "AP" :
5051                      mode == MODE_AP_RPTR ? "AP RPTR" : "Error",
5052                      test_bit(FLAG_RADIO_OFF, &ai->flags) ? "off" : "on",
5053                      ai->config.nodeName,
5054                      ai->config.powerSaveMode == POWERSAVE_CAM ? "CAM" :
5055                      ai->config.powerSaveMode == POWERSAVE_PSP ? "PSP" :
5056                      ai->config.powerSaveMode == POWERSAVE_PSPCAM ? "PSPCAM" :
5057                      "Error",
5058                      (int)ai->config.rates[0],
5059                      (int)ai->config.rates[1],
5060                      (int)ai->config.rates[2],
5061                      (int)ai->config.rates[3],
5062                      (int)ai->config.rates[4],
5063                      (int)ai->config.rates[5],
5064                      (int)ai->config.rates[6],
5065                      (int)ai->config.rates[7],
5066                      le16_to_cpu(ai->config.channelSet),
5067                      le16_to_cpu(ai->config.txPower)
5068                 );
5069         sprintf( data->rbuffer + i,
5070                  "LongRetryLimit: %d\n"
5071                  "ShortRetryLimit: %d\n"
5072                  "RTSThreshold: %d\n"
5073                  "TXMSDULifetime: %d\n"
5074                  "RXMSDULifetime: %d\n"
5075                  "TXDiversity: %s\n"
5076                  "RXDiversity: %s\n"
5077                  "FragThreshold: %d\n"
5078                  "WEP: %s\n"
5079                  "Modulation: %s\n"
5080                  "Preamble: %s\n",
5081                  le16_to_cpu(ai->config.longRetryLimit),
5082                  le16_to_cpu(ai->config.shortRetryLimit),
5083                  le16_to_cpu(ai->config.rtsThres),
5084                  le16_to_cpu(ai->config.txLifetime),
5085                  le16_to_cpu(ai->config.rxLifetime),
5086                  ai->config.txDiversity == 1 ? "left" :
5087                  ai->config.txDiversity == 2 ? "right" : "both",
5088                  ai->config.rxDiversity == 1 ? "left" :
5089                  ai->config.rxDiversity == 2 ? "right" : "both",
5090                  le16_to_cpu(ai->config.fragThresh),
5091                  ai->config.authType == AUTH_ENCRYPT ? "encrypt" :
5092                  ai->config.authType == AUTH_SHAREDKEY ? "shared" : "open",
5093                  ai->config.modulation == MOD_DEFAULT ? "default" :
5094                  ai->config.modulation == MOD_CCK ? "cck" :
5095                  ai->config.modulation == MOD_MOK ? "mok" : "error",
5096                  ai->config.preamble == PREAMBLE_AUTO ? "auto" :
5097                  ai->config.preamble == PREAMBLE_LONG ? "long" :
5098                  ai->config.preamble == PREAMBLE_SHORT ? "short" : "error"
5099                 );
5100         data->readlen = strlen( data->rbuffer );
5101         return 0;
5102 }
5103
5104 static void proc_SSID_on_close(struct inode *inode, struct file *file)
5105 {
5106         struct proc_data *data = file->private_data;
5107         struct net_device *dev = PDE_DATA(inode);
5108         struct airo_info *ai = dev->ml_priv;
5109         SsidRid SSID_rid;
5110         int i;
5111         char *p = data->wbuffer;
5112         char *end = p + data->writelen;
5113
5114         if (!data->writelen)
5115                 return;
5116
5117         *end = '\n'; /* sentinel; we have space for it */
5118
5119         memset(&SSID_rid, 0, sizeof(SSID_rid));
5120
5121         for (i = 0; i < 3 && p < end; i++) {
5122                 int j = 0;
5123                 /* copy up to 32 characters from this line */
5124                 while (*p != '\n' && j < 32)
5125                         SSID_rid.ssids[i].ssid[j++] = *p++;
5126                 if (j == 0)
5127                         break;
5128                 SSID_rid.ssids[i].len = cpu_to_le16(j);
5129                 /* skip to the beginning of the next line */
5130                 while (*p++ != '\n')
5131                         ;
5132         }
5133         if (i)
5134                 SSID_rid.len = cpu_to_le16(sizeof(SSID_rid));
5135         disable_MAC(ai, 1);
5136         writeSsidRid(ai, &SSID_rid, 1);
5137         enable_MAC(ai, 1);
5138 }
5139
5140 static void proc_APList_on_close( struct inode *inode, struct file *file ) {
5141         struct proc_data *data = file->private_data;
5142         struct net_device *dev = PDE_DATA(inode);
5143         struct airo_info *ai = dev->ml_priv;
5144         APListRid *APList_rid = &ai->APList;
5145         int i;
5146
5147         if ( !data->writelen ) return;
5148
5149         memset(APList_rid, 0, sizeof(*APList_rid));
5150         APList_rid->len = cpu_to_le16(sizeof(*APList_rid));
5151
5152         for (i = 0; i < 4 && data->writelen >= (i + 1) * 6 * 3; i++)
5153                 mac_pton(data->wbuffer + i * 6 * 3, APList_rid->ap[i]);
5154
5155         disable_MAC(ai, 1);
5156         writeAPListRid(ai, APList_rid, 1);
5157         enable_MAC(ai, 1);
5158 }
5159
5160 /* This function wraps PC4500_writerid with a MAC disable */
5161 static int do_writerid( struct airo_info *ai, u16 rid, const void *rid_data,
5162                         int len, int dummy ) {
5163         int rc;
5164
5165         disable_MAC(ai, 1);
5166         rc = PC4500_writerid(ai, rid, rid_data, len, 1);
5167         enable_MAC(ai, 1);
5168         return rc;
5169 }
5170
5171 /* Returns the WEP key at the specified index, or -1 if that key does
5172  * not exist.  The buffer is assumed to be at least 16 bytes in length.
5173  */
5174 static int get_wep_key(struct airo_info *ai, u16 index, char *buf, u16 buflen)
5175 {
5176         WepKeyRid wkr;
5177         int rc;
5178         __le16 lastindex;
5179
5180         rc = readWepKeyRid(ai, &wkr, 1, 1);
5181         if (rc != SUCCESS)
5182                 return -1;
5183         do {
5184                 lastindex = wkr.kindex;
5185                 if (le16_to_cpu(wkr.kindex) == index) {
5186                         int klen = min_t(int, buflen, le16_to_cpu(wkr.klen));
5187                         memcpy(buf, wkr.key, klen);
5188                         return klen;
5189                 }
5190                 rc = readWepKeyRid(ai, &wkr, 0, 1);
5191                 if (rc != SUCCESS)
5192                         return -1;
5193         } while (lastindex != wkr.kindex);
5194         return -1;
5195 }
5196
5197 static int get_wep_tx_idx(struct airo_info *ai)
5198 {
5199         WepKeyRid wkr;
5200         int rc;
5201         __le16 lastindex;
5202
5203         rc = readWepKeyRid(ai, &wkr, 1, 1);
5204         if (rc != SUCCESS)
5205                 return -1;
5206         do {
5207                 lastindex = wkr.kindex;
5208                 if (wkr.kindex == cpu_to_le16(0xffff))
5209                         return wkr.mac[0];
5210                 rc = readWepKeyRid(ai, &wkr, 0, 1);
5211                 if (rc != SUCCESS)
5212                         return -1;
5213         } while (lastindex != wkr.kindex);
5214         return -1;
5215 }
5216
5217 static int set_wep_key(struct airo_info *ai, u16 index, const char *key,
5218                        u16 keylen, int perm, int lock)
5219 {
5220         static const unsigned char macaddr[ETH_ALEN] = { 0x01, 0, 0, 0, 0, 0 };
5221         WepKeyRid wkr;
5222         int rc;
5223
5224         if (WARN_ON(keylen == 0))
5225                 return -1;
5226
5227         memset(&wkr, 0, sizeof(wkr));
5228         wkr.len = cpu_to_le16(sizeof(wkr));
5229         wkr.kindex = cpu_to_le16(index);
5230         wkr.klen = cpu_to_le16(keylen);
5231         memcpy(wkr.key, key, keylen);
5232         memcpy(wkr.mac, macaddr, ETH_ALEN);
5233
5234         if (perm) disable_MAC(ai, lock);
5235         rc = writeWepKeyRid(ai, &wkr, perm, lock);
5236         if (perm) enable_MAC(ai, lock);
5237         return rc;
5238 }
5239
5240 static int set_wep_tx_idx(struct airo_info *ai, u16 index, int perm, int lock)
5241 {
5242         WepKeyRid wkr;
5243         int rc;
5244
5245         memset(&wkr, 0, sizeof(wkr));
5246         wkr.len = cpu_to_le16(sizeof(wkr));
5247         wkr.kindex = cpu_to_le16(0xffff);
5248         wkr.mac[0] = (char)index;
5249
5250         if (perm) {
5251                 ai->defindex = (char)index;
5252                 disable_MAC(ai, lock);
5253         }
5254
5255         rc = writeWepKeyRid(ai, &wkr, perm, lock);
5256
5257         if (perm)
5258                 enable_MAC(ai, lock);
5259         return rc;
5260 }
5261
5262 static void proc_wepkey_on_close( struct inode *inode, struct file *file ) {
5263         struct proc_data *data;
5264         struct net_device *dev = PDE_DATA(inode);
5265         struct airo_info *ai = dev->ml_priv;
5266         int i, rc;
5267         char key[16];
5268         u16 index = 0;
5269         int j = 0;
5270
5271         memset(key, 0, sizeof(key));
5272
5273         data = file->private_data;
5274         if ( !data->writelen ) return;
5275
5276         if (data->wbuffer[0] >= '0' && data->wbuffer[0] <= '3' &&
5277             (data->wbuffer[1] == ' ' || data->wbuffer[1] == '\n')) {
5278                 index = data->wbuffer[0] - '0';
5279                 if (data->wbuffer[1] == '\n') {
5280                         rc = set_wep_tx_idx(ai, index, 1, 1);
5281                         if (rc < 0) {
5282                                 airo_print_err(ai->dev->name, "failed to set "
5283                                                "WEP transmit index to %d: %d.",
5284                                                index, rc);
5285                         }
5286                         return;
5287                 }
5288                 j = 2;
5289         } else {
5290                 airo_print_err(ai->dev->name, "WepKey passed invalid key index");
5291                 return;
5292         }
5293
5294         for( i = 0; i < 16*3 && data->wbuffer[i+j]; i++ ) {
5295                 switch(i%3) {
5296                 case 0:
5297                         key[i/3] = hex_to_bin(data->wbuffer[i+j])<<4;
5298                         break;
5299                 case 1:
5300                         key[i/3] |= hex_to_bin(data->wbuffer[i+j]);
5301                         break;
5302                 }
5303         }
5304
5305         rc = set_wep_key(ai, index, key, i/3, 1, 1);
5306         if (rc < 0) {
5307                 airo_print_err(ai->dev->name, "failed to set WEP key at index "
5308                                "%d: %d.", index, rc);
5309         }
5310 }
5311
5312 static int proc_wepkey_open( struct inode *inode, struct file *file )
5313 {
5314         struct proc_data *data;
5315         struct net_device *dev = PDE_DATA(inode);
5316         struct airo_info *ai = dev->ml_priv;
5317         char *ptr;
5318         WepKeyRid wkr;
5319         __le16 lastindex;
5320         int j=0;
5321         int rc;
5322
5323         if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5324                 return -ENOMEM;
5325         memset(&wkr, 0, sizeof(wkr));
5326         data = file->private_data;
5327         if ((data->rbuffer = kzalloc( 180, GFP_KERNEL )) == NULL) {
5328                 kfree (file->private_data);
5329                 return -ENOMEM;
5330         }
5331         data->writelen = 0;
5332         data->maxwritelen = 80;
5333         if ((data->wbuffer = kzalloc( 80, GFP_KERNEL )) == NULL) {
5334                 kfree (data->rbuffer);
5335                 kfree (file->private_data);
5336                 return -ENOMEM;
5337         }
5338         data->on_close = proc_wepkey_on_close;
5339
5340         ptr = data->rbuffer;
5341         strcpy(ptr, "No wep keys\n");
5342         rc = readWepKeyRid(ai, &wkr, 1, 1);
5343         if (rc == SUCCESS) do {
5344                 lastindex = wkr.kindex;
5345                 if (wkr.kindex == cpu_to_le16(0xffff)) {
5346                         j += sprintf(ptr+j, "Tx key = %d\n",
5347                                      (int)wkr.mac[0]);
5348                 } else {
5349                         j += sprintf(ptr+j, "Key %d set with length = %d\n",
5350                                      le16_to_cpu(wkr.kindex),
5351                                      le16_to_cpu(wkr.klen));
5352                 }
5353                 readWepKeyRid(ai, &wkr, 0, 1);
5354         } while((lastindex != wkr.kindex) && (j < 180-30));
5355
5356         data->readlen = strlen( data->rbuffer );
5357         return 0;
5358 }
5359
5360 static int proc_SSID_open(struct inode *inode, struct file *file)
5361 {
5362         struct proc_data *data;
5363         struct net_device *dev = PDE_DATA(inode);
5364         struct airo_info *ai = dev->ml_priv;
5365         int i;
5366         char *ptr;
5367         SsidRid SSID_rid;
5368
5369         if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5370                 return -ENOMEM;
5371         data = file->private_data;
5372         if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5373                 kfree (file->private_data);
5374                 return -ENOMEM;
5375         }
5376         data->writelen = 0;
5377         data->maxwritelen = 33*3;
5378         /* allocate maxwritelen + 1; we'll want a sentinel */
5379         if ((data->wbuffer = kzalloc(33*3 + 1, GFP_KERNEL)) == NULL) {
5380                 kfree (data->rbuffer);
5381                 kfree (file->private_data);
5382                 return -ENOMEM;
5383         }
5384         data->on_close = proc_SSID_on_close;
5385
5386         readSsidRid(ai, &SSID_rid);
5387         ptr = data->rbuffer;
5388         for (i = 0; i < 3; i++) {
5389                 int j;
5390                 size_t len = le16_to_cpu(SSID_rid.ssids[i].len);
5391                 if (!len)
5392                         break;
5393                 if (len > 32)
5394                         len = 32;
5395                 for (j = 0; j < len && SSID_rid.ssids[i].ssid[j]; j++)
5396                         *ptr++ = SSID_rid.ssids[i].ssid[j];
5397                 *ptr++ = '\n';
5398         }
5399         *ptr = '\0';
5400         data->readlen = strlen( data->rbuffer );
5401         return 0;
5402 }
5403
5404 static int proc_APList_open( struct inode *inode, struct file *file ) {
5405         struct proc_data *data;
5406         struct net_device *dev = PDE_DATA(inode);
5407         struct airo_info *ai = dev->ml_priv;
5408         int i;
5409         char *ptr;
5410         APListRid *APList_rid = &ai->APList;
5411
5412         if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5413                 return -ENOMEM;
5414         data = file->private_data;
5415         if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
5416                 kfree (file->private_data);
5417                 return -ENOMEM;
5418         }
5419         data->writelen = 0;
5420         data->maxwritelen = 4*6*3;
5421         if ((data->wbuffer = kzalloc( data->maxwritelen, GFP_KERNEL )) == NULL) {
5422                 kfree (data->rbuffer);
5423                 kfree (file->private_data);
5424                 return -ENOMEM;
5425         }
5426         data->on_close = proc_APList_on_close;
5427
5428         ptr = data->rbuffer;
5429         for( i = 0; i < 4; i++ ) {
5430 // We end when we find a zero MAC
5431                 if ( !*(int*)APList_rid->ap[i] &&
5432                      !*(int*)&APList_rid->ap[i][2]) break;
5433                 ptr += sprintf(ptr, "%pM\n", APList_rid->ap[i]);
5434         }
5435         if (i==0) ptr += sprintf(ptr, "Not using specific APs\n");
5436
5437         *ptr = '\0';
5438         data->readlen = strlen( data->rbuffer );
5439         return 0;
5440 }
5441
5442 static int proc_BSSList_open( struct inode *inode, struct file *file ) {
5443         struct proc_data *data;
5444         struct net_device *dev = PDE_DATA(inode);
5445         struct airo_info *ai = dev->ml_priv;
5446         char *ptr;
5447         BSSListRid BSSList_rid;
5448         int rc;
5449         /* If doLoseSync is not 1, we won't do a Lose Sync */
5450         int doLoseSync = -1;
5451
5452         if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
5453                 return -ENOMEM;
5454         data = file->private_data;
5455         if ((data->rbuffer = kmalloc( 1024, GFP_KERNEL )) == NULL) {
5456                 kfree (file->private_data);
5457                 return -ENOMEM;
5458         }
5459         data->writelen = 0;
5460         data->maxwritelen = 0;
5461         data->wbuffer = NULL;
5462         data->on_close = NULL;
5463
5464         if (file->f_mode & FMODE_WRITE) {
5465                 if (!(file->f_mode & FMODE_READ)) {
5466                         Cmd cmd;
5467                         Resp rsp;
5468
5469                         if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
5470                         memset(&cmd, 0, sizeof(cmd));
5471                         cmd.cmd=CMD_LISTBSS;
5472                         if (down_interruptible(&ai->sem))
5473                                 return -ERESTARTSYS;
5474                         issuecommand(ai, &cmd, &rsp);
5475                         up(&ai->sem);
5476                         data->readlen = 0;
5477                         return 0;
5478                 }
5479                 doLoseSync = 1;
5480         }
5481         ptr = data->rbuffer;
5482         /* There is a race condition here if there are concurrent opens.
5483            Since it is a rare condition, we'll just live with it, otherwise
5484            we have to add a spin lock... */
5485         rc = readBSSListRid(ai, doLoseSync, &BSSList_rid);
5486         while(rc == 0 && BSSList_rid.index != cpu_to_le16(0xffff)) {
5487                 ptr += sprintf(ptr, "%pM %.*s rssi = %d",
5488                                BSSList_rid.bssid,
5489                                 (int)BSSList_rid.ssidLen,
5490                                 BSSList_rid.ssid,
5491                                 le16_to_cpu(BSSList_rid.dBm));
5492                 ptr += sprintf(ptr, " channel = %d %s %s %s %s\n",
5493                                 le16_to_cpu(BSSList_rid.dsChannel),
5494                                 BSSList_rid.cap & CAP_ESS ? "ESS" : "",
5495                                 BSSList_rid.cap & CAP_IBSS ? "adhoc" : "",
5496                                 BSSList_rid.cap & CAP_PRIVACY ? "wep" : "",
5497                                 BSSList_rid.cap & CAP_SHORTHDR ? "shorthdr" : "");
5498                 rc = readBSSListRid(ai, 0, &BSSList_rid);
5499         }
5500         *ptr = '\0';
5501         data->readlen = strlen( data->rbuffer );
5502         return 0;
5503 }
5504
5505 static int proc_close( struct inode *inode, struct file *file )
5506 {
5507         struct proc_data *data = file->private_data;
5508
5509         if (data->on_close != NULL)
5510                 data->on_close(inode, file);
5511         kfree(data->rbuffer);
5512         kfree(data->wbuffer);
5513         kfree(data);
5514         return 0;
5515 }
5516
5517 /* Since the card doesn't automatically switch to the right WEP mode,
5518    we will make it do it.  If the card isn't associated, every secs we
5519    will switch WEP modes to see if that will help.  If the card is
5520    associated we will check every minute to see if anything has
5521    changed. */
5522 static void timer_func( struct net_device *dev ) {
5523         struct airo_info *apriv = dev->ml_priv;
5524
5525 /* We don't have a link so try changing the authtype */
5526         readConfigRid(apriv, 0);
5527         disable_MAC(apriv, 0);
5528         switch(apriv->config.authType) {
5529                 case AUTH_ENCRYPT:
5530 /* So drop to OPEN */
5531                         apriv->config.authType = AUTH_OPEN;
5532                         break;
5533                 case AUTH_SHAREDKEY:
5534                         if (apriv->keyindex < auto_wep) {
5535                                 set_wep_tx_idx(apriv, apriv->keyindex, 0, 0);
5536                                 apriv->config.authType = AUTH_SHAREDKEY;
5537                                 apriv->keyindex++;
5538                         } else {
5539                                 /* Drop to ENCRYPT */
5540                                 apriv->keyindex = 0;
5541                                 set_wep_tx_idx(apriv, apriv->defindex, 0, 0);
5542                                 apriv->config.authType = AUTH_ENCRYPT;
5543                         }
5544                         break;
5545                 default:  /* We'll escalate to SHAREDKEY */
5546                         apriv->config.authType = AUTH_SHAREDKEY;
5547         }
5548         set_bit (FLAG_COMMIT, &apriv->flags);
5549         writeConfigRid(apriv, 0);
5550         enable_MAC(apriv, 0);
5551         up(&apriv->sem);
5552
5553 /* Schedule check to see if the change worked */
5554         clear_bit(JOB_AUTOWEP, &apriv->jobs);
5555         apriv->expires = RUN_AT(HZ*3);
5556 }
5557
5558 #ifdef CONFIG_PCI
5559 static int airo_pci_probe(struct pci_dev *pdev,
5560                                     const struct pci_device_id *pent)
5561 {
5562         struct net_device *dev;
5563
5564         if (pci_enable_device(pdev))
5565                 return -ENODEV;
5566         pci_set_master(pdev);
5567
5568         if (pdev->device == 0x5000 || pdev->device == 0xa504)
5569                         dev = _init_airo_card(pdev->irq, pdev->resource[0].start, 0, pdev, &pdev->dev);
5570         else
5571                         dev = _init_airo_card(pdev->irq, pdev->resource[2].start, 0, pdev, &pdev->dev);
5572         if (!dev) {
5573                 pci_disable_device(pdev);
5574                 return -ENODEV;
5575         }
5576
5577         pci_set_drvdata(pdev, dev);
5578         return 0;
5579 }
5580
5581 static void airo_pci_remove(struct pci_dev *pdev)
5582 {
5583         struct net_device *dev = pci_get_drvdata(pdev);
5584
5585         airo_print_info(dev->name, "Unregistering...");
5586         stop_airo_card(dev, 1);
5587         pci_disable_device(pdev);
5588 }
5589
5590 static int airo_pci_suspend(struct pci_dev *pdev, pm_message_t state)
5591 {
5592         struct net_device *dev = pci_get_drvdata(pdev);
5593         struct airo_info *ai = dev->ml_priv;
5594         Cmd cmd;
5595         Resp rsp;
5596
5597         if (!ai->SSID)
5598                 ai->SSID = kmalloc(sizeof(SsidRid), GFP_KERNEL);
5599         if (!ai->SSID)
5600                 return -ENOMEM;
5601         readSsidRid(ai, ai->SSID);
5602         memset(&cmd, 0, sizeof(cmd));
5603         /* the lock will be released at the end of the resume callback */
5604         if (down_interruptible(&ai->sem))
5605                 return -EAGAIN;
5606         disable_MAC(ai, 0);
5607         netif_device_detach(dev);
5608         ai->power = state;
5609         cmd.cmd = HOSTSLEEP;
5610         issuecommand(ai, &cmd, &rsp);
5611
5612         pci_enable_wake(pdev, pci_choose_state(pdev, state), 1);
5613         pci_save_state(pdev);
5614         pci_set_power_state(pdev, pci_choose_state(pdev, state));
5615         return 0;
5616 }
5617
5618 static int airo_pci_resume(struct pci_dev *pdev)
5619 {
5620         struct net_device *dev = pci_get_drvdata(pdev);
5621         struct airo_info *ai = dev->ml_priv;
5622         pci_power_t prev_state = pdev->current_state;
5623
5624         pci_set_power_state(pdev, PCI_D0);
5625         pci_restore_state(pdev);
5626         pci_enable_wake(pdev, PCI_D0, 0);
5627
5628         if (prev_state != PCI_D1) {
5629                 reset_card(dev, 0);
5630                 mpi_init_descriptors(ai);
5631                 setup_card(ai, dev->dev_addr, 0);
5632                 clear_bit(FLAG_RADIO_OFF, &ai->flags);
5633                 clear_bit(FLAG_PENDING_XMIT, &ai->flags);
5634         } else {
5635                 OUT4500(ai, EVACK, EV_AWAKEN);
5636                 OUT4500(ai, EVACK, EV_AWAKEN);
5637                 msleep(100);
5638         }
5639
5640         set_bit(FLAG_COMMIT, &ai->flags);
5641         disable_MAC(ai, 0);
5642         msleep(200);
5643         if (ai->SSID) {
5644                 writeSsidRid(ai, ai->SSID, 0);
5645                 kfree(ai->SSID);
5646                 ai->SSID = NULL;
5647         }
5648         writeAPListRid(ai, &ai->APList, 0);
5649         writeConfigRid(ai, 0);
5650         enable_MAC(ai, 0);
5651         ai->power = PMSG_ON;
5652         netif_device_attach(dev);
5653         netif_wake_queue(dev);
5654         enable_interrupts(ai);
5655         up(&ai->sem);
5656         return 0;
5657 }
5658 #endif
5659
5660 static int __init airo_init_module( void )
5661 {
5662         int i;
5663
5664         proc_kuid = make_kuid(&init_user_ns, proc_uid);
5665         proc_kgid = make_kgid(&init_user_ns, proc_gid);
5666         if (!uid_valid(proc_kuid) || !gid_valid(proc_kgid))
5667                 return -EINVAL;
5668
5669         airo_entry = proc_mkdir_mode("driver/aironet", airo_perm, NULL);
5670
5671         if (airo_entry)
5672                 proc_set_user(airo_entry, proc_kuid, proc_kgid);
5673
5674         for (i = 0; i < 4 && io[i] && irq[i]; i++) {
5675                 airo_print_info("", "Trying to configure ISA adapter at irq=%d "
5676                         "io=0x%x", irq[i], io[i] );
5677                 if (init_airo_card( irq[i], io[i], 0, NULL ))
5678                         /* do nothing */ ;
5679         }
5680
5681 #ifdef CONFIG_PCI
5682         airo_print_info("", "Probing for PCI adapters");
5683         i = pci_register_driver(&airo_driver);
5684         airo_print_info("", "Finished probing for PCI adapters");
5685
5686         if (i) {
5687                 remove_proc_entry("driver/aironet", NULL);
5688                 return i;
5689         }
5690 #endif
5691
5692         /* Always exit with success, as we are a library module
5693          * as well as a driver module
5694          */
5695         return 0;
5696 }
5697
5698 static void __exit airo_cleanup_module( void )
5699 {
5700         struct airo_info *ai;
5701         while(!list_empty(&airo_devices)) {
5702                 ai = list_entry(airo_devices.next, struct airo_info, dev_list);
5703                 airo_print_info(ai->dev->name, "Unregistering...");
5704                 stop_airo_card(ai->dev, 1);
5705         }
5706 #ifdef CONFIG_PCI
5707         pci_unregister_driver(&airo_driver);
5708 #endif
5709         remove_proc_entry("driver/aironet", NULL);
5710 }
5711
5712 /*
5713  * Initial Wireless Extension code for Aironet driver by :
5714  *      Jean Tourrilhes <jt@hpl.hp.com> - HPL - 17 November 00
5715  * Conversion to new driver API by :
5716  *      Jean Tourrilhes <jt@hpl.hp.com> - HPL - 26 March 02
5717  * Javier also did a good amount of work here, adding some new extensions
5718  * and fixing my code. Let's just say that without him this code just
5719  * would not work at all... - Jean II
5720  */
5721
5722 static u8 airo_rssi_to_dbm (tdsRssiEntry *rssi_rid, u8 rssi)
5723 {
5724         if (!rssi_rid)
5725                 return 0;
5726
5727         return (0x100 - rssi_rid[rssi].rssidBm);
5728 }
5729
5730 static u8 airo_dbm_to_pct (tdsRssiEntry *rssi_rid, u8 dbm)
5731 {
5732         int i;
5733
5734         if (!rssi_rid)
5735                 return 0;
5736
5737         for (i = 0; i < 256; i++)
5738                 if (rssi_rid[i].rssidBm == dbm)
5739                         return rssi_rid[i].rssipct;
5740
5741         return 0;
5742 }
5743
5744
5745 static int airo_get_quality (StatusRid *status_rid, CapabilityRid *cap_rid)
5746 {
5747         int quality = 0;
5748         u16 sq;
5749
5750         if ((status_rid->mode & cpu_to_le16(0x3f)) != cpu_to_le16(0x3f))
5751                 return 0;
5752
5753         if (!(cap_rid->hardCap & cpu_to_le16(8)))
5754                 return 0;
5755
5756         sq = le16_to_cpu(status_rid->signalQuality);
5757         if (memcmp(cap_rid->prodName, "350", 3))
5758                 if (sq > 0x20)
5759                         quality = 0;
5760                 else
5761                         quality = 0x20 - sq;
5762         else
5763                 if (sq > 0xb0)
5764                         quality = 0;
5765                 else if (sq < 0x10)
5766                         quality = 0xa0;
5767                 else
5768                         quality = 0xb0 - sq;
5769         return quality;
5770 }
5771
5772 #define airo_get_max_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x20 : 0xa0)
5773 #define airo_get_avg_quality(cap_rid) (memcmp((cap_rid)->prodName, "350", 3) ? 0x10 : 0x50);
5774
5775 /*------------------------------------------------------------------*/
5776 /*
5777  * Wireless Handler : get protocol name
5778  */
5779 static int airo_get_name(struct net_device *dev,
5780                          struct iw_request_info *info,
5781                          char *cwrq,
5782                          char *extra)
5783 {
5784         strcpy(cwrq, "IEEE 802.11-DS");
5785         return 0;
5786 }
5787
5788 /*------------------------------------------------------------------*/
5789 /*
5790  * Wireless Handler : set frequency
5791  */
5792 static int airo_set_freq(struct net_device *dev,
5793                          struct iw_request_info *info,
5794                          struct iw_freq *fwrq,
5795                          char *extra)
5796 {
5797         struct airo_info *local = dev->ml_priv;
5798         int rc = -EINPROGRESS;          /* Call commit handler */
5799
5800         /* If setting by frequency, convert to a channel */
5801         if(fwrq->e == 1) {
5802                 int f = fwrq->m / 100000;
5803
5804                 /* Hack to fall through... */
5805                 fwrq->e = 0;
5806                 fwrq->m = ieee80211_frequency_to_channel(f);
5807         }
5808         /* Setting by channel number */
5809         if (fwrq->m < 0 || fwrq->m > 1000 || fwrq->e > 0)
5810                 rc = -EOPNOTSUPP;
5811         else {
5812                 int channel = fwrq->m;
5813                 /* We should do a better check than that,
5814                  * based on the card capability !!! */
5815                 if((channel < 1) || (channel > 14)) {
5816                         airo_print_dbg(dev->name, "New channel value of %d is invalid!",
5817                                 fwrq->m);
5818                         rc = -EINVAL;
5819                 } else {
5820                         readConfigRid(local, 1);
5821                         /* Yes ! We can set it !!! */
5822                         local->config.channelSet = cpu_to_le16(channel);
5823                         set_bit (FLAG_COMMIT, &local->flags);
5824                 }
5825         }
5826         return rc;
5827 }
5828
5829 /*------------------------------------------------------------------*/
5830 /*
5831  * Wireless Handler : get frequency
5832  */
5833 static int airo_get_freq(struct net_device *dev,
5834                          struct iw_request_info *info,
5835                          struct iw_freq *fwrq,
5836                          char *extra)
5837 {
5838         struct airo_info *local = dev->ml_priv;
5839         StatusRid status_rid;           /* Card status info */
5840         int ch;
5841
5842         readConfigRid(local, 1);
5843         if ((local->config.opmode & MODE_CFG_MASK) == MODE_STA_ESS)
5844                 status_rid.channel = local->config.channelSet;
5845         else
5846                 readStatusRid(local, &status_rid, 1);
5847
5848         ch = le16_to_cpu(status_rid.channel);
5849         if((ch > 0) && (ch < 15)) {
5850                 fwrq->m = 100000 *
5851                         ieee80211_channel_to_frequency(ch, NL80211_BAND_2GHZ);
5852                 fwrq->e = 1;
5853         } else {
5854                 fwrq->m = ch;
5855                 fwrq->e = 0;
5856         }
5857
5858         return 0;
5859 }
5860
5861 /*------------------------------------------------------------------*/
5862 /*
5863  * Wireless Handler : set ESSID
5864  */
5865 static int airo_set_essid(struct net_device *dev,
5866                           struct iw_request_info *info,
5867                           struct iw_point *dwrq,
5868                           char *extra)
5869 {
5870         struct airo_info *local = dev->ml_priv;
5871         SsidRid SSID_rid;               /* SSIDs */
5872
5873         /* Reload the list of current SSID */
5874         readSsidRid(local, &SSID_rid);
5875
5876         /* Check if we asked for `any' */
5877         if (dwrq->flags == 0) {
5878                 /* Just send an empty SSID list */
5879                 memset(&SSID_rid, 0, sizeof(SSID_rid));
5880         } else {
5881                 unsigned index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
5882
5883                 /* Check the size of the string */
5884                 if (dwrq->length > IW_ESSID_MAX_SIZE)
5885                         return -E2BIG ;
5886
5887                 /* Check if index is valid */
5888                 if (index >= ARRAY_SIZE(SSID_rid.ssids))
5889                         return -EINVAL;
5890
5891                 /* Set the SSID */
5892                 memset(SSID_rid.ssids[index].ssid, 0,
5893                        sizeof(SSID_rid.ssids[index].ssid));
5894                 memcpy(SSID_rid.ssids[index].ssid, extra, dwrq->length);
5895                 SSID_rid.ssids[index].len = cpu_to_le16(dwrq->length);
5896         }
5897         SSID_rid.len = cpu_to_le16(sizeof(SSID_rid));
5898         /* Write it to the card */
5899         disable_MAC(local, 1);
5900         writeSsidRid(local, &SSID_rid, 1);
5901         enable_MAC(local, 1);
5902
5903         return 0;
5904 }
5905
5906 /*------------------------------------------------------------------*/
5907 /*
5908  * Wireless Handler : get ESSID
5909  */
5910 static int airo_get_essid(struct net_device *dev,
5911                           struct iw_request_info *info,
5912                           struct iw_point *dwrq,
5913                           char *extra)
5914 {
5915         struct airo_info *local = dev->ml_priv;
5916         StatusRid status_rid;           /* Card status info */
5917
5918         readStatusRid(local, &status_rid, 1);
5919
5920         /* Note : if dwrq->flags != 0, we should
5921          * get the relevant SSID from the SSID list... */
5922
5923         /* Get the current SSID */
5924         memcpy(extra, status_rid.SSID, le16_to_cpu(status_rid.SSIDlen));
5925         /* If none, we may want to get the one that was set */
5926
5927         /* Push it out ! */
5928         dwrq->length = le16_to_cpu(status_rid.SSIDlen);
5929         dwrq->flags = 1; /* active */
5930
5931         return 0;
5932 }
5933
5934 /*------------------------------------------------------------------*/
5935 /*
5936  * Wireless Handler : set AP address
5937  */
5938 static int airo_set_wap(struct net_device *dev,
5939                         struct iw_request_info *info,
5940                         struct sockaddr *awrq,
5941                         char *extra)
5942 {
5943         struct airo_info *local = dev->ml_priv;
5944         Cmd cmd;
5945         Resp rsp;
5946         APListRid *APList_rid = &local->APList;
5947
5948         if (awrq->sa_family != ARPHRD_ETHER)
5949                 return -EINVAL;
5950         else if (is_broadcast_ether_addr(awrq->sa_data) ||
5951                  is_zero_ether_addr(awrq->sa_data)) {
5952                 memset(&cmd, 0, sizeof(cmd));
5953                 cmd.cmd=CMD_LOSE_SYNC;
5954                 if (down_interruptible(&local->sem))
5955                         return -ERESTARTSYS;
5956                 issuecommand(local, &cmd, &rsp);
5957                 up(&local->sem);
5958         } else {
5959                 memset(APList_rid, 0, sizeof(*APList_rid));
5960                 APList_rid->len = cpu_to_le16(sizeof(*APList_rid));
5961                 memcpy(APList_rid->ap[0], awrq->sa_data, ETH_ALEN);
5962                 disable_MAC(local, 1);
5963                 writeAPListRid(local, APList_rid, 1);
5964                 enable_MAC(local, 1);
5965         }
5966         return 0;
5967 }
5968
5969 /*------------------------------------------------------------------*/
5970 /*
5971  * Wireless Handler : get AP address
5972  */
5973 static int airo_get_wap(struct net_device *dev,
5974                         struct iw_request_info *info,
5975                         struct sockaddr *awrq,
5976                         char *extra)
5977 {
5978         struct airo_info *local = dev->ml_priv;
5979         StatusRid status_rid;           /* Card status info */
5980
5981         readStatusRid(local, &status_rid, 1);
5982
5983         /* Tentative. This seems to work, wow, I'm lucky !!! */
5984         memcpy(awrq->sa_data, status_rid.bssid[0], ETH_ALEN);
5985         awrq->sa_family = ARPHRD_ETHER;
5986
5987         return 0;
5988 }
5989
5990 /*------------------------------------------------------------------*/
5991 /*
5992  * Wireless Handler : set Nickname
5993  */
5994 static int airo_set_nick(struct net_device *dev,
5995                          struct iw_request_info *info,
5996                          struct iw_point *dwrq,
5997                          char *extra)
5998 {
5999         struct airo_info *local = dev->ml_priv;
6000
6001         /* Check the size of the string */
6002         if(dwrq->length > 16) {
6003                 return -E2BIG;
6004         }
6005         readConfigRid(local, 1);
6006         memset(local->config.nodeName, 0, sizeof(local->config.nodeName));
6007         memcpy(local->config.nodeName, extra, dwrq->length);
6008         set_bit (FLAG_COMMIT, &local->flags);
6009
6010         return -EINPROGRESS;            /* Call commit handler */
6011 }
6012
6013 /*------------------------------------------------------------------*/
6014 /*
6015  * Wireless Handler : get Nickname
6016  */
6017 static int airo_get_nick(struct net_device *dev,
6018                          struct iw_request_info *info,
6019                          struct iw_point *dwrq,
6020                          char *extra)
6021 {
6022         struct airo_info *local = dev->ml_priv;
6023
6024         readConfigRid(local, 1);
6025         strncpy(extra, local->config.nodeName, 16);
6026         extra[16] = '\0';
6027         dwrq->length = strlen(extra);
6028
6029         return 0;
6030 }
6031
6032 /*------------------------------------------------------------------*/
6033 /*
6034  * Wireless Handler : set Bit-Rate
6035  */
6036 static int airo_set_rate(struct net_device *dev,
6037                          struct iw_request_info *info,
6038                          struct iw_param *vwrq,
6039                          char *extra)
6040 {
6041         struct airo_info *local = dev->ml_priv;
6042         CapabilityRid cap_rid;          /* Card capability info */
6043         u8      brate = 0;
6044         int     i;
6045
6046         /* First : get a valid bit rate value */
6047         readCapabilityRid(local, &cap_rid, 1);
6048
6049         /* Which type of value ? */
6050         if((vwrq->value < 8) && (vwrq->value >= 0)) {
6051                 /* Setting by rate index */
6052                 /* Find value in the magic rate table */
6053                 brate = cap_rid.supportedRates[vwrq->value];
6054         } else {
6055                 /* Setting by frequency value */
6056                 u8      normvalue = (u8) (vwrq->value/500000);
6057
6058                 /* Check if rate is valid */
6059                 for(i = 0 ; i < 8 ; i++) {
6060                         if(normvalue == cap_rid.supportedRates[i]) {
6061                                 brate = normvalue;
6062                                 break;
6063                         }
6064                 }
6065         }
6066         /* -1 designed the max rate (mostly auto mode) */
6067         if(vwrq->value == -1) {
6068                 /* Get the highest available rate */
6069                 for(i = 0 ; i < 8 ; i++) {
6070                         if(cap_rid.supportedRates[i] == 0)
6071                                 break;
6072                 }
6073                 if(i != 0)
6074                         brate = cap_rid.supportedRates[i - 1];
6075         }
6076         /* Check that it is valid */
6077         if(brate == 0) {
6078                 return -EINVAL;
6079         }
6080
6081         readConfigRid(local, 1);
6082         /* Now, check if we want a fixed or auto value */
6083         if(vwrq->fixed == 0) {
6084                 /* Fill all the rates up to this max rate */
6085                 memset(local->config.rates, 0, 8);
6086                 for(i = 0 ; i < 8 ; i++) {
6087                         local->config.rates[i] = cap_rid.supportedRates[i];
6088                         if(local->config.rates[i] == brate)
6089                                 break;
6090                 }
6091         } else {
6092                 /* Fixed mode */
6093                 /* One rate, fixed */
6094                 memset(local->config.rates, 0, 8);
6095                 local->config.rates[0] = brate;
6096         }
6097         set_bit (FLAG_COMMIT, &local->flags);
6098
6099         return -EINPROGRESS;            /* Call commit handler */
6100 }
6101
6102 /*------------------------------------------------------------------*/
6103 /*
6104  * Wireless Handler : get Bit-Rate
6105  */
6106 static int airo_get_rate(struct net_device *dev,
6107                          struct iw_request_info *info,
6108                          struct iw_param *vwrq,
6109                          char *extra)
6110 {
6111         struct airo_info *local = dev->ml_priv;
6112         StatusRid status_rid;           /* Card status info */
6113
6114         readStatusRid(local, &status_rid, 1);
6115
6116         vwrq->value = le16_to_cpu(status_rid.currentXmitRate) * 500000;
6117         /* If more than one rate, set auto */
6118         readConfigRid(local, 1);
6119         vwrq->fixed = (local->config.rates[1] == 0);
6120
6121         return 0;
6122 }
6123
6124 /*------------------------------------------------------------------*/
6125 /*
6126  * Wireless Handler : set RTS threshold
6127  */
6128 static int airo_set_rts(struct net_device *dev,
6129                         struct iw_request_info *info,
6130                         struct iw_param *vwrq,
6131                         char *extra)
6132 {
6133         struct airo_info *local = dev->ml_priv;
6134         int rthr = vwrq->value;
6135
6136         if(vwrq->disabled)
6137                 rthr = AIRO_DEF_MTU;
6138         if((rthr < 0) || (rthr > AIRO_DEF_MTU)) {
6139                 return -EINVAL;
6140         }
6141         readConfigRid(local, 1);
6142         local->config.rtsThres = cpu_to_le16(rthr);
6143         set_bit (FLAG_COMMIT, &local->flags);
6144
6145         return -EINPROGRESS;            /* Call commit handler */
6146 }
6147
6148 /*------------------------------------------------------------------*/
6149 /*
6150  * Wireless Handler : get RTS threshold
6151  */
6152 static int airo_get_rts(struct net_device *dev,
6153                         struct iw_request_info *info,
6154                         struct iw_param *vwrq,
6155                         char *extra)
6156 {
6157         struct airo_info *local = dev->ml_priv;
6158
6159         readConfigRid(local, 1);
6160         vwrq->value = le16_to_cpu(local->config.rtsThres);
6161         vwrq->disabled = (vwrq->value >= AIRO_DEF_MTU);
6162         vwrq->fixed = 1;
6163
6164         return 0;
6165 }
6166
6167 /*------------------------------------------------------------------*/
6168 /*
6169  * Wireless Handler : set Fragmentation threshold
6170  */
6171 static int airo_set_frag(struct net_device *dev,
6172                          struct iw_request_info *info,
6173                          struct iw_param *vwrq,
6174                          char *extra)
6175 {
6176         struct airo_info *local = dev->ml_priv;
6177         int fthr = vwrq->value;
6178
6179         if(vwrq->disabled)
6180                 fthr = AIRO_DEF_MTU;
6181         if((fthr < 256) || (fthr > AIRO_DEF_MTU)) {
6182                 return -EINVAL;
6183         }
6184         fthr &= ~0x1;   /* Get an even value - is it really needed ??? */
6185         readConfigRid(local, 1);
6186         local->config.fragThresh = cpu_to_le16(fthr);
6187         set_bit (FLAG_COMMIT, &local->flags);
6188
6189         return -EINPROGRESS;            /* Call commit handler */
6190 }
6191
6192 /*------------------------------------------------------------------*/
6193 /*
6194  * Wireless Handler : get Fragmentation threshold
6195  */
6196 static int airo_get_frag(struct net_device *dev,
6197                          struct iw_request_info *info,
6198                          struct iw_param *vwrq,
6199                          char *extra)
6200 {
6201         struct airo_info *local = dev->ml_priv;
6202
6203         readConfigRid(local, 1);
6204         vwrq->value = le16_to_cpu(local->config.fragThresh);
6205         vwrq->disabled = (vwrq->value >= AIRO_DEF_MTU);
6206         vwrq->fixed = 1;
6207
6208         return 0;
6209 }
6210
6211 /*------------------------------------------------------------------*/
6212 /*
6213  * Wireless Handler : set Mode of Operation
6214  */
6215 static int airo_set_mode(struct net_device *dev,
6216                          struct iw_request_info *info,
6217                          __u32 *uwrq,
6218                          char *extra)
6219 {
6220         struct airo_info *local = dev->ml_priv;
6221         int reset = 0;
6222
6223         readConfigRid(local, 1);
6224         if (sniffing_mode(local))
6225                 reset = 1;
6226
6227         switch(*uwrq) {
6228                 case IW_MODE_ADHOC:
6229                         local->config.opmode &= ~MODE_CFG_MASK;
6230                         local->config.opmode |= MODE_STA_IBSS;
6231                         local->config.rmode &= ~RXMODE_FULL_MASK;
6232                         local->config.scanMode = SCANMODE_ACTIVE;
6233                         clear_bit (FLAG_802_11, &local->flags);
6234                         break;
6235                 case IW_MODE_INFRA:
6236                         local->config.opmode &= ~MODE_CFG_MASK;
6237                         local->config.opmode |= MODE_STA_ESS;
6238                         local->config.rmode &= ~RXMODE_FULL_MASK;
6239                         local->config.scanMode = SCANMODE_ACTIVE;
6240                         clear_bit (FLAG_802_11, &local->flags);
6241                         break;
6242                 case IW_MODE_MASTER:
6243                         local->config.opmode &= ~MODE_CFG_MASK;
6244                         local->config.opmode |= MODE_AP;
6245                         local->config.rmode &= ~RXMODE_FULL_MASK;
6246                         local->config.scanMode = SCANMODE_ACTIVE;
6247                         clear_bit (FLAG_802_11, &local->flags);
6248                         break;
6249                 case IW_MODE_REPEAT:
6250                         local->config.opmode &= ~MODE_CFG_MASK;
6251                         local->config.opmode |= MODE_AP_RPTR;
6252                         local->config.rmode &= ~RXMODE_FULL_MASK;
6253                         local->config.scanMode = SCANMODE_ACTIVE;
6254                         clear_bit (FLAG_802_11, &local->flags);
6255                         break;
6256                 case IW_MODE_MONITOR:
6257                         local->config.opmode &= ~MODE_CFG_MASK;
6258                         local->config.opmode |= MODE_STA_ESS;
6259                         local->config.rmode &= ~RXMODE_FULL_MASK;
6260                         local->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
6261                         local->config.scanMode = SCANMODE_PASSIVE;
6262                         set_bit (FLAG_802_11, &local->flags);
6263                         break;
6264                 default:
6265                         return -EINVAL;
6266         }
6267         if (reset)
6268                 set_bit (FLAG_RESET, &local->flags);
6269         set_bit (FLAG_COMMIT, &local->flags);
6270
6271         return -EINPROGRESS;            /* Call commit handler */
6272 }
6273
6274 /*------------------------------------------------------------------*/
6275 /*
6276  * Wireless Handler : get Mode of Operation
6277  */
6278 static int airo_get_mode(struct net_device *dev,
6279                          struct iw_request_info *info,
6280                          __u32 *uwrq,
6281                          char *extra)
6282 {
6283         struct airo_info *local = dev->ml_priv;
6284
6285         readConfigRid(local, 1);
6286         /* If not managed, assume it's ad-hoc */
6287         switch (local->config.opmode & MODE_CFG_MASK) {
6288                 case MODE_STA_ESS:
6289                         *uwrq = IW_MODE_INFRA;
6290                         break;
6291                 case MODE_AP:
6292                         *uwrq = IW_MODE_MASTER;
6293                         break;
6294                 case MODE_AP_RPTR:
6295                         *uwrq = IW_MODE_REPEAT;
6296                         break;
6297                 default:
6298                         *uwrq = IW_MODE_ADHOC;
6299         }
6300
6301         return 0;
6302 }
6303
6304 static inline int valid_index(struct airo_info *ai, int index)
6305 {
6306         return (index >= 0) && (index <= ai->max_wep_idx);
6307 }
6308
6309 /*------------------------------------------------------------------*/
6310 /*
6311  * Wireless Handler : set Encryption Key
6312  */
6313 static int airo_set_encode(struct net_device *dev,
6314                            struct iw_request_info *info,
6315                            struct iw_point *dwrq,
6316                            char *extra)
6317 {
6318         struct airo_info *local = dev->ml_priv;
6319         int perm = (dwrq->flags & IW_ENCODE_TEMP ? 0 : 1);
6320         __le16 currentAuthType = local->config.authType;
6321         int rc = 0;
6322
6323         if (!local->wep_capable)
6324                 return -EOPNOTSUPP;
6325
6326         readConfigRid(local, 1);
6327
6328         /* Basic checking: do we have a key to set ?
6329          * Note : with the new API, it's impossible to get a NULL pointer.
6330          * Therefore, we need to check a key size == 0 instead.
6331          * New version of iwconfig properly set the IW_ENCODE_NOKEY flag
6332          * when no key is present (only change flags), but older versions
6333          * don't do it. - Jean II */
6334         if (dwrq->length > 0) {
6335                 wep_key_t key;
6336                 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6337                 int current_index;
6338
6339                 /* Check the size of the key */
6340                 if (dwrq->length > MAX_KEY_SIZE) {
6341                         return -EINVAL;
6342                 }
6343
6344                 current_index = get_wep_tx_idx(local);
6345                 if (current_index < 0)
6346                         current_index = 0;
6347
6348                 /* Check the index (none -> use current) */
6349                 if (!valid_index(local, index))
6350                         index = current_index;
6351
6352                 /* Set the length */
6353                 if (dwrq->length > MIN_KEY_SIZE)
6354                         key.len = MAX_KEY_SIZE;
6355                 else
6356                         key.len = MIN_KEY_SIZE;
6357                 /* Check if the key is not marked as invalid */
6358                 if(!(dwrq->flags & IW_ENCODE_NOKEY)) {
6359                         /* Cleanup */
6360                         memset(key.key, 0, MAX_KEY_SIZE);
6361                         /* Copy the key in the driver */
6362                         memcpy(key.key, extra, dwrq->length);
6363                         /* Send the key to the card */
6364                         rc = set_wep_key(local, index, key.key, key.len, perm, 1);
6365                         if (rc < 0) {
6366                                 airo_print_err(local->dev->name, "failed to set"
6367                                                " WEP key at index %d: %d.",
6368                                                index, rc);
6369                                 return rc;
6370                         }
6371                 }
6372                 /* WE specify that if a valid key is set, encryption
6373                  * should be enabled (user may turn it off later)
6374                  * This is also how "iwconfig ethX key on" works */
6375                 if((index == current_index) && (key.len > 0) &&
6376                    (local->config.authType == AUTH_OPEN))
6377                         set_auth_type(local, AUTH_ENCRYPT);
6378         } else {
6379                 /* Do we want to just set the transmit key index ? */
6380                 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6381                 if (valid_index(local, index)) {
6382                         rc = set_wep_tx_idx(local, index, perm, 1);
6383                         if (rc < 0) {
6384                                 airo_print_err(local->dev->name, "failed to set"
6385                                                " WEP transmit index to %d: %d.",
6386                                                index, rc);
6387                                 return rc;
6388                         }
6389                 } else {
6390                         /* Don't complain if only change the mode */
6391                         if (!(dwrq->flags & IW_ENCODE_MODE))
6392                                 return -EINVAL;
6393                 }
6394         }
6395         /* Read the flags */
6396         if (dwrq->flags & IW_ENCODE_DISABLED)
6397                 set_auth_type(local, AUTH_OPEN);        /* disable encryption */
6398         if(dwrq->flags & IW_ENCODE_RESTRICTED)
6399                 set_auth_type(local, AUTH_SHAREDKEY);   /* Only Both */
6400         if (dwrq->flags & IW_ENCODE_OPEN)
6401                 set_auth_type(local, AUTH_ENCRYPT);     /* Only Wep */
6402         /* Commit the changes to flags if needed */
6403         if (local->config.authType != currentAuthType)
6404                 set_bit (FLAG_COMMIT, &local->flags);
6405         return -EINPROGRESS;            /* Call commit handler */
6406 }
6407
6408 /*------------------------------------------------------------------*/
6409 /*
6410  * Wireless Handler : get Encryption Key
6411  */
6412 static int airo_get_encode(struct net_device *dev,
6413                            struct iw_request_info *info,
6414                            struct iw_point *dwrq,
6415                            char *extra)
6416 {
6417         struct airo_info *local = dev->ml_priv;
6418         int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
6419         int wep_key_len;
6420         u8 buf[16];
6421
6422         if (!local->wep_capable)
6423                 return -EOPNOTSUPP;
6424
6425         readConfigRid(local, 1);
6426
6427         /* Check encryption mode */
6428         switch(local->config.authType)  {
6429                 case AUTH_ENCRYPT:
6430                         dwrq->flags = IW_ENCODE_OPEN;
6431                         break;
6432                 case AUTH_SHAREDKEY:
6433                         dwrq->flags = IW_ENCODE_RESTRICTED;
6434                         break;
6435                 default:
6436                 case AUTH_OPEN:
6437                         dwrq->flags = IW_ENCODE_DISABLED;
6438                         break;
6439         }
6440         /* We can't return the key, so set the proper flag and return zero */
6441         dwrq->flags |= IW_ENCODE_NOKEY;
6442         memset(extra, 0, 16);
6443
6444         /* Which key do we want ? -1 -> tx index */
6445         if (!valid_index(local, index)) {
6446                 index = get_wep_tx_idx(local);
6447                 if (index < 0)
6448                         index = 0;
6449         }
6450         dwrq->flags |= index + 1;
6451
6452         /* Copy the key to the user buffer */
6453         wep_key_len = get_wep_key(local, index, &buf[0], sizeof(buf));
6454         if (wep_key_len < 0) {
6455                 dwrq->length = 0;
6456         } else {
6457                 dwrq->length = wep_key_len;
6458                 memcpy(extra, buf, dwrq->length);
6459         }
6460
6461         return 0;
6462 }
6463
6464 /*------------------------------------------------------------------*/
6465 /*
6466  * Wireless Handler : set extended Encryption parameters
6467  */
6468 static int airo_set_encodeext(struct net_device *dev,
6469                            struct iw_request_info *info,
6470                             union iwreq_data *wrqu,
6471                             char *extra)
6472 {
6473         struct airo_info *local = dev->ml_priv;
6474         struct iw_point *encoding = &wrqu->encoding;
6475         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6476         int perm = ( encoding->flags & IW_ENCODE_TEMP ? 0 : 1 );
6477         __le16 currentAuthType = local->config.authType;
6478         int idx, key_len, alg = ext->alg, set_key = 1, rc;
6479         wep_key_t key;
6480
6481         if (!local->wep_capable)
6482                 return -EOPNOTSUPP;
6483
6484         readConfigRid(local, 1);
6485
6486         /* Determine and validate the key index */
6487         idx = encoding->flags & IW_ENCODE_INDEX;
6488         if (idx) {
6489                 if (!valid_index(local, idx - 1))
6490                         return -EINVAL;
6491                 idx--;
6492         } else {
6493                 idx = get_wep_tx_idx(local);
6494                 if (idx < 0)
6495                         idx = 0;
6496         }
6497
6498         if (encoding->flags & IW_ENCODE_DISABLED)
6499                 alg = IW_ENCODE_ALG_NONE;
6500
6501         if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
6502                 /* Only set transmit key index here, actual
6503                  * key is set below if needed.
6504                  */
6505                 rc = set_wep_tx_idx(local, idx, perm, 1);
6506                 if (rc < 0) {
6507                         airo_print_err(local->dev->name, "failed to set "
6508                                        "WEP transmit index to %d: %d.",
6509                                        idx, rc);
6510                         return rc;
6511                 }
6512                 set_key = ext->key_len > 0 ? 1 : 0;
6513         }
6514
6515         if (set_key) {
6516                 /* Set the requested key first */
6517                 memset(key.key, 0, MAX_KEY_SIZE);
6518                 switch (alg) {
6519                 case IW_ENCODE_ALG_NONE:
6520                         key.len = 0;
6521                         break;
6522                 case IW_ENCODE_ALG_WEP:
6523                         if (ext->key_len > MIN_KEY_SIZE) {
6524                                 key.len = MAX_KEY_SIZE;
6525                         } else if (ext->key_len > 0) {
6526                                 key.len = MIN_KEY_SIZE;
6527                         } else {
6528                                 return -EINVAL;
6529                         }
6530                         key_len = min (ext->key_len, key.len);
6531                         memcpy(key.key, ext->key, key_len);
6532                         break;
6533                 default:
6534                         return -EINVAL;
6535                 }
6536                 if (key.len == 0) {
6537                         rc = set_wep_tx_idx(local, idx, perm, 1);
6538                         if (rc < 0) {
6539                                 airo_print_err(local->dev->name,
6540                                                "failed to set WEP transmit index to %d: %d.",
6541                                                idx, rc);
6542                                 return rc;
6543                         }
6544                 } else {
6545                         rc = set_wep_key(local, idx, key.key, key.len, perm, 1);
6546                         if (rc < 0) {
6547                                 airo_print_err(local->dev->name,
6548                                                "failed to set WEP key at index %d: %d.",
6549                                                idx, rc);
6550                                 return rc;
6551                         }
6552                 }
6553         }
6554
6555         /* Read the flags */
6556         if (encoding->flags & IW_ENCODE_DISABLED)
6557                 set_auth_type(local, AUTH_OPEN);        /* disable encryption */
6558         if(encoding->flags & IW_ENCODE_RESTRICTED)
6559                 set_auth_type(local, AUTH_SHAREDKEY);   /* Only Both */
6560         if (encoding->flags & IW_ENCODE_OPEN)
6561                 set_auth_type(local, AUTH_ENCRYPT);
6562         /* Commit the changes to flags if needed */
6563         if (local->config.authType != currentAuthType)
6564                 set_bit (FLAG_COMMIT, &local->flags);
6565
6566         return -EINPROGRESS;
6567 }
6568
6569
6570 /*------------------------------------------------------------------*/
6571 /*
6572  * Wireless Handler : get extended Encryption parameters
6573  */
6574 static int airo_get_encodeext(struct net_device *dev,
6575                             struct iw_request_info *info,
6576                             union iwreq_data *wrqu,
6577                             char *extra)
6578 {
6579         struct airo_info *local = dev->ml_priv;
6580         struct iw_point *encoding = &wrqu->encoding;
6581         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6582         int idx, max_key_len, wep_key_len;
6583         u8 buf[16];
6584
6585         if (!local->wep_capable)
6586                 return -EOPNOTSUPP;
6587
6588         readConfigRid(local, 1);
6589
6590         max_key_len = encoding->length - sizeof(*ext);
6591         if (max_key_len < 0)
6592                 return -EINVAL;
6593
6594         idx = encoding->flags & IW_ENCODE_INDEX;
6595         if (idx) {
6596                 if (!valid_index(local, idx - 1))
6597                         return -EINVAL;
6598                 idx--;
6599         } else {
6600                 idx = get_wep_tx_idx(local);
6601                 if (idx < 0)
6602                         idx = 0;
6603         }
6604
6605         encoding->flags = idx + 1;
6606         memset(ext, 0, sizeof(*ext));
6607
6608         /* Check encryption mode */
6609         switch(local->config.authType) {
6610                 case AUTH_ENCRYPT:
6611                         encoding->flags = IW_ENCODE_ALG_WEP | IW_ENCODE_ENABLED;
6612                         break;
6613                 case AUTH_SHAREDKEY:
6614                         encoding->flags = IW_ENCODE_ALG_WEP | IW_ENCODE_ENABLED;
6615                         break;
6616                 default:
6617                 case AUTH_OPEN:
6618                         encoding->flags = IW_ENCODE_ALG_NONE | IW_ENCODE_DISABLED;
6619                         break;
6620         }
6621         /* We can't return the key, so set the proper flag and return zero */
6622         encoding->flags |= IW_ENCODE_NOKEY;
6623         memset(extra, 0, 16);
6624
6625         /* Copy the key to the user buffer */
6626         wep_key_len = get_wep_key(local, idx, &buf[0], sizeof(buf));
6627         if (wep_key_len < 0) {
6628                 ext->key_len = 0;
6629         } else {
6630                 ext->key_len = wep_key_len;
6631                 memcpy(extra, buf, ext->key_len);
6632         }
6633
6634         return 0;
6635 }
6636
6637
6638 /*------------------------------------------------------------------*/
6639 /*
6640  * Wireless Handler : set extended authentication parameters
6641  */
6642 static int airo_set_auth(struct net_device *dev,
6643                                struct iw_request_info *info,
6644                                union iwreq_data *wrqu, char *extra)
6645 {
6646         struct airo_info *local = dev->ml_priv;
6647         struct iw_param *param = &wrqu->param;
6648         __le16 currentAuthType = local->config.authType;
6649
6650         switch (param->flags & IW_AUTH_INDEX) {
6651         case IW_AUTH_WPA_VERSION:
6652         case IW_AUTH_CIPHER_PAIRWISE:
6653         case IW_AUTH_CIPHER_GROUP:
6654         case IW_AUTH_KEY_MGMT:
6655         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6656         case IW_AUTH_PRIVACY_INVOKED:
6657                 /*
6658                  * airo does not use these parameters
6659                  */
6660                 break;
6661
6662         case IW_AUTH_DROP_UNENCRYPTED:
6663                 if (param->value) {
6664                         /* Only change auth type if unencrypted */
6665                         if (currentAuthType == AUTH_OPEN)
6666                                 set_auth_type(local, AUTH_ENCRYPT);
6667                 } else {
6668                         set_auth_type(local, AUTH_OPEN);
6669                 }
6670
6671                 /* Commit the changes to flags if needed */
6672                 if (local->config.authType != currentAuthType)
6673                         set_bit (FLAG_COMMIT, &local->flags);
6674                 break;
6675
6676         case IW_AUTH_80211_AUTH_ALG: {
6677                         if (param->value & IW_AUTH_ALG_SHARED_KEY) {
6678                                 set_auth_type(local, AUTH_SHAREDKEY);
6679                         } else if (param->value & IW_AUTH_ALG_OPEN_SYSTEM) {
6680                                 /* We don't know here if WEP open system or
6681                                  * unencrypted mode was requested - so use the
6682                                  * last mode (of these two) used last time
6683                                  */
6684                                 set_auth_type(local, local->last_auth);
6685                         } else
6686                                 return -EINVAL;
6687
6688                         /* Commit the changes to flags if needed */
6689                         if (local->config.authType != currentAuthType)
6690                                 set_bit (FLAG_COMMIT, &local->flags);
6691                         break;
6692                 }
6693
6694         case IW_AUTH_WPA_ENABLED:
6695                 /* Silently accept disable of WPA */
6696                 if (param->value > 0)
6697                         return -EOPNOTSUPP;
6698                 break;
6699
6700         default:
6701                 return -EOPNOTSUPP;
6702         }
6703         return -EINPROGRESS;
6704 }
6705
6706
6707 /*------------------------------------------------------------------*/
6708 /*
6709  * Wireless Handler : get extended authentication parameters
6710  */
6711 static int airo_get_auth(struct net_device *dev,
6712                                struct iw_request_info *info,
6713                                union iwreq_data *wrqu, char *extra)
6714 {
6715         struct airo_info *local = dev->ml_priv;
6716         struct iw_param *param = &wrqu->param;
6717         __le16 currentAuthType = local->config.authType;
6718
6719         switch (param->flags & IW_AUTH_INDEX) {
6720         case IW_AUTH_DROP_UNENCRYPTED:
6721                 switch (currentAuthType) {
6722                 case AUTH_SHAREDKEY:
6723                 case AUTH_ENCRYPT:
6724                         param->value = 1;
6725                         break;
6726                 default:
6727                         param->value = 0;
6728                         break;
6729                 }
6730                 break;
6731
6732         case IW_AUTH_80211_AUTH_ALG:
6733                 switch (currentAuthType) {
6734                 case AUTH_SHAREDKEY:
6735                         param->value = IW_AUTH_ALG_SHARED_KEY;
6736                         break;
6737                 case AUTH_ENCRYPT:
6738                 default:
6739                         param->value = IW_AUTH_ALG_OPEN_SYSTEM;
6740                         break;
6741                 }
6742                 break;
6743
6744         case IW_AUTH_WPA_ENABLED:
6745                 param->value = 0;
6746                 break;
6747
6748         default:
6749                 return -EOPNOTSUPP;
6750         }
6751         return 0;
6752 }
6753
6754
6755 /*------------------------------------------------------------------*/
6756 /*
6757  * Wireless Handler : set Tx-Power
6758  */
6759 static int airo_set_txpow(struct net_device *dev,
6760                           struct iw_request_info *info,
6761                           struct iw_param *vwrq,
6762                           char *extra)
6763 {
6764         struct airo_info *local = dev->ml_priv;
6765         CapabilityRid cap_rid;          /* Card capability info */
6766         int i;
6767         int rc = -EINVAL;
6768         __le16 v = cpu_to_le16(vwrq->value);
6769
6770         readCapabilityRid(local, &cap_rid, 1);
6771
6772         if (vwrq->disabled) {
6773                 set_bit (FLAG_RADIO_OFF, &local->flags);
6774                 set_bit (FLAG_COMMIT, &local->flags);
6775                 return -EINPROGRESS;            /* Call commit handler */
6776         }
6777         if (vwrq->flags != IW_TXPOW_MWATT) {
6778                 return -EINVAL;
6779         }
6780         clear_bit (FLAG_RADIO_OFF, &local->flags);
6781         for (i = 0; i < 8 && cap_rid.txPowerLevels[i]; i++)
6782                 if (v == cap_rid.txPowerLevels[i]) {
6783                         readConfigRid(local, 1);
6784                         local->config.txPower = v;
6785                         set_bit (FLAG_COMMIT, &local->flags);
6786                         rc = -EINPROGRESS;      /* Call commit handler */
6787                         break;
6788                 }
6789         return rc;
6790 }
6791
6792 /*------------------------------------------------------------------*/
6793 /*
6794  * Wireless Handler : get Tx-Power
6795  */
6796 static int airo_get_txpow(struct net_device *dev,
6797                           struct iw_request_info *info,
6798                           struct iw_param *vwrq,
6799                           char *extra)
6800 {
6801         struct airo_info *local = dev->ml_priv;
6802
6803         readConfigRid(local, 1);
6804         vwrq->value = le16_to_cpu(local->config.txPower);
6805         vwrq->fixed = 1;        /* No power control */
6806         vwrq->disabled = test_bit(FLAG_RADIO_OFF, &local->flags);
6807         vwrq->flags = IW_TXPOW_MWATT;
6808
6809         return 0;
6810 }
6811
6812 /*------------------------------------------------------------------*/
6813 /*
6814  * Wireless Handler : set Retry limits
6815  */
6816 static int airo_set_retry(struct net_device *dev,
6817                           struct iw_request_info *info,
6818                           struct iw_param *vwrq,
6819                           char *extra)
6820 {
6821         struct airo_info *local = dev->ml_priv;
6822         int rc = -EINVAL;
6823
6824         if(vwrq->disabled) {
6825                 return -EINVAL;
6826         }
6827         readConfigRid(local, 1);
6828         if(vwrq->flags & IW_RETRY_LIMIT) {
6829                 __le16 v = cpu_to_le16(vwrq->value);
6830                 if(vwrq->flags & IW_RETRY_LONG)
6831                         local->config.longRetryLimit = v;
6832                 else if (vwrq->flags & IW_RETRY_SHORT)
6833                         local->config.shortRetryLimit = v;
6834                 else {
6835                         /* No modifier : set both */
6836                         local->config.longRetryLimit = v;
6837                         local->config.shortRetryLimit = v;
6838                 }
6839                 set_bit (FLAG_COMMIT, &local->flags);
6840                 rc = -EINPROGRESS;              /* Call commit handler */
6841         }
6842         if(vwrq->flags & IW_RETRY_LIFETIME) {
6843                 local->config.txLifetime = cpu_to_le16(vwrq->value / 1024);
6844                 set_bit (FLAG_COMMIT, &local->flags);
6845                 rc = -EINPROGRESS;              /* Call commit handler */
6846         }
6847         return rc;
6848 }
6849
6850 /*------------------------------------------------------------------*/
6851 /*
6852  * Wireless Handler : get Retry limits
6853  */
6854 static int airo_get_retry(struct net_device *dev,
6855                           struct iw_request_info *info,
6856                           struct iw_param *vwrq,
6857                           char *extra)
6858 {
6859         struct airo_info *local = dev->ml_priv;
6860
6861         vwrq->disabled = 0;      /* Can't be disabled */
6862
6863         readConfigRid(local, 1);
6864         /* Note : by default, display the min retry number */
6865         if((vwrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
6866                 vwrq->flags = IW_RETRY_LIFETIME;
6867                 vwrq->value = le16_to_cpu(local->config.txLifetime) * 1024;
6868         } else if((vwrq->flags & IW_RETRY_LONG)) {
6869                 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
6870                 vwrq->value = le16_to_cpu(local->config.longRetryLimit);
6871         } else {
6872                 vwrq->flags = IW_RETRY_LIMIT;
6873                 vwrq->value = le16_to_cpu(local->config.shortRetryLimit);
6874                 if(local->config.shortRetryLimit != local->config.longRetryLimit)
6875                         vwrq->flags |= IW_RETRY_SHORT;
6876         }
6877
6878         return 0;
6879 }
6880
6881 /*------------------------------------------------------------------*/
6882 /*
6883  * Wireless Handler : get range info
6884  */
6885 static int airo_get_range(struct net_device *dev,
6886                           struct iw_request_info *info,
6887                           struct iw_point *dwrq,
6888                           char *extra)
6889 {
6890         struct airo_info *local = dev->ml_priv;
6891         struct iw_range *range = (struct iw_range *) extra;
6892         CapabilityRid cap_rid;          /* Card capability info */
6893         int             i;
6894         int             k;
6895
6896         readCapabilityRid(local, &cap_rid, 1);
6897
6898         dwrq->length = sizeof(struct iw_range);
6899         memset(range, 0, sizeof(*range));
6900         range->min_nwid = 0x0000;
6901         range->max_nwid = 0x0000;
6902         range->num_channels = 14;
6903         /* Should be based on cap_rid.country to give only
6904          * what the current card support */
6905         k = 0;
6906         for(i = 0; i < 14; i++) {
6907                 range->freq[k].i = i + 1; /* List index */
6908                 range->freq[k].m = 100000 *
6909                      ieee80211_channel_to_frequency(i + 1, NL80211_BAND_2GHZ);
6910                 range->freq[k++].e = 1; /* Values in MHz -> * 10^5 * 10 */
6911         }
6912         range->num_frequency = k;
6913
6914         range->sensitivity = 65535;
6915
6916         /* Hum... Should put the right values there */
6917         if (local->rssi)
6918                 range->max_qual.qual = 100;     /* % */
6919         else
6920                 range->max_qual.qual = airo_get_max_quality(&cap_rid);
6921         range->max_qual.level = 0x100 - 120;    /* -120 dBm */
6922         range->max_qual.noise = 0x100 - 120;    /* -120 dBm */
6923
6924         /* Experimental measurements - boundary 11/5.5 Mb/s */
6925         /* Note : with or without the (local->rssi), results
6926          * are somewhat different. - Jean II */
6927         if (local->rssi) {
6928                 range->avg_qual.qual = 50;              /* % */
6929                 range->avg_qual.level = 0x100 - 70;     /* -70 dBm */
6930         } else {
6931                 range->avg_qual.qual = airo_get_avg_quality(&cap_rid);
6932                 range->avg_qual.level = 0x100 - 80;     /* -80 dBm */
6933         }
6934         range->avg_qual.noise = 0x100 - 85;             /* -85 dBm */
6935
6936         for(i = 0 ; i < 8 ; i++) {
6937                 range->bitrate[i] = cap_rid.supportedRates[i] * 500000;
6938                 if(range->bitrate[i] == 0)
6939                         break;
6940         }
6941         range->num_bitrates = i;
6942
6943         /* Set an indication of the max TCP throughput
6944          * in bit/s that we can expect using this interface.
6945          * May be use for QoS stuff... Jean II */
6946         if(i > 2)
6947                 range->throughput = 5000 * 1000;
6948         else
6949                 range->throughput = 1500 * 1000;
6950
6951         range->min_rts = 0;
6952         range->max_rts = AIRO_DEF_MTU;
6953         range->min_frag = 256;
6954         range->max_frag = AIRO_DEF_MTU;
6955
6956         if(cap_rid.softCap & cpu_to_le16(2)) {
6957                 // WEP: RC4 40 bits
6958                 range->encoding_size[0] = 5;
6959                 // RC4 ~128 bits
6960                 if (cap_rid.softCap & cpu_to_le16(0x100)) {
6961                         range->encoding_size[1] = 13;
6962                         range->num_encoding_sizes = 2;
6963                 } else
6964                         range->num_encoding_sizes = 1;
6965                 range->max_encoding_tokens =
6966                         cap_rid.softCap & cpu_to_le16(0x80) ? 4 : 1;
6967         } else {
6968                 range->num_encoding_sizes = 0;
6969                 range->max_encoding_tokens = 0;
6970         }
6971         range->min_pmp = 0;
6972         range->max_pmp = 5000000;       /* 5 secs */
6973         range->min_pmt = 0;
6974         range->max_pmt = 65535 * 1024;  /* ??? */
6975         range->pmp_flags = IW_POWER_PERIOD;
6976         range->pmt_flags = IW_POWER_TIMEOUT;
6977         range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
6978
6979         /* Transmit Power - values are in mW */
6980         for(i = 0 ; i < 8 ; i++) {
6981                 range->txpower[i] = le16_to_cpu(cap_rid.txPowerLevels[i]);
6982                 if(range->txpower[i] == 0)
6983                         break;
6984         }
6985         range->num_txpower = i;
6986         range->txpower_capa = IW_TXPOW_MWATT;
6987         range->we_version_source = 19;
6988         range->we_version_compiled = WIRELESS_EXT;
6989         range->retry_capa = IW_RETRY_LIMIT | IW_RETRY_LIFETIME;
6990         range->retry_flags = IW_RETRY_LIMIT;
6991         range->r_time_flags = IW_RETRY_LIFETIME;
6992         range->min_retry = 1;
6993         range->max_retry = 65535;
6994         range->min_r_time = 1024;
6995         range->max_r_time = 65535 * 1024;
6996
6997         /* Event capability (kernel + driver) */
6998         range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
6999                                 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
7000                                 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
7001                                 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
7002         range->event_capa[1] = IW_EVENT_CAPA_K_1;
7003         range->event_capa[4] = IW_EVENT_CAPA_MASK(IWEVTXDROP);
7004         return 0;
7005 }
7006
7007 /*------------------------------------------------------------------*/
7008 /*
7009  * Wireless Handler : set Power Management
7010  */
7011 static int airo_set_power(struct net_device *dev,
7012                           struct iw_request_info *info,
7013                           struct iw_param *vwrq,
7014                           char *extra)
7015 {
7016         struct airo_info *local = dev->ml_priv;
7017
7018         readConfigRid(local, 1);
7019         if (vwrq->disabled) {
7020                 if (sniffing_mode(local))
7021                         return -EINVAL;
7022                 local->config.powerSaveMode = POWERSAVE_CAM;
7023                 local->config.rmode &= ~RXMODE_MASK;
7024                 local->config.rmode |= RXMODE_BC_MC_ADDR;
7025                 set_bit (FLAG_COMMIT, &local->flags);
7026                 return -EINPROGRESS;            /* Call commit handler */
7027         }
7028         if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
7029                 local->config.fastListenDelay = cpu_to_le16((vwrq->value + 500) / 1024);
7030                 local->config.powerSaveMode = POWERSAVE_PSPCAM;
7031                 set_bit (FLAG_COMMIT, &local->flags);
7032         } else if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
7033                 local->config.fastListenInterval =
7034                 local->config.listenInterval =
7035                         cpu_to_le16((vwrq->value + 500) / 1024);
7036                 local->config.powerSaveMode = POWERSAVE_PSPCAM;
7037                 set_bit (FLAG_COMMIT, &local->flags);
7038         }
7039         switch (vwrq->flags & IW_POWER_MODE) {
7040                 case IW_POWER_UNICAST_R:
7041                         if (sniffing_mode(local))
7042                                 return -EINVAL;
7043                         local->config.rmode &= ~RXMODE_MASK;
7044                         local->config.rmode |= RXMODE_ADDR;
7045                         set_bit (FLAG_COMMIT, &local->flags);
7046                         break;
7047                 case IW_POWER_ALL_R:
7048                         if (sniffing_mode(local))
7049                                 return -EINVAL;
7050                         local->config.rmode &= ~RXMODE_MASK;
7051                         local->config.rmode |= RXMODE_BC_MC_ADDR;
7052                         set_bit (FLAG_COMMIT, &local->flags);
7053                 case IW_POWER_ON:
7054                         /* This is broken, fixme ;-) */
7055                         break;
7056                 default:
7057                         return -EINVAL;
7058         }
7059         // Note : we may want to factor local->need_commit here
7060         // Note2 : may also want to factor RXMODE_RFMON test
7061         return -EINPROGRESS;            /* Call commit handler */
7062 }
7063
7064 /*------------------------------------------------------------------*/
7065 /*
7066  * Wireless Handler : get Power Management
7067  */
7068 static int airo_get_power(struct net_device *dev,
7069                           struct iw_request_info *info,
7070                           struct iw_param *vwrq,
7071                           char *extra)
7072 {
7073         struct airo_info *local = dev->ml_priv;
7074         __le16 mode;
7075
7076         readConfigRid(local, 1);
7077         mode = local->config.powerSaveMode;
7078         if ((vwrq->disabled = (mode == POWERSAVE_CAM)))
7079                 return 0;
7080         if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
7081                 vwrq->value = le16_to_cpu(local->config.fastListenDelay) * 1024;
7082                 vwrq->flags = IW_POWER_TIMEOUT;
7083         } else {
7084                 vwrq->value = le16_to_cpu(local->config.fastListenInterval) * 1024;
7085                 vwrq->flags = IW_POWER_PERIOD;
7086         }
7087         if ((local->config.rmode & RXMODE_MASK) == RXMODE_ADDR)
7088                 vwrq->flags |= IW_POWER_UNICAST_R;
7089         else
7090                 vwrq->flags |= IW_POWER_ALL_R;
7091
7092         return 0;
7093 }
7094
7095 /*------------------------------------------------------------------*/
7096 /*
7097  * Wireless Handler : set Sensitivity
7098  */
7099 static int airo_set_sens(struct net_device *dev,
7100                          struct iw_request_info *info,
7101                          struct iw_param *vwrq,
7102                          char *extra)
7103 {
7104         struct airo_info *local = dev->ml_priv;
7105
7106         readConfigRid(local, 1);
7107         local->config.rssiThreshold =
7108                 cpu_to_le16(vwrq->disabled ? RSSI_DEFAULT : vwrq->value);
7109         set_bit (FLAG_COMMIT, &local->flags);
7110
7111         return -EINPROGRESS;            /* Call commit handler */
7112 }
7113
7114 /*------------------------------------------------------------------*/
7115 /*
7116  * Wireless Handler : get Sensitivity
7117  */
7118 static int airo_get_sens(struct net_device *dev,
7119                          struct iw_request_info *info,
7120                          struct iw_param *vwrq,
7121                          char *extra)
7122 {
7123         struct airo_info *local = dev->ml_priv;
7124
7125         readConfigRid(local, 1);
7126         vwrq->value = le16_to_cpu(local->config.rssiThreshold);
7127         vwrq->disabled = (vwrq->value == 0);
7128         vwrq->fixed = 1;
7129
7130         return 0;
7131 }
7132
7133 /*------------------------------------------------------------------*/
7134 /*
7135  * Wireless Handler : get AP List
7136  * Note : this is deprecated in favor of IWSCAN
7137  */
7138 static int airo_get_aplist(struct net_device *dev,
7139                            struct iw_request_info *info,
7140                            struct iw_point *dwrq,
7141                            char *extra)
7142 {
7143         struct airo_info *local = dev->ml_priv;
7144         struct sockaddr *address = (struct sockaddr *) extra;
7145         struct iw_quality *qual;
7146         BSSListRid BSSList;
7147         int i;
7148         int loseSync = capable(CAP_NET_ADMIN) ? 1: -1;
7149
7150         qual = kmalloc(IW_MAX_AP * sizeof(*qual), GFP_KERNEL);
7151         if (!qual)
7152                 return -ENOMEM;
7153
7154         for (i = 0; i < IW_MAX_AP; i++) {
7155                 u16 dBm;
7156                 if (readBSSListRid(local, loseSync, &BSSList))
7157                         break;
7158                 loseSync = 0;
7159                 memcpy(address[i].sa_data, BSSList.bssid, ETH_ALEN);
7160                 address[i].sa_family = ARPHRD_ETHER;
7161                 dBm = le16_to_cpu(BSSList.dBm);
7162                 if (local->rssi) {
7163                         qual[i].level = 0x100 - dBm;
7164                         qual[i].qual = airo_dbm_to_pct(local->rssi, dBm);
7165                         qual[i].updated = IW_QUAL_QUAL_UPDATED
7166                                         | IW_QUAL_LEVEL_UPDATED
7167                                         | IW_QUAL_DBM;
7168                 } else {
7169                         qual[i].level = (dBm + 321) / 2;
7170                         qual[i].qual = 0;
7171                         qual[i].updated = IW_QUAL_QUAL_INVALID
7172                                         | IW_QUAL_LEVEL_UPDATED
7173                                         | IW_QUAL_DBM;
7174                 }
7175                 qual[i].noise = local->wstats.qual.noise;
7176                 if (BSSList.index == cpu_to_le16(0xffff))
7177                         break;
7178         }
7179         if (!i) {
7180                 StatusRid status_rid;           /* Card status info */
7181                 readStatusRid(local, &status_rid, 1);
7182                 for (i = 0;
7183                      i < min(IW_MAX_AP, 4) &&
7184                              (status_rid.bssid[i][0]
7185                               & status_rid.bssid[i][1]
7186                               & status_rid.bssid[i][2]
7187                               & status_rid.bssid[i][3]
7188                               & status_rid.bssid[i][4]
7189                               & status_rid.bssid[i][5])!=0xff &&
7190                              (status_rid.bssid[i][0]
7191                               | status_rid.bssid[i][1]
7192                               | status_rid.bssid[i][2]
7193                               | status_rid.bssid[i][3]
7194                               | status_rid.bssid[i][4]
7195                               | status_rid.bssid[i][5]);
7196                      i++) {
7197                         memcpy(address[i].sa_data,
7198                                status_rid.bssid[i], ETH_ALEN);
7199                         address[i].sa_family = ARPHRD_ETHER;
7200                 }
7201         } else {
7202                 dwrq->flags = 1; /* Should be define'd */
7203                 memcpy(extra + sizeof(struct sockaddr) * i, qual,
7204                        sizeof(struct iw_quality) * i);
7205         }
7206         dwrq->length = i;
7207
7208         kfree(qual);
7209         return 0;
7210 }
7211
7212 /*------------------------------------------------------------------*/
7213 /*
7214  * Wireless Handler : Initiate Scan
7215  */
7216 static int airo_set_scan(struct net_device *dev,
7217                          struct iw_request_info *info,
7218                          struct iw_point *dwrq,
7219                          char *extra)
7220 {
7221         struct airo_info *ai = dev->ml_priv;
7222         Cmd cmd;
7223         Resp rsp;
7224         int wake = 0;
7225         APListRid APList_rid_empty;
7226
7227         /* Note : you may have realised that, as this is a SET operation,
7228          * this is privileged and therefore a normal user can't
7229          * perform scanning.
7230          * This is not an error, while the device perform scanning,
7231          * traffic doesn't flow, so it's a perfect DoS...
7232          * Jean II */
7233         if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
7234
7235         if (down_interruptible(&ai->sem))
7236                 return -ERESTARTSYS;
7237
7238         /* If there's already a scan in progress, don't
7239          * trigger another one. */
7240         if (ai->scan_timeout > 0)
7241                 goto out;
7242
7243         /* Clear APList as it affects scan results */
7244         memset(&APList_rid_empty, 0, sizeof(APList_rid_empty));
7245         APList_rid_empty.len = cpu_to_le16(sizeof(APList_rid_empty));
7246         disable_MAC(ai, 2);
7247         writeAPListRid(ai, &APList_rid_empty, 0);
7248         enable_MAC(ai, 0);
7249
7250         /* Initiate a scan command */
7251         ai->scan_timeout = RUN_AT(3*HZ);
7252         memset(&cmd, 0, sizeof(cmd));
7253         cmd.cmd=CMD_LISTBSS;
7254         issuecommand(ai, &cmd, &rsp);
7255         wake = 1;
7256
7257 out:
7258         up(&ai->sem);
7259         if (wake)
7260                 wake_up_interruptible(&ai->thr_wait);
7261         return 0;
7262 }
7263
7264 /*------------------------------------------------------------------*/
7265 /*
7266  * Translate scan data returned from the card to a card independent
7267  * format that the Wireless Tools will understand - Jean II
7268  */
7269 static inline char *airo_translate_scan(struct net_device *dev,
7270                                         struct iw_request_info *info,
7271                                         char *current_ev,
7272                                         char *end_buf,
7273                                         BSSListRid *bss)
7274 {
7275         struct airo_info *ai = dev->ml_priv;
7276         struct iw_event         iwe;            /* Temporary buffer */
7277         __le16                  capabilities;
7278         char *                  current_val;    /* For rates */
7279         int                     i;
7280         char *          buf;
7281         u16 dBm;
7282
7283         /* First entry *MUST* be the AP MAC address */
7284         iwe.cmd = SIOCGIWAP;
7285         iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
7286         memcpy(iwe.u.ap_addr.sa_data, bss->bssid, ETH_ALEN);
7287         current_ev = iwe_stream_add_event(info, current_ev, end_buf,
7288                                           &iwe, IW_EV_ADDR_LEN);
7289
7290         /* Other entries will be displayed in the order we give them */
7291
7292         /* Add the ESSID */
7293         iwe.u.data.length = bss->ssidLen;
7294         if(iwe.u.data.length > 32)
7295                 iwe.u.data.length = 32;
7296         iwe.cmd = SIOCGIWESSID;
7297         iwe.u.data.flags = 1;
7298         current_ev = iwe_stream_add_point(info, current_ev, end_buf,
7299                                           &iwe, bss->ssid);
7300
7301         /* Add mode */
7302         iwe.cmd = SIOCGIWMODE;
7303         capabilities = bss->cap;
7304         if(capabilities & (CAP_ESS | CAP_IBSS)) {
7305                 if(capabilities & CAP_ESS)
7306                         iwe.u.mode = IW_MODE_MASTER;
7307                 else
7308                         iwe.u.mode = IW_MODE_ADHOC;
7309                 current_ev = iwe_stream_add_event(info, current_ev, end_buf,
7310                                                   &iwe, IW_EV_UINT_LEN);
7311         }
7312
7313         /* Add frequency */
7314         iwe.cmd = SIOCGIWFREQ;
7315         iwe.u.freq.m = le16_to_cpu(bss->dsChannel);
7316         iwe.u.freq.m = 100000 *
7317               ieee80211_channel_to_frequency(iwe.u.freq.m, NL80211_BAND_2GHZ);
7318         iwe.u.freq.e = 1;
7319         current_ev = iwe_stream_add_event(info, current_ev, end_buf,
7320                                           &iwe, IW_EV_FREQ_LEN);
7321
7322         dBm = le16_to_cpu(bss->dBm);
7323
7324         /* Add quality statistics */
7325         iwe.cmd = IWEVQUAL;
7326         if (ai->rssi) {
7327                 iwe.u.qual.level = 0x100 - dBm;
7328                 iwe.u.qual.qual = airo_dbm_to_pct(ai->rssi, dBm);
7329                 iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED
7330                                 | IW_QUAL_LEVEL_UPDATED
7331                                 | IW_QUAL_DBM;
7332         } else {
7333                 iwe.u.qual.level = (dBm + 321) / 2;
7334                 iwe.u.qual.qual = 0;
7335                 iwe.u.qual.updated = IW_QUAL_QUAL_INVALID
7336                                 | IW_QUAL_LEVEL_UPDATED
7337                                 | IW_QUAL_DBM;
7338         }
7339         iwe.u.qual.noise = ai->wstats.qual.noise;
7340         current_ev = iwe_stream_add_event(info, current_ev, end_buf,
7341                                           &iwe, IW_EV_QUAL_LEN);
7342
7343         /* Add encryption capability */
7344         iwe.cmd = SIOCGIWENCODE;
7345         if(capabilities & CAP_PRIVACY)
7346                 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
7347         else
7348                 iwe.u.data.flags = IW_ENCODE_DISABLED;
7349         iwe.u.data.length = 0;
7350         current_ev = iwe_stream_add_point(info, current_ev, end_buf,
7351                                           &iwe, bss->ssid);
7352
7353         /* Rate : stuffing multiple values in a single event require a bit
7354          * more of magic - Jean II */
7355         current_val = current_ev + iwe_stream_lcp_len(info);
7356
7357         iwe.cmd = SIOCGIWRATE;
7358         /* Those two flags are ignored... */
7359         iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
7360         /* Max 8 values */
7361         for(i = 0 ; i < 8 ; i++) {
7362                 /* NULL terminated */
7363                 if(bss->rates[i] == 0)
7364                         break;
7365                 /* Bit rate given in 500 kb/s units (+ 0x80) */
7366                 iwe.u.bitrate.value = ((bss->rates[i] & 0x7f) * 500000);
7367                 /* Add new value to event */
7368                 current_val = iwe_stream_add_value(info, current_ev,
7369                                                    current_val, end_buf,
7370                                                    &iwe, IW_EV_PARAM_LEN);
7371         }
7372         /* Check if we added any event */
7373         if ((current_val - current_ev) > iwe_stream_lcp_len(info))
7374                 current_ev = current_val;
7375
7376         /* Beacon interval */
7377         buf = kmalloc(30, GFP_KERNEL);
7378         if (buf) {
7379                 iwe.cmd = IWEVCUSTOM;
7380                 sprintf(buf, "bcn_int=%d", bss->beaconInterval);
7381                 iwe.u.data.length = strlen(buf);
7382                 current_ev = iwe_stream_add_point(info, current_ev, end_buf,
7383                                                   &iwe, buf);
7384                 kfree(buf);
7385         }
7386
7387         /* Put WPA/RSN Information Elements into the event stream */
7388         if (test_bit(FLAG_WPA_CAPABLE, &ai->flags)) {
7389                 unsigned int num_null_ies = 0;
7390                 u16 length = sizeof (bss->extra.iep);
7391                 u8 *ie = (void *)&bss->extra.iep;
7392
7393                 while ((length >= 2) && (num_null_ies < 2)) {
7394                         if (2 + ie[1] > length) {
7395                                 /* Invalid element, don't continue parsing IE */
7396                                 break;
7397                         }
7398
7399                         switch (ie[0]) {
7400                         case WLAN_EID_SSID:
7401                                 /* Two zero-length SSID elements
7402                                  * mean we're done parsing elements */
7403                                 if (!ie[1])
7404                                         num_null_ies++;
7405                                 break;
7406
7407                         case WLAN_EID_VENDOR_SPECIFIC:
7408                                 if (ie[1] >= 4 &&
7409                                     ie[2] == 0x00 &&
7410                                     ie[3] == 0x50 &&
7411                                     ie[4] == 0xf2 &&
7412                                     ie[5] == 0x01) {
7413                                         iwe.cmd = IWEVGENIE;
7414                                         /* 64 is an arbitrary cut-off */
7415                                         iwe.u.data.length = min(ie[1] + 2,
7416                                                                 64);
7417                                         current_ev = iwe_stream_add_point(
7418                                                         info, current_ev,
7419                                                         end_buf, &iwe, ie);
7420                                 }
7421                                 break;
7422
7423                         case WLAN_EID_RSN:
7424                                 iwe.cmd = IWEVGENIE;
7425                                 /* 64 is an arbitrary cut-off */
7426                                 iwe.u.data.length = min(ie[1] + 2, 64);
7427                                 current_ev = iwe_stream_add_point(
7428                                         info, current_ev, end_buf,
7429                                         &iwe, ie);
7430                                 break;
7431
7432                         default:
7433                                 break;
7434                         }
7435
7436                         length -= 2 + ie[1];
7437                         ie += 2 + ie[1];
7438                 }
7439         }
7440         return current_ev;
7441 }
7442
7443 /*------------------------------------------------------------------*/
7444 /*
7445  * Wireless Handler : Read Scan Results
7446  */
7447 static int airo_get_scan(struct net_device *dev,
7448                          struct iw_request_info *info,
7449                          struct iw_point *dwrq,
7450                          char *extra)
7451 {
7452         struct airo_info *ai = dev->ml_priv;
7453         BSSListElement *net;
7454         int err = 0;
7455         char *current_ev = extra;
7456
7457         /* If a scan is in-progress, return -EAGAIN */
7458         if (ai->scan_timeout > 0)
7459                 return -EAGAIN;
7460
7461         if (down_interruptible(&ai->sem))
7462                 return -EAGAIN;
7463
7464         list_for_each_entry (net, &ai->network_list, list) {
7465                 /* Translate to WE format this entry */
7466                 current_ev = airo_translate_scan(dev, info, current_ev,
7467                                                  extra + dwrq->length,
7468                                                  &net->bss);
7469
7470                 /* Check if there is space for one more entry */
7471                 if((extra + dwrq->length - current_ev) <= IW_EV_ADDR_LEN) {
7472                         /* Ask user space to try again with a bigger buffer */
7473                         err = -E2BIG;
7474                         goto out;
7475                 }
7476         }
7477
7478         /* Length of data */
7479         dwrq->length = (current_ev - extra);
7480         dwrq->flags = 0;        /* todo */
7481
7482 out:
7483         up(&ai->sem);
7484         return err;
7485 }
7486
7487 /*------------------------------------------------------------------*/
7488 /*
7489  * Commit handler : called after a bunch of SET operations
7490  */
7491 static int airo_config_commit(struct net_device *dev,
7492                               struct iw_request_info *info,     /* NULL */
7493                               void *zwrq,                       /* NULL */
7494                               char *extra)                      /* NULL */
7495 {
7496         struct airo_info *local = dev->ml_priv;
7497
7498         if (!test_bit (FLAG_COMMIT, &local->flags))
7499                 return 0;
7500
7501         /* Some of the "SET" function may have modified some of the
7502          * parameters. It's now time to commit them in the card */
7503         disable_MAC(local, 1);
7504         if (test_bit (FLAG_RESET, &local->flags)) {
7505                 SsidRid SSID_rid;
7506
7507                 readSsidRid(local, &SSID_rid);
7508                 if (test_bit(FLAG_MPI,&local->flags))
7509                         setup_card(local, dev->dev_addr, 1 );
7510                 else
7511                         reset_airo_card(dev);
7512                 disable_MAC(local, 1);
7513                 writeSsidRid(local, &SSID_rid, 1);
7514                 writeAPListRid(local, &local->APList, 1);
7515         }
7516         if (down_interruptible(&local->sem))
7517                 return -ERESTARTSYS;
7518         writeConfigRid(local, 0);
7519         enable_MAC(local, 0);
7520         if (test_bit (FLAG_RESET, &local->flags))
7521                 airo_set_promisc(local);
7522         else
7523                 up(&local->sem);
7524
7525         return 0;
7526 }
7527
7528 /*------------------------------------------------------------------*/
7529 /*
7530  * Structures to export the Wireless Handlers
7531  */
7532
7533 static const struct iw_priv_args airo_private_args[] = {
7534 /*{ cmd,         set_args,                            get_args, name } */
7535   { AIROIOCTL, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
7536     IW_PRIV_TYPE_BYTE | 2047, "airoioctl" },
7537   { AIROIDIFC, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl),
7538     IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "airoidifc" },
7539 };
7540
7541 static const iw_handler         airo_handler[] =
7542 {
7543         (iw_handler) airo_config_commit,        /* SIOCSIWCOMMIT */
7544         (iw_handler) airo_get_name,             /* SIOCGIWNAME */
7545         (iw_handler) NULL,                      /* SIOCSIWNWID */
7546         (iw_handler) NULL,                      /* SIOCGIWNWID */
7547         (iw_handler) airo_set_freq,             /* SIOCSIWFREQ */
7548         (iw_handler) airo_get_freq,             /* SIOCGIWFREQ */
7549         (iw_handler) airo_set_mode,             /* SIOCSIWMODE */
7550         (iw_handler) airo_get_mode,             /* SIOCGIWMODE */
7551         (iw_handler) airo_set_sens,             /* SIOCSIWSENS */
7552         (iw_handler) airo_get_sens,             /* SIOCGIWSENS */
7553         (iw_handler) NULL,                      /* SIOCSIWRANGE */
7554         (iw_handler) airo_get_range,            /* SIOCGIWRANGE */
7555         (iw_handler) NULL,                      /* SIOCSIWPRIV */
7556         (iw_handler) NULL,                      /* SIOCGIWPRIV */
7557         (iw_handler) NULL,                      /* SIOCSIWSTATS */
7558         (iw_handler) NULL,                      /* SIOCGIWSTATS */
7559         iw_handler_set_spy,                     /* SIOCSIWSPY */
7560         iw_handler_get_spy,                     /* SIOCGIWSPY */
7561         iw_handler_set_thrspy,                  /* SIOCSIWTHRSPY */
7562         iw_handler_get_thrspy,                  /* SIOCGIWTHRSPY */
7563         (iw_handler) airo_set_wap,              /* SIOCSIWAP */
7564         (iw_handler) airo_get_wap,              /* SIOCGIWAP */
7565         (iw_handler) NULL,                      /* -- hole -- */
7566         (iw_handler) airo_get_aplist,           /* SIOCGIWAPLIST */
7567         (iw_handler) airo_set_scan,             /* SIOCSIWSCAN */
7568         (iw_handler) airo_get_scan,             /* SIOCGIWSCAN */
7569         (iw_handler) airo_set_essid,            /* SIOCSIWESSID */
7570         (iw_handler) airo_get_essid,            /* SIOCGIWESSID */
7571         (iw_handler) airo_set_nick,             /* SIOCSIWNICKN */
7572         (iw_handler) airo_get_nick,             /* SIOCGIWNICKN */
7573         (iw_handler) NULL,                      /* -- hole -- */
7574         (iw_handler) NULL,                      /* -- hole -- */
7575         (iw_handler) airo_set_rate,             /* SIOCSIWRATE */
7576         (iw_handler) airo_get_rate,             /* SIOCGIWRATE */
7577         (iw_handler) airo_set_rts,              /* SIOCSIWRTS */
7578         (iw_handler) airo_get_rts,              /* SIOCGIWRTS */
7579         (iw_handler) airo_set_frag,             /* SIOCSIWFRAG */
7580         (iw_handler) airo_get_frag,             /* SIOCGIWFRAG */
7581         (iw_handler) airo_set_txpow,            /* SIOCSIWTXPOW */
7582         (iw_handler) airo_get_txpow,            /* SIOCGIWTXPOW */
7583         (iw_handler) airo_set_retry,            /* SIOCSIWRETRY */
7584         (iw_handler) airo_get_retry,            /* SIOCGIWRETRY */
7585         (iw_handler) airo_set_encode,           /* SIOCSIWENCODE */
7586         (iw_handler) airo_get_encode,           /* SIOCGIWENCODE */
7587         (iw_handler) airo_set_power,            /* SIOCSIWPOWER */
7588         (iw_handler) airo_get_power,            /* SIOCGIWPOWER */
7589         (iw_handler) NULL,                      /* -- hole -- */
7590         (iw_handler) NULL,                      /* -- hole -- */
7591         (iw_handler) NULL,                      /* SIOCSIWGENIE */
7592         (iw_handler) NULL,                      /* SIOCGIWGENIE */
7593         (iw_handler) airo_set_auth,             /* SIOCSIWAUTH */
7594         (iw_handler) airo_get_auth,             /* SIOCGIWAUTH */
7595         (iw_handler) airo_set_encodeext,        /* SIOCSIWENCODEEXT */
7596         (iw_handler) airo_get_encodeext,        /* SIOCGIWENCODEEXT */
7597         (iw_handler) NULL,                      /* SIOCSIWPMKSA */
7598 };
7599
7600 /* Note : don't describe AIROIDIFC and AIROOLDIDIFC in here.
7601  * We want to force the use of the ioctl code, because those can't be
7602  * won't work the iw_handler code (because they simultaneously read
7603  * and write data and iw_handler can't do that).
7604  * Note that it's perfectly legal to read/write on a single ioctl command,
7605  * you just can't use iwpriv and need to force it via the ioctl handler.
7606  * Jean II */
7607 static const iw_handler         airo_private_handler[] =
7608 {
7609         NULL,                           /* SIOCIWFIRSTPRIV */
7610 };
7611
7612 static const struct iw_handler_def      airo_handler_def =
7613 {
7614         .num_standard   = ARRAY_SIZE(airo_handler),
7615         .num_private    = ARRAY_SIZE(airo_private_handler),
7616         .num_private_args = ARRAY_SIZE(airo_private_args),
7617         .standard       = airo_handler,
7618         .private        = airo_private_handler,
7619         .private_args   = airo_private_args,
7620         .get_wireless_stats = airo_get_wireless_stats,
7621 };
7622
7623 /*
7624  * This defines the configuration part of the Wireless Extensions
7625  * Note : irq and spinlock protection will occur in the subroutines
7626  *
7627  * TODO :
7628  *      o Check input value more carefully and fill correct values in range
7629  *      o Test and shakeout the bugs (if any)
7630  *
7631  * Jean II
7632  *
7633  * Javier Achirica did a great job of merging code from the unnamed CISCO
7634  * developer that added support for flashing the card.
7635  */
7636 static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
7637 {
7638         int rc = 0;
7639         struct airo_info *ai = dev->ml_priv;
7640
7641         if (ai->power.event)
7642                 return 0;
7643
7644         switch (cmd) {
7645 #ifdef CISCO_EXT
7646         case AIROIDIFC:
7647 #ifdef AIROOLDIDIFC
7648         case AIROOLDIDIFC:
7649 #endif
7650         {
7651                 int val = AIROMAGIC;
7652                 aironet_ioctl com;
7653                 if (copy_from_user(&com,rq->ifr_data,sizeof(com)))
7654                         rc = -EFAULT;
7655                 else if (copy_to_user(com.data,(char *)&val,sizeof(val)))
7656                         rc = -EFAULT;
7657         }
7658         break;
7659
7660         case AIROIOCTL:
7661 #ifdef AIROOLDIOCTL
7662         case AIROOLDIOCTL:
7663 #endif
7664                 /* Get the command struct and hand it off for evaluation by
7665                  * the proper subfunction
7666                  */
7667         {
7668                 aironet_ioctl com;
7669                 if (copy_from_user(&com,rq->ifr_data,sizeof(com))) {
7670                         rc = -EFAULT;
7671                         break;
7672                 }
7673
7674                 /* Separate R/W functions bracket legality here
7675                  */
7676                 if ( com.command == AIRORSWVERSION ) {
7677                         if (copy_to_user(com.data, swversion, sizeof(swversion)))
7678                                 rc = -EFAULT;
7679                         else
7680                                 rc = 0;
7681                 }
7682                 else if ( com.command <= AIRORRID)
7683                         rc = readrids(dev,&com);
7684                 else if ( com.command >= AIROPCAP && com.command <= (AIROPLEAPUSR+2) )
7685                         rc = writerids(dev,&com);
7686                 else if ( com.command >= AIROFLSHRST && com.command <= AIRORESTART )
7687                         rc = flashcard(dev,&com);
7688                 else
7689                         rc = -EINVAL;      /* Bad command in ioctl */
7690         }
7691         break;
7692 #endif /* CISCO_EXT */
7693
7694         // All other calls are currently unsupported
7695         default:
7696                 rc = -EOPNOTSUPP;
7697         }
7698         return rc;
7699 }
7700
7701 /*
7702  * Get the Wireless stats out of the driver
7703  * Note : irq and spinlock protection will occur in the subroutines
7704  *
7705  * TODO :
7706  *      o Check if work in Ad-Hoc mode (otherwise, use SPY, as in wvlan_cs)
7707  *
7708  * Jean
7709  */
7710 static void airo_read_wireless_stats(struct airo_info *local)
7711 {
7712         StatusRid status_rid;
7713         StatsRid stats_rid;
7714         CapabilityRid cap_rid;
7715         __le32 *vals = stats_rid.vals;
7716
7717         /* Get stats out of the card */
7718         clear_bit(JOB_WSTATS, &local->jobs);
7719         if (local->power.event) {
7720                 up(&local->sem);
7721                 return;
7722         }
7723         readCapabilityRid(local, &cap_rid, 0);
7724         readStatusRid(local, &status_rid, 0);
7725         readStatsRid(local, &stats_rid, RID_STATS, 0);
7726         up(&local->sem);
7727
7728         /* The status */
7729         local->wstats.status = le16_to_cpu(status_rid.mode);
7730
7731         /* Signal quality and co */
7732         if (local->rssi) {
7733                 local->wstats.qual.level =
7734                         airo_rssi_to_dbm(local->rssi,
7735                                          le16_to_cpu(status_rid.sigQuality));
7736                 /* normalizedSignalStrength appears to be a percentage */
7737                 local->wstats.qual.qual =
7738                         le16_to_cpu(status_rid.normalizedSignalStrength);
7739         } else {
7740                 local->wstats.qual.level =
7741                         (le16_to_cpu(status_rid.normalizedSignalStrength) + 321) / 2;
7742                 local->wstats.qual.qual = airo_get_quality(&status_rid, &cap_rid);
7743         }
7744         if (le16_to_cpu(status_rid.len) >= 124) {
7745                 local->wstats.qual.noise = 0x100 - status_rid.noisedBm;
7746                 local->wstats.qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
7747         } else {
7748                 local->wstats.qual.noise = 0;
7749                 local->wstats.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_INVALID | IW_QUAL_DBM;
7750         }
7751
7752         /* Packets discarded in the wireless adapter due to wireless
7753          * specific problems */
7754         local->wstats.discard.nwid = le32_to_cpu(vals[56]) +
7755                                      le32_to_cpu(vals[57]) +
7756                                      le32_to_cpu(vals[58]); /* SSID Mismatch */
7757         local->wstats.discard.code = le32_to_cpu(vals[6]);/* RxWepErr */
7758         local->wstats.discard.fragment = le32_to_cpu(vals[30]);
7759         local->wstats.discard.retries = le32_to_cpu(vals[10]);
7760         local->wstats.discard.misc = le32_to_cpu(vals[1]) +
7761                                      le32_to_cpu(vals[32]);
7762         local->wstats.miss.beacon = le32_to_cpu(vals[34]);
7763 }
7764
7765 static struct iw_statistics *airo_get_wireless_stats(struct net_device *dev)
7766 {
7767         struct airo_info *local =  dev->ml_priv;
7768
7769         if (!test_bit(JOB_WSTATS, &local->jobs)) {
7770                 /* Get stats out of the card if available */
7771                 if (down_trylock(&local->sem) != 0) {
7772                         set_bit(JOB_WSTATS, &local->jobs);
7773                         wake_up_interruptible(&local->thr_wait);
7774                 } else
7775                         airo_read_wireless_stats(local);
7776         }
7777
7778         return &local->wstats;
7779 }
7780
7781 #ifdef CISCO_EXT
7782 /*
7783  * This just translates from driver IOCTL codes to the command codes to
7784  * feed to the radio's host interface. Things can be added/deleted
7785  * as needed.  This represents the READ side of control I/O to
7786  * the card
7787  */
7788 static int readrids(struct net_device *dev, aironet_ioctl *comp) {
7789         unsigned short ridcode;
7790         unsigned char *iobuf;
7791         int len;
7792         struct airo_info *ai = dev->ml_priv;
7793
7794         if (test_bit(FLAG_FLASHING, &ai->flags))
7795                 return -EIO;
7796
7797         switch(comp->command)
7798         {
7799         case AIROGCAP:      ridcode = RID_CAPABILITIES; break;
7800         case AIROGCFG:      ridcode = RID_CONFIG;
7801                 if (test_bit(FLAG_COMMIT, &ai->flags)) {
7802                         disable_MAC (ai, 1);
7803                         writeConfigRid (ai, 1);
7804                         enable_MAC(ai, 1);
7805                 }
7806                 break;
7807         case AIROGSLIST:    ridcode = RID_SSID;         break;
7808         case AIROGVLIST:    ridcode = RID_APLIST;       break;
7809         case AIROGDRVNAM:   ridcode = RID_DRVNAME;      break;
7810         case AIROGEHTENC:   ridcode = RID_ETHERENCAP;   break;
7811         case AIROGWEPKTMP:  ridcode = RID_WEP_TEMP;     break;
7812         case AIROGWEPKNV:   ridcode = RID_WEP_PERM;     break;
7813         case AIROGSTAT:     ridcode = RID_STATUS;       break;
7814         case AIROGSTATSD32: ridcode = RID_STATSDELTA;   break;
7815         case AIROGSTATSC32: ridcode = RID_STATS;        break;
7816         case AIROGMICSTATS:
7817                 if (copy_to_user(comp->data, &ai->micstats,
7818                                  min((int)comp->len,(int)sizeof(ai->micstats))))
7819                         return -EFAULT;
7820                 return 0;
7821         case AIRORRID:      ridcode = comp->ridnum;     break;
7822         default:
7823                 return -EINVAL;
7824         }
7825
7826         if (ridcode == RID_WEP_TEMP || ridcode == RID_WEP_PERM) {
7827                 /* Only super-user can read WEP keys */
7828                 if (!capable(CAP_NET_ADMIN))
7829                         return -EPERM;
7830         }
7831
7832         if ((iobuf = kzalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7833                 return -ENOMEM;
7834
7835         PC4500_readrid(ai,ridcode,iobuf,RIDSIZE, 1);
7836         /* get the count of bytes in the rid  docs say 1st 2 bytes is it.
7837          * then return it to the user
7838          * 9/22/2000 Honor user given length
7839          */
7840         len = comp->len;
7841
7842         if (copy_to_user(comp->data, iobuf, min(len, (int)RIDSIZE))) {
7843                 kfree (iobuf);
7844                 return -EFAULT;
7845         }
7846         kfree (iobuf);
7847         return 0;
7848 }
7849
7850 /*
7851  * Danger Will Robinson write the rids here
7852  */
7853
7854 static int writerids(struct net_device *dev, aironet_ioctl *comp) {
7855         struct airo_info *ai = dev->ml_priv;
7856         int  ridcode;
7857         int  enabled;
7858         static int (* writer)(struct airo_info *, u16 rid, const void *, int, int);
7859         unsigned char *iobuf;
7860
7861         /* Only super-user can write RIDs */
7862         if (!capable(CAP_NET_ADMIN))
7863                 return -EPERM;
7864
7865         if (test_bit(FLAG_FLASHING, &ai->flags))
7866                 return -EIO;
7867
7868         ridcode = 0;
7869         writer = do_writerid;
7870
7871         switch(comp->command)
7872         {
7873         case AIROPSIDS:     ridcode = RID_SSID;         break;
7874         case AIROPCAP:      ridcode = RID_CAPABILITIES; break;
7875         case AIROPAPLIST:   ridcode = RID_APLIST;       break;
7876         case AIROPCFG: ai->config.len = 0;
7877                             clear_bit(FLAG_COMMIT, &ai->flags);
7878                             ridcode = RID_CONFIG;       break;
7879         case AIROPWEPKEYNV: ridcode = RID_WEP_PERM;     break;
7880         case AIROPLEAPUSR:  ridcode = RID_LEAPUSERNAME; break;
7881         case AIROPLEAPPWD:  ridcode = RID_LEAPPASSWORD; break;
7882         case AIROPWEPKEY:   ridcode = RID_WEP_TEMP; writer = PC4500_writerid;
7883                 break;
7884         case AIROPLEAPUSR+1: ridcode = 0xFF2A;          break;
7885         case AIROPLEAPUSR+2: ridcode = 0xFF2B;          break;
7886
7887                 /* this is not really a rid but a command given to the card
7888                  * same with MAC off
7889                  */
7890         case AIROPMACON:
7891                 if (enable_MAC(ai, 1) != 0)
7892                         return -EIO;
7893                 return 0;
7894
7895                 /*
7896                  * Evidently this code in the airo driver does not get a symbol
7897                  * as disable_MAC. it's probably so short the compiler does not gen one.
7898                  */
7899         case AIROPMACOFF:
7900                 disable_MAC(ai, 1);
7901                 return 0;
7902
7903                 /* This command merely clears the counts does not actually store any data
7904                  * only reads rid. But as it changes the cards state, I put it in the
7905                  * writerid routines.
7906                  */
7907         case AIROPSTCLR:
7908                 if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7909                         return -ENOMEM;
7910
7911                 PC4500_readrid(ai,RID_STATSDELTACLEAR,iobuf,RIDSIZE, 1);
7912
7913                 enabled = ai->micstats.enabled;
7914                 memset(&ai->micstats,0,sizeof(ai->micstats));
7915                 ai->micstats.enabled = enabled;
7916
7917                 if (copy_to_user(comp->data, iobuf,
7918                                  min((int)comp->len, (int)RIDSIZE))) {
7919                         kfree (iobuf);
7920                         return -EFAULT;
7921                 }
7922                 kfree (iobuf);
7923                 return 0;
7924
7925         default:
7926                 return -EOPNOTSUPP;     /* Blarg! */
7927         }
7928         if(comp->len > RIDSIZE)
7929                 return -EINVAL;
7930
7931         if ((iobuf = kmalloc(RIDSIZE, GFP_KERNEL)) == NULL)
7932                 return -ENOMEM;
7933
7934         if (copy_from_user(iobuf,comp->data,comp->len)) {
7935                 kfree (iobuf);
7936                 return -EFAULT;
7937         }
7938
7939         if (comp->command == AIROPCFG) {
7940                 ConfigRid *cfg = (ConfigRid *)iobuf;
7941
7942                 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags))
7943                         cfg->opmode |= MODE_MIC;
7944
7945                 if ((cfg->opmode & MODE_CFG_MASK) == MODE_STA_IBSS)
7946                         set_bit (FLAG_ADHOC, &ai->flags);
7947                 else
7948                         clear_bit (FLAG_ADHOC, &ai->flags);
7949         }
7950
7951         if((*writer)(ai, ridcode, iobuf,comp->len,1)) {
7952                 kfree (iobuf);
7953                 return -EIO;
7954         }
7955         kfree (iobuf);
7956         return 0;
7957 }
7958
7959 /*****************************************************************************
7960  * Ancillary flash / mod functions much black magic lurkes here              *
7961  *****************************************************************************
7962  */
7963
7964 /*
7965  * Flash command switch table
7966  */
7967
7968 static int flashcard(struct net_device *dev, aironet_ioctl *comp) {
7969         int z;
7970
7971         /* Only super-user can modify flash */
7972         if (!capable(CAP_NET_ADMIN))
7973                 return -EPERM;
7974
7975         switch(comp->command)
7976         {
7977         case AIROFLSHRST:
7978                 return cmdreset((struct airo_info *)dev->ml_priv);
7979
7980         case AIROFLSHSTFL:
7981                 if (!AIRO_FLASH(dev) &&
7982                     (AIRO_FLASH(dev) = kmalloc(FLASHSIZE, GFP_KERNEL)) == NULL)
7983                         return -ENOMEM;
7984                 return setflashmode((struct airo_info *)dev->ml_priv);
7985
7986         case AIROFLSHGCHR: /* Get char from aux */
7987                 if(comp->len != sizeof(int))
7988                         return -EINVAL;
7989                 if (copy_from_user(&z,comp->data,comp->len))
7990                         return -EFAULT;
7991                 return flashgchar((struct airo_info *)dev->ml_priv, z, 8000);
7992
7993         case AIROFLSHPCHR: /* Send char to card. */
7994                 if(comp->len != sizeof(int))
7995                         return -EINVAL;
7996                 if (copy_from_user(&z,comp->data,comp->len))
7997                         return -EFAULT;
7998                 return flashpchar((struct airo_info *)dev->ml_priv, z, 8000);
7999
8000         case AIROFLPUTBUF: /* Send 32k to card */
8001                 if (!AIRO_FLASH(dev))
8002                         return -ENOMEM;
8003                 if(comp->len > FLASHSIZE)
8004                         return -EINVAL;
8005                 if (copy_from_user(AIRO_FLASH(dev), comp->data, comp->len))
8006                         return -EFAULT;
8007
8008                 flashputbuf((struct airo_info *)dev->ml_priv);
8009                 return 0;
8010
8011         case AIRORESTART:
8012                 if (flashrestart((struct airo_info *)dev->ml_priv, dev))
8013                         return -EIO;
8014                 return 0;
8015         }
8016         return -EINVAL;
8017 }
8018
8019 #define FLASH_COMMAND  0x7e7e
8020
8021 /*
8022  * STEP 1)
8023  * Disable MAC and do soft reset on
8024  * card.
8025  */
8026
8027 static int cmdreset(struct airo_info *ai) {
8028         disable_MAC(ai, 1);
8029
8030         if(!waitbusy (ai)){
8031                 airo_print_info(ai->dev->name, "Waitbusy hang before RESET");
8032                 return -EBUSY;
8033         }
8034
8035         OUT4500(ai,COMMAND,CMD_SOFTRESET);
8036
8037         ssleep(1);                      /* WAS 600 12/7/00 */
8038
8039         if(!waitbusy (ai)){
8040                 airo_print_info(ai->dev->name, "Waitbusy hang AFTER RESET");
8041                 return -EBUSY;
8042         }
8043         return 0;
8044 }
8045
8046 /* STEP 2)
8047  * Put the card in legendary flash
8048  * mode
8049  */
8050
8051 static int setflashmode (struct airo_info *ai) {
8052         set_bit (FLAG_FLASHING, &ai->flags);
8053
8054         OUT4500(ai, SWS0, FLASH_COMMAND);
8055         OUT4500(ai, SWS1, FLASH_COMMAND);
8056         if (probe) {
8057                 OUT4500(ai, SWS0, FLASH_COMMAND);
8058                 OUT4500(ai, COMMAND,0x10);
8059         } else {
8060                 OUT4500(ai, SWS2, FLASH_COMMAND);
8061                 OUT4500(ai, SWS3, FLASH_COMMAND);
8062                 OUT4500(ai, COMMAND,0);
8063         }
8064         msleep(500);            /* 500ms delay */
8065
8066         if(!waitbusy(ai)) {
8067                 clear_bit (FLAG_FLASHING, &ai->flags);
8068                 airo_print_info(ai->dev->name, "Waitbusy hang after setflash mode");
8069                 return -EIO;
8070         }
8071         return 0;
8072 }
8073
8074 /* Put character to SWS0 wait for dwelltime
8075  * x 50us for  echo .
8076  */
8077
8078 static int flashpchar(struct airo_info *ai,int byte,int dwelltime) {
8079         int echo;
8080         int waittime;
8081
8082         byte |= 0x8000;
8083
8084         if(dwelltime == 0 )
8085                 dwelltime = 200;
8086
8087         waittime=dwelltime;
8088
8089         /* Wait for busy bit d15 to go false indicating buffer empty */
8090         while ((IN4500 (ai, SWS0) & 0x8000) && waittime > 0) {
8091                 udelay (50);
8092                 waittime -= 50;
8093         }
8094
8095         /* timeout for busy clear wait */
8096         if(waittime <= 0 ){
8097                 airo_print_info(ai->dev->name, "flash putchar busywait timeout!");
8098                 return -EBUSY;
8099         }
8100
8101         /* Port is clear now write byte and wait for it to echo back */
8102         do {
8103                 OUT4500(ai,SWS0,byte);
8104                 udelay(50);
8105                 dwelltime -= 50;
8106                 echo = IN4500(ai,SWS1);
8107         } while (dwelltime >= 0 && echo != byte);
8108
8109         OUT4500(ai,SWS1,0);
8110
8111         return (echo == byte) ? 0 : -EIO;
8112 }
8113
8114 /*
8115  * Get a character from the card matching matchbyte
8116  * Step 3)
8117  */
8118 static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime){
8119         int           rchar;
8120         unsigned char rbyte=0;
8121
8122         do {
8123                 rchar = IN4500(ai,SWS1);
8124
8125                 if(dwelltime && !(0x8000 & rchar)){
8126                         dwelltime -= 10;
8127                         mdelay(10);
8128                         continue;
8129                 }
8130                 rbyte = 0xff & rchar;
8131
8132                 if( (rbyte == matchbyte) && (0x8000 & rchar) ){
8133                         OUT4500(ai,SWS1,0);
8134                         return 0;
8135                 }
8136                 if( rbyte == 0x81 || rbyte == 0x82 || rbyte == 0x83 || rbyte == 0x1a || 0xffff == rchar)
8137                         break;
8138                 OUT4500(ai,SWS1,0);
8139
8140         }while(dwelltime > 0);
8141         return -EIO;
8142 }
8143
8144 /*
8145  * Transfer 32k of firmware data from user buffer to our buffer and
8146  * send to the card
8147  */
8148
8149 static int flashputbuf(struct airo_info *ai){
8150         int            nwords;
8151
8152         /* Write stuff */
8153         if (test_bit(FLAG_MPI,&ai->flags))
8154                 memcpy_toio(ai->pciaux + 0x8000, ai->flash, FLASHSIZE);
8155         else {
8156                 OUT4500(ai,AUXPAGE,0x100);
8157                 OUT4500(ai,AUXOFF,0);
8158
8159                 for(nwords=0;nwords != FLASHSIZE / 2;nwords++){
8160                         OUT4500(ai,AUXDATA,ai->flash[nwords] & 0xffff);
8161                 }
8162         }
8163         OUT4500(ai,SWS0,0x8000);
8164
8165         return 0;
8166 }
8167
8168 /*
8169  *
8170  */
8171 static int flashrestart(struct airo_info *ai,struct net_device *dev){
8172         int    i,status;
8173
8174         ssleep(1);                      /* Added 12/7/00 */
8175         clear_bit (FLAG_FLASHING, &ai->flags);
8176         if (test_bit(FLAG_MPI, &ai->flags)) {
8177                 status = mpi_init_descriptors(ai);
8178                 if (status != SUCCESS)
8179                         return status;
8180         }
8181         status = setup_card(ai, dev->dev_addr, 1);
8182
8183         if (!test_bit(FLAG_MPI,&ai->flags))
8184                 for( i = 0; i < MAX_FIDS; i++ ) {
8185                         ai->fids[i] = transmit_allocate
8186                                 ( ai, AIRO_DEF_MTU, i >= MAX_FIDS / 2 );
8187                 }
8188
8189         ssleep(1);                      /* Added 12/7/00 */
8190         return status;
8191 }
8192 #endif /* CISCO_EXT */
8193
8194 /*
8195     This program is free software; you can redistribute it and/or
8196     modify it under the terms of the GNU General Public License
8197     as published by the Free Software Foundation; either version 2
8198     of the License, or (at your option) any later version.
8199
8200     This program is distributed in the hope that it will be useful,
8201     but WITHOUT ANY WARRANTY; without even the implied warranty of
8202     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
8203     GNU General Public License for more details.
8204
8205     In addition:
8206
8207     Redistribution and use in source and binary forms, with or without
8208     modification, are permitted provided that the following conditions
8209     are met:
8210
8211     1. Redistributions of source code must retain the above copyright
8212        notice, this list of conditions and the following disclaimer.
8213     2. Redistributions in binary form must reproduce the above copyright
8214        notice, this list of conditions and the following disclaimer in the
8215        documentation and/or other materials provided with the distribution.
8216     3. The name of the author may not be used to endorse or promote
8217        products derived from this software without specific prior written
8218        permission.
8219
8220     THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
8221     IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
8222     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
8223     ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
8224     INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
8225     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
8226     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
8227     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
8228     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
8229     IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
8230     POSSIBILITY OF SUCH DAMAGE.
8231 */
8232
8233 module_init(airo_init_module);
8234 module_exit(airo_cleanup_module);