git.oblomov.eu Git - linux-2.6/blob - drivers/net/wireless/airo.c

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