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