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