err.no Git - linux-2.6/blob - drivers/net/wireless/airo.c

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