SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/wireless/airo.c

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