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

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