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