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