1 // SPDX-License-Identifier: GPL-2.0-only 2 /****************************************************************************** 3 4 Copyright(c) 2003 - 2006 Intel Corporation. All rights reserved. 5 6 7 Contact Information: 8 Intel Linux Wireless <ilw@linux.intel.com> 9 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 10 11 Portions of this file are based on the sample_* files provided by Wireless 12 Extensions 0.26 package and copyright (c) 1997-2003 Jean Tourrilhes 13 <jt@hpl.hp.com> 14 15 Portions of this file are based on the Host AP project, 16 Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen 17 <j@w1.fi> 18 Copyright (c) 2002-2003, Jouni Malinen <j@w1.fi> 19 20 Portions of ipw2100_mod_firmware_load, ipw2100_do_mod_firmware_load, and 21 ipw2100_fw_load are loosely based on drivers/sound/sound_firmware.c 22 available in the 2.4.25 kernel sources, and are copyright (c) Alan Cox 23 24 ******************************************************************************/ 25 /* 26 27 Initial driver on which this is based was developed by Janusz Gorycki, 28 Maciej Urbaniak, and Maciej Sosnowski. 29 30 Promiscuous mode support added by Jacek Wysoczynski and Maciej Urbaniak. 31 32 Theory of Operation 33 34 Tx - Commands and Data 35 36 Firmware and host share a circular queue of Transmit Buffer Descriptors (TBDs) 37 Each TBD contains a pointer to the physical (dma_addr_t) address of data being 38 sent to the firmware as well as the length of the data. 39 40 The host writes to the TBD queue at the WRITE index. The WRITE index points 41 to the _next_ packet to be written and is advanced when after the TBD has been 42 filled. 43 44 The firmware pulls from the TBD queue at the READ index. The READ index points 45 to the currently being read entry, and is advanced once the firmware is 46 done with a packet. 47 48 When data is sent to the firmware, the first TBD is used to indicate to the 49 firmware if a Command or Data is being sent. If it is Command, all of the 50 command information is contained within the physical address referred to by the 51 TBD. If it is Data, the first TBD indicates the type of data packet, number 52 of fragments, etc. The next TBD then refers to the actual packet location. 53 54 The Tx flow cycle is as follows: 55 56 1) ipw2100_tx() is called by kernel with SKB to transmit 57 2) Packet is move from the tx_free_list and appended to the transmit pending 58 list (tx_pend_list) 59 3) work is scheduled to move pending packets into the shared circular queue. 60 4) when placing packet in the circular queue, the incoming SKB is DMA mapped 61 to a physical address. That address is entered into a TBD. Two TBDs are 62 filled out. The first indicating a data packet, the second referring to the 63 actual payload data. 64 5) the packet is removed from tx_pend_list and placed on the end of the 65 firmware pending list (fw_pend_list) 66 6) firmware is notified that the WRITE index has 67 7) Once the firmware has processed the TBD, INTA is triggered. 68 8) For each Tx interrupt received from the firmware, the READ index is checked 69 to see which TBDs are done being processed. 70 9) For each TBD that has been processed, the ISR pulls the oldest packet 71 from the fw_pend_list. 72 10)The packet structure contained in the fw_pend_list is then used 73 to unmap the DMA address and to free the SKB originally passed to the driver 74 from the kernel. 75 11)The packet structure is placed onto the tx_free_list 76 77 The above steps are the same for commands, only the msg_free_list/msg_pend_list 78 are used instead of tx_free_list/tx_pend_list 79 80 ... 81 82 Critical Sections / Locking : 83 84 There are two locks utilized. The first is the low level lock (priv->low_lock) 85 that protects the following: 86 87 - Access to the Tx/Rx queue lists via priv->low_lock. The lists are as follows: 88 89 tx_free_list : Holds pre-allocated Tx buffers. 90 TAIL modified in __ipw2100_tx_process() 91 HEAD modified in ipw2100_tx() 92 93 tx_pend_list : Holds used Tx buffers waiting to go into the TBD ring 94 TAIL modified ipw2100_tx() 95 HEAD modified by ipw2100_tx_send_data() 96 97 msg_free_list : Holds pre-allocated Msg (Command) buffers 98 TAIL modified in __ipw2100_tx_process() 99 HEAD modified in ipw2100_hw_send_command() 100 101 msg_pend_list : Holds used Msg buffers waiting to go into the TBD ring 102 TAIL modified in ipw2100_hw_send_command() 103 HEAD modified in ipw2100_tx_send_commands() 104 105 The flow of data on the TX side is as follows: 106 107 MSG_FREE_LIST + COMMAND => MSG_PEND_LIST => TBD => MSG_FREE_LIST 108 TX_FREE_LIST + DATA => TX_PEND_LIST => TBD => TX_FREE_LIST 109 110 The methods that work on the TBD ring are protected via priv->low_lock. 111 112 - The internal data state of the device itself 113 - Access to the firmware read/write indexes for the BD queues 114 and associated logic 115 116 All external entry functions are locked with the priv->action_lock to ensure 117 that only one external action is invoked at a time. 118 119 120 */ 121 122 #include <linux/compiler.h> 123 #include <linux/errno.h> 124 #include <linux/if_arp.h> 125 #include <linux/in6.h> 126 #include <linux/in.h> 127 #include <linux/ip.h> 128 #include <linux/kernel.h> 129 #include <linux/kmod.h> 130 #include <linux/module.h> 131 #include <linux/netdevice.h> 132 #include <linux/ethtool.h> 133 #include <linux/pci.h> 134 #include <linux/dma-mapping.h> 135 #include <linux/proc_fs.h> 136 #include <linux/skbuff.h> 137 #include <linux/uaccess.h> 138 #include <asm/io.h> 139 #include <linux/fs.h> 140 #include <linux/mm.h> 141 #include <linux/slab.h> 142 #include <linux/unistd.h> 143 #include <linux/stringify.h> 144 #include <linux/tcp.h> 145 #include <linux/types.h> 146 #include <linux/time.h> 147 #include <linux/firmware.h> 148 #include <linux/acpi.h> 149 #include <linux/ctype.h> 150 #include <linux/pm_qos.h> 151 152 #include <net/lib80211.h> 153 154 #include "ipw2100.h" 155 #include "ipw.h" 156 157 #define IPW2100_VERSION "git-1.2.2" 158 159 #define DRV_NAME "ipw2100" 160 #define DRV_VERSION IPW2100_VERSION 161 #define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2100 Network Driver" 162 #define DRV_COPYRIGHT "Copyright(c) 2003-2006 Intel Corporation" 163 164 static struct pm_qos_request ipw2100_pm_qos_req; 165 166 /* Debugging stuff */ 167 #ifdef CONFIG_IPW2100_DEBUG 168 #define IPW2100_RX_DEBUG /* Reception debugging */ 169 #endif 170 171 MODULE_DESCRIPTION(DRV_DESCRIPTION); 172 MODULE_VERSION(DRV_VERSION); 173 MODULE_AUTHOR(DRV_COPYRIGHT); 174 MODULE_LICENSE("GPL"); 175 176 static int debug = 0; 177 static int network_mode = 0; 178 static int channel = 0; 179 static int associate = 0; 180 static int disable = 0; 181 #ifdef CONFIG_PM 182 static struct ipw2100_fw ipw2100_firmware; 183 #endif 184 185 #include <linux/moduleparam.h> 186 module_param(debug, int, 0444); 187 module_param_named(mode, network_mode, int, 0444); 188 module_param(channel, int, 0444); 189 module_param(associate, int, 0444); 190 module_param(disable, int, 0444); 191 192 MODULE_PARM_DESC(debug, "debug level"); 193 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)"); 194 MODULE_PARM_DESC(channel, "channel"); 195 MODULE_PARM_DESC(associate, "auto associate when scanning (default off)"); 196 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])"); 197 198 static u32 ipw2100_debug_level = IPW_DL_NONE; 199 200 #ifdef CONFIG_IPW2100_DEBUG 201 #define IPW_DEBUG(level, message...) \ 202 do { \ 203 if (ipw2100_debug_level & (level)) { \ 204 printk(KERN_DEBUG "ipw2100: %c %s ", \ 205 in_interrupt() ? 'I' : 'U', __func__); \ 206 printk(message); \ 207 } \ 208 } while (0) 209 #else 210 #define IPW_DEBUG(level, message...) do {} while (0) 211 #endif /* CONFIG_IPW2100_DEBUG */ 212 213 #ifdef CONFIG_IPW2100_DEBUG 214 static const char *command_types[] = { 215 "undefined", 216 "unused", /* HOST_ATTENTION */ 217 "HOST_COMPLETE", 218 "unused", /* SLEEP */ 219 "unused", /* HOST_POWER_DOWN */ 220 "unused", 221 "SYSTEM_CONFIG", 222 "unused", /* SET_IMR */ 223 "SSID", 224 "MANDATORY_BSSID", 225 "AUTHENTICATION_TYPE", 226 "ADAPTER_ADDRESS", 227 "PORT_TYPE", 228 "INTERNATIONAL_MODE", 229 "CHANNEL", 230 "RTS_THRESHOLD", 231 "FRAG_THRESHOLD", 232 "POWER_MODE", 233 "TX_RATES", 234 "BASIC_TX_RATES", 235 "WEP_KEY_INFO", 236 "unused", 237 "unused", 238 "unused", 239 "unused", 240 "WEP_KEY_INDEX", 241 "WEP_FLAGS", 242 "ADD_MULTICAST", 243 "CLEAR_ALL_MULTICAST", 244 "BEACON_INTERVAL", 245 "ATIM_WINDOW", 246 "CLEAR_STATISTICS", 247 "undefined", 248 "undefined", 249 "undefined", 250 "undefined", 251 "TX_POWER_INDEX", 252 "undefined", 253 "undefined", 254 "undefined", 255 "undefined", 256 "undefined", 257 "undefined", 258 "BROADCAST_SCAN", 259 "CARD_DISABLE", 260 "PREFERRED_BSSID", 261 "SET_SCAN_OPTIONS", 262 "SCAN_DWELL_TIME", 263 "SWEEP_TABLE", 264 "AP_OR_STATION_TABLE", 265 "GROUP_ORDINALS", 266 "SHORT_RETRY_LIMIT", 267 "LONG_RETRY_LIMIT", 268 "unused", /* SAVE_CALIBRATION */ 269 "unused", /* RESTORE_CALIBRATION */ 270 "undefined", 271 "undefined", 272 "undefined", 273 "HOST_PRE_POWER_DOWN", 274 "unused", /* HOST_INTERRUPT_COALESCING */ 275 "undefined", 276 "CARD_DISABLE_PHY_OFF", 277 "MSDU_TX_RATES", 278 "undefined", 279 "SET_STATION_STAT_BITS", 280 "CLEAR_STATIONS_STAT_BITS", 281 "LEAP_ROGUE_MODE", 282 "SET_SECURITY_INFORMATION", 283 "DISASSOCIATION_BSSID", 284 "SET_WPA_ASS_IE" 285 }; 286 #endif 287 288 static const long ipw2100_frequencies[] = { 289 2412, 2417, 2422, 2427, 290 2432, 2437, 2442, 2447, 291 2452, 2457, 2462, 2467, 292 2472, 2484 293 }; 294 295 #define FREQ_COUNT ARRAY_SIZE(ipw2100_frequencies) 296 297 static struct ieee80211_rate ipw2100_bg_rates[] = { 298 { .bitrate = 10 }, 299 { .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 300 { .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 301 { .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 302 }; 303 304 #define RATE_COUNT ARRAY_SIZE(ipw2100_bg_rates) 305 306 /* Pre-decl until we get the code solid and then we can clean it up */ 307 static void ipw2100_tx_send_commands(struct ipw2100_priv *priv); 308 static void ipw2100_tx_send_data(struct ipw2100_priv *priv); 309 static int ipw2100_adapter_setup(struct ipw2100_priv *priv); 310 311 static void ipw2100_queues_initialize(struct ipw2100_priv *priv); 312 static void ipw2100_queues_free(struct ipw2100_priv *priv); 313 static int ipw2100_queues_allocate(struct ipw2100_priv *priv); 314 315 static int ipw2100_fw_download(struct ipw2100_priv *priv, 316 struct ipw2100_fw *fw); 317 static int ipw2100_get_firmware(struct ipw2100_priv *priv, 318 struct ipw2100_fw *fw); 319 static int ipw2100_get_fwversion(struct ipw2100_priv *priv, char *buf, 320 size_t max); 321 static int ipw2100_get_ucodeversion(struct ipw2100_priv *priv, char *buf, 322 size_t max); 323 static void ipw2100_release_firmware(struct ipw2100_priv *priv, 324 struct ipw2100_fw *fw); 325 static int ipw2100_ucode_download(struct ipw2100_priv *priv, 326 struct ipw2100_fw *fw); 327 static void ipw2100_wx_event_work(struct work_struct *work); 328 static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev); 329 static const struct iw_handler_def ipw2100_wx_handler_def; 330 331 static inline void read_register(struct net_device *dev, u32 reg, u32 * val) 332 { 333 struct ipw2100_priv *priv = libipw_priv(dev); 334 335 *val = ioread32(priv->ioaddr + reg); 336 IPW_DEBUG_IO("r: 0x%08X => 0x%08X\n", reg, *val); 337 } 338 339 static inline void write_register(struct net_device *dev, u32 reg, u32 val) 340 { 341 struct ipw2100_priv *priv = libipw_priv(dev); 342 343 iowrite32(val, priv->ioaddr + reg); 344 IPW_DEBUG_IO("w: 0x%08X <= 0x%08X\n", reg, val); 345 } 346 347 static inline void read_register_word(struct net_device *dev, u32 reg, 348 u16 * val) 349 { 350 struct ipw2100_priv *priv = libipw_priv(dev); 351 352 *val = ioread16(priv->ioaddr + reg); 353 IPW_DEBUG_IO("r: 0x%08X => %04X\n", reg, *val); 354 } 355 356 static inline void read_register_byte(struct net_device *dev, u32 reg, u8 * val) 357 { 358 struct ipw2100_priv *priv = libipw_priv(dev); 359 360 *val = ioread8(priv->ioaddr + reg); 361 IPW_DEBUG_IO("r: 0x%08X => %02X\n", reg, *val); 362 } 363 364 static inline void write_register_word(struct net_device *dev, u32 reg, u16 val) 365 { 366 struct ipw2100_priv *priv = libipw_priv(dev); 367 368 iowrite16(val, priv->ioaddr + reg); 369 IPW_DEBUG_IO("w: 0x%08X <= %04X\n", reg, val); 370 } 371 372 static inline void write_register_byte(struct net_device *dev, u32 reg, u8 val) 373 { 374 struct ipw2100_priv *priv = libipw_priv(dev); 375 376 iowrite8(val, priv->ioaddr + reg); 377 IPW_DEBUG_IO("w: 0x%08X =< %02X\n", reg, val); 378 } 379 380 static inline void read_nic_dword(struct net_device *dev, u32 addr, u32 * val) 381 { 382 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 383 addr & IPW_REG_INDIRECT_ADDR_MASK); 384 read_register(dev, IPW_REG_INDIRECT_ACCESS_DATA, val); 385 } 386 387 static inline void write_nic_dword(struct net_device *dev, u32 addr, u32 val) 388 { 389 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 390 addr & IPW_REG_INDIRECT_ADDR_MASK); 391 write_register(dev, IPW_REG_INDIRECT_ACCESS_DATA, val); 392 } 393 394 static inline void read_nic_word(struct net_device *dev, u32 addr, u16 * val) 395 { 396 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 397 addr & IPW_REG_INDIRECT_ADDR_MASK); 398 read_register_word(dev, IPW_REG_INDIRECT_ACCESS_DATA, val); 399 } 400 401 static inline void write_nic_word(struct net_device *dev, u32 addr, u16 val) 402 { 403 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 404 addr & IPW_REG_INDIRECT_ADDR_MASK); 405 write_register_word(dev, IPW_REG_INDIRECT_ACCESS_DATA, val); 406 } 407 408 static inline void read_nic_byte(struct net_device *dev, u32 addr, u8 * val) 409 { 410 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 411 addr & IPW_REG_INDIRECT_ADDR_MASK); 412 read_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA, val); 413 } 414 415 static inline void write_nic_byte(struct net_device *dev, u32 addr, u8 val) 416 { 417 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 418 addr & IPW_REG_INDIRECT_ADDR_MASK); 419 write_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA, val); 420 } 421 422 static inline void write_nic_auto_inc_address(struct net_device *dev, u32 addr) 423 { 424 write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, 425 addr & IPW_REG_INDIRECT_ADDR_MASK); 426 } 427 428 static inline void write_nic_dword_auto_inc(struct net_device *dev, u32 val) 429 { 430 write_register(dev, IPW_REG_AUTOINCREMENT_DATA, val); 431 } 432 433 static void write_nic_memory(struct net_device *dev, u32 addr, u32 len, 434 const u8 * buf) 435 { 436 u32 aligned_addr; 437 u32 aligned_len; 438 u32 dif_len; 439 u32 i; 440 441 /* read first nibble byte by byte */ 442 aligned_addr = addr & (~0x3); 443 dif_len = addr - aligned_addr; 444 if (dif_len) { 445 /* Start reading at aligned_addr + dif_len */ 446 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 447 aligned_addr); 448 for (i = dif_len; i < 4; i++, buf++) 449 write_register_byte(dev, 450 IPW_REG_INDIRECT_ACCESS_DATA + i, 451 *buf); 452 453 len -= dif_len; 454 aligned_addr += 4; 455 } 456 457 /* read DWs through autoincrement registers */ 458 write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, aligned_addr); 459 aligned_len = len & (~0x3); 460 for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4) 461 write_register(dev, IPW_REG_AUTOINCREMENT_DATA, *(u32 *) buf); 462 463 /* copy the last nibble */ 464 dif_len = len - aligned_len; 465 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, aligned_addr); 466 for (i = 0; i < dif_len; i++, buf++) 467 write_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA + i, 468 *buf); 469 } 470 471 static void read_nic_memory(struct net_device *dev, u32 addr, u32 len, 472 u8 * buf) 473 { 474 u32 aligned_addr; 475 u32 aligned_len; 476 u32 dif_len; 477 u32 i; 478 479 /* read first nibble byte by byte */ 480 aligned_addr = addr & (~0x3); 481 dif_len = addr - aligned_addr; 482 if (dif_len) { 483 /* Start reading at aligned_addr + dif_len */ 484 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, 485 aligned_addr); 486 for (i = dif_len; i < 4; i++, buf++) 487 read_register_byte(dev, 488 IPW_REG_INDIRECT_ACCESS_DATA + i, 489 buf); 490 491 len -= dif_len; 492 aligned_addr += 4; 493 } 494 495 /* read DWs through autoincrement registers */ 496 write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, aligned_addr); 497 aligned_len = len & (~0x3); 498 for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4) 499 read_register(dev, IPW_REG_AUTOINCREMENT_DATA, (u32 *) buf); 500 501 /* copy the last nibble */ 502 dif_len = len - aligned_len; 503 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, aligned_addr); 504 for (i = 0; i < dif_len; i++, buf++) 505 read_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA + i, buf); 506 } 507 508 static bool ipw2100_hw_is_adapter_in_system(struct net_device *dev) 509 { 510 u32 dbg; 511 512 read_register(dev, IPW_REG_DOA_DEBUG_AREA_START, &dbg); 513 514 return dbg == IPW_DATA_DOA_DEBUG_VALUE; 515 } 516 517 static int ipw2100_get_ordinal(struct ipw2100_priv *priv, u32 ord, 518 void *val, u32 * len) 519 { 520 struct ipw2100_ordinals *ordinals = &priv->ordinals; 521 u32 addr; 522 u32 field_info; 523 u16 field_len; 524 u16 field_count; 525 u32 total_length; 526 527 if (ordinals->table1_addr == 0) { 528 printk(KERN_WARNING DRV_NAME ": attempt to use fw ordinals " 529 "before they have been loaded.\n"); 530 return -EINVAL; 531 } 532 533 if (IS_ORDINAL_TABLE_ONE(ordinals, ord)) { 534 if (*len < IPW_ORD_TAB_1_ENTRY_SIZE) { 535 *len = IPW_ORD_TAB_1_ENTRY_SIZE; 536 537 printk(KERN_WARNING DRV_NAME 538 ": ordinal buffer length too small, need %zd\n", 539 IPW_ORD_TAB_1_ENTRY_SIZE); 540 541 return -EINVAL; 542 } 543 544 read_nic_dword(priv->net_dev, 545 ordinals->table1_addr + (ord << 2), &addr); 546 read_nic_dword(priv->net_dev, addr, val); 547 548 *len = IPW_ORD_TAB_1_ENTRY_SIZE; 549 550 return 0; 551 } 552 553 if (IS_ORDINAL_TABLE_TWO(ordinals, ord)) { 554 555 ord -= IPW_START_ORD_TAB_2; 556 557 /* get the address of statistic */ 558 read_nic_dword(priv->net_dev, 559 ordinals->table2_addr + (ord << 3), &addr); 560 561 /* get the second DW of statistics ; 562 * two 16-bit words - first is length, second is count */ 563 read_nic_dword(priv->net_dev, 564 ordinals->table2_addr + (ord << 3) + sizeof(u32), 565 &field_info); 566 567 /* get each entry length */ 568 field_len = *((u16 *) & field_info); 569 570 /* get number of entries */ 571 field_count = *(((u16 *) & field_info) + 1); 572 573 /* abort if no enough memory */ 574 total_length = field_len * field_count; 575 if (total_length > *len) { 576 *len = total_length; 577 return -EINVAL; 578 } 579 580 *len = total_length; 581 if (!total_length) 582 return 0; 583 584 /* read the ordinal data from the SRAM */ 585 read_nic_memory(priv->net_dev, addr, total_length, val); 586 587 return 0; 588 } 589 590 printk(KERN_WARNING DRV_NAME ": ordinal %d neither in table 1 nor " 591 "in table 2\n", ord); 592 593 return -EINVAL; 594 } 595 596 static int ipw2100_set_ordinal(struct ipw2100_priv *priv, u32 ord, u32 * val, 597 u32 * len) 598 { 599 struct ipw2100_ordinals *ordinals = &priv->ordinals; 600 u32 addr; 601 602 if (IS_ORDINAL_TABLE_ONE(ordinals, ord)) { 603 if (*len != IPW_ORD_TAB_1_ENTRY_SIZE) { 604 *len = IPW_ORD_TAB_1_ENTRY_SIZE; 605 IPW_DEBUG_INFO("wrong size\n"); 606 return -EINVAL; 607 } 608 609 read_nic_dword(priv->net_dev, 610 ordinals->table1_addr + (ord << 2), &addr); 611 612 write_nic_dword(priv->net_dev, addr, *val); 613 614 *len = IPW_ORD_TAB_1_ENTRY_SIZE; 615 616 return 0; 617 } 618 619 IPW_DEBUG_INFO("wrong table\n"); 620 if (IS_ORDINAL_TABLE_TWO(ordinals, ord)) 621 return -EINVAL; 622 623 return -EINVAL; 624 } 625 626 static char *snprint_line(char *buf, size_t count, 627 const u8 * data, u32 len, u32 ofs) 628 { 629 int out, i, j, l; 630 char c; 631 632 out = snprintf(buf, count, "%08X", ofs); 633 634 for (l = 0, i = 0; i < 2; i++) { 635 out += snprintf(buf + out, count - out, " "); 636 for (j = 0; j < 8 && l < len; j++, l++) 637 out += snprintf(buf + out, count - out, "%02X ", 638 data[(i * 8 + j)]); 639 for (; j < 8; j++) 640 out += snprintf(buf + out, count - out, " "); 641 } 642 643 out += snprintf(buf + out, count - out, " "); 644 for (l = 0, i = 0; i < 2; i++) { 645 out += snprintf(buf + out, count - out, " "); 646 for (j = 0; j < 8 && l < len; j++, l++) { 647 c = data[(i * 8 + j)]; 648 if (!isascii(c) || !isprint(c)) 649 c = '.'; 650 651 out += snprintf(buf + out, count - out, "%c", c); 652 } 653 654 for (; j < 8; j++) 655 out += snprintf(buf + out, count - out, " "); 656 } 657 658 return buf; 659 } 660 661 static void printk_buf(int level, const u8 * data, u32 len) 662 { 663 char line[81]; 664 u32 ofs = 0; 665 if (!(ipw2100_debug_level & level)) 666 return; 667 668 while (len) { 669 printk(KERN_DEBUG "%s\n", 670 snprint_line(line, sizeof(line), &data[ofs], 671 min(len, 16U), ofs)); 672 ofs += 16; 673 len -= min(len, 16U); 674 } 675 } 676 677 #define MAX_RESET_BACKOFF 10 678 679 static void schedule_reset(struct ipw2100_priv *priv) 680 { 681 time64_t now = ktime_get_boottime_seconds(); 682 683 /* If we haven't received a reset request within the backoff period, 684 * then we can reset the backoff interval so this reset occurs 685 * immediately */ 686 if (priv->reset_backoff && 687 (now - priv->last_reset > priv->reset_backoff)) 688 priv->reset_backoff = 0; 689 690 priv->last_reset = now; 691 692 if (!(priv->status & STATUS_RESET_PENDING)) { 693 IPW_DEBUG_INFO("%s: Scheduling firmware restart (%llds).\n", 694 priv->net_dev->name, priv->reset_backoff); 695 netif_carrier_off(priv->net_dev); 696 netif_stop_queue(priv->net_dev); 697 priv->status |= STATUS_RESET_PENDING; 698 if (priv->reset_backoff) 699 schedule_delayed_work(&priv->reset_work, 700 priv->reset_backoff * HZ); 701 else 702 schedule_delayed_work(&priv->reset_work, 0); 703 704 if (priv->reset_backoff < MAX_RESET_BACKOFF) 705 priv->reset_backoff++; 706 707 wake_up_interruptible(&priv->wait_command_queue); 708 } else 709 IPW_DEBUG_INFO("%s: Firmware restart already in progress.\n", 710 priv->net_dev->name); 711 712 } 713 714 #define HOST_COMPLETE_TIMEOUT (2 * HZ) 715 static int ipw2100_hw_send_command(struct ipw2100_priv *priv, 716 struct host_command *cmd) 717 { 718 struct list_head *element; 719 struct ipw2100_tx_packet *packet; 720 unsigned long flags; 721 int err = 0; 722 723 IPW_DEBUG_HC("Sending %s command (#%d), %d bytes\n", 724 command_types[cmd->host_command], cmd->host_command, 725 cmd->host_command_length); 726 printk_buf(IPW_DL_HC, (u8 *) cmd->host_command_parameters, 727 cmd->host_command_length); 728 729 spin_lock_irqsave(&priv->low_lock, flags); 730 731 if (priv->fatal_error) { 732 IPW_DEBUG_INFO 733 ("Attempt to send command while hardware in fatal error condition.\n"); 734 err = -EIO; 735 goto fail_unlock; 736 } 737 738 if (!(priv->status & STATUS_RUNNING)) { 739 IPW_DEBUG_INFO 740 ("Attempt to send command while hardware is not running.\n"); 741 err = -EIO; 742 goto fail_unlock; 743 } 744 745 if (priv->status & STATUS_CMD_ACTIVE) { 746 IPW_DEBUG_INFO 747 ("Attempt to send command while another command is pending.\n"); 748 err = -EBUSY; 749 goto fail_unlock; 750 } 751 752 if (list_empty(&priv->msg_free_list)) { 753 IPW_DEBUG_INFO("no available msg buffers\n"); 754 goto fail_unlock; 755 } 756 757 priv->status |= STATUS_CMD_ACTIVE; 758 priv->messages_sent++; 759 760 element = priv->msg_free_list.next; 761 762 packet = list_entry(element, struct ipw2100_tx_packet, list); 763 packet->jiffy_start = jiffies; 764 765 /* initialize the firmware command packet */ 766 packet->info.c_struct.cmd->host_command_reg = cmd->host_command; 767 packet->info.c_struct.cmd->host_command_reg1 = cmd->host_command1; 768 packet->info.c_struct.cmd->host_command_len_reg = 769 cmd->host_command_length; 770 packet->info.c_struct.cmd->sequence = cmd->host_command_sequence; 771 772 memcpy(packet->info.c_struct.cmd->host_command_params_reg, 773 cmd->host_command_parameters, 774 sizeof(packet->info.c_struct.cmd->host_command_params_reg)); 775 776 list_del(element); 777 DEC_STAT(&priv->msg_free_stat); 778 779 list_add_tail(element, &priv->msg_pend_list); 780 INC_STAT(&priv->msg_pend_stat); 781 782 ipw2100_tx_send_commands(priv); 783 ipw2100_tx_send_data(priv); 784 785 spin_unlock_irqrestore(&priv->low_lock, flags); 786 787 /* 788 * We must wait for this command to complete before another 789 * command can be sent... but if we wait more than 3 seconds 790 * then there is a problem. 791 */ 792 793 err = 794 wait_event_interruptible_timeout(priv->wait_command_queue, 795 !(priv-> 796 status & STATUS_CMD_ACTIVE), 797 HOST_COMPLETE_TIMEOUT); 798 799 if (err == 0) { 800 IPW_DEBUG_INFO("Command completion failed out after %dms.\n", 801 1000 * (HOST_COMPLETE_TIMEOUT / HZ)); 802 priv->fatal_error = IPW2100_ERR_MSG_TIMEOUT; 803 priv->status &= ~STATUS_CMD_ACTIVE; 804 schedule_reset(priv); 805 return -EIO; 806 } 807 808 if (priv->fatal_error) { 809 printk(KERN_WARNING DRV_NAME ": %s: firmware fatal error\n", 810 priv->net_dev->name); 811 return -EIO; 812 } 813 814 /* !!!!! HACK TEST !!!!! 815 * When lots of debug trace statements are enabled, the driver 816 * doesn't seem to have as many firmware restart cycles... 817 * 818 * As a test, we're sticking in a 1/100s delay here */ 819 schedule_timeout_uninterruptible(msecs_to_jiffies(10)); 820 821 return 0; 822 823 fail_unlock: 824 spin_unlock_irqrestore(&priv->low_lock, flags); 825 826 return err; 827 } 828 829 /* 830 * Verify the values and data access of the hardware 831 * No locks needed or used. No functions called. 832 */ 833 static int ipw2100_verify(struct ipw2100_priv *priv) 834 { 835 u32 data1, data2; 836 u32 address; 837 838 u32 val1 = 0x76543210; 839 u32 val2 = 0xFEDCBA98; 840 841 /* Domain 0 check - all values should be DOA_DEBUG */ 842 for (address = IPW_REG_DOA_DEBUG_AREA_START; 843 address < IPW_REG_DOA_DEBUG_AREA_END; address += sizeof(u32)) { 844 read_register(priv->net_dev, address, &data1); 845 if (data1 != IPW_DATA_DOA_DEBUG_VALUE) 846 return -EIO; 847 } 848 849 /* Domain 1 check - use arbitrary read/write compare */ 850 for (address = 0; address < 5; address++) { 851 /* The memory area is not used now */ 852 write_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x32, 853 val1); 854 write_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x36, 855 val2); 856 read_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x32, 857 &data1); 858 read_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x36, 859 &data2); 860 if (val1 == data1 && val2 == data2) 861 return 0; 862 } 863 864 return -EIO; 865 } 866 867 /* 868 * 869 * Loop until the CARD_DISABLED bit is the same value as the 870 * supplied parameter 871 * 872 * TODO: See if it would be more efficient to do a wait/wake 873 * cycle and have the completion event trigger the wakeup 874 * 875 */ 876 #define IPW_CARD_DISABLE_COMPLETE_WAIT 100 // 100 milli 877 static int ipw2100_wait_for_card_state(struct ipw2100_priv *priv, int state) 878 { 879 int i; 880 u32 card_state; 881 u32 len = sizeof(card_state); 882 int err; 883 884 for (i = 0; i <= IPW_CARD_DISABLE_COMPLETE_WAIT * 1000; i += 50) { 885 err = ipw2100_get_ordinal(priv, IPW_ORD_CARD_DISABLED, 886 &card_state, &len); 887 if (err) { 888 IPW_DEBUG_INFO("Query of CARD_DISABLED ordinal " 889 "failed.\n"); 890 return 0; 891 } 892 893 /* We'll break out if either the HW state says it is 894 * in the state we want, or if HOST_COMPLETE command 895 * finishes */ 896 if ((card_state == state) || 897 ((priv->status & STATUS_ENABLED) ? 898 IPW_HW_STATE_ENABLED : IPW_HW_STATE_DISABLED) == state) { 899 if (state == IPW_HW_STATE_ENABLED) 900 priv->status |= STATUS_ENABLED; 901 else 902 priv->status &= ~STATUS_ENABLED; 903 904 return 0; 905 } 906 907 udelay(50); 908 } 909 910 IPW_DEBUG_INFO("ipw2100_wait_for_card_state to %s state timed out\n", 911 state ? "DISABLED" : "ENABLED"); 912 return -EIO; 913 } 914 915 /********************************************************************* 916 Procedure : sw_reset_and_clock 917 Purpose : Asserts s/w reset, asserts clock initialization 918 and waits for clock stabilization 919 ********************************************************************/ 920 static int sw_reset_and_clock(struct ipw2100_priv *priv) 921 { 922 int i; 923 u32 r; 924 925 // assert s/w reset 926 write_register(priv->net_dev, IPW_REG_RESET_REG, 927 IPW_AUX_HOST_RESET_REG_SW_RESET); 928 929 // wait for clock stabilization 930 for (i = 0; i < 1000; i++) { 931 udelay(IPW_WAIT_RESET_ARC_COMPLETE_DELAY); 932 933 // check clock ready bit 934 read_register(priv->net_dev, IPW_REG_RESET_REG, &r); 935 if (r & IPW_AUX_HOST_RESET_REG_PRINCETON_RESET) 936 break; 937 } 938 939 if (i == 1000) 940 return -EIO; // TODO: better error value 941 942 /* set "initialization complete" bit to move adapter to 943 * D0 state */ 944 write_register(priv->net_dev, IPW_REG_GP_CNTRL, 945 IPW_AUX_HOST_GP_CNTRL_BIT_INIT_DONE); 946 947 /* wait for clock stabilization */ 948 for (i = 0; i < 10000; i++) { 949 udelay(IPW_WAIT_CLOCK_STABILIZATION_DELAY * 4); 950 951 /* check clock ready bit */ 952 read_register(priv->net_dev, IPW_REG_GP_CNTRL, &r); 953 if (r & IPW_AUX_HOST_GP_CNTRL_BIT_CLOCK_READY) 954 break; 955 } 956 957 if (i == 10000) 958 return -EIO; /* TODO: better error value */ 959 960 /* set D0 standby bit */ 961 read_register(priv->net_dev, IPW_REG_GP_CNTRL, &r); 962 write_register(priv->net_dev, IPW_REG_GP_CNTRL, 963 r | IPW_AUX_HOST_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY); 964 965 return 0; 966 } 967 968 /********************************************************************* 969 Procedure : ipw2100_download_firmware 970 Purpose : Initiaze adapter after power on. 971 The sequence is: 972 1. assert s/w reset first! 973 2. awake clocks & wait for clock stabilization 974 3. hold ARC (don't ask me why...) 975 4. load Dino ucode and reset/clock init again 976 5. zero-out shared mem 977 6. download f/w 978 *******************************************************************/ 979 static int ipw2100_download_firmware(struct ipw2100_priv *priv) 980 { 981 u32 address; 982 int err; 983 984 #ifndef CONFIG_PM 985 /* Fetch the firmware and microcode */ 986 struct ipw2100_fw ipw2100_firmware; 987 #endif 988 989 if (priv->fatal_error) { 990 IPW_DEBUG_ERROR("%s: ipw2100_download_firmware called after " 991 "fatal error %d. Interface must be brought down.\n", 992 priv->net_dev->name, priv->fatal_error); 993 return -EINVAL; 994 } 995 #ifdef CONFIG_PM 996 if (!ipw2100_firmware.version) { 997 err = ipw2100_get_firmware(priv, &ipw2100_firmware); 998 if (err) { 999 IPW_DEBUG_ERROR("%s: ipw2100_get_firmware failed: %d\n", 1000 priv->net_dev->name, err); 1001 priv->fatal_error = IPW2100_ERR_FW_LOAD; 1002 goto fail; 1003 } 1004 } 1005 #else 1006 err = ipw2100_get_firmware(priv, &ipw2100_firmware); 1007 if (err) { 1008 IPW_DEBUG_ERROR("%s: ipw2100_get_firmware failed: %d\n", 1009 priv->net_dev->name, err); 1010 priv->fatal_error = IPW2100_ERR_FW_LOAD; 1011 goto fail; 1012 } 1013 #endif 1014 priv->firmware_version = ipw2100_firmware.version; 1015 1016 /* s/w reset and clock stabilization */ 1017 err = sw_reset_and_clock(priv); 1018 if (err) { 1019 IPW_DEBUG_ERROR("%s: sw_reset_and_clock failed: %d\n", 1020 priv->net_dev->name, err); 1021 goto fail; 1022 } 1023 1024 err = ipw2100_verify(priv); 1025 if (err) { 1026 IPW_DEBUG_ERROR("%s: ipw2100_verify failed: %d\n", 1027 priv->net_dev->name, err); 1028 goto fail; 1029 } 1030 1031 /* Hold ARC */ 1032 write_nic_dword(priv->net_dev, 1033 IPW_INTERNAL_REGISTER_HALT_AND_RESET, 0x80000000); 1034 1035 /* allow ARC to run */ 1036 write_register(priv->net_dev, IPW_REG_RESET_REG, 0); 1037 1038 /* load microcode */ 1039 err = ipw2100_ucode_download(priv, &ipw2100_firmware); 1040 if (err) { 1041 printk(KERN_ERR DRV_NAME ": %s: Error loading microcode: %d\n", 1042 priv->net_dev->name, err); 1043 goto fail; 1044 } 1045 1046 /* release ARC */ 1047 write_nic_dword(priv->net_dev, 1048 IPW_INTERNAL_REGISTER_HALT_AND_RESET, 0x00000000); 1049 1050 /* s/w reset and clock stabilization (again!!!) */ 1051 err = sw_reset_and_clock(priv); 1052 if (err) { 1053 printk(KERN_ERR DRV_NAME 1054 ": %s: sw_reset_and_clock failed: %d\n", 1055 priv->net_dev->name, err); 1056 goto fail; 1057 } 1058 1059 /* load f/w */ 1060 err = ipw2100_fw_download(priv, &ipw2100_firmware); 1061 if (err) { 1062 IPW_DEBUG_ERROR("%s: Error loading firmware: %d\n", 1063 priv->net_dev->name, err); 1064 goto fail; 1065 } 1066 #ifndef CONFIG_PM 1067 /* 1068 * When the .resume method of the driver is called, the other 1069 * part of the system, i.e. the ide driver could still stay in 1070 * the suspend stage. This prevents us from loading the firmware 1071 * from the disk. --YZ 1072 */ 1073 1074 /* free any storage allocated for firmware image */ 1075 ipw2100_release_firmware(priv, &ipw2100_firmware); 1076 #endif 1077 1078 /* zero out Domain 1 area indirectly (Si requirement) */ 1079 for (address = IPW_HOST_FW_SHARED_AREA0; 1080 address < IPW_HOST_FW_SHARED_AREA0_END; address += 4) 1081 write_nic_dword(priv->net_dev, address, 0); 1082 for (address = IPW_HOST_FW_SHARED_AREA1; 1083 address < IPW_HOST_FW_SHARED_AREA1_END; address += 4) 1084 write_nic_dword(priv->net_dev, address, 0); 1085 for (address = IPW_HOST_FW_SHARED_AREA2; 1086 address < IPW_HOST_FW_SHARED_AREA2_END; address += 4) 1087 write_nic_dword(priv->net_dev, address, 0); 1088 for (address = IPW_HOST_FW_SHARED_AREA3; 1089 address < IPW_HOST_FW_SHARED_AREA3_END; address += 4) 1090 write_nic_dword(priv->net_dev, address, 0); 1091 for (address = IPW_HOST_FW_INTERRUPT_AREA; 1092 address < IPW_HOST_FW_INTERRUPT_AREA_END; address += 4) 1093 write_nic_dword(priv->net_dev, address, 0); 1094 1095 return 0; 1096 1097 fail: 1098 ipw2100_release_firmware(priv, &ipw2100_firmware); 1099 return err; 1100 } 1101 1102 static inline void ipw2100_enable_interrupts(struct ipw2100_priv *priv) 1103 { 1104 if (priv->status & STATUS_INT_ENABLED) 1105 return; 1106 priv->status |= STATUS_INT_ENABLED; 1107 write_register(priv->net_dev, IPW_REG_INTA_MASK, IPW_INTERRUPT_MASK); 1108 } 1109 1110 static inline void ipw2100_disable_interrupts(struct ipw2100_priv *priv) 1111 { 1112 if (!(priv->status & STATUS_INT_ENABLED)) 1113 return; 1114 priv->status &= ~STATUS_INT_ENABLED; 1115 write_register(priv->net_dev, IPW_REG_INTA_MASK, 0x0); 1116 } 1117 1118 static void ipw2100_initialize_ordinals(struct ipw2100_priv *priv) 1119 { 1120 struct ipw2100_ordinals *ord = &priv->ordinals; 1121 1122 IPW_DEBUG_INFO("enter\n"); 1123 1124 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_ORDINALS_TABLE_1, 1125 &ord->table1_addr); 1126 1127 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_ORDINALS_TABLE_2, 1128 &ord->table2_addr); 1129 1130 read_nic_dword(priv->net_dev, ord->table1_addr, &ord->table1_size); 1131 read_nic_dword(priv->net_dev, ord->table2_addr, &ord->table2_size); 1132 1133 ord->table2_size &= 0x0000FFFF; 1134 1135 IPW_DEBUG_INFO("table 1 size: %d\n", ord->table1_size); 1136 IPW_DEBUG_INFO("table 2 size: %d\n", ord->table2_size); 1137 IPW_DEBUG_INFO("exit\n"); 1138 } 1139 1140 static inline void ipw2100_hw_set_gpio(struct ipw2100_priv *priv) 1141 { 1142 u32 reg = 0; 1143 /* 1144 * Set GPIO 3 writable by FW; GPIO 1 writable 1145 * by driver and enable clock 1146 */ 1147 reg = (IPW_BIT_GPIO_GPIO3_MASK | IPW_BIT_GPIO_GPIO1_ENABLE | 1148 IPW_BIT_GPIO_LED_OFF); 1149 write_register(priv->net_dev, IPW_REG_GPIO, reg); 1150 } 1151 1152 static int rf_kill_active(struct ipw2100_priv *priv) 1153 { 1154 #define MAX_RF_KILL_CHECKS 5 1155 #define RF_KILL_CHECK_DELAY 40 1156 1157 unsigned short value = 0; 1158 u32 reg = 0; 1159 int i; 1160 1161 if (!(priv->hw_features & HW_FEATURE_RFKILL)) { 1162 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false); 1163 priv->status &= ~STATUS_RF_KILL_HW; 1164 return 0; 1165 } 1166 1167 for (i = 0; i < MAX_RF_KILL_CHECKS; i++) { 1168 udelay(RF_KILL_CHECK_DELAY); 1169 read_register(priv->net_dev, IPW_REG_GPIO, ®); 1170 value = (value << 1) | ((reg & IPW_BIT_GPIO_RF_KILL) ? 0 : 1); 1171 } 1172 1173 if (value == 0) { 1174 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true); 1175 priv->status |= STATUS_RF_KILL_HW; 1176 } else { 1177 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false); 1178 priv->status &= ~STATUS_RF_KILL_HW; 1179 } 1180 1181 return (value == 0); 1182 } 1183 1184 static int ipw2100_get_hw_features(struct ipw2100_priv *priv) 1185 { 1186 u32 addr, len; 1187 u32 val; 1188 1189 /* 1190 * EEPROM_SRAM_DB_START_ADDRESS using ordinal in ordinal table 1 1191 */ 1192 len = sizeof(addr); 1193 if (ipw2100_get_ordinal 1194 (priv, IPW_ORD_EEPROM_SRAM_DB_BLOCK_START_ADDRESS, &addr, &len)) { 1195 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 1196 __LINE__); 1197 return -EIO; 1198 } 1199 1200 IPW_DEBUG_INFO("EEPROM address: %08X\n", addr); 1201 1202 /* 1203 * EEPROM version is the byte at offset 0xfd in firmware 1204 * We read 4 bytes, then shift out the byte we actually want */ 1205 read_nic_dword(priv->net_dev, addr + 0xFC, &val); 1206 priv->eeprom_version = (val >> 24) & 0xFF; 1207 IPW_DEBUG_INFO("EEPROM version: %d\n", priv->eeprom_version); 1208 1209 /* 1210 * HW RF Kill enable is bit 0 in byte at offset 0x21 in firmware 1211 * 1212 * notice that the EEPROM bit is reverse polarity, i.e. 1213 * bit = 0 signifies HW RF kill switch is supported 1214 * bit = 1 signifies HW RF kill switch is NOT supported 1215 */ 1216 read_nic_dword(priv->net_dev, addr + 0x20, &val); 1217 if (!((val >> 24) & 0x01)) 1218 priv->hw_features |= HW_FEATURE_RFKILL; 1219 1220 IPW_DEBUG_INFO("HW RF Kill: %ssupported.\n", 1221 (priv->hw_features & HW_FEATURE_RFKILL) ? "" : "not "); 1222 1223 return 0; 1224 } 1225 1226 /* 1227 * Start firmware execution after power on and initialization 1228 * The sequence is: 1229 * 1. Release ARC 1230 * 2. Wait for f/w initialization completes; 1231 */ 1232 static int ipw2100_start_adapter(struct ipw2100_priv *priv) 1233 { 1234 int i; 1235 u32 inta, inta_mask, gpio; 1236 1237 IPW_DEBUG_INFO("enter\n"); 1238 1239 if (priv->status & STATUS_RUNNING) 1240 return 0; 1241 1242 /* 1243 * Initialize the hw - drive adapter to DO state by setting 1244 * init_done bit. Wait for clk_ready bit and Download 1245 * fw & dino ucode 1246 */ 1247 if (ipw2100_download_firmware(priv)) { 1248 printk(KERN_ERR DRV_NAME 1249 ": %s: Failed to power on the adapter.\n", 1250 priv->net_dev->name); 1251 return -EIO; 1252 } 1253 1254 /* Clear the Tx, Rx and Msg queues and the r/w indexes 1255 * in the firmware RBD and TBD ring queue */ 1256 ipw2100_queues_initialize(priv); 1257 1258 ipw2100_hw_set_gpio(priv); 1259 1260 /* TODO -- Look at disabling interrupts here to make sure none 1261 * get fired during FW initialization */ 1262 1263 /* Release ARC - clear reset bit */ 1264 write_register(priv->net_dev, IPW_REG_RESET_REG, 0); 1265 1266 /* wait for f/w initialization complete */ 1267 IPW_DEBUG_FW("Waiting for f/w initialization to complete...\n"); 1268 i = 5000; 1269 do { 1270 schedule_timeout_uninterruptible(msecs_to_jiffies(40)); 1271 /* Todo... wait for sync command ... */ 1272 1273 read_register(priv->net_dev, IPW_REG_INTA, &inta); 1274 1275 /* check "init done" bit */ 1276 if (inta & IPW2100_INTA_FW_INIT_DONE) { 1277 /* reset "init done" bit */ 1278 write_register(priv->net_dev, IPW_REG_INTA, 1279 IPW2100_INTA_FW_INIT_DONE); 1280 break; 1281 } 1282 1283 /* check error conditions : we check these after the firmware 1284 * check so that if there is an error, the interrupt handler 1285 * will see it and the adapter will be reset */ 1286 if (inta & 1287 (IPW2100_INTA_FATAL_ERROR | IPW2100_INTA_PARITY_ERROR)) { 1288 /* clear error conditions */ 1289 write_register(priv->net_dev, IPW_REG_INTA, 1290 IPW2100_INTA_FATAL_ERROR | 1291 IPW2100_INTA_PARITY_ERROR); 1292 } 1293 } while (--i); 1294 1295 /* Clear out any pending INTAs since we aren't supposed to have 1296 * interrupts enabled at this point... */ 1297 read_register(priv->net_dev, IPW_REG_INTA, &inta); 1298 read_register(priv->net_dev, IPW_REG_INTA_MASK, &inta_mask); 1299 inta &= IPW_INTERRUPT_MASK; 1300 /* Clear out any pending interrupts */ 1301 if (inta & inta_mask) 1302 write_register(priv->net_dev, IPW_REG_INTA, inta); 1303 1304 IPW_DEBUG_FW("f/w initialization complete: %s\n", 1305 i ? "SUCCESS" : "FAILED"); 1306 1307 if (!i) { 1308 printk(KERN_WARNING DRV_NAME 1309 ": %s: Firmware did not initialize.\n", 1310 priv->net_dev->name); 1311 return -EIO; 1312 } 1313 1314 /* allow firmware to write to GPIO1 & GPIO3 */ 1315 read_register(priv->net_dev, IPW_REG_GPIO, &gpio); 1316 1317 gpio |= (IPW_BIT_GPIO_GPIO1_MASK | IPW_BIT_GPIO_GPIO3_MASK); 1318 1319 write_register(priv->net_dev, IPW_REG_GPIO, gpio); 1320 1321 /* Ready to receive commands */ 1322 priv->status |= STATUS_RUNNING; 1323 1324 /* The adapter has been reset; we are not associated */ 1325 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED); 1326 1327 IPW_DEBUG_INFO("exit\n"); 1328 1329 return 0; 1330 } 1331 1332 static inline void ipw2100_reset_fatalerror(struct ipw2100_priv *priv) 1333 { 1334 if (!priv->fatal_error) 1335 return; 1336 1337 priv->fatal_errors[priv->fatal_index++] = priv->fatal_error; 1338 priv->fatal_index %= IPW2100_ERROR_QUEUE; 1339 priv->fatal_error = 0; 1340 } 1341 1342 /* NOTE: Our interrupt is disabled when this method is called */ 1343 static int ipw2100_power_cycle_adapter(struct ipw2100_priv *priv) 1344 { 1345 u32 reg; 1346 int i; 1347 1348 IPW_DEBUG_INFO("Power cycling the hardware.\n"); 1349 1350 ipw2100_hw_set_gpio(priv); 1351 1352 /* Step 1. Stop Master Assert */ 1353 write_register(priv->net_dev, IPW_REG_RESET_REG, 1354 IPW_AUX_HOST_RESET_REG_STOP_MASTER); 1355 1356 /* Step 2. Wait for stop Master Assert 1357 * (not more than 50us, otherwise ret error */ 1358 i = 5; 1359 do { 1360 udelay(IPW_WAIT_RESET_MASTER_ASSERT_COMPLETE_DELAY); 1361 read_register(priv->net_dev, IPW_REG_RESET_REG, ®); 1362 1363 if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED) 1364 break; 1365 } while (--i); 1366 1367 priv->status &= ~STATUS_RESET_PENDING; 1368 1369 if (!i) { 1370 IPW_DEBUG_INFO 1371 ("exit - waited too long for master assert stop\n"); 1372 return -EIO; 1373 } 1374 1375 write_register(priv->net_dev, IPW_REG_RESET_REG, 1376 IPW_AUX_HOST_RESET_REG_SW_RESET); 1377 1378 /* Reset any fatal_error conditions */ 1379 ipw2100_reset_fatalerror(priv); 1380 1381 /* At this point, the adapter is now stopped and disabled */ 1382 priv->status &= ~(STATUS_RUNNING | STATUS_ASSOCIATING | 1383 STATUS_ASSOCIATED | STATUS_ENABLED); 1384 1385 return 0; 1386 } 1387 1388 /* 1389 * Send the CARD_DISABLE_PHY_OFF command to the card to disable it 1390 * 1391 * After disabling, if the card was associated, a STATUS_ASSN_LOST will be sent. 1392 * 1393 * STATUS_CARD_DISABLE_NOTIFICATION will be sent regardless of 1394 * if STATUS_ASSN_LOST is sent. 1395 */ 1396 static int ipw2100_hw_phy_off(struct ipw2100_priv *priv) 1397 { 1398 1399 #define HW_PHY_OFF_LOOP_DELAY (msecs_to_jiffies(50)) 1400 1401 struct host_command cmd = { 1402 .host_command = CARD_DISABLE_PHY_OFF, 1403 .host_command_sequence = 0, 1404 .host_command_length = 0, 1405 }; 1406 int err, i; 1407 u32 val1, val2; 1408 1409 IPW_DEBUG_HC("CARD_DISABLE_PHY_OFF\n"); 1410 1411 /* Turn off the radio */ 1412 err = ipw2100_hw_send_command(priv, &cmd); 1413 if (err) 1414 return err; 1415 1416 for (i = 0; i < 2500; i++) { 1417 read_nic_dword(priv->net_dev, IPW2100_CONTROL_REG, &val1); 1418 read_nic_dword(priv->net_dev, IPW2100_COMMAND, &val2); 1419 1420 if ((val1 & IPW2100_CONTROL_PHY_OFF) && 1421 (val2 & IPW2100_COMMAND_PHY_OFF)) 1422 return 0; 1423 1424 schedule_timeout_uninterruptible(HW_PHY_OFF_LOOP_DELAY); 1425 } 1426 1427 return -EIO; 1428 } 1429 1430 static int ipw2100_enable_adapter(struct ipw2100_priv *priv) 1431 { 1432 struct host_command cmd = { 1433 .host_command = HOST_COMPLETE, 1434 .host_command_sequence = 0, 1435 .host_command_length = 0 1436 }; 1437 int err = 0; 1438 1439 IPW_DEBUG_HC("HOST_COMPLETE\n"); 1440 1441 if (priv->status & STATUS_ENABLED) 1442 return 0; 1443 1444 mutex_lock(&priv->adapter_mutex); 1445 1446 if (rf_kill_active(priv)) { 1447 IPW_DEBUG_HC("Command aborted due to RF kill active.\n"); 1448 goto fail_up; 1449 } 1450 1451 err = ipw2100_hw_send_command(priv, &cmd); 1452 if (err) { 1453 IPW_DEBUG_INFO("Failed to send HOST_COMPLETE command\n"); 1454 goto fail_up; 1455 } 1456 1457 err = ipw2100_wait_for_card_state(priv, IPW_HW_STATE_ENABLED); 1458 if (err) { 1459 IPW_DEBUG_INFO("%s: card not responding to init command.\n", 1460 priv->net_dev->name); 1461 goto fail_up; 1462 } 1463 1464 if (priv->stop_hang_check) { 1465 priv->stop_hang_check = 0; 1466 schedule_delayed_work(&priv->hang_check, HZ / 2); 1467 } 1468 1469 fail_up: 1470 mutex_unlock(&priv->adapter_mutex); 1471 return err; 1472 } 1473 1474 static int ipw2100_hw_stop_adapter(struct ipw2100_priv *priv) 1475 { 1476 #define HW_POWER_DOWN_DELAY (msecs_to_jiffies(100)) 1477 1478 struct host_command cmd = { 1479 .host_command = HOST_PRE_POWER_DOWN, 1480 .host_command_sequence = 0, 1481 .host_command_length = 0, 1482 }; 1483 int err, i; 1484 u32 reg; 1485 1486 if (!(priv->status & STATUS_RUNNING)) 1487 return 0; 1488 1489 priv->status |= STATUS_STOPPING; 1490 1491 /* We can only shut down the card if the firmware is operational. So, 1492 * if we haven't reset since a fatal_error, then we can not send the 1493 * shutdown commands. */ 1494 if (!priv->fatal_error) { 1495 /* First, make sure the adapter is enabled so that the PHY_OFF 1496 * command can shut it down */ 1497 ipw2100_enable_adapter(priv); 1498 1499 err = ipw2100_hw_phy_off(priv); 1500 if (err) 1501 printk(KERN_WARNING DRV_NAME 1502 ": Error disabling radio %d\n", err); 1503 1504 /* 1505 * If in D0-standby mode going directly to D3 may cause a 1506 * PCI bus violation. Therefore we must change out of the D0 1507 * state. 1508 * 1509 * Sending the PREPARE_FOR_POWER_DOWN will restrict the 1510 * hardware from going into standby mode and will transition 1511 * out of D0-standby if it is already in that state. 1512 * 1513 * STATUS_PREPARE_POWER_DOWN_COMPLETE will be sent by the 1514 * driver upon completion. Once received, the driver can 1515 * proceed to the D3 state. 1516 * 1517 * Prepare for power down command to fw. This command would 1518 * take HW out of D0-standby and prepare it for D3 state. 1519 * 1520 * Currently FW does not support event notification for this 1521 * event. Therefore, skip waiting for it. Just wait a fixed 1522 * 100ms 1523 */ 1524 IPW_DEBUG_HC("HOST_PRE_POWER_DOWN\n"); 1525 1526 err = ipw2100_hw_send_command(priv, &cmd); 1527 if (err) 1528 printk(KERN_WARNING DRV_NAME ": " 1529 "%s: Power down command failed: Error %d\n", 1530 priv->net_dev->name, err); 1531 else 1532 schedule_timeout_uninterruptible(HW_POWER_DOWN_DELAY); 1533 } 1534 1535 priv->status &= ~STATUS_ENABLED; 1536 1537 /* 1538 * Set GPIO 3 writable by FW; GPIO 1 writable 1539 * by driver and enable clock 1540 */ 1541 ipw2100_hw_set_gpio(priv); 1542 1543 /* 1544 * Power down adapter. Sequence: 1545 * 1. Stop master assert (RESET_REG[9]=1) 1546 * 2. Wait for stop master (RESET_REG[8]==1) 1547 * 3. S/w reset assert (RESET_REG[7] = 1) 1548 */ 1549 1550 /* Stop master assert */ 1551 write_register(priv->net_dev, IPW_REG_RESET_REG, 1552 IPW_AUX_HOST_RESET_REG_STOP_MASTER); 1553 1554 /* wait stop master not more than 50 usec. 1555 * Otherwise return error. */ 1556 for (i = 5; i > 0; i--) { 1557 udelay(10); 1558 1559 /* Check master stop bit */ 1560 read_register(priv->net_dev, IPW_REG_RESET_REG, ®); 1561 1562 if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED) 1563 break; 1564 } 1565 1566 if (i == 0) 1567 printk(KERN_WARNING DRV_NAME 1568 ": %s: Could now power down adapter.\n", 1569 priv->net_dev->name); 1570 1571 /* assert s/w reset */ 1572 write_register(priv->net_dev, IPW_REG_RESET_REG, 1573 IPW_AUX_HOST_RESET_REG_SW_RESET); 1574 1575 priv->status &= ~(STATUS_RUNNING | STATUS_STOPPING); 1576 1577 return 0; 1578 } 1579 1580 static int ipw2100_disable_adapter(struct ipw2100_priv *priv) 1581 { 1582 struct host_command cmd = { 1583 .host_command = CARD_DISABLE, 1584 .host_command_sequence = 0, 1585 .host_command_length = 0 1586 }; 1587 int err = 0; 1588 1589 IPW_DEBUG_HC("CARD_DISABLE\n"); 1590 1591 if (!(priv->status & STATUS_ENABLED)) 1592 return 0; 1593 1594 /* Make sure we clear the associated state */ 1595 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING); 1596 1597 if (!priv->stop_hang_check) { 1598 priv->stop_hang_check = 1; 1599 cancel_delayed_work(&priv->hang_check); 1600 } 1601 1602 mutex_lock(&priv->adapter_mutex); 1603 1604 err = ipw2100_hw_send_command(priv, &cmd); 1605 if (err) { 1606 printk(KERN_WARNING DRV_NAME 1607 ": exit - failed to send CARD_DISABLE command\n"); 1608 goto fail_up; 1609 } 1610 1611 err = ipw2100_wait_for_card_state(priv, IPW_HW_STATE_DISABLED); 1612 if (err) { 1613 printk(KERN_WARNING DRV_NAME 1614 ": exit - card failed to change to DISABLED\n"); 1615 goto fail_up; 1616 } 1617 1618 IPW_DEBUG_INFO("TODO: implement scan state machine\n"); 1619 1620 fail_up: 1621 mutex_unlock(&priv->adapter_mutex); 1622 return err; 1623 } 1624 1625 static int ipw2100_set_scan_options(struct ipw2100_priv *priv) 1626 { 1627 struct host_command cmd = { 1628 .host_command = SET_SCAN_OPTIONS, 1629 .host_command_sequence = 0, 1630 .host_command_length = 8 1631 }; 1632 int err; 1633 1634 IPW_DEBUG_INFO("enter\n"); 1635 1636 IPW_DEBUG_SCAN("setting scan options\n"); 1637 1638 cmd.host_command_parameters[0] = 0; 1639 1640 if (!(priv->config & CFG_ASSOCIATE)) 1641 cmd.host_command_parameters[0] |= IPW_SCAN_NOASSOCIATE; 1642 if ((priv->ieee->sec.flags & SEC_ENABLED) && priv->ieee->sec.enabled) 1643 cmd.host_command_parameters[0] |= IPW_SCAN_MIXED_CELL; 1644 if (priv->config & CFG_PASSIVE_SCAN) 1645 cmd.host_command_parameters[0] |= IPW_SCAN_PASSIVE; 1646 1647 cmd.host_command_parameters[1] = priv->channel_mask; 1648 1649 err = ipw2100_hw_send_command(priv, &cmd); 1650 1651 IPW_DEBUG_HC("SET_SCAN_OPTIONS 0x%04X\n", 1652 cmd.host_command_parameters[0]); 1653 1654 return err; 1655 } 1656 1657 static int ipw2100_start_scan(struct ipw2100_priv *priv) 1658 { 1659 struct host_command cmd = { 1660 .host_command = BROADCAST_SCAN, 1661 .host_command_sequence = 0, 1662 .host_command_length = 4 1663 }; 1664 int err; 1665 1666 IPW_DEBUG_HC("START_SCAN\n"); 1667 1668 cmd.host_command_parameters[0] = 0; 1669 1670 /* No scanning if in monitor mode */ 1671 if (priv->ieee->iw_mode == IW_MODE_MONITOR) 1672 return 1; 1673 1674 if (priv->status & STATUS_SCANNING) { 1675 IPW_DEBUG_SCAN("Scan requested while already in scan...\n"); 1676 return 0; 1677 } 1678 1679 IPW_DEBUG_INFO("enter\n"); 1680 1681 /* Not clearing here; doing so makes iwlist always return nothing... 1682 * 1683 * We should modify the table logic to use aging tables vs. clearing 1684 * the table on each scan start. 1685 */ 1686 IPW_DEBUG_SCAN("starting scan\n"); 1687 1688 priv->status |= STATUS_SCANNING; 1689 err = ipw2100_hw_send_command(priv, &cmd); 1690 if (err) 1691 priv->status &= ~STATUS_SCANNING; 1692 1693 IPW_DEBUG_INFO("exit\n"); 1694 1695 return err; 1696 } 1697 1698 static const struct libipw_geo ipw_geos[] = { 1699 { /* Restricted */ 1700 "---", 1701 .bg_channels = 14, 1702 .bg = {{2412, 1}, {2417, 2}, {2422, 3}, 1703 {2427, 4}, {2432, 5}, {2437, 6}, 1704 {2442, 7}, {2447, 8}, {2452, 9}, 1705 {2457, 10}, {2462, 11}, {2467, 12}, 1706 {2472, 13}, {2484, 14}}, 1707 }, 1708 }; 1709 1710 static int ipw2100_up(struct ipw2100_priv *priv, int deferred) 1711 { 1712 unsigned long flags; 1713 int err = 0; 1714 u32 lock; 1715 u32 ord_len = sizeof(lock); 1716 1717 /* Age scan list entries found before suspend */ 1718 if (priv->suspend_time) { 1719 libipw_networks_age(priv->ieee, priv->suspend_time); 1720 priv->suspend_time = 0; 1721 } 1722 1723 /* Quiet if manually disabled. */ 1724 if (priv->status & STATUS_RF_KILL_SW) { 1725 IPW_DEBUG_INFO("%s: Radio is disabled by Manual Disable " 1726 "switch\n", priv->net_dev->name); 1727 return 0; 1728 } 1729 1730 /* the ipw2100 hardware really doesn't want power management delays 1731 * longer than 175usec 1732 */ 1733 pm_qos_update_request(&ipw2100_pm_qos_req, 175); 1734 1735 /* If the interrupt is enabled, turn it off... */ 1736 spin_lock_irqsave(&priv->low_lock, flags); 1737 ipw2100_disable_interrupts(priv); 1738 1739 /* Reset any fatal_error conditions */ 1740 ipw2100_reset_fatalerror(priv); 1741 spin_unlock_irqrestore(&priv->low_lock, flags); 1742 1743 if (priv->status & STATUS_POWERED || 1744 (priv->status & STATUS_RESET_PENDING)) { 1745 /* Power cycle the card ... */ 1746 err = ipw2100_power_cycle_adapter(priv); 1747 if (err) { 1748 printk(KERN_WARNING DRV_NAME 1749 ": %s: Could not cycle adapter.\n", 1750 priv->net_dev->name); 1751 goto exit; 1752 } 1753 } else 1754 priv->status |= STATUS_POWERED; 1755 1756 /* Load the firmware, start the clocks, etc. */ 1757 err = ipw2100_start_adapter(priv); 1758 if (err) { 1759 printk(KERN_ERR DRV_NAME 1760 ": %s: Failed to start the firmware.\n", 1761 priv->net_dev->name); 1762 goto exit; 1763 } 1764 1765 ipw2100_initialize_ordinals(priv); 1766 1767 /* Determine capabilities of this particular HW configuration */ 1768 err = ipw2100_get_hw_features(priv); 1769 if (err) { 1770 printk(KERN_ERR DRV_NAME 1771 ": %s: Failed to determine HW features.\n", 1772 priv->net_dev->name); 1773 goto exit; 1774 } 1775 1776 /* Initialize the geo */ 1777 libipw_set_geo(priv->ieee, &ipw_geos[0]); 1778 priv->ieee->freq_band = LIBIPW_24GHZ_BAND; 1779 1780 lock = LOCK_NONE; 1781 err = ipw2100_set_ordinal(priv, IPW_ORD_PERS_DB_LOCK, &lock, &ord_len); 1782 if (err) { 1783 printk(KERN_ERR DRV_NAME 1784 ": %s: Failed to clear ordinal lock.\n", 1785 priv->net_dev->name); 1786 goto exit; 1787 } 1788 1789 priv->status &= ~STATUS_SCANNING; 1790 1791 if (rf_kill_active(priv)) { 1792 printk(KERN_INFO "%s: Radio is disabled by RF switch.\n", 1793 priv->net_dev->name); 1794 1795 if (priv->stop_rf_kill) { 1796 priv->stop_rf_kill = 0; 1797 schedule_delayed_work(&priv->rf_kill, 1798 round_jiffies_relative(HZ)); 1799 } 1800 1801 deferred = 1; 1802 } 1803 1804 /* Turn on the interrupt so that commands can be processed */ 1805 ipw2100_enable_interrupts(priv); 1806 1807 /* Send all of the commands that must be sent prior to 1808 * HOST_COMPLETE */ 1809 err = ipw2100_adapter_setup(priv); 1810 if (err) { 1811 printk(KERN_ERR DRV_NAME ": %s: Failed to start the card.\n", 1812 priv->net_dev->name); 1813 goto exit; 1814 } 1815 1816 if (!deferred) { 1817 /* Enable the adapter - sends HOST_COMPLETE */ 1818 err = ipw2100_enable_adapter(priv); 1819 if (err) { 1820 printk(KERN_ERR DRV_NAME ": " 1821 "%s: failed in call to enable adapter.\n", 1822 priv->net_dev->name); 1823 ipw2100_hw_stop_adapter(priv); 1824 goto exit; 1825 } 1826 1827 /* Start a scan . . . */ 1828 ipw2100_set_scan_options(priv); 1829 ipw2100_start_scan(priv); 1830 } 1831 1832 exit: 1833 return err; 1834 } 1835 1836 static void ipw2100_down(struct ipw2100_priv *priv) 1837 { 1838 unsigned long flags; 1839 union iwreq_data wrqu = { 1840 .ap_addr = { 1841 .sa_family = ARPHRD_ETHER} 1842 }; 1843 int associated = priv->status & STATUS_ASSOCIATED; 1844 1845 /* Kill the RF switch timer */ 1846 if (!priv->stop_rf_kill) { 1847 priv->stop_rf_kill = 1; 1848 cancel_delayed_work(&priv->rf_kill); 1849 } 1850 1851 /* Kill the firmware hang check timer */ 1852 if (!priv->stop_hang_check) { 1853 priv->stop_hang_check = 1; 1854 cancel_delayed_work(&priv->hang_check); 1855 } 1856 1857 /* Kill any pending resets */ 1858 if (priv->status & STATUS_RESET_PENDING) 1859 cancel_delayed_work(&priv->reset_work); 1860 1861 /* Make sure the interrupt is on so that FW commands will be 1862 * processed correctly */ 1863 spin_lock_irqsave(&priv->low_lock, flags); 1864 ipw2100_enable_interrupts(priv); 1865 spin_unlock_irqrestore(&priv->low_lock, flags); 1866 1867 if (ipw2100_hw_stop_adapter(priv)) 1868 printk(KERN_ERR DRV_NAME ": %s: Error stopping adapter.\n", 1869 priv->net_dev->name); 1870 1871 /* Do not disable the interrupt until _after_ we disable 1872 * the adaptor. Otherwise the CARD_DISABLE command will never 1873 * be ack'd by the firmware */ 1874 spin_lock_irqsave(&priv->low_lock, flags); 1875 ipw2100_disable_interrupts(priv); 1876 spin_unlock_irqrestore(&priv->low_lock, flags); 1877 1878 pm_qos_update_request(&ipw2100_pm_qos_req, PM_QOS_DEFAULT_VALUE); 1879 1880 /* We have to signal any supplicant if we are disassociating */ 1881 if (associated) 1882 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL); 1883 1884 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING); 1885 netif_carrier_off(priv->net_dev); 1886 netif_stop_queue(priv->net_dev); 1887 } 1888 1889 static int ipw2100_wdev_init(struct net_device *dev) 1890 { 1891 struct ipw2100_priv *priv = libipw_priv(dev); 1892 const struct libipw_geo *geo = libipw_get_geo(priv->ieee); 1893 struct wireless_dev *wdev = &priv->ieee->wdev; 1894 int i; 1895 1896 memcpy(wdev->wiphy->perm_addr, priv->mac_addr, ETH_ALEN); 1897 1898 /* fill-out priv->ieee->bg_band */ 1899 if (geo->bg_channels) { 1900 struct ieee80211_supported_band *bg_band = &priv->ieee->bg_band; 1901 1902 bg_band->band = NL80211_BAND_2GHZ; 1903 bg_band->n_channels = geo->bg_channels; 1904 bg_band->channels = kcalloc(geo->bg_channels, 1905 sizeof(struct ieee80211_channel), 1906 GFP_KERNEL); 1907 if (!bg_band->channels) { 1908 ipw2100_down(priv); 1909 return -ENOMEM; 1910 } 1911 /* translate geo->bg to bg_band.channels */ 1912 for (i = 0; i < geo->bg_channels; i++) { 1913 bg_band->channels[i].band = NL80211_BAND_2GHZ; 1914 bg_band->channels[i].center_freq = geo->bg[i].freq; 1915 bg_band->channels[i].hw_value = geo->bg[i].channel; 1916 bg_band->channels[i].max_power = geo->bg[i].max_power; 1917 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY) 1918 bg_band->channels[i].flags |= 1919 IEEE80211_CHAN_NO_IR; 1920 if (geo->bg[i].flags & LIBIPW_CH_NO_IBSS) 1921 bg_band->channels[i].flags |= 1922 IEEE80211_CHAN_NO_IR; 1923 if (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT) 1924 bg_band->channels[i].flags |= 1925 IEEE80211_CHAN_RADAR; 1926 /* No equivalent for LIBIPW_CH_80211H_RULES, 1927 LIBIPW_CH_UNIFORM_SPREADING, or 1928 LIBIPW_CH_B_ONLY... */ 1929 } 1930 /* point at bitrate info */ 1931 bg_band->bitrates = ipw2100_bg_rates; 1932 bg_band->n_bitrates = RATE_COUNT; 1933 1934 wdev->wiphy->bands[NL80211_BAND_2GHZ] = bg_band; 1935 } 1936 1937 wdev->wiphy->cipher_suites = ipw_cipher_suites; 1938 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(ipw_cipher_suites); 1939 1940 set_wiphy_dev(wdev->wiphy, &priv->pci_dev->dev); 1941 if (wiphy_register(wdev->wiphy)) 1942 return -EIO; 1943 return 0; 1944 } 1945 1946 static void ipw2100_reset_adapter(struct work_struct *work) 1947 { 1948 struct ipw2100_priv *priv = 1949 container_of(work, struct ipw2100_priv, reset_work.work); 1950 unsigned long flags; 1951 union iwreq_data wrqu = { 1952 .ap_addr = { 1953 .sa_family = ARPHRD_ETHER} 1954 }; 1955 int associated = priv->status & STATUS_ASSOCIATED; 1956 1957 spin_lock_irqsave(&priv->low_lock, flags); 1958 IPW_DEBUG_INFO(": %s: Restarting adapter.\n", priv->net_dev->name); 1959 priv->resets++; 1960 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING); 1961 priv->status |= STATUS_SECURITY_UPDATED; 1962 1963 /* Force a power cycle even if interface hasn't been opened 1964 * yet */ 1965 cancel_delayed_work(&priv->reset_work); 1966 priv->status |= STATUS_RESET_PENDING; 1967 spin_unlock_irqrestore(&priv->low_lock, flags); 1968 1969 mutex_lock(&priv->action_mutex); 1970 /* stop timed checks so that they don't interfere with reset */ 1971 priv->stop_hang_check = 1; 1972 cancel_delayed_work(&priv->hang_check); 1973 1974 /* We have to signal any supplicant if we are disassociating */ 1975 if (associated) 1976 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL); 1977 1978 ipw2100_up(priv, 0); 1979 mutex_unlock(&priv->action_mutex); 1980 1981 } 1982 1983 static void isr_indicate_associated(struct ipw2100_priv *priv, u32 status) 1984 { 1985 1986 #define MAC_ASSOCIATION_READ_DELAY (HZ) 1987 int ret; 1988 unsigned int len, essid_len; 1989 char essid[IW_ESSID_MAX_SIZE]; 1990 u32 txrate; 1991 u32 chan; 1992 char *txratename; 1993 u8 bssid[ETH_ALEN]; 1994 1995 /* 1996 * TBD: BSSID is usually 00:00:00:00:00:00 here and not 1997 * an actual MAC of the AP. Seems like FW sets this 1998 * address too late. Read it later and expose through 1999 * /proc or schedule a later task to query and update 2000 */ 2001 2002 essid_len = IW_ESSID_MAX_SIZE; 2003 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_SSID, 2004 essid, &essid_len); 2005 if (ret) { 2006 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 2007 __LINE__); 2008 return; 2009 } 2010 2011 len = sizeof(u32); 2012 ret = ipw2100_get_ordinal(priv, IPW_ORD_CURRENT_TX_RATE, &txrate, &len); 2013 if (ret) { 2014 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 2015 __LINE__); 2016 return; 2017 } 2018 2019 len = sizeof(u32); 2020 ret = ipw2100_get_ordinal(priv, IPW_ORD_OUR_FREQ, &chan, &len); 2021 if (ret) { 2022 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 2023 __LINE__); 2024 return; 2025 } 2026 len = ETH_ALEN; 2027 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID, bssid, 2028 &len); 2029 if (ret) { 2030 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 2031 __LINE__); 2032 return; 2033 } 2034 memcpy(priv->ieee->bssid, bssid, ETH_ALEN); 2035 2036 switch (txrate) { 2037 case TX_RATE_1_MBIT: 2038 txratename = "1Mbps"; 2039 break; 2040 case TX_RATE_2_MBIT: 2041 txratename = "2Mbsp"; 2042 break; 2043 case TX_RATE_5_5_MBIT: 2044 txratename = "5.5Mbps"; 2045 break; 2046 case TX_RATE_11_MBIT: 2047 txratename = "11Mbps"; 2048 break; 2049 default: 2050 IPW_DEBUG_INFO("Unknown rate: %d\n", txrate); 2051 txratename = "unknown rate"; 2052 break; 2053 } 2054 2055 IPW_DEBUG_INFO("%s: Associated with '%*pE' at %s, channel %d (BSSID=%pM)\n", 2056 priv->net_dev->name, essid_len, essid, 2057 txratename, chan, bssid); 2058 2059 /* now we copy read ssid into dev */ 2060 if (!(priv->config & CFG_STATIC_ESSID)) { 2061 priv->essid_len = min((u8) essid_len, (u8) IW_ESSID_MAX_SIZE); 2062 memcpy(priv->essid, essid, priv->essid_len); 2063 } 2064 priv->channel = chan; 2065 memcpy(priv->bssid, bssid, ETH_ALEN); 2066 2067 priv->status |= STATUS_ASSOCIATING; 2068 priv->connect_start = ktime_get_boottime_seconds(); 2069 2070 schedule_delayed_work(&priv->wx_event_work, HZ / 10); 2071 } 2072 2073 static int ipw2100_set_essid(struct ipw2100_priv *priv, char *essid, 2074 int length, int batch_mode) 2075 { 2076 int ssid_len = min(length, IW_ESSID_MAX_SIZE); 2077 struct host_command cmd = { 2078 .host_command = SSID, 2079 .host_command_sequence = 0, 2080 .host_command_length = ssid_len 2081 }; 2082 int err; 2083 2084 IPW_DEBUG_HC("SSID: '%*pE'\n", ssid_len, essid); 2085 2086 if (ssid_len) 2087 memcpy(cmd.host_command_parameters, essid, ssid_len); 2088 2089 if (!batch_mode) { 2090 err = ipw2100_disable_adapter(priv); 2091 if (err) 2092 return err; 2093 } 2094 2095 /* Bug in FW currently doesn't honor bit 0 in SET_SCAN_OPTIONS to 2096 * disable auto association -- so we cheat by setting a bogus SSID */ 2097 if (!ssid_len && !(priv->config & CFG_ASSOCIATE)) { 2098 int i; 2099 u8 *bogus = (u8 *) cmd.host_command_parameters; 2100 for (i = 0; i < IW_ESSID_MAX_SIZE; i++) 2101 bogus[i] = 0x18 + i; 2102 cmd.host_command_length = IW_ESSID_MAX_SIZE; 2103 } 2104 2105 /* NOTE: We always send the SSID command even if the provided ESSID is 2106 * the same as what we currently think is set. */ 2107 2108 err = ipw2100_hw_send_command(priv, &cmd); 2109 if (!err) { 2110 memset(priv->essid + ssid_len, 0, IW_ESSID_MAX_SIZE - ssid_len); 2111 memcpy(priv->essid, essid, ssid_len); 2112 priv->essid_len = ssid_len; 2113 } 2114 2115 if (!batch_mode) { 2116 if (ipw2100_enable_adapter(priv)) 2117 err = -EIO; 2118 } 2119 2120 return err; 2121 } 2122 2123 static void isr_indicate_association_lost(struct ipw2100_priv *priv, u32 status) 2124 { 2125 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC, 2126 "disassociated: '%*pE' %pM\n", priv->essid_len, priv->essid, 2127 priv->bssid); 2128 2129 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING); 2130 2131 if (priv->status & STATUS_STOPPING) { 2132 IPW_DEBUG_INFO("Card is stopping itself, discard ASSN_LOST.\n"); 2133 return; 2134 } 2135 2136 eth_zero_addr(priv->bssid); 2137 eth_zero_addr(priv->ieee->bssid); 2138 2139 netif_carrier_off(priv->net_dev); 2140 netif_stop_queue(priv->net_dev); 2141 2142 if (!(priv->status & STATUS_RUNNING)) 2143 return; 2144 2145 if (priv->status & STATUS_SECURITY_UPDATED) 2146 schedule_delayed_work(&priv->security_work, 0); 2147 2148 schedule_delayed_work(&priv->wx_event_work, 0); 2149 } 2150 2151 static void isr_indicate_rf_kill(struct ipw2100_priv *priv, u32 status) 2152 { 2153 IPW_DEBUG_INFO("%s: RF Kill state changed to radio OFF.\n", 2154 priv->net_dev->name); 2155 2156 /* RF_KILL is now enabled (else we wouldn't be here) */ 2157 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true); 2158 priv->status |= STATUS_RF_KILL_HW; 2159 2160 /* Make sure the RF Kill check timer is running */ 2161 priv->stop_rf_kill = 0; 2162 mod_delayed_work(system_wq, &priv->rf_kill, round_jiffies_relative(HZ)); 2163 } 2164 2165 static void ipw2100_scan_event(struct work_struct *work) 2166 { 2167 struct ipw2100_priv *priv = container_of(work, struct ipw2100_priv, 2168 scan_event.work); 2169 union iwreq_data wrqu; 2170 2171 wrqu.data.length = 0; 2172 wrqu.data.flags = 0; 2173 wireless_send_event(priv->net_dev, SIOCGIWSCAN, &wrqu, NULL); 2174 } 2175 2176 static void isr_scan_complete(struct ipw2100_priv *priv, u32 status) 2177 { 2178 IPW_DEBUG_SCAN("scan complete\n"); 2179 /* Age the scan results... */ 2180 priv->ieee->scans++; 2181 priv->status &= ~STATUS_SCANNING; 2182 2183 /* Only userspace-requested scan completion events go out immediately */ 2184 if (!priv->user_requested_scan) { 2185 schedule_delayed_work(&priv->scan_event, 2186 round_jiffies_relative(msecs_to_jiffies(4000))); 2187 } else { 2188 priv->user_requested_scan = 0; 2189 mod_delayed_work(system_wq, &priv->scan_event, 0); 2190 } 2191 } 2192 2193 #ifdef CONFIG_IPW2100_DEBUG 2194 #define IPW2100_HANDLER(v, f) { v, f, # v } 2195 struct ipw2100_status_indicator { 2196 int status; 2197 void (*cb) (struct ipw2100_priv * priv, u32 status); 2198 char *name; 2199 }; 2200 #else 2201 #define IPW2100_HANDLER(v, f) { v, f } 2202 struct ipw2100_status_indicator { 2203 int status; 2204 void (*cb) (struct ipw2100_priv * priv, u32 status); 2205 }; 2206 #endif /* CONFIG_IPW2100_DEBUG */ 2207 2208 static void isr_indicate_scanning(struct ipw2100_priv *priv, u32 status) 2209 { 2210 IPW_DEBUG_SCAN("Scanning...\n"); 2211 priv->status |= STATUS_SCANNING; 2212 } 2213 2214 static const struct ipw2100_status_indicator status_handlers[] = { 2215 IPW2100_HANDLER(IPW_STATE_INITIALIZED, NULL), 2216 IPW2100_HANDLER(IPW_STATE_COUNTRY_FOUND, NULL), 2217 IPW2100_HANDLER(IPW_STATE_ASSOCIATED, isr_indicate_associated), 2218 IPW2100_HANDLER(IPW_STATE_ASSN_LOST, isr_indicate_association_lost), 2219 IPW2100_HANDLER(IPW_STATE_ASSN_CHANGED, NULL), 2220 IPW2100_HANDLER(IPW_STATE_SCAN_COMPLETE, isr_scan_complete), 2221 IPW2100_HANDLER(IPW_STATE_ENTERED_PSP, NULL), 2222 IPW2100_HANDLER(IPW_STATE_LEFT_PSP, NULL), 2223 IPW2100_HANDLER(IPW_STATE_RF_KILL, isr_indicate_rf_kill), 2224 IPW2100_HANDLER(IPW_STATE_DISABLED, NULL), 2225 IPW2100_HANDLER(IPW_STATE_POWER_DOWN, NULL), 2226 IPW2100_HANDLER(IPW_STATE_SCANNING, isr_indicate_scanning), 2227 IPW2100_HANDLER(-1, NULL) 2228 }; 2229 2230 static void isr_status_change(struct ipw2100_priv *priv, int status) 2231 { 2232 int i; 2233 2234 if (status == IPW_STATE_SCANNING && 2235 priv->status & STATUS_ASSOCIATED && 2236 !(priv->status & STATUS_SCANNING)) { 2237 IPW_DEBUG_INFO("Scan detected while associated, with " 2238 "no scan request. Restarting firmware.\n"); 2239 2240 /* Wake up any sleeping jobs */ 2241 schedule_reset(priv); 2242 } 2243 2244 for (i = 0; status_handlers[i].status != -1; i++) { 2245 if (status == status_handlers[i].status) { 2246 IPW_DEBUG_NOTIF("Status change: %s\n", 2247 status_handlers[i].name); 2248 if (status_handlers[i].cb) 2249 status_handlers[i].cb(priv, status); 2250 priv->wstats.status = status; 2251 return; 2252 } 2253 } 2254 2255 IPW_DEBUG_NOTIF("unknown status received: %04x\n", status); 2256 } 2257 2258 static void isr_rx_complete_command(struct ipw2100_priv *priv, 2259 struct ipw2100_cmd_header *cmd) 2260 { 2261 #ifdef CONFIG_IPW2100_DEBUG 2262 if (cmd->host_command_reg < ARRAY_SIZE(command_types)) { 2263 IPW_DEBUG_HC("Command completed '%s (%d)'\n", 2264 command_types[cmd->host_command_reg], 2265 cmd->host_command_reg); 2266 } 2267 #endif 2268 if (cmd->host_command_reg == HOST_COMPLETE) 2269 priv->status |= STATUS_ENABLED; 2270 2271 if (cmd->host_command_reg == CARD_DISABLE) 2272 priv->status &= ~STATUS_ENABLED; 2273 2274 priv->status &= ~STATUS_CMD_ACTIVE; 2275 2276 wake_up_interruptible(&priv->wait_command_queue); 2277 } 2278 2279 #ifdef CONFIG_IPW2100_DEBUG 2280 static const char *frame_types[] = { 2281 "COMMAND_STATUS_VAL", 2282 "STATUS_CHANGE_VAL", 2283 "P80211_DATA_VAL", 2284 "P8023_DATA_VAL", 2285 "HOST_NOTIFICATION_VAL" 2286 }; 2287 #endif 2288 2289 static int ipw2100_alloc_skb(struct ipw2100_priv *priv, 2290 struct ipw2100_rx_packet *packet) 2291 { 2292 packet->skb = dev_alloc_skb(sizeof(struct ipw2100_rx)); 2293 if (!packet->skb) 2294 return -ENOMEM; 2295 2296 packet->rxp = (struct ipw2100_rx *)packet->skb->data; 2297 packet->dma_addr = pci_map_single(priv->pci_dev, packet->skb->data, 2298 sizeof(struct ipw2100_rx), 2299 PCI_DMA_FROMDEVICE); 2300 if (pci_dma_mapping_error(priv->pci_dev, packet->dma_addr)) { 2301 dev_kfree_skb(packet->skb); 2302 return -ENOMEM; 2303 } 2304 2305 return 0; 2306 } 2307 2308 #define SEARCH_ERROR 0xffffffff 2309 #define SEARCH_FAIL 0xfffffffe 2310 #define SEARCH_SUCCESS 0xfffffff0 2311 #define SEARCH_DISCARD 0 2312 #define SEARCH_SNAPSHOT 1 2313 2314 #define SNAPSHOT_ADDR(ofs) (priv->snapshot[((ofs) >> 12) & 0xff] + ((ofs) & 0xfff)) 2315 static void ipw2100_snapshot_free(struct ipw2100_priv *priv) 2316 { 2317 int i; 2318 if (!priv->snapshot[0]) 2319 return; 2320 for (i = 0; i < 0x30; i++) 2321 kfree(priv->snapshot[i]); 2322 priv->snapshot[0] = NULL; 2323 } 2324 2325 #ifdef IPW2100_DEBUG_C3 2326 static int ipw2100_snapshot_alloc(struct ipw2100_priv *priv) 2327 { 2328 int i; 2329 if (priv->snapshot[0]) 2330 return 1; 2331 for (i = 0; i < 0x30; i++) { 2332 priv->snapshot[i] = kmalloc(0x1000, GFP_ATOMIC); 2333 if (!priv->snapshot[i]) { 2334 IPW_DEBUG_INFO("%s: Error allocating snapshot " 2335 "buffer %d\n", priv->net_dev->name, i); 2336 while (i > 0) 2337 kfree(priv->snapshot[--i]); 2338 priv->snapshot[0] = NULL; 2339 return 0; 2340 } 2341 } 2342 2343 return 1; 2344 } 2345 2346 static u32 ipw2100_match_buf(struct ipw2100_priv *priv, u8 * in_buf, 2347 size_t len, int mode) 2348 { 2349 u32 i, j; 2350 u32 tmp; 2351 u8 *s, *d; 2352 u32 ret; 2353 2354 s = in_buf; 2355 if (mode == SEARCH_SNAPSHOT) { 2356 if (!ipw2100_snapshot_alloc(priv)) 2357 mode = SEARCH_DISCARD; 2358 } 2359 2360 for (ret = SEARCH_FAIL, i = 0; i < 0x30000; i += 4) { 2361 read_nic_dword(priv->net_dev, i, &tmp); 2362 if (mode == SEARCH_SNAPSHOT) 2363 *(u32 *) SNAPSHOT_ADDR(i) = tmp; 2364 if (ret == SEARCH_FAIL) { 2365 d = (u8 *) & tmp; 2366 for (j = 0; j < 4; j++) { 2367 if (*s != *d) { 2368 s = in_buf; 2369 continue; 2370 } 2371 2372 s++; 2373 d++; 2374 2375 if ((s - in_buf) == len) 2376 ret = (i + j) - len + 1; 2377 } 2378 } else if (mode == SEARCH_DISCARD) 2379 return ret; 2380 } 2381 2382 return ret; 2383 } 2384 #endif 2385 2386 /* 2387 * 2388 * 0) Disconnect the SKB from the firmware (just unmap) 2389 * 1) Pack the ETH header into the SKB 2390 * 2) Pass the SKB to the network stack 2391 * 2392 * When packet is provided by the firmware, it contains the following: 2393 * 2394 * . libipw_hdr 2395 * . libipw_snap_hdr 2396 * 2397 * The size of the constructed ethernet 2398 * 2399 */ 2400 #ifdef IPW2100_RX_DEBUG 2401 static u8 packet_data[IPW_RX_NIC_BUFFER_LENGTH]; 2402 #endif 2403 2404 static void ipw2100_corruption_detected(struct ipw2100_priv *priv, int i) 2405 { 2406 #ifdef IPW2100_DEBUG_C3 2407 struct ipw2100_status *status = &priv->status_queue.drv[i]; 2408 u32 match, reg; 2409 int j; 2410 #endif 2411 2412 IPW_DEBUG_INFO(": PCI latency error detected at 0x%04zX.\n", 2413 i * sizeof(struct ipw2100_status)); 2414 2415 #ifdef IPW2100_DEBUG_C3 2416 /* Halt the firmware so we can get a good image */ 2417 write_register(priv->net_dev, IPW_REG_RESET_REG, 2418 IPW_AUX_HOST_RESET_REG_STOP_MASTER); 2419 j = 5; 2420 do { 2421 udelay(IPW_WAIT_RESET_MASTER_ASSERT_COMPLETE_DELAY); 2422 read_register(priv->net_dev, IPW_REG_RESET_REG, ®); 2423 2424 if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED) 2425 break; 2426 } while (j--); 2427 2428 match = ipw2100_match_buf(priv, (u8 *) status, 2429 sizeof(struct ipw2100_status), 2430 SEARCH_SNAPSHOT); 2431 if (match < SEARCH_SUCCESS) 2432 IPW_DEBUG_INFO("%s: DMA status match in Firmware at " 2433 "offset 0x%06X, length %d:\n", 2434 priv->net_dev->name, match, 2435 sizeof(struct ipw2100_status)); 2436 else 2437 IPW_DEBUG_INFO("%s: No DMA status match in " 2438 "Firmware.\n", priv->net_dev->name); 2439 2440 printk_buf((u8 *) priv->status_queue.drv, 2441 sizeof(struct ipw2100_status) * RX_QUEUE_LENGTH); 2442 #endif 2443 2444 priv->fatal_error = IPW2100_ERR_C3_CORRUPTION; 2445 priv->net_dev->stats.rx_errors++; 2446 schedule_reset(priv); 2447 } 2448 2449 static void isr_rx(struct ipw2100_priv *priv, int i, 2450 struct libipw_rx_stats *stats) 2451 { 2452 struct net_device *dev = priv->net_dev; 2453 struct ipw2100_status *status = &priv->status_queue.drv[i]; 2454 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i]; 2455 2456 IPW_DEBUG_RX("Handler...\n"); 2457 2458 if (unlikely(status->frame_size > skb_tailroom(packet->skb))) { 2459 IPW_DEBUG_INFO("%s: frame_size (%u) > skb_tailroom (%u)!" 2460 " Dropping.\n", 2461 dev->name, 2462 status->frame_size, skb_tailroom(packet->skb)); 2463 dev->stats.rx_errors++; 2464 return; 2465 } 2466 2467 if (unlikely(!netif_running(dev))) { 2468 dev->stats.rx_errors++; 2469 priv->wstats.discard.misc++; 2470 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n"); 2471 return; 2472 } 2473 2474 if (unlikely(priv->ieee->iw_mode != IW_MODE_MONITOR && 2475 !(priv->status & STATUS_ASSOCIATED))) { 2476 IPW_DEBUG_DROP("Dropping packet while not associated.\n"); 2477 priv->wstats.discard.misc++; 2478 return; 2479 } 2480 2481 pci_unmap_single(priv->pci_dev, 2482 packet->dma_addr, 2483 sizeof(struct ipw2100_rx), PCI_DMA_FROMDEVICE); 2484 2485 skb_put(packet->skb, status->frame_size); 2486 2487 #ifdef IPW2100_RX_DEBUG 2488 /* Make a copy of the frame so we can dump it to the logs if 2489 * libipw_rx fails */ 2490 skb_copy_from_linear_data(packet->skb, packet_data, 2491 min_t(u32, status->frame_size, 2492 IPW_RX_NIC_BUFFER_LENGTH)); 2493 #endif 2494 2495 if (!libipw_rx(priv->ieee, packet->skb, stats)) { 2496 #ifdef IPW2100_RX_DEBUG 2497 IPW_DEBUG_DROP("%s: Non consumed packet:\n", 2498 dev->name); 2499 printk_buf(IPW_DL_DROP, packet_data, status->frame_size); 2500 #endif 2501 dev->stats.rx_errors++; 2502 2503 /* libipw_rx failed, so it didn't free the SKB */ 2504 dev_kfree_skb_any(packet->skb); 2505 packet->skb = NULL; 2506 } 2507 2508 /* We need to allocate a new SKB and attach it to the RDB. */ 2509 if (unlikely(ipw2100_alloc_skb(priv, packet))) { 2510 printk(KERN_WARNING DRV_NAME ": " 2511 "%s: Unable to allocate SKB onto RBD ring - disabling " 2512 "adapter.\n", dev->name); 2513 /* TODO: schedule adapter shutdown */ 2514 IPW_DEBUG_INFO("TODO: Shutdown adapter...\n"); 2515 } 2516 2517 /* Update the RDB entry */ 2518 priv->rx_queue.drv[i].host_addr = packet->dma_addr; 2519 } 2520 2521 #ifdef CONFIG_IPW2100_MONITOR 2522 2523 static void isr_rx_monitor(struct ipw2100_priv *priv, int i, 2524 struct libipw_rx_stats *stats) 2525 { 2526 struct net_device *dev = priv->net_dev; 2527 struct ipw2100_status *status = &priv->status_queue.drv[i]; 2528 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i]; 2529 2530 /* Magic struct that slots into the radiotap header -- no reason 2531 * to build this manually element by element, we can write it much 2532 * more efficiently than we can parse it. ORDER MATTERS HERE */ 2533 struct ipw_rt_hdr { 2534 struct ieee80211_radiotap_header rt_hdr; 2535 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */ 2536 } *ipw_rt; 2537 2538 IPW_DEBUG_RX("Handler...\n"); 2539 2540 if (unlikely(status->frame_size > skb_tailroom(packet->skb) - 2541 sizeof(struct ipw_rt_hdr))) { 2542 IPW_DEBUG_INFO("%s: frame_size (%u) > skb_tailroom (%u)!" 2543 " Dropping.\n", 2544 dev->name, 2545 status->frame_size, 2546 skb_tailroom(packet->skb)); 2547 dev->stats.rx_errors++; 2548 return; 2549 } 2550 2551 if (unlikely(!netif_running(dev))) { 2552 dev->stats.rx_errors++; 2553 priv->wstats.discard.misc++; 2554 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n"); 2555 return; 2556 } 2557 2558 if (unlikely(priv->config & CFG_CRC_CHECK && 2559 status->flags & IPW_STATUS_FLAG_CRC_ERROR)) { 2560 IPW_DEBUG_RX("CRC error in packet. Dropping.\n"); 2561 dev->stats.rx_errors++; 2562 return; 2563 } 2564 2565 pci_unmap_single(priv->pci_dev, packet->dma_addr, 2566 sizeof(struct ipw2100_rx), PCI_DMA_FROMDEVICE); 2567 memmove(packet->skb->data + sizeof(struct ipw_rt_hdr), 2568 packet->skb->data, status->frame_size); 2569 2570 ipw_rt = (struct ipw_rt_hdr *) packet->skb->data; 2571 2572 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION; 2573 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */ 2574 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct ipw_rt_hdr)); /* total hdr+data */ 2575 2576 ipw_rt->rt_hdr.it_present = cpu_to_le32(1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL); 2577 2578 ipw_rt->rt_dbmsignal = status->rssi + IPW2100_RSSI_TO_DBM; 2579 2580 skb_put(packet->skb, status->frame_size + sizeof(struct ipw_rt_hdr)); 2581 2582 if (!libipw_rx(priv->ieee, packet->skb, stats)) { 2583 dev->stats.rx_errors++; 2584 2585 /* libipw_rx failed, so it didn't free the SKB */ 2586 dev_kfree_skb_any(packet->skb); 2587 packet->skb = NULL; 2588 } 2589 2590 /* We need to allocate a new SKB and attach it to the RDB. */ 2591 if (unlikely(ipw2100_alloc_skb(priv, packet))) { 2592 IPW_DEBUG_WARNING( 2593 "%s: Unable to allocate SKB onto RBD ring - disabling " 2594 "adapter.\n", dev->name); 2595 /* TODO: schedule adapter shutdown */ 2596 IPW_DEBUG_INFO("TODO: Shutdown adapter...\n"); 2597 } 2598 2599 /* Update the RDB entry */ 2600 priv->rx_queue.drv[i].host_addr = packet->dma_addr; 2601 } 2602 2603 #endif 2604 2605 static int ipw2100_corruption_check(struct ipw2100_priv *priv, int i) 2606 { 2607 struct ipw2100_status *status = &priv->status_queue.drv[i]; 2608 struct ipw2100_rx *u = priv->rx_buffers[i].rxp; 2609 u16 frame_type = status->status_fields & STATUS_TYPE_MASK; 2610 2611 switch (frame_type) { 2612 case COMMAND_STATUS_VAL: 2613 return (status->frame_size != sizeof(u->rx_data.command)); 2614 case STATUS_CHANGE_VAL: 2615 return (status->frame_size != sizeof(u->rx_data.status)); 2616 case HOST_NOTIFICATION_VAL: 2617 return (status->frame_size < sizeof(u->rx_data.notification)); 2618 case P80211_DATA_VAL: 2619 case P8023_DATA_VAL: 2620 #ifdef CONFIG_IPW2100_MONITOR 2621 return 0; 2622 #else 2623 switch (WLAN_FC_GET_TYPE(le16_to_cpu(u->rx_data.header.frame_ctl))) { 2624 case IEEE80211_FTYPE_MGMT: 2625 case IEEE80211_FTYPE_CTL: 2626 return 0; 2627 case IEEE80211_FTYPE_DATA: 2628 return (status->frame_size > 2629 IPW_MAX_802_11_PAYLOAD_LENGTH); 2630 } 2631 #endif 2632 } 2633 2634 return 1; 2635 } 2636 2637 /* 2638 * ipw2100 interrupts are disabled at this point, and the ISR 2639 * is the only code that calls this method. So, we do not need 2640 * to play with any locks. 2641 * 2642 * RX Queue works as follows: 2643 * 2644 * Read index - firmware places packet in entry identified by the 2645 * Read index and advances Read index. In this manner, 2646 * Read index will always point to the next packet to 2647 * be filled--but not yet valid. 2648 * 2649 * Write index - driver fills this entry with an unused RBD entry. 2650 * This entry has not filled by the firmware yet. 2651 * 2652 * In between the W and R indexes are the RBDs that have been received 2653 * but not yet processed. 2654 * 2655 * The process of handling packets will start at WRITE + 1 and advance 2656 * until it reaches the READ index. 2657 * 2658 * The WRITE index is cached in the variable 'priv->rx_queue.next'. 2659 * 2660 */ 2661 static void __ipw2100_rx_process(struct ipw2100_priv *priv) 2662 { 2663 struct ipw2100_bd_queue *rxq = &priv->rx_queue; 2664 struct ipw2100_status_queue *sq = &priv->status_queue; 2665 struct ipw2100_rx_packet *packet; 2666 u16 frame_type; 2667 u32 r, w, i, s; 2668 struct ipw2100_rx *u; 2669 struct libipw_rx_stats stats = { 2670 .mac_time = jiffies, 2671 }; 2672 2673 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_READ_INDEX, &r); 2674 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_WRITE_INDEX, &w); 2675 2676 if (r >= rxq->entries) { 2677 IPW_DEBUG_RX("exit - bad read index\n"); 2678 return; 2679 } 2680 2681 i = (rxq->next + 1) % rxq->entries; 2682 s = i; 2683 while (i != r) { 2684 /* IPW_DEBUG_RX("r = %d : w = %d : processing = %d\n", 2685 r, rxq->next, i); */ 2686 2687 packet = &priv->rx_buffers[i]; 2688 2689 /* Sync the DMA for the RX buffer so CPU is sure to get 2690 * the correct values */ 2691 pci_dma_sync_single_for_cpu(priv->pci_dev, packet->dma_addr, 2692 sizeof(struct ipw2100_rx), 2693 PCI_DMA_FROMDEVICE); 2694 2695 if (unlikely(ipw2100_corruption_check(priv, i))) { 2696 ipw2100_corruption_detected(priv, i); 2697 goto increment; 2698 } 2699 2700 u = packet->rxp; 2701 frame_type = sq->drv[i].status_fields & STATUS_TYPE_MASK; 2702 stats.rssi = sq->drv[i].rssi + IPW2100_RSSI_TO_DBM; 2703 stats.len = sq->drv[i].frame_size; 2704 2705 stats.mask = 0; 2706 if (stats.rssi != 0) 2707 stats.mask |= LIBIPW_STATMASK_RSSI; 2708 stats.freq = LIBIPW_24GHZ_BAND; 2709 2710 IPW_DEBUG_RX("%s: '%s' frame type received (%d).\n", 2711 priv->net_dev->name, frame_types[frame_type], 2712 stats.len); 2713 2714 switch (frame_type) { 2715 case COMMAND_STATUS_VAL: 2716 /* Reset Rx watchdog */ 2717 isr_rx_complete_command(priv, &u->rx_data.command); 2718 break; 2719 2720 case STATUS_CHANGE_VAL: 2721 isr_status_change(priv, u->rx_data.status); 2722 break; 2723 2724 case P80211_DATA_VAL: 2725 case P8023_DATA_VAL: 2726 #ifdef CONFIG_IPW2100_MONITOR 2727 if (priv->ieee->iw_mode == IW_MODE_MONITOR) { 2728 isr_rx_monitor(priv, i, &stats); 2729 break; 2730 } 2731 #endif 2732 if (stats.len < sizeof(struct libipw_hdr_3addr)) 2733 break; 2734 switch (WLAN_FC_GET_TYPE(le16_to_cpu(u->rx_data.header.frame_ctl))) { 2735 case IEEE80211_FTYPE_MGMT: 2736 libipw_rx_mgt(priv->ieee, 2737 &u->rx_data.header, &stats); 2738 break; 2739 2740 case IEEE80211_FTYPE_CTL: 2741 break; 2742 2743 case IEEE80211_FTYPE_DATA: 2744 isr_rx(priv, i, &stats); 2745 break; 2746 2747 } 2748 break; 2749 } 2750 2751 increment: 2752 /* clear status field associated with this RBD */ 2753 rxq->drv[i].status.info.field = 0; 2754 2755 i = (i + 1) % rxq->entries; 2756 } 2757 2758 if (i != s) { 2759 /* backtrack one entry, wrapping to end if at 0 */ 2760 rxq->next = (i ? i : rxq->entries) - 1; 2761 2762 write_register(priv->net_dev, 2763 IPW_MEM_HOST_SHARED_RX_WRITE_INDEX, rxq->next); 2764 } 2765 } 2766 2767 /* 2768 * __ipw2100_tx_process 2769 * 2770 * This routine will determine whether the next packet on 2771 * the fw_pend_list has been processed by the firmware yet. 2772 * 2773 * If not, then it does nothing and returns. 2774 * 2775 * If so, then it removes the item from the fw_pend_list, frees 2776 * any associated storage, and places the item back on the 2777 * free list of its source (either msg_free_list or tx_free_list) 2778 * 2779 * TX Queue works as follows: 2780 * 2781 * Read index - points to the next TBD that the firmware will 2782 * process. The firmware will read the data, and once 2783 * done processing, it will advance the Read index. 2784 * 2785 * Write index - driver fills this entry with an constructed TBD 2786 * entry. The Write index is not advanced until the 2787 * packet has been configured. 2788 * 2789 * In between the W and R indexes are the TBDs that have NOT been 2790 * processed. Lagging behind the R index are packets that have 2791 * been processed but have not been freed by the driver. 2792 * 2793 * In order to free old storage, an internal index will be maintained 2794 * that points to the next packet to be freed. When all used 2795 * packets have been freed, the oldest index will be the same as the 2796 * firmware's read index. 2797 * 2798 * The OLDEST index is cached in the variable 'priv->tx_queue.oldest' 2799 * 2800 * Because the TBD structure can not contain arbitrary data, the 2801 * driver must keep an internal queue of cached allocations such that 2802 * it can put that data back into the tx_free_list and msg_free_list 2803 * for use by future command and data packets. 2804 * 2805 */ 2806 static int __ipw2100_tx_process(struct ipw2100_priv *priv) 2807 { 2808 struct ipw2100_bd_queue *txq = &priv->tx_queue; 2809 struct ipw2100_bd *tbd; 2810 struct list_head *element; 2811 struct ipw2100_tx_packet *packet; 2812 int descriptors_used; 2813 int e, i; 2814 u32 r, w, frag_num = 0; 2815 2816 if (list_empty(&priv->fw_pend_list)) 2817 return 0; 2818 2819 element = priv->fw_pend_list.next; 2820 2821 packet = list_entry(element, struct ipw2100_tx_packet, list); 2822 tbd = &txq->drv[packet->index]; 2823 2824 /* Determine how many TBD entries must be finished... */ 2825 switch (packet->type) { 2826 case COMMAND: 2827 /* COMMAND uses only one slot; don't advance */ 2828 descriptors_used = 1; 2829 e = txq->oldest; 2830 break; 2831 2832 case DATA: 2833 /* DATA uses two slots; advance and loop position. */ 2834 descriptors_used = tbd->num_fragments; 2835 frag_num = tbd->num_fragments - 1; 2836 e = txq->oldest + frag_num; 2837 e %= txq->entries; 2838 break; 2839 2840 default: 2841 printk(KERN_WARNING DRV_NAME ": %s: Bad fw_pend_list entry!\n", 2842 priv->net_dev->name); 2843 return 0; 2844 } 2845 2846 /* if the last TBD is not done by NIC yet, then packet is 2847 * not ready to be released. 2848 * 2849 */ 2850 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_TX_QUEUE_READ_INDEX, 2851 &r); 2852 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX, 2853 &w); 2854 if (w != txq->next) 2855 printk(KERN_WARNING DRV_NAME ": %s: write index mismatch\n", 2856 priv->net_dev->name); 2857 2858 /* 2859 * txq->next is the index of the last packet written txq->oldest is 2860 * the index of the r is the index of the next packet to be read by 2861 * firmware 2862 */ 2863 2864 /* 2865 * Quick graphic to help you visualize the following 2866 * if / else statement 2867 * 2868 * ===>| s---->|=============== 2869 * e>| 2870 * | a | b | c | d | e | f | g | h | i | j | k | l 2871 * r---->| 2872 * w 2873 * 2874 * w - updated by driver 2875 * r - updated by firmware 2876 * s - start of oldest BD entry (txq->oldest) 2877 * e - end of oldest BD entry 2878 * 2879 */ 2880 if (!((r <= w && (e < r || e >= w)) || (e < r && e >= w))) { 2881 IPW_DEBUG_TX("exit - no processed packets ready to release.\n"); 2882 return 0; 2883 } 2884 2885 list_del(element); 2886 DEC_STAT(&priv->fw_pend_stat); 2887 2888 #ifdef CONFIG_IPW2100_DEBUG 2889 { 2890 i = txq->oldest; 2891 IPW_DEBUG_TX("TX%d V=%p P=%04X T=%04X L=%d\n", i, 2892 &txq->drv[i], 2893 (u32) (txq->nic + i * sizeof(struct ipw2100_bd)), 2894 txq->drv[i].host_addr, txq->drv[i].buf_length); 2895 2896 if (packet->type == DATA) { 2897 i = (i + 1) % txq->entries; 2898 2899 IPW_DEBUG_TX("TX%d V=%p P=%04X T=%04X L=%d\n", i, 2900 &txq->drv[i], 2901 (u32) (txq->nic + i * 2902 sizeof(struct ipw2100_bd)), 2903 (u32) txq->drv[i].host_addr, 2904 txq->drv[i].buf_length); 2905 } 2906 } 2907 #endif 2908 2909 switch (packet->type) { 2910 case DATA: 2911 if (txq->drv[txq->oldest].status.info.fields.txType != 0) 2912 printk(KERN_WARNING DRV_NAME ": %s: Queue mismatch. " 2913 "Expecting DATA TBD but pulled " 2914 "something else: ids %d=%d.\n", 2915 priv->net_dev->name, txq->oldest, packet->index); 2916 2917 /* DATA packet; we have to unmap and free the SKB */ 2918 for (i = 0; i < frag_num; i++) { 2919 tbd = &txq->drv[(packet->index + 1 + i) % txq->entries]; 2920 2921 IPW_DEBUG_TX("TX%d P=%08x L=%d\n", 2922 (packet->index + 1 + i) % txq->entries, 2923 tbd->host_addr, tbd->buf_length); 2924 2925 pci_unmap_single(priv->pci_dev, 2926 tbd->host_addr, 2927 tbd->buf_length, PCI_DMA_TODEVICE); 2928 } 2929 2930 libipw_txb_free(packet->info.d_struct.txb); 2931 packet->info.d_struct.txb = NULL; 2932 2933 list_add_tail(element, &priv->tx_free_list); 2934 INC_STAT(&priv->tx_free_stat); 2935 2936 /* We have a free slot in the Tx queue, so wake up the 2937 * transmit layer if it is stopped. */ 2938 if (priv->status & STATUS_ASSOCIATED) 2939 netif_wake_queue(priv->net_dev); 2940 2941 /* A packet was processed by the hardware, so update the 2942 * watchdog */ 2943 netif_trans_update(priv->net_dev); 2944 2945 break; 2946 2947 case COMMAND: 2948 if (txq->drv[txq->oldest].status.info.fields.txType != 1) 2949 printk(KERN_WARNING DRV_NAME ": %s: Queue mismatch. " 2950 "Expecting COMMAND TBD but pulled " 2951 "something else: ids %d=%d.\n", 2952 priv->net_dev->name, txq->oldest, packet->index); 2953 2954 #ifdef CONFIG_IPW2100_DEBUG 2955 if (packet->info.c_struct.cmd->host_command_reg < 2956 ARRAY_SIZE(command_types)) 2957 IPW_DEBUG_TX("Command '%s (%d)' processed: %d.\n", 2958 command_types[packet->info.c_struct.cmd-> 2959 host_command_reg], 2960 packet->info.c_struct.cmd-> 2961 host_command_reg, 2962 packet->info.c_struct.cmd->cmd_status_reg); 2963 #endif 2964 2965 list_add_tail(element, &priv->msg_free_list); 2966 INC_STAT(&priv->msg_free_stat); 2967 break; 2968 } 2969 2970 /* advance oldest used TBD pointer to start of next entry */ 2971 txq->oldest = (e + 1) % txq->entries; 2972 /* increase available TBDs number */ 2973 txq->available += descriptors_used; 2974 SET_STAT(&priv->txq_stat, txq->available); 2975 2976 IPW_DEBUG_TX("packet latency (send to process) %ld jiffies\n", 2977 jiffies - packet->jiffy_start); 2978 2979 return (!list_empty(&priv->fw_pend_list)); 2980 } 2981 2982 static inline void __ipw2100_tx_complete(struct ipw2100_priv *priv) 2983 { 2984 int i = 0; 2985 2986 while (__ipw2100_tx_process(priv) && i < 200) 2987 i++; 2988 2989 if (i == 200) { 2990 printk(KERN_WARNING DRV_NAME ": " 2991 "%s: Driver is running slow (%d iters).\n", 2992 priv->net_dev->name, i); 2993 } 2994 } 2995 2996 static void ipw2100_tx_send_commands(struct ipw2100_priv *priv) 2997 { 2998 struct list_head *element; 2999 struct ipw2100_tx_packet *packet; 3000 struct ipw2100_bd_queue *txq = &priv->tx_queue; 3001 struct ipw2100_bd *tbd; 3002 int next = txq->next; 3003 3004 while (!list_empty(&priv->msg_pend_list)) { 3005 /* if there isn't enough space in TBD queue, then 3006 * don't stuff a new one in. 3007 * NOTE: 3 are needed as a command will take one, 3008 * and there is a minimum of 2 that must be 3009 * maintained between the r and w indexes 3010 */ 3011 if (txq->available <= 3) { 3012 IPW_DEBUG_TX("no room in tx_queue\n"); 3013 break; 3014 } 3015 3016 element = priv->msg_pend_list.next; 3017 list_del(element); 3018 DEC_STAT(&priv->msg_pend_stat); 3019 3020 packet = list_entry(element, struct ipw2100_tx_packet, list); 3021 3022 IPW_DEBUG_TX("using TBD at virt=%p, phys=%04X\n", 3023 &txq->drv[txq->next], 3024 (u32) (txq->nic + txq->next * 3025 sizeof(struct ipw2100_bd))); 3026 3027 packet->index = txq->next; 3028 3029 tbd = &txq->drv[txq->next]; 3030 3031 /* initialize TBD */ 3032 tbd->host_addr = packet->info.c_struct.cmd_phys; 3033 tbd->buf_length = sizeof(struct ipw2100_cmd_header); 3034 /* not marking number of fragments causes problems 3035 * with f/w debug version */ 3036 tbd->num_fragments = 1; 3037 tbd->status.info.field = 3038 IPW_BD_STATUS_TX_FRAME_COMMAND | 3039 IPW_BD_STATUS_TX_INTERRUPT_ENABLE; 3040 3041 /* update TBD queue counters */ 3042 txq->next++; 3043 txq->next %= txq->entries; 3044 txq->available--; 3045 DEC_STAT(&priv->txq_stat); 3046 3047 list_add_tail(element, &priv->fw_pend_list); 3048 INC_STAT(&priv->fw_pend_stat); 3049 } 3050 3051 if (txq->next != next) { 3052 /* kick off the DMA by notifying firmware the 3053 * write index has moved; make sure TBD stores are sync'd */ 3054 wmb(); 3055 write_register(priv->net_dev, 3056 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX, 3057 txq->next); 3058 } 3059 } 3060 3061 /* 3062 * ipw2100_tx_send_data 3063 * 3064 */ 3065 static void ipw2100_tx_send_data(struct ipw2100_priv *priv) 3066 { 3067 struct list_head *element; 3068 struct ipw2100_tx_packet *packet; 3069 struct ipw2100_bd_queue *txq = &priv->tx_queue; 3070 struct ipw2100_bd *tbd; 3071 int next = txq->next; 3072 int i = 0; 3073 struct ipw2100_data_header *ipw_hdr; 3074 struct libipw_hdr_3addr *hdr; 3075 3076 while (!list_empty(&priv->tx_pend_list)) { 3077 /* if there isn't enough space in TBD queue, then 3078 * don't stuff a new one in. 3079 * NOTE: 4 are needed as a data will take two, 3080 * and there is a minimum of 2 that must be 3081 * maintained between the r and w indexes 3082 */ 3083 element = priv->tx_pend_list.next; 3084 packet = list_entry(element, struct ipw2100_tx_packet, list); 3085 3086 if (unlikely(1 + packet->info.d_struct.txb->nr_frags > 3087 IPW_MAX_BDS)) { 3088 /* TODO: Support merging buffers if more than 3089 * IPW_MAX_BDS are used */ 3090 IPW_DEBUG_INFO("%s: Maximum BD threshold exceeded. " 3091 "Increase fragmentation level.\n", 3092 priv->net_dev->name); 3093 } 3094 3095 if (txq->available <= 3 + packet->info.d_struct.txb->nr_frags) { 3096 IPW_DEBUG_TX("no room in tx_queue\n"); 3097 break; 3098 } 3099 3100 list_del(element); 3101 DEC_STAT(&priv->tx_pend_stat); 3102 3103 tbd = &txq->drv[txq->next]; 3104 3105 packet->index = txq->next; 3106 3107 ipw_hdr = packet->info.d_struct.data; 3108 hdr = (struct libipw_hdr_3addr *)packet->info.d_struct.txb-> 3109 fragments[0]->data; 3110 3111 if (priv->ieee->iw_mode == IW_MODE_INFRA) { 3112 /* To DS: Addr1 = BSSID, Addr2 = SA, 3113 Addr3 = DA */ 3114 memcpy(ipw_hdr->src_addr, hdr->addr2, ETH_ALEN); 3115 memcpy(ipw_hdr->dst_addr, hdr->addr3, ETH_ALEN); 3116 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) { 3117 /* not From/To DS: Addr1 = DA, Addr2 = SA, 3118 Addr3 = BSSID */ 3119 memcpy(ipw_hdr->src_addr, hdr->addr2, ETH_ALEN); 3120 memcpy(ipw_hdr->dst_addr, hdr->addr1, ETH_ALEN); 3121 } 3122 3123 ipw_hdr->host_command_reg = SEND; 3124 ipw_hdr->host_command_reg1 = 0; 3125 3126 /* For now we only support host based encryption */ 3127 ipw_hdr->needs_encryption = 0; 3128 ipw_hdr->encrypted = packet->info.d_struct.txb->encrypted; 3129 if (packet->info.d_struct.txb->nr_frags > 1) 3130 ipw_hdr->fragment_size = 3131 packet->info.d_struct.txb->frag_size - 3132 LIBIPW_3ADDR_LEN; 3133 else 3134 ipw_hdr->fragment_size = 0; 3135 3136 tbd->host_addr = packet->info.d_struct.data_phys; 3137 tbd->buf_length = sizeof(struct ipw2100_data_header); 3138 tbd->num_fragments = 1 + packet->info.d_struct.txb->nr_frags; 3139 tbd->status.info.field = 3140 IPW_BD_STATUS_TX_FRAME_802_3 | 3141 IPW_BD_STATUS_TX_FRAME_NOT_LAST_FRAGMENT; 3142 txq->next++; 3143 txq->next %= txq->entries; 3144 3145 IPW_DEBUG_TX("data header tbd TX%d P=%08x L=%d\n", 3146 packet->index, tbd->host_addr, tbd->buf_length); 3147 #ifdef CONFIG_IPW2100_DEBUG 3148 if (packet->info.d_struct.txb->nr_frags > 1) 3149 IPW_DEBUG_FRAG("fragment Tx: %d frames\n", 3150 packet->info.d_struct.txb->nr_frags); 3151 #endif 3152 3153 for (i = 0; i < packet->info.d_struct.txb->nr_frags; i++) { 3154 tbd = &txq->drv[txq->next]; 3155 if (i == packet->info.d_struct.txb->nr_frags - 1) 3156 tbd->status.info.field = 3157 IPW_BD_STATUS_TX_FRAME_802_3 | 3158 IPW_BD_STATUS_TX_INTERRUPT_ENABLE; 3159 else 3160 tbd->status.info.field = 3161 IPW_BD_STATUS_TX_FRAME_802_3 | 3162 IPW_BD_STATUS_TX_FRAME_NOT_LAST_FRAGMENT; 3163 3164 tbd->buf_length = packet->info.d_struct.txb-> 3165 fragments[i]->len - LIBIPW_3ADDR_LEN; 3166 3167 tbd->host_addr = pci_map_single(priv->pci_dev, 3168 packet->info.d_struct. 3169 txb->fragments[i]-> 3170 data + 3171 LIBIPW_3ADDR_LEN, 3172 tbd->buf_length, 3173 PCI_DMA_TODEVICE); 3174 if (pci_dma_mapping_error(priv->pci_dev, 3175 tbd->host_addr)) { 3176 IPW_DEBUG_TX("dma mapping error\n"); 3177 break; 3178 } 3179 3180 IPW_DEBUG_TX("data frag tbd TX%d P=%08x L=%d\n", 3181 txq->next, tbd->host_addr, 3182 tbd->buf_length); 3183 3184 pci_dma_sync_single_for_device(priv->pci_dev, 3185 tbd->host_addr, 3186 tbd->buf_length, 3187 PCI_DMA_TODEVICE); 3188 3189 txq->next++; 3190 txq->next %= txq->entries; 3191 } 3192 3193 txq->available -= 1 + packet->info.d_struct.txb->nr_frags; 3194 SET_STAT(&priv->txq_stat, txq->available); 3195 3196 list_add_tail(element, &priv->fw_pend_list); 3197 INC_STAT(&priv->fw_pend_stat); 3198 } 3199 3200 if (txq->next != next) { 3201 /* kick off the DMA by notifying firmware the 3202 * write index has moved; make sure TBD stores are sync'd */ 3203 write_register(priv->net_dev, 3204 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX, 3205 txq->next); 3206 } 3207 } 3208 3209 static void ipw2100_irq_tasklet(unsigned long data) 3210 { 3211 struct ipw2100_priv *priv = (struct ipw2100_priv *)data; 3212 struct net_device *dev = priv->net_dev; 3213 unsigned long flags; 3214 u32 inta, tmp; 3215 3216 spin_lock_irqsave(&priv->low_lock, flags); 3217 ipw2100_disable_interrupts(priv); 3218 3219 read_register(dev, IPW_REG_INTA, &inta); 3220 3221 IPW_DEBUG_ISR("enter - INTA: 0x%08lX\n", 3222 (unsigned long)inta & IPW_INTERRUPT_MASK); 3223 3224 priv->in_isr++; 3225 priv->interrupts++; 3226 3227 /* We do not loop and keep polling for more interrupts as this 3228 * is frowned upon and doesn't play nicely with other potentially 3229 * chained IRQs */ 3230 IPW_DEBUG_ISR("INTA: 0x%08lX\n", 3231 (unsigned long)inta & IPW_INTERRUPT_MASK); 3232 3233 if (inta & IPW2100_INTA_FATAL_ERROR) { 3234 printk(KERN_WARNING DRV_NAME 3235 ": Fatal interrupt. Scheduling firmware restart.\n"); 3236 priv->inta_other++; 3237 write_register(dev, IPW_REG_INTA, IPW2100_INTA_FATAL_ERROR); 3238 3239 read_nic_dword(dev, IPW_NIC_FATAL_ERROR, &priv->fatal_error); 3240 IPW_DEBUG_INFO("%s: Fatal error value: 0x%08X\n", 3241 priv->net_dev->name, priv->fatal_error); 3242 3243 read_nic_dword(dev, IPW_ERROR_ADDR(priv->fatal_error), &tmp); 3244 IPW_DEBUG_INFO("%s: Fatal error address value: 0x%08X\n", 3245 priv->net_dev->name, tmp); 3246 3247 /* Wake up any sleeping jobs */ 3248 schedule_reset(priv); 3249 } 3250 3251 if (inta & IPW2100_INTA_PARITY_ERROR) { 3252 printk(KERN_ERR DRV_NAME 3253 ": ***** PARITY ERROR INTERRUPT !!!!\n"); 3254 priv->inta_other++; 3255 write_register(dev, IPW_REG_INTA, IPW2100_INTA_PARITY_ERROR); 3256 } 3257 3258 if (inta & IPW2100_INTA_RX_TRANSFER) { 3259 IPW_DEBUG_ISR("RX interrupt\n"); 3260 3261 priv->rx_interrupts++; 3262 3263 write_register(dev, IPW_REG_INTA, IPW2100_INTA_RX_TRANSFER); 3264 3265 __ipw2100_rx_process(priv); 3266 __ipw2100_tx_complete(priv); 3267 } 3268 3269 if (inta & IPW2100_INTA_TX_TRANSFER) { 3270 IPW_DEBUG_ISR("TX interrupt\n"); 3271 3272 priv->tx_interrupts++; 3273 3274 write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_TRANSFER); 3275 3276 __ipw2100_tx_complete(priv); 3277 ipw2100_tx_send_commands(priv); 3278 ipw2100_tx_send_data(priv); 3279 } 3280 3281 if (inta & IPW2100_INTA_TX_COMPLETE) { 3282 IPW_DEBUG_ISR("TX complete\n"); 3283 priv->inta_other++; 3284 write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_COMPLETE); 3285 3286 __ipw2100_tx_complete(priv); 3287 } 3288 3289 if (inta & IPW2100_INTA_EVENT_INTERRUPT) { 3290 /* ipw2100_handle_event(dev); */ 3291 priv->inta_other++; 3292 write_register(dev, IPW_REG_INTA, IPW2100_INTA_EVENT_INTERRUPT); 3293 } 3294 3295 if (inta & IPW2100_INTA_FW_INIT_DONE) { 3296 IPW_DEBUG_ISR("FW init done interrupt\n"); 3297 priv->inta_other++; 3298 3299 read_register(dev, IPW_REG_INTA, &tmp); 3300 if (tmp & (IPW2100_INTA_FATAL_ERROR | 3301 IPW2100_INTA_PARITY_ERROR)) { 3302 write_register(dev, IPW_REG_INTA, 3303 IPW2100_INTA_FATAL_ERROR | 3304 IPW2100_INTA_PARITY_ERROR); 3305 } 3306 3307 write_register(dev, IPW_REG_INTA, IPW2100_INTA_FW_INIT_DONE); 3308 } 3309 3310 if (inta & IPW2100_INTA_STATUS_CHANGE) { 3311 IPW_DEBUG_ISR("Status change interrupt\n"); 3312 priv->inta_other++; 3313 write_register(dev, IPW_REG_INTA, IPW2100_INTA_STATUS_CHANGE); 3314 } 3315 3316 if (inta & IPW2100_INTA_SLAVE_MODE_HOST_COMMAND_DONE) { 3317 IPW_DEBUG_ISR("slave host mode interrupt\n"); 3318 priv->inta_other++; 3319 write_register(dev, IPW_REG_INTA, 3320 IPW2100_INTA_SLAVE_MODE_HOST_COMMAND_DONE); 3321 } 3322 3323 priv->in_isr--; 3324 ipw2100_enable_interrupts(priv); 3325 3326 spin_unlock_irqrestore(&priv->low_lock, flags); 3327 3328 IPW_DEBUG_ISR("exit\n"); 3329 } 3330 3331 static irqreturn_t ipw2100_interrupt(int irq, void *data) 3332 { 3333 struct ipw2100_priv *priv = data; 3334 u32 inta, inta_mask; 3335 3336 if (!data) 3337 return IRQ_NONE; 3338 3339 spin_lock(&priv->low_lock); 3340 3341 /* We check to see if we should be ignoring interrupts before 3342 * we touch the hardware. During ucode load if we try and handle 3343 * an interrupt we can cause keyboard problems as well as cause 3344 * the ucode to fail to initialize */ 3345 if (!(priv->status & STATUS_INT_ENABLED)) { 3346 /* Shared IRQ */ 3347 goto none; 3348 } 3349 3350 read_register(priv->net_dev, IPW_REG_INTA_MASK, &inta_mask); 3351 read_register(priv->net_dev, IPW_REG_INTA, &inta); 3352 3353 if (inta == 0xFFFFFFFF) { 3354 /* Hardware disappeared */ 3355 printk(KERN_WARNING DRV_NAME ": IRQ INTA == 0xFFFFFFFF\n"); 3356 goto none; 3357 } 3358 3359 inta &= IPW_INTERRUPT_MASK; 3360 3361 if (!(inta & inta_mask)) { 3362 /* Shared interrupt */ 3363 goto none; 3364 } 3365 3366 /* We disable the hardware interrupt here just to prevent unneeded 3367 * calls to be made. We disable this again within the actual 3368 * work tasklet, so if another part of the code re-enables the 3369 * interrupt, that is fine */ 3370 ipw2100_disable_interrupts(priv); 3371 3372 tasklet_schedule(&priv->irq_tasklet); 3373 spin_unlock(&priv->low_lock); 3374 3375 return IRQ_HANDLED; 3376 none: 3377 spin_unlock(&priv->low_lock); 3378 return IRQ_NONE; 3379 } 3380 3381 static netdev_tx_t ipw2100_tx(struct libipw_txb *txb, 3382 struct net_device *dev, int pri) 3383 { 3384 struct ipw2100_priv *priv = libipw_priv(dev); 3385 struct list_head *element; 3386 struct ipw2100_tx_packet *packet; 3387 unsigned long flags; 3388 3389 spin_lock_irqsave(&priv->low_lock, flags); 3390 3391 if (!(priv->status & STATUS_ASSOCIATED)) { 3392 IPW_DEBUG_INFO("Can not transmit when not connected.\n"); 3393 priv->net_dev->stats.tx_carrier_errors++; 3394 netif_stop_queue(dev); 3395 goto fail_unlock; 3396 } 3397 3398 if (list_empty(&priv->tx_free_list)) 3399 goto fail_unlock; 3400 3401 element = priv->tx_free_list.next; 3402 packet = list_entry(element, struct ipw2100_tx_packet, list); 3403 3404 packet->info.d_struct.txb = txb; 3405 3406 IPW_DEBUG_TX("Sending fragment (%d bytes):\n", txb->fragments[0]->len); 3407 printk_buf(IPW_DL_TX, txb->fragments[0]->data, txb->fragments[0]->len); 3408 3409 packet->jiffy_start = jiffies; 3410 3411 list_del(element); 3412 DEC_STAT(&priv->tx_free_stat); 3413 3414 list_add_tail(element, &priv->tx_pend_list); 3415 INC_STAT(&priv->tx_pend_stat); 3416 3417 ipw2100_tx_send_data(priv); 3418 3419 spin_unlock_irqrestore(&priv->low_lock, flags); 3420 return NETDEV_TX_OK; 3421 3422 fail_unlock: 3423 netif_stop_queue(dev); 3424 spin_unlock_irqrestore(&priv->low_lock, flags); 3425 return NETDEV_TX_BUSY; 3426 } 3427 3428 static int ipw2100_msg_allocate(struct ipw2100_priv *priv) 3429 { 3430 int i, j, err = -EINVAL; 3431 void *v; 3432 dma_addr_t p; 3433 3434 priv->msg_buffers = 3435 kmalloc_array(IPW_COMMAND_POOL_SIZE, 3436 sizeof(struct ipw2100_tx_packet), 3437 GFP_KERNEL); 3438 if (!priv->msg_buffers) 3439 return -ENOMEM; 3440 3441 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) { 3442 v = pci_zalloc_consistent(priv->pci_dev, 3443 sizeof(struct ipw2100_cmd_header), 3444 &p); 3445 if (!v) { 3446 printk(KERN_ERR DRV_NAME ": " 3447 "%s: PCI alloc failed for msg " 3448 "buffers.\n", priv->net_dev->name); 3449 err = -ENOMEM; 3450 break; 3451 } 3452 3453 priv->msg_buffers[i].type = COMMAND; 3454 priv->msg_buffers[i].info.c_struct.cmd = 3455 (struct ipw2100_cmd_header *)v; 3456 priv->msg_buffers[i].info.c_struct.cmd_phys = p; 3457 } 3458 3459 if (i == IPW_COMMAND_POOL_SIZE) 3460 return 0; 3461 3462 for (j = 0; j < i; j++) { 3463 pci_free_consistent(priv->pci_dev, 3464 sizeof(struct ipw2100_cmd_header), 3465 priv->msg_buffers[j].info.c_struct.cmd, 3466 priv->msg_buffers[j].info.c_struct. 3467 cmd_phys); 3468 } 3469 3470 kfree(priv->msg_buffers); 3471 priv->msg_buffers = NULL; 3472 3473 return err; 3474 } 3475 3476 static int ipw2100_msg_initialize(struct ipw2100_priv *priv) 3477 { 3478 int i; 3479 3480 INIT_LIST_HEAD(&priv->msg_free_list); 3481 INIT_LIST_HEAD(&priv->msg_pend_list); 3482 3483 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) 3484 list_add_tail(&priv->msg_buffers[i].list, &priv->msg_free_list); 3485 SET_STAT(&priv->msg_free_stat, i); 3486 3487 return 0; 3488 } 3489 3490 static void ipw2100_msg_free(struct ipw2100_priv *priv) 3491 { 3492 int i; 3493 3494 if (!priv->msg_buffers) 3495 return; 3496 3497 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) { 3498 pci_free_consistent(priv->pci_dev, 3499 sizeof(struct ipw2100_cmd_header), 3500 priv->msg_buffers[i].info.c_struct.cmd, 3501 priv->msg_buffers[i].info.c_struct. 3502 cmd_phys); 3503 } 3504 3505 kfree(priv->msg_buffers); 3506 priv->msg_buffers = NULL; 3507 } 3508 3509 static ssize_t show_pci(struct device *d, struct device_attribute *attr, 3510 char *buf) 3511 { 3512 struct pci_dev *pci_dev = to_pci_dev(d); 3513 char *out = buf; 3514 int i, j; 3515 u32 val; 3516 3517 for (i = 0; i < 16; i++) { 3518 out += sprintf(out, "[%08X] ", i * 16); 3519 for (j = 0; j < 16; j += 4) { 3520 pci_read_config_dword(pci_dev, i * 16 + j, &val); 3521 out += sprintf(out, "%08X ", val); 3522 } 3523 out += sprintf(out, "\n"); 3524 } 3525 3526 return out - buf; 3527 } 3528 3529 static DEVICE_ATTR(pci, 0444, show_pci, NULL); 3530 3531 static ssize_t show_cfg(struct device *d, struct device_attribute *attr, 3532 char *buf) 3533 { 3534 struct ipw2100_priv *p = dev_get_drvdata(d); 3535 return sprintf(buf, "0x%08x\n", (int)p->config); 3536 } 3537 3538 static DEVICE_ATTR(cfg, 0444, show_cfg, NULL); 3539 3540 static ssize_t show_status(struct device *d, struct device_attribute *attr, 3541 char *buf) 3542 { 3543 struct ipw2100_priv *p = dev_get_drvdata(d); 3544 return sprintf(buf, "0x%08x\n", (int)p->status); 3545 } 3546 3547 static DEVICE_ATTR(status, 0444, show_status, NULL); 3548 3549 static ssize_t show_capability(struct device *d, struct device_attribute *attr, 3550 char *buf) 3551 { 3552 struct ipw2100_priv *p = dev_get_drvdata(d); 3553 return sprintf(buf, "0x%08x\n", (int)p->capability); 3554 } 3555 3556 static DEVICE_ATTR(capability, 0444, show_capability, NULL); 3557 3558 #define IPW2100_REG(x) { IPW_ ##x, #x } 3559 static const struct { 3560 u32 addr; 3561 const char *name; 3562 } hw_data[] = { 3563 IPW2100_REG(REG_GP_CNTRL), 3564 IPW2100_REG(REG_GPIO), 3565 IPW2100_REG(REG_INTA), 3566 IPW2100_REG(REG_INTA_MASK), IPW2100_REG(REG_RESET_REG),}; 3567 #define IPW2100_NIC(x, s) { x, #x, s } 3568 static const struct { 3569 u32 addr; 3570 const char *name; 3571 size_t size; 3572 } nic_data[] = { 3573 IPW2100_NIC(IPW2100_CONTROL_REG, 2), 3574 IPW2100_NIC(0x210014, 1), IPW2100_NIC(0x210000, 1),}; 3575 #define IPW2100_ORD(x, d) { IPW_ORD_ ##x, #x, d } 3576 static const struct { 3577 u8 index; 3578 const char *name; 3579 const char *desc; 3580 } ord_data[] = { 3581 IPW2100_ORD(STAT_TX_HOST_REQUESTS, "requested Host Tx's (MSDU)"), 3582 IPW2100_ORD(STAT_TX_HOST_COMPLETE, 3583 "successful Host Tx's (MSDU)"), 3584 IPW2100_ORD(STAT_TX_DIR_DATA, 3585 "successful Directed Tx's (MSDU)"), 3586 IPW2100_ORD(STAT_TX_DIR_DATA1, 3587 "successful Directed Tx's (MSDU) @ 1MB"), 3588 IPW2100_ORD(STAT_TX_DIR_DATA2, 3589 "successful Directed Tx's (MSDU) @ 2MB"), 3590 IPW2100_ORD(STAT_TX_DIR_DATA5_5, 3591 "successful Directed Tx's (MSDU) @ 5_5MB"), 3592 IPW2100_ORD(STAT_TX_DIR_DATA11, 3593 "successful Directed Tx's (MSDU) @ 11MB"), 3594 IPW2100_ORD(STAT_TX_NODIR_DATA1, 3595 "successful Non_Directed Tx's (MSDU) @ 1MB"), 3596 IPW2100_ORD(STAT_TX_NODIR_DATA2, 3597 "successful Non_Directed Tx's (MSDU) @ 2MB"), 3598 IPW2100_ORD(STAT_TX_NODIR_DATA5_5, 3599 "successful Non_Directed Tx's (MSDU) @ 5.5MB"), 3600 IPW2100_ORD(STAT_TX_NODIR_DATA11, 3601 "successful Non_Directed Tx's (MSDU) @ 11MB"), 3602 IPW2100_ORD(STAT_NULL_DATA, "successful NULL data Tx's"), 3603 IPW2100_ORD(STAT_TX_RTS, "successful Tx RTS"), 3604 IPW2100_ORD(STAT_TX_CTS, "successful Tx CTS"), 3605 IPW2100_ORD(STAT_TX_ACK, "successful Tx ACK"), 3606 IPW2100_ORD(STAT_TX_ASSN, "successful Association Tx's"), 3607 IPW2100_ORD(STAT_TX_ASSN_RESP, 3608 "successful Association response Tx's"), 3609 IPW2100_ORD(STAT_TX_REASSN, 3610 "successful Reassociation Tx's"), 3611 IPW2100_ORD(STAT_TX_REASSN_RESP, 3612 "successful Reassociation response Tx's"), 3613 IPW2100_ORD(STAT_TX_PROBE, 3614 "probes successfully transmitted"), 3615 IPW2100_ORD(STAT_TX_PROBE_RESP, 3616 "probe responses successfully transmitted"), 3617 IPW2100_ORD(STAT_TX_BEACON, "tx beacon"), 3618 IPW2100_ORD(STAT_TX_ATIM, "Tx ATIM"), 3619 IPW2100_ORD(STAT_TX_DISASSN, 3620 "successful Disassociation TX"), 3621 IPW2100_ORD(STAT_TX_AUTH, "successful Authentication Tx"), 3622 IPW2100_ORD(STAT_TX_DEAUTH, 3623 "successful Deauthentication TX"), 3624 IPW2100_ORD(STAT_TX_TOTAL_BYTES, 3625 "Total successful Tx data bytes"), 3626 IPW2100_ORD(STAT_TX_RETRIES, "Tx retries"), 3627 IPW2100_ORD(STAT_TX_RETRY1, "Tx retries at 1MBPS"), 3628 IPW2100_ORD(STAT_TX_RETRY2, "Tx retries at 2MBPS"), 3629 IPW2100_ORD(STAT_TX_RETRY5_5, "Tx retries at 5.5MBPS"), 3630 IPW2100_ORD(STAT_TX_RETRY11, "Tx retries at 11MBPS"), 3631 IPW2100_ORD(STAT_TX_FAILURES, "Tx Failures"), 3632 IPW2100_ORD(STAT_TX_MAX_TRIES_IN_HOP, 3633 "times max tries in a hop failed"), 3634 IPW2100_ORD(STAT_TX_DISASSN_FAIL, 3635 "times disassociation failed"), 3636 IPW2100_ORD(STAT_TX_ERR_CTS, "missed/bad CTS frames"), 3637 IPW2100_ORD(STAT_TX_ERR_ACK, "tx err due to acks"), 3638 IPW2100_ORD(STAT_RX_HOST, "packets passed to host"), 3639 IPW2100_ORD(STAT_RX_DIR_DATA, "directed packets"), 3640 IPW2100_ORD(STAT_RX_DIR_DATA1, "directed packets at 1MB"), 3641 IPW2100_ORD(STAT_RX_DIR_DATA2, "directed packets at 2MB"), 3642 IPW2100_ORD(STAT_RX_DIR_DATA5_5, 3643 "directed packets at 5.5MB"), 3644 IPW2100_ORD(STAT_RX_DIR_DATA11, "directed packets at 11MB"), 3645 IPW2100_ORD(STAT_RX_NODIR_DATA, "nondirected packets"), 3646 IPW2100_ORD(STAT_RX_NODIR_DATA1, 3647 "nondirected packets at 1MB"), 3648 IPW2100_ORD(STAT_RX_NODIR_DATA2, 3649 "nondirected packets at 2MB"), 3650 IPW2100_ORD(STAT_RX_NODIR_DATA5_5, 3651 "nondirected packets at 5.5MB"), 3652 IPW2100_ORD(STAT_RX_NODIR_DATA11, 3653 "nondirected packets at 11MB"), 3654 IPW2100_ORD(STAT_RX_NULL_DATA, "null data rx's"), 3655 IPW2100_ORD(STAT_RX_RTS, "Rx RTS"), IPW2100_ORD(STAT_RX_CTS, 3656 "Rx CTS"), 3657 IPW2100_ORD(STAT_RX_ACK, "Rx ACK"), 3658 IPW2100_ORD(STAT_RX_CFEND, "Rx CF End"), 3659 IPW2100_ORD(STAT_RX_CFEND_ACK, "Rx CF End + CF Ack"), 3660 IPW2100_ORD(STAT_RX_ASSN, "Association Rx's"), 3661 IPW2100_ORD(STAT_RX_ASSN_RESP, "Association response Rx's"), 3662 IPW2100_ORD(STAT_RX_REASSN, "Reassociation Rx's"), 3663 IPW2100_ORD(STAT_RX_REASSN_RESP, 3664 "Reassociation response Rx's"), 3665 IPW2100_ORD(STAT_RX_PROBE, "probe Rx's"), 3666 IPW2100_ORD(STAT_RX_PROBE_RESP, "probe response Rx's"), 3667 IPW2100_ORD(STAT_RX_BEACON, "Rx beacon"), 3668 IPW2100_ORD(STAT_RX_ATIM, "Rx ATIM"), 3669 IPW2100_ORD(STAT_RX_DISASSN, "disassociation Rx"), 3670 IPW2100_ORD(STAT_RX_AUTH, "authentication Rx"), 3671 IPW2100_ORD(STAT_RX_DEAUTH, "deauthentication Rx"), 3672 IPW2100_ORD(STAT_RX_TOTAL_BYTES, 3673 "Total rx data bytes received"), 3674 IPW2100_ORD(STAT_RX_ERR_CRC, "packets with Rx CRC error"), 3675 IPW2100_ORD(STAT_RX_ERR_CRC1, "Rx CRC errors at 1MB"), 3676 IPW2100_ORD(STAT_RX_ERR_CRC2, "Rx CRC errors at 2MB"), 3677 IPW2100_ORD(STAT_RX_ERR_CRC5_5, "Rx CRC errors at 5.5MB"), 3678 IPW2100_ORD(STAT_RX_ERR_CRC11, "Rx CRC errors at 11MB"), 3679 IPW2100_ORD(STAT_RX_DUPLICATE1, 3680 "duplicate rx packets at 1MB"), 3681 IPW2100_ORD(STAT_RX_DUPLICATE2, 3682 "duplicate rx packets at 2MB"), 3683 IPW2100_ORD(STAT_RX_DUPLICATE5_5, 3684 "duplicate rx packets at 5.5MB"), 3685 IPW2100_ORD(STAT_RX_DUPLICATE11, 3686 "duplicate rx packets at 11MB"), 3687 IPW2100_ORD(STAT_RX_DUPLICATE, "duplicate rx packets"), 3688 IPW2100_ORD(PERS_DB_LOCK, "locking fw permanent db"), 3689 IPW2100_ORD(PERS_DB_SIZE, "size of fw permanent db"), 3690 IPW2100_ORD(PERS_DB_ADDR, "address of fw permanent db"), 3691 IPW2100_ORD(STAT_RX_INVALID_PROTOCOL, 3692 "rx frames with invalid protocol"), 3693 IPW2100_ORD(SYS_BOOT_TIME, "Boot time"), 3694 IPW2100_ORD(STAT_RX_NO_BUFFER, 3695 "rx frames rejected due to no buffer"), 3696 IPW2100_ORD(STAT_RX_MISSING_FRAG, 3697 "rx frames dropped due to missing fragment"), 3698 IPW2100_ORD(STAT_RX_ORPHAN_FRAG, 3699 "rx frames dropped due to non-sequential fragment"), 3700 IPW2100_ORD(STAT_RX_ORPHAN_FRAME, 3701 "rx frames dropped due to unmatched 1st frame"), 3702 IPW2100_ORD(STAT_RX_FRAG_AGEOUT, 3703 "rx frames dropped due to uncompleted frame"), 3704 IPW2100_ORD(STAT_RX_ICV_ERRORS, 3705 "ICV errors during decryption"), 3706 IPW2100_ORD(STAT_PSP_SUSPENSION, "times adapter suspended"), 3707 IPW2100_ORD(STAT_PSP_BCN_TIMEOUT, "beacon timeout"), 3708 IPW2100_ORD(STAT_PSP_POLL_TIMEOUT, 3709 "poll response timeouts"), 3710 IPW2100_ORD(STAT_PSP_NONDIR_TIMEOUT, 3711 "timeouts waiting for last {broad,multi}cast pkt"), 3712 IPW2100_ORD(STAT_PSP_RX_DTIMS, "PSP DTIMs received"), 3713 IPW2100_ORD(STAT_PSP_RX_TIMS, "PSP TIMs received"), 3714 IPW2100_ORD(STAT_PSP_STATION_ID, "PSP Station ID"), 3715 IPW2100_ORD(LAST_ASSN_TIME, "RTC time of last association"), 3716 IPW2100_ORD(STAT_PERCENT_MISSED_BCNS, 3717 "current calculation of % missed beacons"), 3718 IPW2100_ORD(STAT_PERCENT_RETRIES, 3719 "current calculation of % missed tx retries"), 3720 IPW2100_ORD(ASSOCIATED_AP_PTR, 3721 "0 if not associated, else pointer to AP table entry"), 3722 IPW2100_ORD(AVAILABLE_AP_CNT, 3723 "AP's described in the AP table"), 3724 IPW2100_ORD(AP_LIST_PTR, "Ptr to list of available APs"), 3725 IPW2100_ORD(STAT_AP_ASSNS, "associations"), 3726 IPW2100_ORD(STAT_ASSN_FAIL, "association failures"), 3727 IPW2100_ORD(STAT_ASSN_RESP_FAIL, 3728 "failures due to response fail"), 3729 IPW2100_ORD(STAT_FULL_SCANS, "full scans"), 3730 IPW2100_ORD(CARD_DISABLED, "Card Disabled"), 3731 IPW2100_ORD(STAT_ROAM_INHIBIT, 3732 "times roaming was inhibited due to activity"), 3733 IPW2100_ORD(RSSI_AT_ASSN, 3734 "RSSI of associated AP at time of association"), 3735 IPW2100_ORD(STAT_ASSN_CAUSE1, 3736 "reassociation: no probe response or TX on hop"), 3737 IPW2100_ORD(STAT_ASSN_CAUSE2, 3738 "reassociation: poor tx/rx quality"), 3739 IPW2100_ORD(STAT_ASSN_CAUSE3, 3740 "reassociation: tx/rx quality (excessive AP load"), 3741 IPW2100_ORD(STAT_ASSN_CAUSE4, 3742 "reassociation: AP RSSI level"), 3743 IPW2100_ORD(STAT_ASSN_CAUSE5, 3744 "reassociations due to load leveling"), 3745 IPW2100_ORD(STAT_AUTH_FAIL, "times authentication failed"), 3746 IPW2100_ORD(STAT_AUTH_RESP_FAIL, 3747 "times authentication response failed"), 3748 IPW2100_ORD(STATION_TABLE_CNT, 3749 "entries in association table"), 3750 IPW2100_ORD(RSSI_AVG_CURR, "Current avg RSSI"), 3751 IPW2100_ORD(POWER_MGMT_MODE, "Power mode - 0=CAM, 1=PSP"), 3752 IPW2100_ORD(COUNTRY_CODE, 3753 "IEEE country code as recv'd from beacon"), 3754 IPW2100_ORD(COUNTRY_CHANNELS, 3755 "channels supported by country"), 3756 IPW2100_ORD(RESET_CNT, "adapter resets (warm)"), 3757 IPW2100_ORD(BEACON_INTERVAL, "Beacon interval"), 3758 IPW2100_ORD(ANTENNA_DIVERSITY, 3759 "TRUE if antenna diversity is disabled"), 3760 IPW2100_ORD(DTIM_PERIOD, "beacon intervals between DTIMs"), 3761 IPW2100_ORD(OUR_FREQ, 3762 "current radio freq lower digits - channel ID"), 3763 IPW2100_ORD(RTC_TIME, "current RTC time"), 3764 IPW2100_ORD(PORT_TYPE, "operating mode"), 3765 IPW2100_ORD(CURRENT_TX_RATE, "current tx rate"), 3766 IPW2100_ORD(SUPPORTED_RATES, "supported tx rates"), 3767 IPW2100_ORD(ATIM_WINDOW, "current ATIM Window"), 3768 IPW2100_ORD(BASIC_RATES, "basic tx rates"), 3769 IPW2100_ORD(NIC_HIGHEST_RATE, "NIC highest tx rate"), 3770 IPW2100_ORD(AP_HIGHEST_RATE, "AP highest tx rate"), 3771 IPW2100_ORD(CAPABILITIES, 3772 "Management frame capability field"), 3773 IPW2100_ORD(AUTH_TYPE, "Type of authentication"), 3774 IPW2100_ORD(RADIO_TYPE, "Adapter card platform type"), 3775 IPW2100_ORD(RTS_THRESHOLD, 3776 "Min packet length for RTS handshaking"), 3777 IPW2100_ORD(INT_MODE, "International mode"), 3778 IPW2100_ORD(FRAGMENTATION_THRESHOLD, 3779 "protocol frag threshold"), 3780 IPW2100_ORD(EEPROM_SRAM_DB_BLOCK_START_ADDRESS, 3781 "EEPROM offset in SRAM"), 3782 IPW2100_ORD(EEPROM_SRAM_DB_BLOCK_SIZE, 3783 "EEPROM size in SRAM"), 3784 IPW2100_ORD(EEPROM_SKU_CAPABILITY, "EEPROM SKU Capability"), 3785 IPW2100_ORD(EEPROM_IBSS_11B_CHANNELS, 3786 "EEPROM IBSS 11b channel set"), 3787 IPW2100_ORD(MAC_VERSION, "MAC Version"), 3788 IPW2100_ORD(MAC_REVISION, "MAC Revision"), 3789 IPW2100_ORD(RADIO_VERSION, "Radio Version"), 3790 IPW2100_ORD(NIC_MANF_DATE_TIME, "MANF Date/Time STAMP"), 3791 IPW2100_ORD(UCODE_VERSION, "Ucode Version"),}; 3792 3793 static ssize_t show_registers(struct device *d, struct device_attribute *attr, 3794 char *buf) 3795 { 3796 int i; 3797 struct ipw2100_priv *priv = dev_get_drvdata(d); 3798 struct net_device *dev = priv->net_dev; 3799 char *out = buf; 3800 u32 val = 0; 3801 3802 out += sprintf(out, "%30s [Address ] : Hex\n", "Register"); 3803 3804 for (i = 0; i < ARRAY_SIZE(hw_data); i++) { 3805 read_register(dev, hw_data[i].addr, &val); 3806 out += sprintf(out, "%30s [%08X] : %08X\n", 3807 hw_data[i].name, hw_data[i].addr, val); 3808 } 3809 3810 return out - buf; 3811 } 3812 3813 static DEVICE_ATTR(registers, 0444, show_registers, NULL); 3814 3815 static ssize_t show_hardware(struct device *d, struct device_attribute *attr, 3816 char *buf) 3817 { 3818 struct ipw2100_priv *priv = dev_get_drvdata(d); 3819 struct net_device *dev = priv->net_dev; 3820 char *out = buf; 3821 int i; 3822 3823 out += sprintf(out, "%30s [Address ] : Hex\n", "NIC entry"); 3824 3825 for (i = 0; i < ARRAY_SIZE(nic_data); i++) { 3826 u8 tmp8; 3827 u16 tmp16; 3828 u32 tmp32; 3829 3830 switch (nic_data[i].size) { 3831 case 1: 3832 read_nic_byte(dev, nic_data[i].addr, &tmp8); 3833 out += sprintf(out, "%30s [%08X] : %02X\n", 3834 nic_data[i].name, nic_data[i].addr, 3835 tmp8); 3836 break; 3837 case 2: 3838 read_nic_word(dev, nic_data[i].addr, &tmp16); 3839 out += sprintf(out, "%30s [%08X] : %04X\n", 3840 nic_data[i].name, nic_data[i].addr, 3841 tmp16); 3842 break; 3843 case 4: 3844 read_nic_dword(dev, nic_data[i].addr, &tmp32); 3845 out += sprintf(out, "%30s [%08X] : %08X\n", 3846 nic_data[i].name, nic_data[i].addr, 3847 tmp32); 3848 break; 3849 } 3850 } 3851 return out - buf; 3852 } 3853 3854 static DEVICE_ATTR(hardware, 0444, show_hardware, NULL); 3855 3856 static ssize_t show_memory(struct device *d, struct device_attribute *attr, 3857 char *buf) 3858 { 3859 struct ipw2100_priv *priv = dev_get_drvdata(d); 3860 struct net_device *dev = priv->net_dev; 3861 static unsigned long loop = 0; 3862 int len = 0; 3863 u32 buffer[4]; 3864 int i; 3865 char line[81]; 3866 3867 if (loop >= 0x30000) 3868 loop = 0; 3869 3870 /* sysfs provides us PAGE_SIZE buffer */ 3871 while (len < PAGE_SIZE - 128 && loop < 0x30000) { 3872 3873 if (priv->snapshot[0]) 3874 for (i = 0; i < 4; i++) 3875 buffer[i] = 3876 *(u32 *) SNAPSHOT_ADDR(loop + i * 4); 3877 else 3878 for (i = 0; i < 4; i++) 3879 read_nic_dword(dev, loop + i * 4, &buffer[i]); 3880 3881 if (priv->dump_raw) 3882 len += sprintf(buf + len, 3883 "%c%c%c%c" 3884 "%c%c%c%c" 3885 "%c%c%c%c" 3886 "%c%c%c%c", 3887 ((u8 *) buffer)[0x0], 3888 ((u8 *) buffer)[0x1], 3889 ((u8 *) buffer)[0x2], 3890 ((u8 *) buffer)[0x3], 3891 ((u8 *) buffer)[0x4], 3892 ((u8 *) buffer)[0x5], 3893 ((u8 *) buffer)[0x6], 3894 ((u8 *) buffer)[0x7], 3895 ((u8 *) buffer)[0x8], 3896 ((u8 *) buffer)[0x9], 3897 ((u8 *) buffer)[0xa], 3898 ((u8 *) buffer)[0xb], 3899 ((u8 *) buffer)[0xc], 3900 ((u8 *) buffer)[0xd], 3901 ((u8 *) buffer)[0xe], 3902 ((u8 *) buffer)[0xf]); 3903 else 3904 len += sprintf(buf + len, "%s\n", 3905 snprint_line(line, sizeof(line), 3906 (u8 *) buffer, 16, loop)); 3907 loop += 16; 3908 } 3909 3910 return len; 3911 } 3912 3913 static ssize_t store_memory(struct device *d, struct device_attribute *attr, 3914 const char *buf, size_t count) 3915 { 3916 struct ipw2100_priv *priv = dev_get_drvdata(d); 3917 struct net_device *dev = priv->net_dev; 3918 const char *p = buf; 3919 3920 (void)dev; /* kill unused-var warning for debug-only code */ 3921 3922 if (count < 1) 3923 return count; 3924 3925 if (p[0] == '1' || 3926 (count >= 2 && tolower(p[0]) == 'o' && tolower(p[1]) == 'n')) { 3927 IPW_DEBUG_INFO("%s: Setting memory dump to RAW mode.\n", 3928 dev->name); 3929 priv->dump_raw = 1; 3930 3931 } else if (p[0] == '0' || (count >= 2 && tolower(p[0]) == 'o' && 3932 tolower(p[1]) == 'f')) { 3933 IPW_DEBUG_INFO("%s: Setting memory dump to HEX mode.\n", 3934 dev->name); 3935 priv->dump_raw = 0; 3936 3937 } else if (tolower(p[0]) == 'r') { 3938 IPW_DEBUG_INFO("%s: Resetting firmware snapshot.\n", dev->name); 3939 ipw2100_snapshot_free(priv); 3940 3941 } else 3942 IPW_DEBUG_INFO("%s: Usage: 0|on = HEX, 1|off = RAW, " 3943 "reset = clear memory snapshot\n", dev->name); 3944 3945 return count; 3946 } 3947 3948 static DEVICE_ATTR(memory, 0644, show_memory, store_memory); 3949 3950 static ssize_t show_ordinals(struct device *d, struct device_attribute *attr, 3951 char *buf) 3952 { 3953 struct ipw2100_priv *priv = dev_get_drvdata(d); 3954 u32 val = 0; 3955 int len = 0; 3956 u32 val_len; 3957 static int loop = 0; 3958 3959 if (priv->status & STATUS_RF_KILL_MASK) 3960 return 0; 3961 3962 if (loop >= ARRAY_SIZE(ord_data)) 3963 loop = 0; 3964 3965 /* sysfs provides us PAGE_SIZE buffer */ 3966 while (len < PAGE_SIZE - 128 && loop < ARRAY_SIZE(ord_data)) { 3967 val_len = sizeof(u32); 3968 3969 if (ipw2100_get_ordinal(priv, ord_data[loop].index, &val, 3970 &val_len)) 3971 len += sprintf(buf + len, "[0x%02X] = ERROR %s\n", 3972 ord_data[loop].index, 3973 ord_data[loop].desc); 3974 else 3975 len += sprintf(buf + len, "[0x%02X] = 0x%08X %s\n", 3976 ord_data[loop].index, val, 3977 ord_data[loop].desc); 3978 loop++; 3979 } 3980 3981 return len; 3982 } 3983 3984 static DEVICE_ATTR(ordinals, 0444, show_ordinals, NULL); 3985 3986 static ssize_t show_stats(struct device *d, struct device_attribute *attr, 3987 char *buf) 3988 { 3989 struct ipw2100_priv *priv = dev_get_drvdata(d); 3990 char *out = buf; 3991 3992 out += sprintf(out, "interrupts: %d {tx: %d, rx: %d, other: %d}\n", 3993 priv->interrupts, priv->tx_interrupts, 3994 priv->rx_interrupts, priv->inta_other); 3995 out += sprintf(out, "firmware resets: %d\n", priv->resets); 3996 out += sprintf(out, "firmware hangs: %d\n", priv->hangs); 3997 #ifdef CONFIG_IPW2100_DEBUG 3998 out += sprintf(out, "packet mismatch image: %s\n", 3999 priv->snapshot[0] ? "YES" : "NO"); 4000 #endif 4001 4002 return out - buf; 4003 } 4004 4005 static DEVICE_ATTR(stats, 0444, show_stats, NULL); 4006 4007 static int ipw2100_switch_mode(struct ipw2100_priv *priv, u32 mode) 4008 { 4009 int err; 4010 4011 if (mode == priv->ieee->iw_mode) 4012 return 0; 4013 4014 err = ipw2100_disable_adapter(priv); 4015 if (err) { 4016 printk(KERN_ERR DRV_NAME ": %s: Could not disable adapter %d\n", 4017 priv->net_dev->name, err); 4018 return err; 4019 } 4020 4021 switch (mode) { 4022 case IW_MODE_INFRA: 4023 priv->net_dev->type = ARPHRD_ETHER; 4024 break; 4025 case IW_MODE_ADHOC: 4026 priv->net_dev->type = ARPHRD_ETHER; 4027 break; 4028 #ifdef CONFIG_IPW2100_MONITOR 4029 case IW_MODE_MONITOR: 4030 priv->last_mode = priv->ieee->iw_mode; 4031 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP; 4032 break; 4033 #endif /* CONFIG_IPW2100_MONITOR */ 4034 } 4035 4036 priv->ieee->iw_mode = mode; 4037 4038 #ifdef CONFIG_PM 4039 /* Indicate ipw2100_download_firmware download firmware 4040 * from disk instead of memory. */ 4041 ipw2100_firmware.version = 0; 4042 #endif 4043 4044 printk(KERN_INFO "%s: Resetting on mode change.\n", priv->net_dev->name); 4045 priv->reset_backoff = 0; 4046 schedule_reset(priv); 4047 4048 return 0; 4049 } 4050 4051 static ssize_t show_internals(struct device *d, struct device_attribute *attr, 4052 char *buf) 4053 { 4054 struct ipw2100_priv *priv = dev_get_drvdata(d); 4055 int len = 0; 4056 4057 #define DUMP_VAR(x,y) len += sprintf(buf + len, # x ": %" y "\n", priv-> x) 4058 4059 if (priv->status & STATUS_ASSOCIATED) 4060 len += sprintf(buf + len, "connected: %llu\n", 4061 ktime_get_boottime_seconds() - priv->connect_start); 4062 else 4063 len += sprintf(buf + len, "not connected\n"); 4064 4065 DUMP_VAR(ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx], "p"); 4066 DUMP_VAR(status, "08lx"); 4067 DUMP_VAR(config, "08lx"); 4068 DUMP_VAR(capability, "08lx"); 4069 4070 len += 4071 sprintf(buf + len, "last_rtc: %lu\n", 4072 (unsigned long)priv->last_rtc); 4073 4074 DUMP_VAR(fatal_error, "d"); 4075 DUMP_VAR(stop_hang_check, "d"); 4076 DUMP_VAR(stop_rf_kill, "d"); 4077 DUMP_VAR(messages_sent, "d"); 4078 4079 DUMP_VAR(tx_pend_stat.value, "d"); 4080 DUMP_VAR(tx_pend_stat.hi, "d"); 4081 4082 DUMP_VAR(tx_free_stat.value, "d"); 4083 DUMP_VAR(tx_free_stat.lo, "d"); 4084 4085 DUMP_VAR(msg_free_stat.value, "d"); 4086 DUMP_VAR(msg_free_stat.lo, "d"); 4087 4088 DUMP_VAR(msg_pend_stat.value, "d"); 4089 DUMP_VAR(msg_pend_stat.hi, "d"); 4090 4091 DUMP_VAR(fw_pend_stat.value, "d"); 4092 DUMP_VAR(fw_pend_stat.hi, "d"); 4093 4094 DUMP_VAR(txq_stat.value, "d"); 4095 DUMP_VAR(txq_stat.lo, "d"); 4096 4097 DUMP_VAR(ieee->scans, "d"); 4098 DUMP_VAR(reset_backoff, "lld"); 4099 4100 return len; 4101 } 4102 4103 static DEVICE_ATTR(internals, 0444, show_internals, NULL); 4104 4105 static ssize_t show_bssinfo(struct device *d, struct device_attribute *attr, 4106 char *buf) 4107 { 4108 struct ipw2100_priv *priv = dev_get_drvdata(d); 4109 char essid[IW_ESSID_MAX_SIZE + 1]; 4110 u8 bssid[ETH_ALEN]; 4111 u32 chan = 0; 4112 char *out = buf; 4113 unsigned int length; 4114 int ret; 4115 4116 if (priv->status & STATUS_RF_KILL_MASK) 4117 return 0; 4118 4119 memset(essid, 0, sizeof(essid)); 4120 memset(bssid, 0, sizeof(bssid)); 4121 4122 length = IW_ESSID_MAX_SIZE; 4123 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_SSID, essid, &length); 4124 if (ret) 4125 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 4126 __LINE__); 4127 4128 length = sizeof(bssid); 4129 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID, 4130 bssid, &length); 4131 if (ret) 4132 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 4133 __LINE__); 4134 4135 length = sizeof(u32); 4136 ret = ipw2100_get_ordinal(priv, IPW_ORD_OUR_FREQ, &chan, &length); 4137 if (ret) 4138 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 4139 __LINE__); 4140 4141 out += sprintf(out, "ESSID: %s\n", essid); 4142 out += sprintf(out, "BSSID: %pM\n", bssid); 4143 out += sprintf(out, "Channel: %d\n", chan); 4144 4145 return out - buf; 4146 } 4147 4148 static DEVICE_ATTR(bssinfo, 0444, show_bssinfo, NULL); 4149 4150 #ifdef CONFIG_IPW2100_DEBUG 4151 static ssize_t debug_level_show(struct device_driver *d, char *buf) 4152 { 4153 return sprintf(buf, "0x%08X\n", ipw2100_debug_level); 4154 } 4155 4156 static ssize_t debug_level_store(struct device_driver *d, 4157 const char *buf, size_t count) 4158 { 4159 u32 val; 4160 int ret; 4161 4162 ret = kstrtou32(buf, 0, &val); 4163 if (ret) 4164 IPW_DEBUG_INFO(": %s is not in hex or decimal form.\n", buf); 4165 else 4166 ipw2100_debug_level = val; 4167 4168 return strnlen(buf, count); 4169 } 4170 static DRIVER_ATTR_RW(debug_level); 4171 #endif /* CONFIG_IPW2100_DEBUG */ 4172 4173 static ssize_t show_fatal_error(struct device *d, 4174 struct device_attribute *attr, char *buf) 4175 { 4176 struct ipw2100_priv *priv = dev_get_drvdata(d); 4177 char *out = buf; 4178 int i; 4179 4180 if (priv->fatal_error) 4181 out += sprintf(out, "0x%08X\n", priv->fatal_error); 4182 else 4183 out += sprintf(out, "0\n"); 4184 4185 for (i = 1; i <= IPW2100_ERROR_QUEUE; i++) { 4186 if (!priv->fatal_errors[(priv->fatal_index - i) % 4187 IPW2100_ERROR_QUEUE]) 4188 continue; 4189 4190 out += sprintf(out, "%d. 0x%08X\n", i, 4191 priv->fatal_errors[(priv->fatal_index - i) % 4192 IPW2100_ERROR_QUEUE]); 4193 } 4194 4195 return out - buf; 4196 } 4197 4198 static ssize_t store_fatal_error(struct device *d, 4199 struct device_attribute *attr, const char *buf, 4200 size_t count) 4201 { 4202 struct ipw2100_priv *priv = dev_get_drvdata(d); 4203 schedule_reset(priv); 4204 return count; 4205 } 4206 4207 static DEVICE_ATTR(fatal_error, 0644, show_fatal_error, store_fatal_error); 4208 4209 static ssize_t show_scan_age(struct device *d, struct device_attribute *attr, 4210 char *buf) 4211 { 4212 struct ipw2100_priv *priv = dev_get_drvdata(d); 4213 return sprintf(buf, "%d\n", priv->ieee->scan_age); 4214 } 4215 4216 static ssize_t store_scan_age(struct device *d, struct device_attribute *attr, 4217 const char *buf, size_t count) 4218 { 4219 struct ipw2100_priv *priv = dev_get_drvdata(d); 4220 struct net_device *dev = priv->net_dev; 4221 unsigned long val; 4222 int ret; 4223 4224 (void)dev; /* kill unused-var warning for debug-only code */ 4225 4226 IPW_DEBUG_INFO("enter\n"); 4227 4228 ret = kstrtoul(buf, 0, &val); 4229 if (ret) { 4230 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name); 4231 } else { 4232 priv->ieee->scan_age = val; 4233 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age); 4234 } 4235 4236 IPW_DEBUG_INFO("exit\n"); 4237 return strnlen(buf, count); 4238 } 4239 4240 static DEVICE_ATTR(scan_age, 0644, show_scan_age, store_scan_age); 4241 4242 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr, 4243 char *buf) 4244 { 4245 /* 0 - RF kill not enabled 4246 1 - SW based RF kill active (sysfs) 4247 2 - HW based RF kill active 4248 3 - Both HW and SW baed RF kill active */ 4249 struct ipw2100_priv *priv = dev_get_drvdata(d); 4250 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) | 4251 (rf_kill_active(priv) ? 0x2 : 0x0); 4252 return sprintf(buf, "%i\n", val); 4253 } 4254 4255 static int ipw_radio_kill_sw(struct ipw2100_priv *priv, int disable_radio) 4256 { 4257 if ((disable_radio ? 1 : 0) == 4258 (priv->status & STATUS_RF_KILL_SW ? 1 : 0)) 4259 return 0; 4260 4261 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n", 4262 disable_radio ? "OFF" : "ON"); 4263 4264 mutex_lock(&priv->action_mutex); 4265 4266 if (disable_radio) { 4267 priv->status |= STATUS_RF_KILL_SW; 4268 ipw2100_down(priv); 4269 } else { 4270 priv->status &= ~STATUS_RF_KILL_SW; 4271 if (rf_kill_active(priv)) { 4272 IPW_DEBUG_RF_KILL("Can not turn radio back on - " 4273 "disabled by HW switch\n"); 4274 /* Make sure the RF_KILL check timer is running */ 4275 priv->stop_rf_kill = 0; 4276 mod_delayed_work(system_wq, &priv->rf_kill, 4277 round_jiffies_relative(HZ)); 4278 } else 4279 schedule_reset(priv); 4280 } 4281 4282 mutex_unlock(&priv->action_mutex); 4283 return 1; 4284 } 4285 4286 static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr, 4287 const char *buf, size_t count) 4288 { 4289 struct ipw2100_priv *priv = dev_get_drvdata(d); 4290 ipw_radio_kill_sw(priv, buf[0] == '1'); 4291 return count; 4292 } 4293 4294 static DEVICE_ATTR(rf_kill, 0644, show_rf_kill, store_rf_kill); 4295 4296 static struct attribute *ipw2100_sysfs_entries[] = { 4297 &dev_attr_hardware.attr, 4298 &dev_attr_registers.attr, 4299 &dev_attr_ordinals.attr, 4300 &dev_attr_pci.attr, 4301 &dev_attr_stats.attr, 4302 &dev_attr_internals.attr, 4303 &dev_attr_bssinfo.attr, 4304 &dev_attr_memory.attr, 4305 &dev_attr_scan_age.attr, 4306 &dev_attr_fatal_error.attr, 4307 &dev_attr_rf_kill.attr, 4308 &dev_attr_cfg.attr, 4309 &dev_attr_status.attr, 4310 &dev_attr_capability.attr, 4311 NULL, 4312 }; 4313 4314 static const struct attribute_group ipw2100_attribute_group = { 4315 .attrs = ipw2100_sysfs_entries, 4316 }; 4317 4318 static int status_queue_allocate(struct ipw2100_priv *priv, int entries) 4319 { 4320 struct ipw2100_status_queue *q = &priv->status_queue; 4321 4322 IPW_DEBUG_INFO("enter\n"); 4323 4324 q->size = entries * sizeof(struct ipw2100_status); 4325 q->drv = pci_zalloc_consistent(priv->pci_dev, q->size, &q->nic); 4326 if (!q->drv) { 4327 IPW_DEBUG_WARNING("Can not allocate status queue.\n"); 4328 return -ENOMEM; 4329 } 4330 4331 IPW_DEBUG_INFO("exit\n"); 4332 4333 return 0; 4334 } 4335 4336 static void status_queue_free(struct ipw2100_priv *priv) 4337 { 4338 IPW_DEBUG_INFO("enter\n"); 4339 4340 if (priv->status_queue.drv) { 4341 pci_free_consistent(priv->pci_dev, priv->status_queue.size, 4342 priv->status_queue.drv, 4343 priv->status_queue.nic); 4344 priv->status_queue.drv = NULL; 4345 } 4346 4347 IPW_DEBUG_INFO("exit\n"); 4348 } 4349 4350 static int bd_queue_allocate(struct ipw2100_priv *priv, 4351 struct ipw2100_bd_queue *q, int entries) 4352 { 4353 IPW_DEBUG_INFO("enter\n"); 4354 4355 memset(q, 0, sizeof(struct ipw2100_bd_queue)); 4356 4357 q->entries = entries; 4358 q->size = entries * sizeof(struct ipw2100_bd); 4359 q->drv = pci_zalloc_consistent(priv->pci_dev, q->size, &q->nic); 4360 if (!q->drv) { 4361 IPW_DEBUG_INFO 4362 ("can't allocate shared memory for buffer descriptors\n"); 4363 return -ENOMEM; 4364 } 4365 4366 IPW_DEBUG_INFO("exit\n"); 4367 4368 return 0; 4369 } 4370 4371 static void bd_queue_free(struct ipw2100_priv *priv, struct ipw2100_bd_queue *q) 4372 { 4373 IPW_DEBUG_INFO("enter\n"); 4374 4375 if (!q) 4376 return; 4377 4378 if (q->drv) { 4379 pci_free_consistent(priv->pci_dev, q->size, q->drv, q->nic); 4380 q->drv = NULL; 4381 } 4382 4383 IPW_DEBUG_INFO("exit\n"); 4384 } 4385 4386 static void bd_queue_initialize(struct ipw2100_priv *priv, 4387 struct ipw2100_bd_queue *q, u32 base, u32 size, 4388 u32 r, u32 w) 4389 { 4390 IPW_DEBUG_INFO("enter\n"); 4391 4392 IPW_DEBUG_INFO("initializing bd queue at virt=%p, phys=%08x\n", q->drv, 4393 (u32) q->nic); 4394 4395 write_register(priv->net_dev, base, q->nic); 4396 write_register(priv->net_dev, size, q->entries); 4397 write_register(priv->net_dev, r, q->oldest); 4398 write_register(priv->net_dev, w, q->next); 4399 4400 IPW_DEBUG_INFO("exit\n"); 4401 } 4402 4403 static void ipw2100_kill_works(struct ipw2100_priv *priv) 4404 { 4405 priv->stop_rf_kill = 1; 4406 priv->stop_hang_check = 1; 4407 cancel_delayed_work_sync(&priv->reset_work); 4408 cancel_delayed_work_sync(&priv->security_work); 4409 cancel_delayed_work_sync(&priv->wx_event_work); 4410 cancel_delayed_work_sync(&priv->hang_check); 4411 cancel_delayed_work_sync(&priv->rf_kill); 4412 cancel_delayed_work_sync(&priv->scan_event); 4413 } 4414 4415 static int ipw2100_tx_allocate(struct ipw2100_priv *priv) 4416 { 4417 int i, j, err; 4418 void *v; 4419 dma_addr_t p; 4420 4421 IPW_DEBUG_INFO("enter\n"); 4422 4423 err = bd_queue_allocate(priv, &priv->tx_queue, TX_QUEUE_LENGTH); 4424 if (err) { 4425 IPW_DEBUG_ERROR("%s: failed bd_queue_allocate\n", 4426 priv->net_dev->name); 4427 return err; 4428 } 4429 4430 priv->tx_buffers = kmalloc_array(TX_PENDED_QUEUE_LENGTH, 4431 sizeof(struct ipw2100_tx_packet), 4432 GFP_ATOMIC); 4433 if (!priv->tx_buffers) { 4434 bd_queue_free(priv, &priv->tx_queue); 4435 return -ENOMEM; 4436 } 4437 4438 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) { 4439 v = pci_alloc_consistent(priv->pci_dev, 4440 sizeof(struct ipw2100_data_header), 4441 &p); 4442 if (!v) { 4443 printk(KERN_ERR DRV_NAME 4444 ": %s: PCI alloc failed for tx " "buffers.\n", 4445 priv->net_dev->name); 4446 err = -ENOMEM; 4447 break; 4448 } 4449 4450 priv->tx_buffers[i].type = DATA; 4451 priv->tx_buffers[i].info.d_struct.data = 4452 (struct ipw2100_data_header *)v; 4453 priv->tx_buffers[i].info.d_struct.data_phys = p; 4454 priv->tx_buffers[i].info.d_struct.txb = NULL; 4455 } 4456 4457 if (i == TX_PENDED_QUEUE_LENGTH) 4458 return 0; 4459 4460 for (j = 0; j < i; j++) { 4461 pci_free_consistent(priv->pci_dev, 4462 sizeof(struct ipw2100_data_header), 4463 priv->tx_buffers[j].info.d_struct.data, 4464 priv->tx_buffers[j].info.d_struct. 4465 data_phys); 4466 } 4467 4468 kfree(priv->tx_buffers); 4469 priv->tx_buffers = NULL; 4470 4471 return err; 4472 } 4473 4474 static void ipw2100_tx_initialize(struct ipw2100_priv *priv) 4475 { 4476 int i; 4477 4478 IPW_DEBUG_INFO("enter\n"); 4479 4480 /* 4481 * reinitialize packet info lists 4482 */ 4483 INIT_LIST_HEAD(&priv->fw_pend_list); 4484 INIT_STAT(&priv->fw_pend_stat); 4485 4486 /* 4487 * reinitialize lists 4488 */ 4489 INIT_LIST_HEAD(&priv->tx_pend_list); 4490 INIT_LIST_HEAD(&priv->tx_free_list); 4491 INIT_STAT(&priv->tx_pend_stat); 4492 INIT_STAT(&priv->tx_free_stat); 4493 4494 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) { 4495 /* We simply drop any SKBs that have been queued for 4496 * transmit */ 4497 if (priv->tx_buffers[i].info.d_struct.txb) { 4498 libipw_txb_free(priv->tx_buffers[i].info.d_struct. 4499 txb); 4500 priv->tx_buffers[i].info.d_struct.txb = NULL; 4501 } 4502 4503 list_add_tail(&priv->tx_buffers[i].list, &priv->tx_free_list); 4504 } 4505 4506 SET_STAT(&priv->tx_free_stat, i); 4507 4508 priv->tx_queue.oldest = 0; 4509 priv->tx_queue.available = priv->tx_queue.entries; 4510 priv->tx_queue.next = 0; 4511 INIT_STAT(&priv->txq_stat); 4512 SET_STAT(&priv->txq_stat, priv->tx_queue.available); 4513 4514 bd_queue_initialize(priv, &priv->tx_queue, 4515 IPW_MEM_HOST_SHARED_TX_QUEUE_BD_BASE, 4516 IPW_MEM_HOST_SHARED_TX_QUEUE_BD_SIZE, 4517 IPW_MEM_HOST_SHARED_TX_QUEUE_READ_INDEX, 4518 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX); 4519 4520 IPW_DEBUG_INFO("exit\n"); 4521 4522 } 4523 4524 static void ipw2100_tx_free(struct ipw2100_priv *priv) 4525 { 4526 int i; 4527 4528 IPW_DEBUG_INFO("enter\n"); 4529 4530 bd_queue_free(priv, &priv->tx_queue); 4531 4532 if (!priv->tx_buffers) 4533 return; 4534 4535 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) { 4536 if (priv->tx_buffers[i].info.d_struct.txb) { 4537 libipw_txb_free(priv->tx_buffers[i].info.d_struct. 4538 txb); 4539 priv->tx_buffers[i].info.d_struct.txb = NULL; 4540 } 4541 if (priv->tx_buffers[i].info.d_struct.data) 4542 pci_free_consistent(priv->pci_dev, 4543 sizeof(struct ipw2100_data_header), 4544 priv->tx_buffers[i].info.d_struct. 4545 data, 4546 priv->tx_buffers[i].info.d_struct. 4547 data_phys); 4548 } 4549 4550 kfree(priv->tx_buffers); 4551 priv->tx_buffers = NULL; 4552 4553 IPW_DEBUG_INFO("exit\n"); 4554 } 4555 4556 static int ipw2100_rx_allocate(struct ipw2100_priv *priv) 4557 { 4558 int i, j, err = -EINVAL; 4559 4560 IPW_DEBUG_INFO("enter\n"); 4561 4562 err = bd_queue_allocate(priv, &priv->rx_queue, RX_QUEUE_LENGTH); 4563 if (err) { 4564 IPW_DEBUG_INFO("failed bd_queue_allocate\n"); 4565 return err; 4566 } 4567 4568 err = status_queue_allocate(priv, RX_QUEUE_LENGTH); 4569 if (err) { 4570 IPW_DEBUG_INFO("failed status_queue_allocate\n"); 4571 bd_queue_free(priv, &priv->rx_queue); 4572 return err; 4573 } 4574 4575 /* 4576 * allocate packets 4577 */ 4578 priv->rx_buffers = kmalloc_array(RX_QUEUE_LENGTH, 4579 sizeof(struct ipw2100_rx_packet), 4580 GFP_KERNEL); 4581 if (!priv->rx_buffers) { 4582 IPW_DEBUG_INFO("can't allocate rx packet buffer table\n"); 4583 4584 bd_queue_free(priv, &priv->rx_queue); 4585 4586 status_queue_free(priv); 4587 4588 return -ENOMEM; 4589 } 4590 4591 for (i = 0; i < RX_QUEUE_LENGTH; i++) { 4592 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i]; 4593 4594 err = ipw2100_alloc_skb(priv, packet); 4595 if (unlikely(err)) { 4596 err = -ENOMEM; 4597 break; 4598 } 4599 4600 /* The BD holds the cache aligned address */ 4601 priv->rx_queue.drv[i].host_addr = packet->dma_addr; 4602 priv->rx_queue.drv[i].buf_length = IPW_RX_NIC_BUFFER_LENGTH; 4603 priv->status_queue.drv[i].status_fields = 0; 4604 } 4605 4606 if (i == RX_QUEUE_LENGTH) 4607 return 0; 4608 4609 for (j = 0; j < i; j++) { 4610 pci_unmap_single(priv->pci_dev, priv->rx_buffers[j].dma_addr, 4611 sizeof(struct ipw2100_rx_packet), 4612 PCI_DMA_FROMDEVICE); 4613 dev_kfree_skb(priv->rx_buffers[j].skb); 4614 } 4615 4616 kfree(priv->rx_buffers); 4617 priv->rx_buffers = NULL; 4618 4619 bd_queue_free(priv, &priv->rx_queue); 4620 4621 status_queue_free(priv); 4622 4623 return err; 4624 } 4625 4626 static void ipw2100_rx_initialize(struct ipw2100_priv *priv) 4627 { 4628 IPW_DEBUG_INFO("enter\n"); 4629 4630 priv->rx_queue.oldest = 0; 4631 priv->rx_queue.available = priv->rx_queue.entries - 1; 4632 priv->rx_queue.next = priv->rx_queue.entries - 1; 4633 4634 INIT_STAT(&priv->rxq_stat); 4635 SET_STAT(&priv->rxq_stat, priv->rx_queue.available); 4636 4637 bd_queue_initialize(priv, &priv->rx_queue, 4638 IPW_MEM_HOST_SHARED_RX_BD_BASE, 4639 IPW_MEM_HOST_SHARED_RX_BD_SIZE, 4640 IPW_MEM_HOST_SHARED_RX_READ_INDEX, 4641 IPW_MEM_HOST_SHARED_RX_WRITE_INDEX); 4642 4643 /* set up the status queue */ 4644 write_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_STATUS_BASE, 4645 priv->status_queue.nic); 4646 4647 IPW_DEBUG_INFO("exit\n"); 4648 } 4649 4650 static void ipw2100_rx_free(struct ipw2100_priv *priv) 4651 { 4652 int i; 4653 4654 IPW_DEBUG_INFO("enter\n"); 4655 4656 bd_queue_free(priv, &priv->rx_queue); 4657 status_queue_free(priv); 4658 4659 if (!priv->rx_buffers) 4660 return; 4661 4662 for (i = 0; i < RX_QUEUE_LENGTH; i++) { 4663 if (priv->rx_buffers[i].rxp) { 4664 pci_unmap_single(priv->pci_dev, 4665 priv->rx_buffers[i].dma_addr, 4666 sizeof(struct ipw2100_rx), 4667 PCI_DMA_FROMDEVICE); 4668 dev_kfree_skb(priv->rx_buffers[i].skb); 4669 } 4670 } 4671 4672 kfree(priv->rx_buffers); 4673 priv->rx_buffers = NULL; 4674 4675 IPW_DEBUG_INFO("exit\n"); 4676 } 4677 4678 static int ipw2100_read_mac_address(struct ipw2100_priv *priv) 4679 { 4680 u32 length = ETH_ALEN; 4681 u8 addr[ETH_ALEN]; 4682 4683 int err; 4684 4685 err = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ADAPTER_MAC, addr, &length); 4686 if (err) { 4687 IPW_DEBUG_INFO("MAC address read failed\n"); 4688 return -EIO; 4689 } 4690 4691 memcpy(priv->net_dev->dev_addr, addr, ETH_ALEN); 4692 IPW_DEBUG_INFO("card MAC is %pM\n", priv->net_dev->dev_addr); 4693 4694 return 0; 4695 } 4696 4697 /******************************************************************** 4698 * 4699 * Firmware Commands 4700 * 4701 ********************************************************************/ 4702 4703 static int ipw2100_set_mac_address(struct ipw2100_priv *priv, int batch_mode) 4704 { 4705 struct host_command cmd = { 4706 .host_command = ADAPTER_ADDRESS, 4707 .host_command_sequence = 0, 4708 .host_command_length = ETH_ALEN 4709 }; 4710 int err; 4711 4712 IPW_DEBUG_HC("SET_MAC_ADDRESS\n"); 4713 4714 IPW_DEBUG_INFO("enter\n"); 4715 4716 if (priv->config & CFG_CUSTOM_MAC) { 4717 memcpy(cmd.host_command_parameters, priv->mac_addr, ETH_ALEN); 4718 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN); 4719 } else 4720 memcpy(cmd.host_command_parameters, priv->net_dev->dev_addr, 4721 ETH_ALEN); 4722 4723 err = ipw2100_hw_send_command(priv, &cmd); 4724 4725 IPW_DEBUG_INFO("exit\n"); 4726 return err; 4727 } 4728 4729 static int ipw2100_set_port_type(struct ipw2100_priv *priv, u32 port_type, 4730 int batch_mode) 4731 { 4732 struct host_command cmd = { 4733 .host_command = PORT_TYPE, 4734 .host_command_sequence = 0, 4735 .host_command_length = sizeof(u32) 4736 }; 4737 int err; 4738 4739 switch (port_type) { 4740 case IW_MODE_INFRA: 4741 cmd.host_command_parameters[0] = IPW_BSS; 4742 break; 4743 case IW_MODE_ADHOC: 4744 cmd.host_command_parameters[0] = IPW_IBSS; 4745 break; 4746 } 4747 4748 IPW_DEBUG_HC("PORT_TYPE: %s\n", 4749 port_type == IPW_IBSS ? "Ad-Hoc" : "Managed"); 4750 4751 if (!batch_mode) { 4752 err = ipw2100_disable_adapter(priv); 4753 if (err) { 4754 printk(KERN_ERR DRV_NAME 4755 ": %s: Could not disable adapter %d\n", 4756 priv->net_dev->name, err); 4757 return err; 4758 } 4759 } 4760 4761 /* send cmd to firmware */ 4762 err = ipw2100_hw_send_command(priv, &cmd); 4763 4764 if (!batch_mode) 4765 ipw2100_enable_adapter(priv); 4766 4767 return err; 4768 } 4769 4770 static int ipw2100_set_channel(struct ipw2100_priv *priv, u32 channel, 4771 int batch_mode) 4772 { 4773 struct host_command cmd = { 4774 .host_command = CHANNEL, 4775 .host_command_sequence = 0, 4776 .host_command_length = sizeof(u32) 4777 }; 4778 int err; 4779 4780 cmd.host_command_parameters[0] = channel; 4781 4782 IPW_DEBUG_HC("CHANNEL: %d\n", channel); 4783 4784 /* If BSS then we don't support channel selection */ 4785 if (priv->ieee->iw_mode == IW_MODE_INFRA) 4786 return 0; 4787 4788 if ((channel != 0) && 4789 ((channel < REG_MIN_CHANNEL) || (channel > REG_MAX_CHANNEL))) 4790 return -EINVAL; 4791 4792 if (!batch_mode) { 4793 err = ipw2100_disable_adapter(priv); 4794 if (err) 4795 return err; 4796 } 4797 4798 err = ipw2100_hw_send_command(priv, &cmd); 4799 if (err) { 4800 IPW_DEBUG_INFO("Failed to set channel to %d", channel); 4801 return err; 4802 } 4803 4804 if (channel) 4805 priv->config |= CFG_STATIC_CHANNEL; 4806 else 4807 priv->config &= ~CFG_STATIC_CHANNEL; 4808 4809 priv->channel = channel; 4810 4811 if (!batch_mode) { 4812 err = ipw2100_enable_adapter(priv); 4813 if (err) 4814 return err; 4815 } 4816 4817 return 0; 4818 } 4819 4820 static int ipw2100_system_config(struct ipw2100_priv *priv, int batch_mode) 4821 { 4822 struct host_command cmd = { 4823 .host_command = SYSTEM_CONFIG, 4824 .host_command_sequence = 0, 4825 .host_command_length = 12, 4826 }; 4827 u32 ibss_mask, len = sizeof(u32); 4828 int err; 4829 4830 /* Set system configuration */ 4831 4832 if (!batch_mode) { 4833 err = ipw2100_disable_adapter(priv); 4834 if (err) 4835 return err; 4836 } 4837 4838 if (priv->ieee->iw_mode == IW_MODE_ADHOC) 4839 cmd.host_command_parameters[0] |= IPW_CFG_IBSS_AUTO_START; 4840 4841 cmd.host_command_parameters[0] |= IPW_CFG_IBSS_MASK | 4842 IPW_CFG_BSS_MASK | IPW_CFG_802_1x_ENABLE; 4843 4844 if (!(priv->config & CFG_LONG_PREAMBLE)) 4845 cmd.host_command_parameters[0] |= IPW_CFG_PREAMBLE_AUTO; 4846 4847 err = ipw2100_get_ordinal(priv, 4848 IPW_ORD_EEPROM_IBSS_11B_CHANNELS, 4849 &ibss_mask, &len); 4850 if (err) 4851 ibss_mask = IPW_IBSS_11B_DEFAULT_MASK; 4852 4853 cmd.host_command_parameters[1] = REG_CHANNEL_MASK; 4854 cmd.host_command_parameters[2] = REG_CHANNEL_MASK & ibss_mask; 4855 4856 /* 11b only */ 4857 /*cmd.host_command_parameters[0] |= DIVERSITY_ANTENNA_A; */ 4858 4859 err = ipw2100_hw_send_command(priv, &cmd); 4860 if (err) 4861 return err; 4862 4863 /* If IPv6 is configured in the kernel then we don't want to filter out all 4864 * of the multicast packets as IPv6 needs some. */ 4865 #if !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE) 4866 cmd.host_command = ADD_MULTICAST; 4867 cmd.host_command_sequence = 0; 4868 cmd.host_command_length = 0; 4869 4870 ipw2100_hw_send_command(priv, &cmd); 4871 #endif 4872 if (!batch_mode) { 4873 err = ipw2100_enable_adapter(priv); 4874 if (err) 4875 return err; 4876 } 4877 4878 return 0; 4879 } 4880 4881 static int ipw2100_set_tx_rates(struct ipw2100_priv *priv, u32 rate, 4882 int batch_mode) 4883 { 4884 struct host_command cmd = { 4885 .host_command = BASIC_TX_RATES, 4886 .host_command_sequence = 0, 4887 .host_command_length = 4 4888 }; 4889 int err; 4890 4891 cmd.host_command_parameters[0] = rate & TX_RATE_MASK; 4892 4893 if (!batch_mode) { 4894 err = ipw2100_disable_adapter(priv); 4895 if (err) 4896 return err; 4897 } 4898 4899 /* Set BASIC TX Rate first */ 4900 ipw2100_hw_send_command(priv, &cmd); 4901 4902 /* Set TX Rate */ 4903 cmd.host_command = TX_RATES; 4904 ipw2100_hw_send_command(priv, &cmd); 4905 4906 /* Set MSDU TX Rate */ 4907 cmd.host_command = MSDU_TX_RATES; 4908 ipw2100_hw_send_command(priv, &cmd); 4909 4910 if (!batch_mode) { 4911 err = ipw2100_enable_adapter(priv); 4912 if (err) 4913 return err; 4914 } 4915 4916 priv->tx_rates = rate; 4917 4918 return 0; 4919 } 4920 4921 static int ipw2100_set_power_mode(struct ipw2100_priv *priv, int power_level) 4922 { 4923 struct host_command cmd = { 4924 .host_command = POWER_MODE, 4925 .host_command_sequence = 0, 4926 .host_command_length = 4 4927 }; 4928 int err; 4929 4930 cmd.host_command_parameters[0] = power_level; 4931 4932 err = ipw2100_hw_send_command(priv, &cmd); 4933 if (err) 4934 return err; 4935 4936 if (power_level == IPW_POWER_MODE_CAM) 4937 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode); 4938 else 4939 priv->power_mode = IPW_POWER_ENABLED | power_level; 4940 4941 #ifdef IPW2100_TX_POWER 4942 if (priv->port_type == IBSS && priv->adhoc_power != DFTL_IBSS_TX_POWER) { 4943 /* Set beacon interval */ 4944 cmd.host_command = TX_POWER_INDEX; 4945 cmd.host_command_parameters[0] = (u32) priv->adhoc_power; 4946 4947 err = ipw2100_hw_send_command(priv, &cmd); 4948 if (err) 4949 return err; 4950 } 4951 #endif 4952 4953 return 0; 4954 } 4955 4956 static int ipw2100_set_rts_threshold(struct ipw2100_priv *priv, u32 threshold) 4957 { 4958 struct host_command cmd = { 4959 .host_command = RTS_THRESHOLD, 4960 .host_command_sequence = 0, 4961 .host_command_length = 4 4962 }; 4963 int err; 4964 4965 if (threshold & RTS_DISABLED) 4966 cmd.host_command_parameters[0] = MAX_RTS_THRESHOLD; 4967 else 4968 cmd.host_command_parameters[0] = threshold & ~RTS_DISABLED; 4969 4970 err = ipw2100_hw_send_command(priv, &cmd); 4971 if (err) 4972 return err; 4973 4974 priv->rts_threshold = threshold; 4975 4976 return 0; 4977 } 4978 4979 #if 0 4980 int ipw2100_set_fragmentation_threshold(struct ipw2100_priv *priv, 4981 u32 threshold, int batch_mode) 4982 { 4983 struct host_command cmd = { 4984 .host_command = FRAG_THRESHOLD, 4985 .host_command_sequence = 0, 4986 .host_command_length = 4, 4987 .host_command_parameters[0] = 0, 4988 }; 4989 int err; 4990 4991 if (!batch_mode) { 4992 err = ipw2100_disable_adapter(priv); 4993 if (err) 4994 return err; 4995 } 4996 4997 if (threshold == 0) 4998 threshold = DEFAULT_FRAG_THRESHOLD; 4999 else { 5000 threshold = max(threshold, MIN_FRAG_THRESHOLD); 5001 threshold = min(threshold, MAX_FRAG_THRESHOLD); 5002 } 5003 5004 cmd.host_command_parameters[0] = threshold; 5005 5006 IPW_DEBUG_HC("FRAG_THRESHOLD: %u\n", threshold); 5007 5008 err = ipw2100_hw_send_command(priv, &cmd); 5009 5010 if (!batch_mode) 5011 ipw2100_enable_adapter(priv); 5012 5013 if (!err) 5014 priv->frag_threshold = threshold; 5015 5016 return err; 5017 } 5018 #endif 5019 5020 static int ipw2100_set_short_retry(struct ipw2100_priv *priv, u32 retry) 5021 { 5022 struct host_command cmd = { 5023 .host_command = SHORT_RETRY_LIMIT, 5024 .host_command_sequence = 0, 5025 .host_command_length = 4 5026 }; 5027 int err; 5028 5029 cmd.host_command_parameters[0] = retry; 5030 5031 err = ipw2100_hw_send_command(priv, &cmd); 5032 if (err) 5033 return err; 5034 5035 priv->short_retry_limit = retry; 5036 5037 return 0; 5038 } 5039 5040 static int ipw2100_set_long_retry(struct ipw2100_priv *priv, u32 retry) 5041 { 5042 struct host_command cmd = { 5043 .host_command = LONG_RETRY_LIMIT, 5044 .host_command_sequence = 0, 5045 .host_command_length = 4 5046 }; 5047 int err; 5048 5049 cmd.host_command_parameters[0] = retry; 5050 5051 err = ipw2100_hw_send_command(priv, &cmd); 5052 if (err) 5053 return err; 5054 5055 priv->long_retry_limit = retry; 5056 5057 return 0; 5058 } 5059 5060 static int ipw2100_set_mandatory_bssid(struct ipw2100_priv *priv, u8 * bssid, 5061 int batch_mode) 5062 { 5063 struct host_command cmd = { 5064 .host_command = MANDATORY_BSSID, 5065 .host_command_sequence = 0, 5066 .host_command_length = (bssid == NULL) ? 0 : ETH_ALEN 5067 }; 5068 int err; 5069 5070 #ifdef CONFIG_IPW2100_DEBUG 5071 if (bssid != NULL) 5072 IPW_DEBUG_HC("MANDATORY_BSSID: %pM\n", bssid); 5073 else 5074 IPW_DEBUG_HC("MANDATORY_BSSID: <clear>\n"); 5075 #endif 5076 /* if BSSID is empty then we disable mandatory bssid mode */ 5077 if (bssid != NULL) 5078 memcpy(cmd.host_command_parameters, bssid, ETH_ALEN); 5079 5080 if (!batch_mode) { 5081 err = ipw2100_disable_adapter(priv); 5082 if (err) 5083 return err; 5084 } 5085 5086 err = ipw2100_hw_send_command(priv, &cmd); 5087 5088 if (!batch_mode) 5089 ipw2100_enable_adapter(priv); 5090 5091 return err; 5092 } 5093 5094 static int ipw2100_disassociate_bssid(struct ipw2100_priv *priv) 5095 { 5096 struct host_command cmd = { 5097 .host_command = DISASSOCIATION_BSSID, 5098 .host_command_sequence = 0, 5099 .host_command_length = ETH_ALEN 5100 }; 5101 int err; 5102 5103 IPW_DEBUG_HC("DISASSOCIATION_BSSID\n"); 5104 5105 /* The Firmware currently ignores the BSSID and just disassociates from 5106 * the currently associated AP -- but in the off chance that a future 5107 * firmware does use the BSSID provided here, we go ahead and try and 5108 * set it to the currently associated AP's BSSID */ 5109 memcpy(cmd.host_command_parameters, priv->bssid, ETH_ALEN); 5110 5111 err = ipw2100_hw_send_command(priv, &cmd); 5112 5113 return err; 5114 } 5115 5116 static int ipw2100_set_wpa_ie(struct ipw2100_priv *, 5117 struct ipw2100_wpa_assoc_frame *, int) 5118 __attribute__ ((unused)); 5119 5120 static int ipw2100_set_wpa_ie(struct ipw2100_priv *priv, 5121 struct ipw2100_wpa_assoc_frame *wpa_frame, 5122 int batch_mode) 5123 { 5124 struct host_command cmd = { 5125 .host_command = SET_WPA_IE, 5126 .host_command_sequence = 0, 5127 .host_command_length = sizeof(struct ipw2100_wpa_assoc_frame), 5128 }; 5129 int err; 5130 5131 IPW_DEBUG_HC("SET_WPA_IE\n"); 5132 5133 if (!batch_mode) { 5134 err = ipw2100_disable_adapter(priv); 5135 if (err) 5136 return err; 5137 } 5138 5139 memcpy(cmd.host_command_parameters, wpa_frame, 5140 sizeof(struct ipw2100_wpa_assoc_frame)); 5141 5142 err = ipw2100_hw_send_command(priv, &cmd); 5143 5144 if (!batch_mode) { 5145 if (ipw2100_enable_adapter(priv)) 5146 err = -EIO; 5147 } 5148 5149 return err; 5150 } 5151 5152 struct security_info_params { 5153 u32 allowed_ciphers; 5154 u16 version; 5155 u8 auth_mode; 5156 u8 replay_counters_number; 5157 u8 unicast_using_group; 5158 } __packed; 5159 5160 static int ipw2100_set_security_information(struct ipw2100_priv *priv, 5161 int auth_mode, 5162 int security_level, 5163 int unicast_using_group, 5164 int batch_mode) 5165 { 5166 struct host_command cmd = { 5167 .host_command = SET_SECURITY_INFORMATION, 5168 .host_command_sequence = 0, 5169 .host_command_length = sizeof(struct security_info_params) 5170 }; 5171 struct security_info_params *security = 5172 (struct security_info_params *)&cmd.host_command_parameters; 5173 int err; 5174 memset(security, 0, sizeof(*security)); 5175 5176 /* If shared key AP authentication is turned on, then we need to 5177 * configure the firmware to try and use it. 5178 * 5179 * Actual data encryption/decryption is handled by the host. */ 5180 security->auth_mode = auth_mode; 5181 security->unicast_using_group = unicast_using_group; 5182 5183 switch (security_level) { 5184 default: 5185 case SEC_LEVEL_0: 5186 security->allowed_ciphers = IPW_NONE_CIPHER; 5187 break; 5188 case SEC_LEVEL_1: 5189 security->allowed_ciphers = IPW_WEP40_CIPHER | 5190 IPW_WEP104_CIPHER; 5191 break; 5192 case SEC_LEVEL_2: 5193 security->allowed_ciphers = IPW_WEP40_CIPHER | 5194 IPW_WEP104_CIPHER | IPW_TKIP_CIPHER; 5195 break; 5196 case SEC_LEVEL_2_CKIP: 5197 security->allowed_ciphers = IPW_WEP40_CIPHER | 5198 IPW_WEP104_CIPHER | IPW_CKIP_CIPHER; 5199 break; 5200 case SEC_LEVEL_3: 5201 security->allowed_ciphers = IPW_WEP40_CIPHER | 5202 IPW_WEP104_CIPHER | IPW_TKIP_CIPHER | IPW_CCMP_CIPHER; 5203 break; 5204 } 5205 5206 IPW_DEBUG_HC 5207 ("SET_SECURITY_INFORMATION: auth:%d cipher:0x%02X (level %d)\n", 5208 security->auth_mode, security->allowed_ciphers, security_level); 5209 5210 security->replay_counters_number = 0; 5211 5212 if (!batch_mode) { 5213 err = ipw2100_disable_adapter(priv); 5214 if (err) 5215 return err; 5216 } 5217 5218 err = ipw2100_hw_send_command(priv, &cmd); 5219 5220 if (!batch_mode) 5221 ipw2100_enable_adapter(priv); 5222 5223 return err; 5224 } 5225 5226 static int ipw2100_set_tx_power(struct ipw2100_priv *priv, u32 tx_power) 5227 { 5228 struct host_command cmd = { 5229 .host_command = TX_POWER_INDEX, 5230 .host_command_sequence = 0, 5231 .host_command_length = 4 5232 }; 5233 int err = 0; 5234 u32 tmp = tx_power; 5235 5236 if (tx_power != IPW_TX_POWER_DEFAULT) 5237 tmp = (tx_power - IPW_TX_POWER_MIN_DBM) * 16 / 5238 (IPW_TX_POWER_MAX_DBM - IPW_TX_POWER_MIN_DBM); 5239 5240 cmd.host_command_parameters[0] = tmp; 5241 5242 if (priv->ieee->iw_mode == IW_MODE_ADHOC) 5243 err = ipw2100_hw_send_command(priv, &cmd); 5244 if (!err) 5245 priv->tx_power = tx_power; 5246 5247 return 0; 5248 } 5249 5250 static int ipw2100_set_ibss_beacon_interval(struct ipw2100_priv *priv, 5251 u32 interval, int batch_mode) 5252 { 5253 struct host_command cmd = { 5254 .host_command = BEACON_INTERVAL, 5255 .host_command_sequence = 0, 5256 .host_command_length = 4 5257 }; 5258 int err; 5259 5260 cmd.host_command_parameters[0] = interval; 5261 5262 IPW_DEBUG_INFO("enter\n"); 5263 5264 if (priv->ieee->iw_mode == IW_MODE_ADHOC) { 5265 if (!batch_mode) { 5266 err = ipw2100_disable_adapter(priv); 5267 if (err) 5268 return err; 5269 } 5270 5271 ipw2100_hw_send_command(priv, &cmd); 5272 5273 if (!batch_mode) { 5274 err = ipw2100_enable_adapter(priv); 5275 if (err) 5276 return err; 5277 } 5278 } 5279 5280 IPW_DEBUG_INFO("exit\n"); 5281 5282 return 0; 5283 } 5284 5285 static void ipw2100_queues_initialize(struct ipw2100_priv *priv) 5286 { 5287 ipw2100_tx_initialize(priv); 5288 ipw2100_rx_initialize(priv); 5289 ipw2100_msg_initialize(priv); 5290 } 5291 5292 static void ipw2100_queues_free(struct ipw2100_priv *priv) 5293 { 5294 ipw2100_tx_free(priv); 5295 ipw2100_rx_free(priv); 5296 ipw2100_msg_free(priv); 5297 } 5298 5299 static int ipw2100_queues_allocate(struct ipw2100_priv *priv) 5300 { 5301 if (ipw2100_tx_allocate(priv) || 5302 ipw2100_rx_allocate(priv) || ipw2100_msg_allocate(priv)) 5303 goto fail; 5304 5305 return 0; 5306 5307 fail: 5308 ipw2100_tx_free(priv); 5309 ipw2100_rx_free(priv); 5310 ipw2100_msg_free(priv); 5311 return -ENOMEM; 5312 } 5313 5314 #define IPW_PRIVACY_CAPABLE 0x0008 5315 5316 static int ipw2100_set_wep_flags(struct ipw2100_priv *priv, u32 flags, 5317 int batch_mode) 5318 { 5319 struct host_command cmd = { 5320 .host_command = WEP_FLAGS, 5321 .host_command_sequence = 0, 5322 .host_command_length = 4 5323 }; 5324 int err; 5325 5326 cmd.host_command_parameters[0] = flags; 5327 5328 IPW_DEBUG_HC("WEP_FLAGS: flags = 0x%08X\n", flags); 5329 5330 if (!batch_mode) { 5331 err = ipw2100_disable_adapter(priv); 5332 if (err) { 5333 printk(KERN_ERR DRV_NAME 5334 ": %s: Could not disable adapter %d\n", 5335 priv->net_dev->name, err); 5336 return err; 5337 } 5338 } 5339 5340 /* send cmd to firmware */ 5341 err = ipw2100_hw_send_command(priv, &cmd); 5342 5343 if (!batch_mode) 5344 ipw2100_enable_adapter(priv); 5345 5346 return err; 5347 } 5348 5349 struct ipw2100_wep_key { 5350 u8 idx; 5351 u8 len; 5352 u8 key[13]; 5353 }; 5354 5355 /* Macros to ease up priting WEP keys */ 5356 #define WEP_FMT_64 "%02X%02X%02X%02X-%02X" 5357 #define WEP_FMT_128 "%02X%02X%02X%02X-%02X%02X%02X%02X-%02X%02X%02X" 5358 #define WEP_STR_64(x) x[0],x[1],x[2],x[3],x[4] 5359 #define WEP_STR_128(x) x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],x[8],x[9],x[10] 5360 5361 /** 5362 * Set a the wep key 5363 * 5364 * @priv: struct to work on 5365 * @idx: index of the key we want to set 5366 * @key: ptr to the key data to set 5367 * @len: length of the buffer at @key 5368 * @batch_mode: FIXME perform the operation in batch mode, not 5369 * disabling the device. 5370 * 5371 * @returns 0 if OK, < 0 errno code on error. 5372 * 5373 * Fill out a command structure with the new wep key, length an 5374 * index and send it down the wire. 5375 */ 5376 static int ipw2100_set_key(struct ipw2100_priv *priv, 5377 int idx, char *key, int len, int batch_mode) 5378 { 5379 int keylen = len ? (len <= 5 ? 5 : 13) : 0; 5380 struct host_command cmd = { 5381 .host_command = WEP_KEY_INFO, 5382 .host_command_sequence = 0, 5383 .host_command_length = sizeof(struct ipw2100_wep_key), 5384 }; 5385 struct ipw2100_wep_key *wep_key = (void *)cmd.host_command_parameters; 5386 int err; 5387 5388 IPW_DEBUG_HC("WEP_KEY_INFO: index = %d, len = %d/%d\n", 5389 idx, keylen, len); 5390 5391 /* NOTE: We don't check cached values in case the firmware was reset 5392 * or some other problem is occurring. If the user is setting the key, 5393 * then we push the change */ 5394 5395 wep_key->idx = idx; 5396 wep_key->len = keylen; 5397 5398 if (keylen) { 5399 memcpy(wep_key->key, key, len); 5400 memset(wep_key->key + len, 0, keylen - len); 5401 } 5402 5403 /* Will be optimized out on debug not being configured in */ 5404 if (keylen == 0) 5405 IPW_DEBUG_WEP("%s: Clearing key %d\n", 5406 priv->net_dev->name, wep_key->idx); 5407 else if (keylen == 5) 5408 IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_64 "\n", 5409 priv->net_dev->name, wep_key->idx, wep_key->len, 5410 WEP_STR_64(wep_key->key)); 5411 else 5412 IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_128 5413 "\n", 5414 priv->net_dev->name, wep_key->idx, wep_key->len, 5415 WEP_STR_128(wep_key->key)); 5416 5417 if (!batch_mode) { 5418 err = ipw2100_disable_adapter(priv); 5419 /* FIXME: IPG: shouldn't this prink be in _disable_adapter()? */ 5420 if (err) { 5421 printk(KERN_ERR DRV_NAME 5422 ": %s: Could not disable adapter %d\n", 5423 priv->net_dev->name, err); 5424 return err; 5425 } 5426 } 5427 5428 /* send cmd to firmware */ 5429 err = ipw2100_hw_send_command(priv, &cmd); 5430 5431 if (!batch_mode) { 5432 int err2 = ipw2100_enable_adapter(priv); 5433 if (err == 0) 5434 err = err2; 5435 } 5436 return err; 5437 } 5438 5439 static int ipw2100_set_key_index(struct ipw2100_priv *priv, 5440 int idx, int batch_mode) 5441 { 5442 struct host_command cmd = { 5443 .host_command = WEP_KEY_INDEX, 5444 .host_command_sequence = 0, 5445 .host_command_length = 4, 5446 .host_command_parameters = {idx}, 5447 }; 5448 int err; 5449 5450 IPW_DEBUG_HC("WEP_KEY_INDEX: index = %d\n", idx); 5451 5452 if (idx < 0 || idx > 3) 5453 return -EINVAL; 5454 5455 if (!batch_mode) { 5456 err = ipw2100_disable_adapter(priv); 5457 if (err) { 5458 printk(KERN_ERR DRV_NAME 5459 ": %s: Could not disable adapter %d\n", 5460 priv->net_dev->name, err); 5461 return err; 5462 } 5463 } 5464 5465 /* send cmd to firmware */ 5466 err = ipw2100_hw_send_command(priv, &cmd); 5467 5468 if (!batch_mode) 5469 ipw2100_enable_adapter(priv); 5470 5471 return err; 5472 } 5473 5474 static int ipw2100_configure_security(struct ipw2100_priv *priv, int batch_mode) 5475 { 5476 int i, err, auth_mode, sec_level, use_group; 5477 5478 if (!(priv->status & STATUS_RUNNING)) 5479 return 0; 5480 5481 if (!batch_mode) { 5482 err = ipw2100_disable_adapter(priv); 5483 if (err) 5484 return err; 5485 } 5486 5487 if (!priv->ieee->sec.enabled) { 5488 err = 5489 ipw2100_set_security_information(priv, IPW_AUTH_OPEN, 5490 SEC_LEVEL_0, 0, 1); 5491 } else { 5492 auth_mode = IPW_AUTH_OPEN; 5493 if (priv->ieee->sec.flags & SEC_AUTH_MODE) { 5494 if (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY) 5495 auth_mode = IPW_AUTH_SHARED; 5496 else if (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP) 5497 auth_mode = IPW_AUTH_LEAP_CISCO_ID; 5498 } 5499 5500 sec_level = SEC_LEVEL_0; 5501 if (priv->ieee->sec.flags & SEC_LEVEL) 5502 sec_level = priv->ieee->sec.level; 5503 5504 use_group = 0; 5505 if (priv->ieee->sec.flags & SEC_UNICAST_GROUP) 5506 use_group = priv->ieee->sec.unicast_uses_group; 5507 5508 err = 5509 ipw2100_set_security_information(priv, auth_mode, sec_level, 5510 use_group, 1); 5511 } 5512 5513 if (err) 5514 goto exit; 5515 5516 if (priv->ieee->sec.enabled) { 5517 for (i = 0; i < 4; i++) { 5518 if (!(priv->ieee->sec.flags & (1 << i))) { 5519 memset(priv->ieee->sec.keys[i], 0, WEP_KEY_LEN); 5520 priv->ieee->sec.key_sizes[i] = 0; 5521 } else { 5522 err = ipw2100_set_key(priv, i, 5523 priv->ieee->sec.keys[i], 5524 priv->ieee->sec. 5525 key_sizes[i], 1); 5526 if (err) 5527 goto exit; 5528 } 5529 } 5530 5531 ipw2100_set_key_index(priv, priv->ieee->crypt_info.tx_keyidx, 1); 5532 } 5533 5534 /* Always enable privacy so the Host can filter WEP packets if 5535 * encrypted data is sent up */ 5536 err = 5537 ipw2100_set_wep_flags(priv, 5538 priv->ieee->sec. 5539 enabled ? IPW_PRIVACY_CAPABLE : 0, 1); 5540 if (err) 5541 goto exit; 5542 5543 priv->status &= ~STATUS_SECURITY_UPDATED; 5544 5545 exit: 5546 if (!batch_mode) 5547 ipw2100_enable_adapter(priv); 5548 5549 return err; 5550 } 5551 5552 static void ipw2100_security_work(struct work_struct *work) 5553 { 5554 struct ipw2100_priv *priv = 5555 container_of(work, struct ipw2100_priv, security_work.work); 5556 5557 /* If we happen to have reconnected before we get a chance to 5558 * process this, then update the security settings--which causes 5559 * a disassociation to occur */ 5560 if (!(priv->status & STATUS_ASSOCIATED) && 5561 priv->status & STATUS_SECURITY_UPDATED) 5562 ipw2100_configure_security(priv, 0); 5563 } 5564 5565 static void shim__set_security(struct net_device *dev, 5566 struct libipw_security *sec) 5567 { 5568 struct ipw2100_priv *priv = libipw_priv(dev); 5569 int i; 5570 5571 mutex_lock(&priv->action_mutex); 5572 if (!(priv->status & STATUS_INITIALIZED)) 5573 goto done; 5574 5575 for (i = 0; i < 4; i++) { 5576 if (sec->flags & (1 << i)) { 5577 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i]; 5578 if (sec->key_sizes[i] == 0) 5579 priv->ieee->sec.flags &= ~(1 << i); 5580 else 5581 memcpy(priv->ieee->sec.keys[i], sec->keys[i], 5582 sec->key_sizes[i]); 5583 if (sec->level == SEC_LEVEL_1) { 5584 priv->ieee->sec.flags |= (1 << i); 5585 priv->status |= STATUS_SECURITY_UPDATED; 5586 } else 5587 priv->ieee->sec.flags &= ~(1 << i); 5588 } 5589 } 5590 5591 if ((sec->flags & SEC_ACTIVE_KEY) && 5592 priv->ieee->sec.active_key != sec->active_key) { 5593 priv->ieee->sec.active_key = sec->active_key; 5594 priv->ieee->sec.flags |= SEC_ACTIVE_KEY; 5595 priv->status |= STATUS_SECURITY_UPDATED; 5596 } 5597 5598 if ((sec->flags & SEC_AUTH_MODE) && 5599 (priv->ieee->sec.auth_mode != sec->auth_mode)) { 5600 priv->ieee->sec.auth_mode = sec->auth_mode; 5601 priv->ieee->sec.flags |= SEC_AUTH_MODE; 5602 priv->status |= STATUS_SECURITY_UPDATED; 5603 } 5604 5605 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) { 5606 priv->ieee->sec.flags |= SEC_ENABLED; 5607 priv->ieee->sec.enabled = sec->enabled; 5608 priv->status |= STATUS_SECURITY_UPDATED; 5609 } 5610 5611 if (sec->flags & SEC_ENCRYPT) 5612 priv->ieee->sec.encrypt = sec->encrypt; 5613 5614 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) { 5615 priv->ieee->sec.level = sec->level; 5616 priv->ieee->sec.flags |= SEC_LEVEL; 5617 priv->status |= STATUS_SECURITY_UPDATED; 5618 } 5619 5620 IPW_DEBUG_WEP("Security flags: %c %c%c%c%c %c%c%c%c\n", 5621 priv->ieee->sec.flags & (1 << 8) ? '1' : '0', 5622 priv->ieee->sec.flags & (1 << 7) ? '1' : '0', 5623 priv->ieee->sec.flags & (1 << 6) ? '1' : '0', 5624 priv->ieee->sec.flags & (1 << 5) ? '1' : '0', 5625 priv->ieee->sec.flags & (1 << 4) ? '1' : '0', 5626 priv->ieee->sec.flags & (1 << 3) ? '1' : '0', 5627 priv->ieee->sec.flags & (1 << 2) ? '1' : '0', 5628 priv->ieee->sec.flags & (1 << 1) ? '1' : '0', 5629 priv->ieee->sec.flags & (1 << 0) ? '1' : '0'); 5630 5631 /* As a temporary work around to enable WPA until we figure out why 5632 * wpa_supplicant toggles the security capability of the driver, which 5633 * forces a disassociation with force_update... 5634 * 5635 * if (force_update || !(priv->status & STATUS_ASSOCIATED))*/ 5636 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING))) 5637 ipw2100_configure_security(priv, 0); 5638 done: 5639 mutex_unlock(&priv->action_mutex); 5640 } 5641 5642 static int ipw2100_adapter_setup(struct ipw2100_priv *priv) 5643 { 5644 int err; 5645 int batch_mode = 1; 5646 u8 *bssid; 5647 5648 IPW_DEBUG_INFO("enter\n"); 5649 5650 err = ipw2100_disable_adapter(priv); 5651 if (err) 5652 return err; 5653 #ifdef CONFIG_IPW2100_MONITOR 5654 if (priv->ieee->iw_mode == IW_MODE_MONITOR) { 5655 err = ipw2100_set_channel(priv, priv->channel, batch_mode); 5656 if (err) 5657 return err; 5658 5659 IPW_DEBUG_INFO("exit\n"); 5660 5661 return 0; 5662 } 5663 #endif /* CONFIG_IPW2100_MONITOR */ 5664 5665 err = ipw2100_read_mac_address(priv); 5666 if (err) 5667 return -EIO; 5668 5669 err = ipw2100_set_mac_address(priv, batch_mode); 5670 if (err) 5671 return err; 5672 5673 err = ipw2100_set_port_type(priv, priv->ieee->iw_mode, batch_mode); 5674 if (err) 5675 return err; 5676 5677 if (priv->ieee->iw_mode == IW_MODE_ADHOC) { 5678 err = ipw2100_set_channel(priv, priv->channel, batch_mode); 5679 if (err) 5680 return err; 5681 } 5682 5683 err = ipw2100_system_config(priv, batch_mode); 5684 if (err) 5685 return err; 5686 5687 err = ipw2100_set_tx_rates(priv, priv->tx_rates, batch_mode); 5688 if (err) 5689 return err; 5690 5691 /* Default to power mode OFF */ 5692 err = ipw2100_set_power_mode(priv, IPW_POWER_MODE_CAM); 5693 if (err) 5694 return err; 5695 5696 err = ipw2100_set_rts_threshold(priv, priv->rts_threshold); 5697 if (err) 5698 return err; 5699 5700 if (priv->config & CFG_STATIC_BSSID) 5701 bssid = priv->bssid; 5702 else 5703 bssid = NULL; 5704 err = ipw2100_set_mandatory_bssid(priv, bssid, batch_mode); 5705 if (err) 5706 return err; 5707 5708 if (priv->config & CFG_STATIC_ESSID) 5709 err = ipw2100_set_essid(priv, priv->essid, priv->essid_len, 5710 batch_mode); 5711 else 5712 err = ipw2100_set_essid(priv, NULL, 0, batch_mode); 5713 if (err) 5714 return err; 5715 5716 err = ipw2100_configure_security(priv, batch_mode); 5717 if (err) 5718 return err; 5719 5720 if (priv->ieee->iw_mode == IW_MODE_ADHOC) { 5721 err = 5722 ipw2100_set_ibss_beacon_interval(priv, 5723 priv->beacon_interval, 5724 batch_mode); 5725 if (err) 5726 return err; 5727 5728 err = ipw2100_set_tx_power(priv, priv->tx_power); 5729 if (err) 5730 return err; 5731 } 5732 5733 /* 5734 err = ipw2100_set_fragmentation_threshold( 5735 priv, priv->frag_threshold, batch_mode); 5736 if (err) 5737 return err; 5738 */ 5739 5740 IPW_DEBUG_INFO("exit\n"); 5741 5742 return 0; 5743 } 5744 5745 /************************************************************************* 5746 * 5747 * EXTERNALLY CALLED METHODS 5748 * 5749 *************************************************************************/ 5750 5751 /* This method is called by the network layer -- not to be confused with 5752 * ipw2100_set_mac_address() declared above called by this driver (and this 5753 * method as well) to talk to the firmware */ 5754 static int ipw2100_set_address(struct net_device *dev, void *p) 5755 { 5756 struct ipw2100_priv *priv = libipw_priv(dev); 5757 struct sockaddr *addr = p; 5758 int err = 0; 5759 5760 if (!is_valid_ether_addr(addr->sa_data)) 5761 return -EADDRNOTAVAIL; 5762 5763 mutex_lock(&priv->action_mutex); 5764 5765 priv->config |= CFG_CUSTOM_MAC; 5766 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN); 5767 5768 err = ipw2100_set_mac_address(priv, 0); 5769 if (err) 5770 goto done; 5771 5772 priv->reset_backoff = 0; 5773 mutex_unlock(&priv->action_mutex); 5774 ipw2100_reset_adapter(&priv->reset_work.work); 5775 return 0; 5776 5777 done: 5778 mutex_unlock(&priv->action_mutex); 5779 return err; 5780 } 5781 5782 static int ipw2100_open(struct net_device *dev) 5783 { 5784 struct ipw2100_priv *priv = libipw_priv(dev); 5785 unsigned long flags; 5786 IPW_DEBUG_INFO("dev->open\n"); 5787 5788 spin_lock_irqsave(&priv->low_lock, flags); 5789 if (priv->status & STATUS_ASSOCIATED) { 5790 netif_carrier_on(dev); 5791 netif_start_queue(dev); 5792 } 5793 spin_unlock_irqrestore(&priv->low_lock, flags); 5794 5795 return 0; 5796 } 5797 5798 static int ipw2100_close(struct net_device *dev) 5799 { 5800 struct ipw2100_priv *priv = libipw_priv(dev); 5801 unsigned long flags; 5802 struct list_head *element; 5803 struct ipw2100_tx_packet *packet; 5804 5805 IPW_DEBUG_INFO("enter\n"); 5806 5807 spin_lock_irqsave(&priv->low_lock, flags); 5808 5809 if (priv->status & STATUS_ASSOCIATED) 5810 netif_carrier_off(dev); 5811 netif_stop_queue(dev); 5812 5813 /* Flush the TX queue ... */ 5814 while (!list_empty(&priv->tx_pend_list)) { 5815 element = priv->tx_pend_list.next; 5816 packet = list_entry(element, struct ipw2100_tx_packet, list); 5817 5818 list_del(element); 5819 DEC_STAT(&priv->tx_pend_stat); 5820 5821 libipw_txb_free(packet->info.d_struct.txb); 5822 packet->info.d_struct.txb = NULL; 5823 5824 list_add_tail(element, &priv->tx_free_list); 5825 INC_STAT(&priv->tx_free_stat); 5826 } 5827 spin_unlock_irqrestore(&priv->low_lock, flags); 5828 5829 IPW_DEBUG_INFO("exit\n"); 5830 5831 return 0; 5832 } 5833 5834 /* 5835 * TODO: Fix this function... its just wrong 5836 */ 5837 static void ipw2100_tx_timeout(struct net_device *dev, unsigned int txqueue) 5838 { 5839 struct ipw2100_priv *priv = libipw_priv(dev); 5840 5841 dev->stats.tx_errors++; 5842 5843 #ifdef CONFIG_IPW2100_MONITOR 5844 if (priv->ieee->iw_mode == IW_MODE_MONITOR) 5845 return; 5846 #endif 5847 5848 IPW_DEBUG_INFO("%s: TX timed out. Scheduling firmware restart.\n", 5849 dev->name); 5850 schedule_reset(priv); 5851 } 5852 5853 static int ipw2100_wpa_enable(struct ipw2100_priv *priv, int value) 5854 { 5855 /* This is called when wpa_supplicant loads and closes the driver 5856 * interface. */ 5857 priv->ieee->wpa_enabled = value; 5858 return 0; 5859 } 5860 5861 static int ipw2100_wpa_set_auth_algs(struct ipw2100_priv *priv, int value) 5862 { 5863 5864 struct libipw_device *ieee = priv->ieee; 5865 struct libipw_security sec = { 5866 .flags = SEC_AUTH_MODE, 5867 }; 5868 int ret = 0; 5869 5870 if (value & IW_AUTH_ALG_SHARED_KEY) { 5871 sec.auth_mode = WLAN_AUTH_SHARED_KEY; 5872 ieee->open_wep = 0; 5873 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) { 5874 sec.auth_mode = WLAN_AUTH_OPEN; 5875 ieee->open_wep = 1; 5876 } else if (value & IW_AUTH_ALG_LEAP) { 5877 sec.auth_mode = WLAN_AUTH_LEAP; 5878 ieee->open_wep = 1; 5879 } else 5880 return -EINVAL; 5881 5882 if (ieee->set_security) 5883 ieee->set_security(ieee->dev, &sec); 5884 else 5885 ret = -EOPNOTSUPP; 5886 5887 return ret; 5888 } 5889 5890 static void ipw2100_wpa_assoc_frame(struct ipw2100_priv *priv, 5891 char *wpa_ie, int wpa_ie_len) 5892 { 5893 5894 struct ipw2100_wpa_assoc_frame frame; 5895 5896 frame.fixed_ie_mask = 0; 5897 5898 /* copy WPA IE */ 5899 memcpy(frame.var_ie, wpa_ie, wpa_ie_len); 5900 frame.var_ie_len = wpa_ie_len; 5901 5902 /* make sure WPA is enabled */ 5903 ipw2100_wpa_enable(priv, 1); 5904 ipw2100_set_wpa_ie(priv, &frame, 0); 5905 } 5906 5907 static void ipw_ethtool_get_drvinfo(struct net_device *dev, 5908 struct ethtool_drvinfo *info) 5909 { 5910 struct ipw2100_priv *priv = libipw_priv(dev); 5911 char fw_ver[64], ucode_ver[64]; 5912 5913 strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 5914 strlcpy(info->version, DRV_VERSION, sizeof(info->version)); 5915 5916 ipw2100_get_fwversion(priv, fw_ver, sizeof(fw_ver)); 5917 ipw2100_get_ucodeversion(priv, ucode_ver, sizeof(ucode_ver)); 5918 5919 snprintf(info->fw_version, sizeof(info->fw_version), "%s:%d:%s", 5920 fw_ver, priv->eeprom_version, ucode_ver); 5921 5922 strlcpy(info->bus_info, pci_name(priv->pci_dev), 5923 sizeof(info->bus_info)); 5924 } 5925 5926 static u32 ipw2100_ethtool_get_link(struct net_device *dev) 5927 { 5928 struct ipw2100_priv *priv = libipw_priv(dev); 5929 return (priv->status & STATUS_ASSOCIATED) ? 1 : 0; 5930 } 5931 5932 static const struct ethtool_ops ipw2100_ethtool_ops = { 5933 .get_link = ipw2100_ethtool_get_link, 5934 .get_drvinfo = ipw_ethtool_get_drvinfo, 5935 }; 5936 5937 static void ipw2100_hang_check(struct work_struct *work) 5938 { 5939 struct ipw2100_priv *priv = 5940 container_of(work, struct ipw2100_priv, hang_check.work); 5941 unsigned long flags; 5942 u32 rtc = 0xa5a5a5a5; 5943 u32 len = sizeof(rtc); 5944 int restart = 0; 5945 5946 spin_lock_irqsave(&priv->low_lock, flags); 5947 5948 if (priv->fatal_error != 0) { 5949 /* If fatal_error is set then we need to restart */ 5950 IPW_DEBUG_INFO("%s: Hardware fatal error detected.\n", 5951 priv->net_dev->name); 5952 5953 restart = 1; 5954 } else if (ipw2100_get_ordinal(priv, IPW_ORD_RTC_TIME, &rtc, &len) || 5955 (rtc == priv->last_rtc)) { 5956 /* Check if firmware is hung */ 5957 IPW_DEBUG_INFO("%s: Firmware RTC stalled.\n", 5958 priv->net_dev->name); 5959 5960 restart = 1; 5961 } 5962 5963 if (restart) { 5964 /* Kill timer */ 5965 priv->stop_hang_check = 1; 5966 priv->hangs++; 5967 5968 /* Restart the NIC */ 5969 schedule_reset(priv); 5970 } 5971 5972 priv->last_rtc = rtc; 5973 5974 if (!priv->stop_hang_check) 5975 schedule_delayed_work(&priv->hang_check, HZ / 2); 5976 5977 spin_unlock_irqrestore(&priv->low_lock, flags); 5978 } 5979 5980 static void ipw2100_rf_kill(struct work_struct *work) 5981 { 5982 struct ipw2100_priv *priv = 5983 container_of(work, struct ipw2100_priv, rf_kill.work); 5984 unsigned long flags; 5985 5986 spin_lock_irqsave(&priv->low_lock, flags); 5987 5988 if (rf_kill_active(priv)) { 5989 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n"); 5990 if (!priv->stop_rf_kill) 5991 schedule_delayed_work(&priv->rf_kill, 5992 round_jiffies_relative(HZ)); 5993 goto exit_unlock; 5994 } 5995 5996 /* RF Kill is now disabled, so bring the device back up */ 5997 5998 if (!(priv->status & STATUS_RF_KILL_MASK)) { 5999 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting " 6000 "device\n"); 6001 schedule_reset(priv); 6002 } else 6003 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still " 6004 "enabled\n"); 6005 6006 exit_unlock: 6007 spin_unlock_irqrestore(&priv->low_lock, flags); 6008 } 6009 6010 static void ipw2100_irq_tasklet(unsigned long data); 6011 6012 static const struct net_device_ops ipw2100_netdev_ops = { 6013 .ndo_open = ipw2100_open, 6014 .ndo_stop = ipw2100_close, 6015 .ndo_start_xmit = libipw_xmit, 6016 .ndo_tx_timeout = ipw2100_tx_timeout, 6017 .ndo_set_mac_address = ipw2100_set_address, 6018 .ndo_validate_addr = eth_validate_addr, 6019 }; 6020 6021 /* Look into using netdev destructor to shutdown libipw? */ 6022 6023 static struct net_device *ipw2100_alloc_device(struct pci_dev *pci_dev, 6024 void __iomem * ioaddr) 6025 { 6026 struct ipw2100_priv *priv; 6027 struct net_device *dev; 6028 6029 dev = alloc_libipw(sizeof(struct ipw2100_priv), 0); 6030 if (!dev) 6031 return NULL; 6032 priv = libipw_priv(dev); 6033 priv->ieee = netdev_priv(dev); 6034 priv->pci_dev = pci_dev; 6035 priv->net_dev = dev; 6036 priv->ioaddr = ioaddr; 6037 6038 priv->ieee->hard_start_xmit = ipw2100_tx; 6039 priv->ieee->set_security = shim__set_security; 6040 6041 priv->ieee->perfect_rssi = -20; 6042 priv->ieee->worst_rssi = -85; 6043 6044 dev->netdev_ops = &ipw2100_netdev_ops; 6045 dev->ethtool_ops = &ipw2100_ethtool_ops; 6046 dev->wireless_handlers = &ipw2100_wx_handler_def; 6047 priv->wireless_data.libipw = priv->ieee; 6048 dev->wireless_data = &priv->wireless_data; 6049 dev->watchdog_timeo = 3 * HZ; 6050 dev->irq = 0; 6051 dev->min_mtu = 68; 6052 dev->max_mtu = LIBIPW_DATA_LEN; 6053 6054 /* NOTE: We don't use the wireless_handlers hook 6055 * in dev as the system will start throwing WX requests 6056 * to us before we're actually initialized and it just 6057 * ends up causing problems. So, we just handle 6058 * the WX extensions through the ipw2100_ioctl interface */ 6059 6060 /* memset() puts everything to 0, so we only have explicitly set 6061 * those values that need to be something else */ 6062 6063 /* If power management is turned on, default to AUTO mode */ 6064 priv->power_mode = IPW_POWER_AUTO; 6065 6066 #ifdef CONFIG_IPW2100_MONITOR 6067 priv->config |= CFG_CRC_CHECK; 6068 #endif 6069 priv->ieee->wpa_enabled = 0; 6070 priv->ieee->drop_unencrypted = 0; 6071 priv->ieee->privacy_invoked = 0; 6072 priv->ieee->ieee802_1x = 1; 6073 6074 /* Set module parameters */ 6075 switch (network_mode) { 6076 case 1: 6077 priv->ieee->iw_mode = IW_MODE_ADHOC; 6078 break; 6079 #ifdef CONFIG_IPW2100_MONITOR 6080 case 2: 6081 priv->ieee->iw_mode = IW_MODE_MONITOR; 6082 break; 6083 #endif 6084 default: 6085 case 0: 6086 priv->ieee->iw_mode = IW_MODE_INFRA; 6087 break; 6088 } 6089 6090 if (disable == 1) 6091 priv->status |= STATUS_RF_KILL_SW; 6092 6093 if (channel != 0 && 6094 ((channel >= REG_MIN_CHANNEL) && (channel <= REG_MAX_CHANNEL))) { 6095 priv->config |= CFG_STATIC_CHANNEL; 6096 priv->channel = channel; 6097 } 6098 6099 if (associate) 6100 priv->config |= CFG_ASSOCIATE; 6101 6102 priv->beacon_interval = DEFAULT_BEACON_INTERVAL; 6103 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT; 6104 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT; 6105 priv->rts_threshold = DEFAULT_RTS_THRESHOLD | RTS_DISABLED; 6106 priv->frag_threshold = DEFAULT_FTS | FRAG_DISABLED; 6107 priv->tx_power = IPW_TX_POWER_DEFAULT; 6108 priv->tx_rates = DEFAULT_TX_RATES; 6109 6110 strcpy(priv->nick, "ipw2100"); 6111 6112 spin_lock_init(&priv->low_lock); 6113 mutex_init(&priv->action_mutex); 6114 mutex_init(&priv->adapter_mutex); 6115 6116 init_waitqueue_head(&priv->wait_command_queue); 6117 6118 netif_carrier_off(dev); 6119 6120 INIT_LIST_HEAD(&priv->msg_free_list); 6121 INIT_LIST_HEAD(&priv->msg_pend_list); 6122 INIT_STAT(&priv->msg_free_stat); 6123 INIT_STAT(&priv->msg_pend_stat); 6124 6125 INIT_LIST_HEAD(&priv->tx_free_list); 6126 INIT_LIST_HEAD(&priv->tx_pend_list); 6127 INIT_STAT(&priv->tx_free_stat); 6128 INIT_STAT(&priv->tx_pend_stat); 6129 6130 INIT_LIST_HEAD(&priv->fw_pend_list); 6131 INIT_STAT(&priv->fw_pend_stat); 6132 6133 INIT_DELAYED_WORK(&priv->reset_work, ipw2100_reset_adapter); 6134 INIT_DELAYED_WORK(&priv->security_work, ipw2100_security_work); 6135 INIT_DELAYED_WORK(&priv->wx_event_work, ipw2100_wx_event_work); 6136 INIT_DELAYED_WORK(&priv->hang_check, ipw2100_hang_check); 6137 INIT_DELAYED_WORK(&priv->rf_kill, ipw2100_rf_kill); 6138 INIT_DELAYED_WORK(&priv->scan_event, ipw2100_scan_event); 6139 6140 tasklet_init(&priv->irq_tasklet, 6141 ipw2100_irq_tasklet, (unsigned long)priv); 6142 6143 /* NOTE: We do not start the deferred work for status checks yet */ 6144 priv->stop_rf_kill = 1; 6145 priv->stop_hang_check = 1; 6146 6147 return dev; 6148 } 6149 6150 static int ipw2100_pci_init_one(struct pci_dev *pci_dev, 6151 const struct pci_device_id *ent) 6152 { 6153 void __iomem *ioaddr; 6154 struct net_device *dev = NULL; 6155 struct ipw2100_priv *priv = NULL; 6156 int err = 0; 6157 int registered = 0; 6158 u32 val; 6159 6160 IPW_DEBUG_INFO("enter\n"); 6161 6162 if (!(pci_resource_flags(pci_dev, 0) & IORESOURCE_MEM)) { 6163 IPW_DEBUG_INFO("weird - resource type is not memory\n"); 6164 err = -ENODEV; 6165 goto out; 6166 } 6167 6168 ioaddr = pci_iomap(pci_dev, 0, 0); 6169 if (!ioaddr) { 6170 printk(KERN_WARNING DRV_NAME 6171 "Error calling ioremap.\n"); 6172 err = -EIO; 6173 goto fail; 6174 } 6175 6176 /* allocate and initialize our net_device */ 6177 dev = ipw2100_alloc_device(pci_dev, ioaddr); 6178 if (!dev) { 6179 printk(KERN_WARNING DRV_NAME 6180 "Error calling ipw2100_alloc_device.\n"); 6181 err = -ENOMEM; 6182 goto fail; 6183 } 6184 6185 /* set up PCI mappings for device */ 6186 err = pci_enable_device(pci_dev); 6187 if (err) { 6188 printk(KERN_WARNING DRV_NAME 6189 "Error calling pci_enable_device.\n"); 6190 return err; 6191 } 6192 6193 priv = libipw_priv(dev); 6194 6195 pci_set_master(pci_dev); 6196 pci_set_drvdata(pci_dev, priv); 6197 6198 err = pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32)); 6199 if (err) { 6200 printk(KERN_WARNING DRV_NAME 6201 "Error calling pci_set_dma_mask.\n"); 6202 pci_disable_device(pci_dev); 6203 return err; 6204 } 6205 6206 err = pci_request_regions(pci_dev, DRV_NAME); 6207 if (err) { 6208 printk(KERN_WARNING DRV_NAME 6209 "Error calling pci_request_regions.\n"); 6210 pci_disable_device(pci_dev); 6211 return err; 6212 } 6213 6214 /* We disable the RETRY_TIMEOUT register (0x41) to keep 6215 * PCI Tx retries from interfering with C3 CPU state */ 6216 pci_read_config_dword(pci_dev, 0x40, &val); 6217 if ((val & 0x0000ff00) != 0) 6218 pci_write_config_dword(pci_dev, 0x40, val & 0xffff00ff); 6219 6220 if (!ipw2100_hw_is_adapter_in_system(dev)) { 6221 printk(KERN_WARNING DRV_NAME 6222 "Device not found via register read.\n"); 6223 err = -ENODEV; 6224 goto fail; 6225 } 6226 6227 SET_NETDEV_DEV(dev, &pci_dev->dev); 6228 6229 /* Force interrupts to be shut off on the device */ 6230 priv->status |= STATUS_INT_ENABLED; 6231 ipw2100_disable_interrupts(priv); 6232 6233 /* Allocate and initialize the Tx/Rx queues and lists */ 6234 if (ipw2100_queues_allocate(priv)) { 6235 printk(KERN_WARNING DRV_NAME 6236 "Error calling ipw2100_queues_allocate.\n"); 6237 err = -ENOMEM; 6238 goto fail; 6239 } 6240 ipw2100_queues_initialize(priv); 6241 6242 err = request_irq(pci_dev->irq, 6243 ipw2100_interrupt, IRQF_SHARED, dev->name, priv); 6244 if (err) { 6245 printk(KERN_WARNING DRV_NAME 6246 "Error calling request_irq: %d.\n", pci_dev->irq); 6247 goto fail; 6248 } 6249 dev->irq = pci_dev->irq; 6250 6251 IPW_DEBUG_INFO("Attempting to register device...\n"); 6252 6253 printk(KERN_INFO DRV_NAME 6254 ": Detected Intel PRO/Wireless 2100 Network Connection\n"); 6255 6256 err = ipw2100_up(priv, 1); 6257 if (err) 6258 goto fail; 6259 6260 err = ipw2100_wdev_init(dev); 6261 if (err) 6262 goto fail; 6263 registered = 1; 6264 6265 /* Bring up the interface. Pre 0.46, after we registered the 6266 * network device we would call ipw2100_up. This introduced a race 6267 * condition with newer hotplug configurations (network was coming 6268 * up and making calls before the device was initialized). 6269 */ 6270 err = register_netdev(dev); 6271 if (err) { 6272 printk(KERN_WARNING DRV_NAME 6273 "Error calling register_netdev.\n"); 6274 goto fail; 6275 } 6276 registered = 2; 6277 6278 mutex_lock(&priv->action_mutex); 6279 6280 IPW_DEBUG_INFO("%s: Bound to %s\n", dev->name, pci_name(pci_dev)); 6281 6282 /* perform this after register_netdev so that dev->name is set */ 6283 err = sysfs_create_group(&pci_dev->dev.kobj, &ipw2100_attribute_group); 6284 if (err) 6285 goto fail_unlock; 6286 6287 /* If the RF Kill switch is disabled, go ahead and complete the 6288 * startup sequence */ 6289 if (!(priv->status & STATUS_RF_KILL_MASK)) { 6290 /* Enable the adapter - sends HOST_COMPLETE */ 6291 if (ipw2100_enable_adapter(priv)) { 6292 printk(KERN_WARNING DRV_NAME 6293 ": %s: failed in call to enable adapter.\n", 6294 priv->net_dev->name); 6295 ipw2100_hw_stop_adapter(priv); 6296 err = -EIO; 6297 goto fail_unlock; 6298 } 6299 6300 /* Start a scan . . . */ 6301 ipw2100_set_scan_options(priv); 6302 ipw2100_start_scan(priv); 6303 } 6304 6305 IPW_DEBUG_INFO("exit\n"); 6306 6307 priv->status |= STATUS_INITIALIZED; 6308 6309 mutex_unlock(&priv->action_mutex); 6310 out: 6311 return err; 6312 6313 fail_unlock: 6314 mutex_unlock(&priv->action_mutex); 6315 fail: 6316 if (dev) { 6317 if (registered >= 2) 6318 unregister_netdev(dev); 6319 6320 if (registered) { 6321 wiphy_unregister(priv->ieee->wdev.wiphy); 6322 kfree(priv->ieee->bg_band.channels); 6323 } 6324 6325 ipw2100_hw_stop_adapter(priv); 6326 6327 ipw2100_disable_interrupts(priv); 6328 6329 if (dev->irq) 6330 free_irq(dev->irq, priv); 6331 6332 ipw2100_kill_works(priv); 6333 6334 /* These are safe to call even if they weren't allocated */ 6335 ipw2100_queues_free(priv); 6336 sysfs_remove_group(&pci_dev->dev.kobj, 6337 &ipw2100_attribute_group); 6338 6339 free_libipw(dev, 0); 6340 } 6341 6342 pci_iounmap(pci_dev, ioaddr); 6343 6344 pci_release_regions(pci_dev); 6345 pci_disable_device(pci_dev); 6346 goto out; 6347 } 6348 6349 static void ipw2100_pci_remove_one(struct pci_dev *pci_dev) 6350 { 6351 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev); 6352 struct net_device *dev = priv->net_dev; 6353 6354 mutex_lock(&priv->action_mutex); 6355 6356 priv->status &= ~STATUS_INITIALIZED; 6357 6358 sysfs_remove_group(&pci_dev->dev.kobj, &ipw2100_attribute_group); 6359 6360 #ifdef CONFIG_PM 6361 if (ipw2100_firmware.version) 6362 ipw2100_release_firmware(priv, &ipw2100_firmware); 6363 #endif 6364 /* Take down the hardware */ 6365 ipw2100_down(priv); 6366 6367 /* Release the mutex so that the network subsystem can 6368 * complete any needed calls into the driver... */ 6369 mutex_unlock(&priv->action_mutex); 6370 6371 /* Unregister the device first - this results in close() 6372 * being called if the device is open. If we free storage 6373 * first, then close() will crash. 6374 * FIXME: remove the comment above. */ 6375 unregister_netdev(dev); 6376 6377 ipw2100_kill_works(priv); 6378 6379 ipw2100_queues_free(priv); 6380 6381 /* Free potential debugging firmware snapshot */ 6382 ipw2100_snapshot_free(priv); 6383 6384 free_irq(dev->irq, priv); 6385 6386 pci_iounmap(pci_dev, priv->ioaddr); 6387 6388 /* wiphy_unregister needs to be here, before free_libipw */ 6389 wiphy_unregister(priv->ieee->wdev.wiphy); 6390 kfree(priv->ieee->bg_band.channels); 6391 free_libipw(dev, 0); 6392 6393 pci_release_regions(pci_dev); 6394 pci_disable_device(pci_dev); 6395 6396 IPW_DEBUG_INFO("exit\n"); 6397 } 6398 6399 #ifdef CONFIG_PM 6400 static int ipw2100_suspend(struct pci_dev *pci_dev, pm_message_t state) 6401 { 6402 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev); 6403 struct net_device *dev = priv->net_dev; 6404 6405 IPW_DEBUG_INFO("%s: Going into suspend...\n", dev->name); 6406 6407 mutex_lock(&priv->action_mutex); 6408 if (priv->status & STATUS_INITIALIZED) { 6409 /* Take down the device; powers it off, etc. */ 6410 ipw2100_down(priv); 6411 } 6412 6413 /* Remove the PRESENT state of the device */ 6414 netif_device_detach(dev); 6415 6416 pci_save_state(pci_dev); 6417 pci_disable_device(pci_dev); 6418 pci_set_power_state(pci_dev, PCI_D3hot); 6419 6420 priv->suspend_at = ktime_get_boottime_seconds(); 6421 6422 mutex_unlock(&priv->action_mutex); 6423 6424 return 0; 6425 } 6426 6427 static int ipw2100_resume(struct pci_dev *pci_dev) 6428 { 6429 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev); 6430 struct net_device *dev = priv->net_dev; 6431 int err; 6432 u32 val; 6433 6434 if (IPW2100_PM_DISABLED) 6435 return 0; 6436 6437 mutex_lock(&priv->action_mutex); 6438 6439 IPW_DEBUG_INFO("%s: Coming out of suspend...\n", dev->name); 6440 6441 pci_set_power_state(pci_dev, PCI_D0); 6442 err = pci_enable_device(pci_dev); 6443 if (err) { 6444 printk(KERN_ERR "%s: pci_enable_device failed on resume\n", 6445 dev->name); 6446 mutex_unlock(&priv->action_mutex); 6447 return err; 6448 } 6449 pci_restore_state(pci_dev); 6450 6451 /* 6452 * Suspend/Resume resets the PCI configuration space, so we have to 6453 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries 6454 * from interfering with C3 CPU state. pci_restore_state won't help 6455 * here since it only restores the first 64 bytes pci config header. 6456 */ 6457 pci_read_config_dword(pci_dev, 0x40, &val); 6458 if ((val & 0x0000ff00) != 0) 6459 pci_write_config_dword(pci_dev, 0x40, val & 0xffff00ff); 6460 6461 /* Set the device back into the PRESENT state; this will also wake 6462 * the queue of needed */ 6463 netif_device_attach(dev); 6464 6465 priv->suspend_time = ktime_get_boottime_seconds() - priv->suspend_at; 6466 6467 /* Bring the device back up */ 6468 if (!(priv->status & STATUS_RF_KILL_SW)) 6469 ipw2100_up(priv, 0); 6470 6471 mutex_unlock(&priv->action_mutex); 6472 6473 return 0; 6474 } 6475 #endif 6476 6477 static void ipw2100_shutdown(struct pci_dev *pci_dev) 6478 { 6479 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev); 6480 6481 /* Take down the device; powers it off, etc. */ 6482 ipw2100_down(priv); 6483 6484 pci_disable_device(pci_dev); 6485 } 6486 6487 #define IPW2100_DEV_ID(x) { PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, x } 6488 6489 static const struct pci_device_id ipw2100_pci_id_table[] = { 6490 IPW2100_DEV_ID(0x2520), /* IN 2100A mPCI 3A */ 6491 IPW2100_DEV_ID(0x2521), /* IN 2100A mPCI 3B */ 6492 IPW2100_DEV_ID(0x2524), /* IN 2100A mPCI 3B */ 6493 IPW2100_DEV_ID(0x2525), /* IN 2100A mPCI 3B */ 6494 IPW2100_DEV_ID(0x2526), /* IN 2100A mPCI Gen A3 */ 6495 IPW2100_DEV_ID(0x2522), /* IN 2100 mPCI 3B */ 6496 IPW2100_DEV_ID(0x2523), /* IN 2100 mPCI 3A */ 6497 IPW2100_DEV_ID(0x2527), /* IN 2100 mPCI 3B */ 6498 IPW2100_DEV_ID(0x2528), /* IN 2100 mPCI 3B */ 6499 IPW2100_DEV_ID(0x2529), /* IN 2100 mPCI 3B */ 6500 IPW2100_DEV_ID(0x252B), /* IN 2100 mPCI 3A */ 6501 IPW2100_DEV_ID(0x252C), /* IN 2100 mPCI 3A */ 6502 IPW2100_DEV_ID(0x252D), /* IN 2100 mPCI 3A */ 6503 6504 IPW2100_DEV_ID(0x2550), /* IB 2100A mPCI 3B */ 6505 IPW2100_DEV_ID(0x2551), /* IB 2100 mPCI 3B */ 6506 IPW2100_DEV_ID(0x2553), /* IB 2100 mPCI 3B */ 6507 IPW2100_DEV_ID(0x2554), /* IB 2100 mPCI 3B */ 6508 IPW2100_DEV_ID(0x2555), /* IB 2100 mPCI 3B */ 6509 6510 IPW2100_DEV_ID(0x2560), /* DE 2100A mPCI 3A */ 6511 IPW2100_DEV_ID(0x2562), /* DE 2100A mPCI 3A */ 6512 IPW2100_DEV_ID(0x2563), /* DE 2100A mPCI 3A */ 6513 IPW2100_DEV_ID(0x2561), /* DE 2100 mPCI 3A */ 6514 IPW2100_DEV_ID(0x2565), /* DE 2100 mPCI 3A */ 6515 IPW2100_DEV_ID(0x2566), /* DE 2100 mPCI 3A */ 6516 IPW2100_DEV_ID(0x2567), /* DE 2100 mPCI 3A */ 6517 6518 IPW2100_DEV_ID(0x2570), /* GA 2100 mPCI 3B */ 6519 6520 IPW2100_DEV_ID(0x2580), /* TO 2100A mPCI 3B */ 6521 IPW2100_DEV_ID(0x2582), /* TO 2100A mPCI 3B */ 6522 IPW2100_DEV_ID(0x2583), /* TO 2100A mPCI 3B */ 6523 IPW2100_DEV_ID(0x2581), /* TO 2100 mPCI 3B */ 6524 IPW2100_DEV_ID(0x2585), /* TO 2100 mPCI 3B */ 6525 IPW2100_DEV_ID(0x2586), /* TO 2100 mPCI 3B */ 6526 IPW2100_DEV_ID(0x2587), /* TO 2100 mPCI 3B */ 6527 6528 IPW2100_DEV_ID(0x2590), /* SO 2100A mPCI 3B */ 6529 IPW2100_DEV_ID(0x2592), /* SO 2100A mPCI 3B */ 6530 IPW2100_DEV_ID(0x2591), /* SO 2100 mPCI 3B */ 6531 IPW2100_DEV_ID(0x2593), /* SO 2100 mPCI 3B */ 6532 IPW2100_DEV_ID(0x2596), /* SO 2100 mPCI 3B */ 6533 IPW2100_DEV_ID(0x2598), /* SO 2100 mPCI 3B */ 6534 6535 IPW2100_DEV_ID(0x25A0), /* HP 2100 mPCI 3B */ 6536 {0,}, 6537 }; 6538 6539 MODULE_DEVICE_TABLE(pci, ipw2100_pci_id_table); 6540 6541 static struct pci_driver ipw2100_pci_driver = { 6542 .name = DRV_NAME, 6543 .id_table = ipw2100_pci_id_table, 6544 .probe = ipw2100_pci_init_one, 6545 .remove = ipw2100_pci_remove_one, 6546 #ifdef CONFIG_PM 6547 .suspend = ipw2100_suspend, 6548 .resume = ipw2100_resume, 6549 #endif 6550 .shutdown = ipw2100_shutdown, 6551 }; 6552 6553 /** 6554 * Initialize the ipw2100 driver/module 6555 * 6556 * @returns 0 if ok, < 0 errno node con error. 6557 * 6558 * Note: we cannot init the /proc stuff until the PCI driver is there, 6559 * or we risk an unlikely race condition on someone accessing 6560 * uninitialized data in the PCI dev struct through /proc. 6561 */ 6562 static int __init ipw2100_init(void) 6563 { 6564 int ret; 6565 6566 printk(KERN_INFO DRV_NAME ": %s, %s\n", DRV_DESCRIPTION, DRV_VERSION); 6567 printk(KERN_INFO DRV_NAME ": %s\n", DRV_COPYRIGHT); 6568 6569 pm_qos_add_request(&ipw2100_pm_qos_req, PM_QOS_CPU_DMA_LATENCY, 6570 PM_QOS_DEFAULT_VALUE); 6571 6572 ret = pci_register_driver(&ipw2100_pci_driver); 6573 if (ret) 6574 goto out; 6575 6576 #ifdef CONFIG_IPW2100_DEBUG 6577 ipw2100_debug_level = debug; 6578 ret = driver_create_file(&ipw2100_pci_driver.driver, 6579 &driver_attr_debug_level); 6580 #endif 6581 6582 out: 6583 return ret; 6584 } 6585 6586 /** 6587 * Cleanup ipw2100 driver registration 6588 */ 6589 static void __exit ipw2100_exit(void) 6590 { 6591 /* FIXME: IPG: check that we have no instances of the devices open */ 6592 #ifdef CONFIG_IPW2100_DEBUG 6593 driver_remove_file(&ipw2100_pci_driver.driver, 6594 &driver_attr_debug_level); 6595 #endif 6596 pci_unregister_driver(&ipw2100_pci_driver); 6597 pm_qos_remove_request(&ipw2100_pm_qos_req); 6598 } 6599 6600 module_init(ipw2100_init); 6601 module_exit(ipw2100_exit); 6602 6603 static int ipw2100_wx_get_name(struct net_device *dev, 6604 struct iw_request_info *info, 6605 union iwreq_data *wrqu, char *extra) 6606 { 6607 /* 6608 * This can be called at any time. No action lock required 6609 */ 6610 6611 struct ipw2100_priv *priv = libipw_priv(dev); 6612 if (!(priv->status & STATUS_ASSOCIATED)) 6613 strcpy(wrqu->name, "unassociated"); 6614 else 6615 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11b"); 6616 6617 IPW_DEBUG_WX("Name: %s\n", wrqu->name); 6618 return 0; 6619 } 6620 6621 static int ipw2100_wx_set_freq(struct net_device *dev, 6622 struct iw_request_info *info, 6623 union iwreq_data *wrqu, char *extra) 6624 { 6625 struct ipw2100_priv *priv = libipw_priv(dev); 6626 struct iw_freq *fwrq = &wrqu->freq; 6627 int err = 0; 6628 6629 if (priv->ieee->iw_mode == IW_MODE_INFRA) 6630 return -EOPNOTSUPP; 6631 6632 mutex_lock(&priv->action_mutex); 6633 if (!(priv->status & STATUS_INITIALIZED)) { 6634 err = -EIO; 6635 goto done; 6636 } 6637 6638 /* if setting by freq convert to channel */ 6639 if (fwrq->e == 1) { 6640 if ((fwrq->m >= (int)2.412e8 && fwrq->m <= (int)2.487e8)) { 6641 int f = fwrq->m / 100000; 6642 int c = 0; 6643 6644 while ((c < REG_MAX_CHANNEL) && 6645 (f != ipw2100_frequencies[c])) 6646 c++; 6647 6648 /* hack to fall through */ 6649 fwrq->e = 0; 6650 fwrq->m = c + 1; 6651 } 6652 } 6653 6654 if (fwrq->e > 0 || fwrq->m > 1000) { 6655 err = -EOPNOTSUPP; 6656 goto done; 6657 } else { /* Set the channel */ 6658 IPW_DEBUG_WX("SET Freq/Channel -> %d\n", fwrq->m); 6659 err = ipw2100_set_channel(priv, fwrq->m, 0); 6660 } 6661 6662 done: 6663 mutex_unlock(&priv->action_mutex); 6664 return err; 6665 } 6666 6667 static int ipw2100_wx_get_freq(struct net_device *dev, 6668 struct iw_request_info *info, 6669 union iwreq_data *wrqu, char *extra) 6670 { 6671 /* 6672 * This can be called at any time. No action lock required 6673 */ 6674 6675 struct ipw2100_priv *priv = libipw_priv(dev); 6676 6677 wrqu->freq.e = 0; 6678 6679 /* If we are associated, trying to associate, or have a statically 6680 * configured CHANNEL then return that; otherwise return ANY */ 6681 if (priv->config & CFG_STATIC_CHANNEL || 6682 priv->status & STATUS_ASSOCIATED) 6683 wrqu->freq.m = priv->channel; 6684 else 6685 wrqu->freq.m = 0; 6686 6687 IPW_DEBUG_WX("GET Freq/Channel -> %d\n", priv->channel); 6688 return 0; 6689 6690 } 6691 6692 static int ipw2100_wx_set_mode(struct net_device *dev, 6693 struct iw_request_info *info, 6694 union iwreq_data *wrqu, char *extra) 6695 { 6696 struct ipw2100_priv *priv = libipw_priv(dev); 6697 int err = 0; 6698 6699 IPW_DEBUG_WX("SET Mode -> %d\n", wrqu->mode); 6700 6701 if (wrqu->mode == priv->ieee->iw_mode) 6702 return 0; 6703 6704 mutex_lock(&priv->action_mutex); 6705 if (!(priv->status & STATUS_INITIALIZED)) { 6706 err = -EIO; 6707 goto done; 6708 } 6709 6710 switch (wrqu->mode) { 6711 #ifdef CONFIG_IPW2100_MONITOR 6712 case IW_MODE_MONITOR: 6713 err = ipw2100_switch_mode(priv, IW_MODE_MONITOR); 6714 break; 6715 #endif /* CONFIG_IPW2100_MONITOR */ 6716 case IW_MODE_ADHOC: 6717 err = ipw2100_switch_mode(priv, IW_MODE_ADHOC); 6718 break; 6719 case IW_MODE_INFRA: 6720 case IW_MODE_AUTO: 6721 default: 6722 err = ipw2100_switch_mode(priv, IW_MODE_INFRA); 6723 break; 6724 } 6725 6726 done: 6727 mutex_unlock(&priv->action_mutex); 6728 return err; 6729 } 6730 6731 static int ipw2100_wx_get_mode(struct net_device *dev, 6732 struct iw_request_info *info, 6733 union iwreq_data *wrqu, char *extra) 6734 { 6735 /* 6736 * This can be called at any time. No action lock required 6737 */ 6738 6739 struct ipw2100_priv *priv = libipw_priv(dev); 6740 6741 wrqu->mode = priv->ieee->iw_mode; 6742 IPW_DEBUG_WX("GET Mode -> %d\n", wrqu->mode); 6743 6744 return 0; 6745 } 6746 6747 #define POWER_MODES 5 6748 6749 /* Values are in microsecond */ 6750 static const s32 timeout_duration[POWER_MODES] = { 6751 350000, 6752 250000, 6753 75000, 6754 37000, 6755 25000, 6756 }; 6757 6758 static const s32 period_duration[POWER_MODES] = { 6759 400000, 6760 700000, 6761 1000000, 6762 1000000, 6763 1000000 6764 }; 6765 6766 static int ipw2100_wx_get_range(struct net_device *dev, 6767 struct iw_request_info *info, 6768 union iwreq_data *wrqu, char *extra) 6769 { 6770 /* 6771 * This can be called at any time. No action lock required 6772 */ 6773 6774 struct ipw2100_priv *priv = libipw_priv(dev); 6775 struct iw_range *range = (struct iw_range *)extra; 6776 u16 val; 6777 int i, level; 6778 6779 wrqu->data.length = sizeof(*range); 6780 memset(range, 0, sizeof(*range)); 6781 6782 /* Let's try to keep this struct in the same order as in 6783 * linux/include/wireless.h 6784 */ 6785 6786 /* TODO: See what values we can set, and remove the ones we can't 6787 * set, or fill them with some default data. 6788 */ 6789 6790 /* ~5 Mb/s real (802.11b) */ 6791 range->throughput = 5 * 1000 * 1000; 6792 6793 // range->sensitivity; /* signal level threshold range */ 6794 6795 range->max_qual.qual = 100; 6796 /* TODO: Find real max RSSI and stick here */ 6797 range->max_qual.level = 0; 6798 range->max_qual.noise = 0; 6799 range->max_qual.updated = 7; /* Updated all three */ 6800 6801 range->avg_qual.qual = 70; /* > 8% missed beacons is 'bad' */ 6802 /* TODO: Find real 'good' to 'bad' threshold value for RSSI */ 6803 range->avg_qual.level = 20 + IPW2100_RSSI_TO_DBM; 6804 range->avg_qual.noise = 0; 6805 range->avg_qual.updated = 7; /* Updated all three */ 6806 6807 range->num_bitrates = RATE_COUNT; 6808 6809 for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++) { 6810 range->bitrate[i] = ipw2100_bg_rates[i].bitrate * 100 * 1000; 6811 } 6812 6813 range->min_rts = MIN_RTS_THRESHOLD; 6814 range->max_rts = MAX_RTS_THRESHOLD; 6815 range->min_frag = MIN_FRAG_THRESHOLD; 6816 range->max_frag = MAX_FRAG_THRESHOLD; 6817 6818 range->min_pmp = period_duration[0]; /* Minimal PM period */ 6819 range->max_pmp = period_duration[POWER_MODES - 1]; /* Maximal PM period */ 6820 range->min_pmt = timeout_duration[POWER_MODES - 1]; /* Minimal PM timeout */ 6821 range->max_pmt = timeout_duration[0]; /* Maximal PM timeout */ 6822 6823 /* How to decode max/min PM period */ 6824 range->pmp_flags = IW_POWER_PERIOD; 6825 /* How to decode max/min PM period */ 6826 range->pmt_flags = IW_POWER_TIMEOUT; 6827 /* What PM options are supported */ 6828 range->pm_capa = IW_POWER_TIMEOUT | IW_POWER_PERIOD; 6829 6830 range->encoding_size[0] = 5; 6831 range->encoding_size[1] = 13; /* Different token sizes */ 6832 range->num_encoding_sizes = 2; /* Number of entry in the list */ 6833 range->max_encoding_tokens = WEP_KEYS; /* Max number of tokens */ 6834 // range->encoding_login_index; /* token index for login token */ 6835 6836 if (priv->ieee->iw_mode == IW_MODE_ADHOC) { 6837 range->txpower_capa = IW_TXPOW_DBM; 6838 range->num_txpower = IW_MAX_TXPOWER; 6839 for (i = 0, level = (IPW_TX_POWER_MAX_DBM * 16); 6840 i < IW_MAX_TXPOWER; 6841 i++, level -= 6842 ((IPW_TX_POWER_MAX_DBM - 6843 IPW_TX_POWER_MIN_DBM) * 16) / (IW_MAX_TXPOWER - 1)) 6844 range->txpower[i] = level / 16; 6845 } else { 6846 range->txpower_capa = 0; 6847 range->num_txpower = 0; 6848 } 6849 6850 /* Set the Wireless Extension versions */ 6851 range->we_version_compiled = WIRELESS_EXT; 6852 range->we_version_source = 18; 6853 6854 // range->retry_capa; /* What retry options are supported */ 6855 // range->retry_flags; /* How to decode max/min retry limit */ 6856 // range->r_time_flags; /* How to decode max/min retry life */ 6857 // range->min_retry; /* Minimal number of retries */ 6858 // range->max_retry; /* Maximal number of retries */ 6859 // range->min_r_time; /* Minimal retry lifetime */ 6860 // range->max_r_time; /* Maximal retry lifetime */ 6861 6862 range->num_channels = FREQ_COUNT; 6863 6864 val = 0; 6865 for (i = 0; i < FREQ_COUNT; i++) { 6866 // TODO: Include only legal frequencies for some countries 6867 // if (local->channel_mask & (1 << i)) { 6868 range->freq[val].i = i + 1; 6869 range->freq[val].m = ipw2100_frequencies[i] * 100000; 6870 range->freq[val].e = 1; 6871 val++; 6872 // } 6873 if (val == IW_MAX_FREQUENCIES) 6874 break; 6875 } 6876 range->num_frequency = val; 6877 6878 /* Event capability (kernel + driver) */ 6879 range->event_capa[0] = (IW_EVENT_CAPA_K_0 | 6880 IW_EVENT_CAPA_MASK(SIOCGIWAP)); 6881 range->event_capa[1] = IW_EVENT_CAPA_K_1; 6882 6883 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 | 6884 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP; 6885 6886 IPW_DEBUG_WX("GET Range\n"); 6887 6888 return 0; 6889 } 6890 6891 static int ipw2100_wx_set_wap(struct net_device *dev, 6892 struct iw_request_info *info, 6893 union iwreq_data *wrqu, char *extra) 6894 { 6895 struct ipw2100_priv *priv = libipw_priv(dev); 6896 int err = 0; 6897 6898 // sanity checks 6899 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER) 6900 return -EINVAL; 6901 6902 mutex_lock(&priv->action_mutex); 6903 if (!(priv->status & STATUS_INITIALIZED)) { 6904 err = -EIO; 6905 goto done; 6906 } 6907 6908 if (is_broadcast_ether_addr(wrqu->ap_addr.sa_data) || 6909 is_zero_ether_addr(wrqu->ap_addr.sa_data)) { 6910 /* we disable mandatory BSSID association */ 6911 IPW_DEBUG_WX("exit - disable mandatory BSSID\n"); 6912 priv->config &= ~CFG_STATIC_BSSID; 6913 err = ipw2100_set_mandatory_bssid(priv, NULL, 0); 6914 goto done; 6915 } 6916 6917 priv->config |= CFG_STATIC_BSSID; 6918 memcpy(priv->mandatory_bssid_mac, wrqu->ap_addr.sa_data, ETH_ALEN); 6919 6920 err = ipw2100_set_mandatory_bssid(priv, wrqu->ap_addr.sa_data, 0); 6921 6922 IPW_DEBUG_WX("SET BSSID -> %pM\n", wrqu->ap_addr.sa_data); 6923 6924 done: 6925 mutex_unlock(&priv->action_mutex); 6926 return err; 6927 } 6928 6929 static int ipw2100_wx_get_wap(struct net_device *dev, 6930 struct iw_request_info *info, 6931 union iwreq_data *wrqu, char *extra) 6932 { 6933 /* 6934 * This can be called at any time. No action lock required 6935 */ 6936 6937 struct ipw2100_priv *priv = libipw_priv(dev); 6938 6939 /* If we are associated, trying to associate, or have a statically 6940 * configured BSSID then return that; otherwise return ANY */ 6941 if (priv->config & CFG_STATIC_BSSID || priv->status & STATUS_ASSOCIATED) { 6942 wrqu->ap_addr.sa_family = ARPHRD_ETHER; 6943 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN); 6944 } else 6945 eth_zero_addr(wrqu->ap_addr.sa_data); 6946 6947 IPW_DEBUG_WX("Getting WAP BSSID: %pM\n", wrqu->ap_addr.sa_data); 6948 return 0; 6949 } 6950 6951 static int ipw2100_wx_set_essid(struct net_device *dev, 6952 struct iw_request_info *info, 6953 union iwreq_data *wrqu, char *extra) 6954 { 6955 struct ipw2100_priv *priv = libipw_priv(dev); 6956 char *essid = ""; /* ANY */ 6957 int length = 0; 6958 int err = 0; 6959 6960 mutex_lock(&priv->action_mutex); 6961 if (!(priv->status & STATUS_INITIALIZED)) { 6962 err = -EIO; 6963 goto done; 6964 } 6965 6966 if (wrqu->essid.flags && wrqu->essid.length) { 6967 length = wrqu->essid.length; 6968 essid = extra; 6969 } 6970 6971 if (length == 0) { 6972 IPW_DEBUG_WX("Setting ESSID to ANY\n"); 6973 priv->config &= ~CFG_STATIC_ESSID; 6974 err = ipw2100_set_essid(priv, NULL, 0, 0); 6975 goto done; 6976 } 6977 6978 length = min(length, IW_ESSID_MAX_SIZE); 6979 6980 priv->config |= CFG_STATIC_ESSID; 6981 6982 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) { 6983 IPW_DEBUG_WX("ESSID set to current ESSID.\n"); 6984 err = 0; 6985 goto done; 6986 } 6987 6988 IPW_DEBUG_WX("Setting ESSID: '%*pE' (%d)\n", length, essid, length); 6989 6990 priv->essid_len = length; 6991 memcpy(priv->essid, essid, priv->essid_len); 6992 6993 err = ipw2100_set_essid(priv, essid, length, 0); 6994 6995 done: 6996 mutex_unlock(&priv->action_mutex); 6997 return err; 6998 } 6999 7000 static int ipw2100_wx_get_essid(struct net_device *dev, 7001 struct iw_request_info *info, 7002 union iwreq_data *wrqu, char *extra) 7003 { 7004 /* 7005 * This can be called at any time. No action lock required 7006 */ 7007 7008 struct ipw2100_priv *priv = libipw_priv(dev); 7009 7010 /* If we are associated, trying to associate, or have a statically 7011 * configured ESSID then return that; otherwise return ANY */ 7012 if (priv->config & CFG_STATIC_ESSID || priv->status & STATUS_ASSOCIATED) { 7013 IPW_DEBUG_WX("Getting essid: '%*pE'\n", 7014 priv->essid_len, priv->essid); 7015 memcpy(extra, priv->essid, priv->essid_len); 7016 wrqu->essid.length = priv->essid_len; 7017 wrqu->essid.flags = 1; /* active */ 7018 } else { 7019 IPW_DEBUG_WX("Getting essid: ANY\n"); 7020 wrqu->essid.length = 0; 7021 wrqu->essid.flags = 0; /* active */ 7022 } 7023 7024 return 0; 7025 } 7026 7027 static int ipw2100_wx_set_nick(struct net_device *dev, 7028 struct iw_request_info *info, 7029 union iwreq_data *wrqu, char *extra) 7030 { 7031 /* 7032 * This can be called at any time. No action lock required 7033 */ 7034 7035 struct ipw2100_priv *priv = libipw_priv(dev); 7036 7037 if (wrqu->data.length > IW_ESSID_MAX_SIZE) 7038 return -E2BIG; 7039 7040 wrqu->data.length = min_t(size_t, wrqu->data.length, sizeof(priv->nick)); 7041 memset(priv->nick, 0, sizeof(priv->nick)); 7042 memcpy(priv->nick, extra, wrqu->data.length); 7043 7044 IPW_DEBUG_WX("SET Nickname -> %s\n", priv->nick); 7045 7046 return 0; 7047 } 7048 7049 static int ipw2100_wx_get_nick(struct net_device *dev, 7050 struct iw_request_info *info, 7051 union iwreq_data *wrqu, char *extra) 7052 { 7053 /* 7054 * This can be called at any time. No action lock required 7055 */ 7056 7057 struct ipw2100_priv *priv = libipw_priv(dev); 7058 7059 wrqu->data.length = strlen(priv->nick); 7060 memcpy(extra, priv->nick, wrqu->data.length); 7061 wrqu->data.flags = 1; /* active */ 7062 7063 IPW_DEBUG_WX("GET Nickname -> %s\n", extra); 7064 7065 return 0; 7066 } 7067 7068 static int ipw2100_wx_set_rate(struct net_device *dev, 7069 struct iw_request_info *info, 7070 union iwreq_data *wrqu, char *extra) 7071 { 7072 struct ipw2100_priv *priv = libipw_priv(dev); 7073 u32 target_rate = wrqu->bitrate.value; 7074 u32 rate; 7075 int err = 0; 7076 7077 mutex_lock(&priv->action_mutex); 7078 if (!(priv->status & STATUS_INITIALIZED)) { 7079 err = -EIO; 7080 goto done; 7081 } 7082 7083 rate = 0; 7084 7085 if (target_rate == 1000000 || 7086 (!wrqu->bitrate.fixed && target_rate > 1000000)) 7087 rate |= TX_RATE_1_MBIT; 7088 if (target_rate == 2000000 || 7089 (!wrqu->bitrate.fixed && target_rate > 2000000)) 7090 rate |= TX_RATE_2_MBIT; 7091 if (target_rate == 5500000 || 7092 (!wrqu->bitrate.fixed && target_rate > 5500000)) 7093 rate |= TX_RATE_5_5_MBIT; 7094 if (target_rate == 11000000 || 7095 (!wrqu->bitrate.fixed && target_rate > 11000000)) 7096 rate |= TX_RATE_11_MBIT; 7097 if (rate == 0) 7098 rate = DEFAULT_TX_RATES; 7099 7100 err = ipw2100_set_tx_rates(priv, rate, 0); 7101 7102 IPW_DEBUG_WX("SET Rate -> %04X\n", rate); 7103 done: 7104 mutex_unlock(&priv->action_mutex); 7105 return err; 7106 } 7107 7108 static int ipw2100_wx_get_rate(struct net_device *dev, 7109 struct iw_request_info *info, 7110 union iwreq_data *wrqu, char *extra) 7111 { 7112 struct ipw2100_priv *priv = libipw_priv(dev); 7113 int val; 7114 unsigned int len = sizeof(val); 7115 int err = 0; 7116 7117 if (!(priv->status & STATUS_ENABLED) || 7118 priv->status & STATUS_RF_KILL_MASK || 7119 !(priv->status & STATUS_ASSOCIATED)) { 7120 wrqu->bitrate.value = 0; 7121 return 0; 7122 } 7123 7124 mutex_lock(&priv->action_mutex); 7125 if (!(priv->status & STATUS_INITIALIZED)) { 7126 err = -EIO; 7127 goto done; 7128 } 7129 7130 err = ipw2100_get_ordinal(priv, IPW_ORD_CURRENT_TX_RATE, &val, &len); 7131 if (err) { 7132 IPW_DEBUG_WX("failed querying ordinals.\n"); 7133 goto done; 7134 } 7135 7136 switch (val & TX_RATE_MASK) { 7137 case TX_RATE_1_MBIT: 7138 wrqu->bitrate.value = 1000000; 7139 break; 7140 case TX_RATE_2_MBIT: 7141 wrqu->bitrate.value = 2000000; 7142 break; 7143 case TX_RATE_5_5_MBIT: 7144 wrqu->bitrate.value = 5500000; 7145 break; 7146 case TX_RATE_11_MBIT: 7147 wrqu->bitrate.value = 11000000; 7148 break; 7149 default: 7150 wrqu->bitrate.value = 0; 7151 } 7152 7153 IPW_DEBUG_WX("GET Rate -> %d\n", wrqu->bitrate.value); 7154 7155 done: 7156 mutex_unlock(&priv->action_mutex); 7157 return err; 7158 } 7159 7160 static int ipw2100_wx_set_rts(struct net_device *dev, 7161 struct iw_request_info *info, 7162 union iwreq_data *wrqu, char *extra) 7163 { 7164 struct ipw2100_priv *priv = libipw_priv(dev); 7165 int value, err; 7166 7167 /* Auto RTS not yet supported */ 7168 if (wrqu->rts.fixed == 0) 7169 return -EINVAL; 7170 7171 mutex_lock(&priv->action_mutex); 7172 if (!(priv->status & STATUS_INITIALIZED)) { 7173 err = -EIO; 7174 goto done; 7175 } 7176 7177 if (wrqu->rts.disabled) 7178 value = priv->rts_threshold | RTS_DISABLED; 7179 else { 7180 if (wrqu->rts.value < 1 || wrqu->rts.value > 2304) { 7181 err = -EINVAL; 7182 goto done; 7183 } 7184 value = wrqu->rts.value; 7185 } 7186 7187 err = ipw2100_set_rts_threshold(priv, value); 7188 7189 IPW_DEBUG_WX("SET RTS Threshold -> 0x%08X\n", value); 7190 done: 7191 mutex_unlock(&priv->action_mutex); 7192 return err; 7193 } 7194 7195 static int ipw2100_wx_get_rts(struct net_device *dev, 7196 struct iw_request_info *info, 7197 union iwreq_data *wrqu, char *extra) 7198 { 7199 /* 7200 * This can be called at any time. No action lock required 7201 */ 7202 7203 struct ipw2100_priv *priv = libipw_priv(dev); 7204 7205 wrqu->rts.value = priv->rts_threshold & ~RTS_DISABLED; 7206 wrqu->rts.fixed = 1; /* no auto select */ 7207 7208 /* If RTS is set to the default value, then it is disabled */ 7209 wrqu->rts.disabled = (priv->rts_threshold & RTS_DISABLED) ? 1 : 0; 7210 7211 IPW_DEBUG_WX("GET RTS Threshold -> 0x%08X\n", wrqu->rts.value); 7212 7213 return 0; 7214 } 7215 7216 static int ipw2100_wx_set_txpow(struct net_device *dev, 7217 struct iw_request_info *info, 7218 union iwreq_data *wrqu, char *extra) 7219 { 7220 struct ipw2100_priv *priv = libipw_priv(dev); 7221 int err = 0, value; 7222 7223 if (ipw_radio_kill_sw(priv, wrqu->txpower.disabled)) 7224 return -EINPROGRESS; 7225 7226 if (priv->ieee->iw_mode != IW_MODE_ADHOC) 7227 return 0; 7228 7229 if ((wrqu->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM) 7230 return -EINVAL; 7231 7232 if (wrqu->txpower.fixed == 0) 7233 value = IPW_TX_POWER_DEFAULT; 7234 else { 7235 if (wrqu->txpower.value < IPW_TX_POWER_MIN_DBM || 7236 wrqu->txpower.value > IPW_TX_POWER_MAX_DBM) 7237 return -EINVAL; 7238 7239 value = wrqu->txpower.value; 7240 } 7241 7242 mutex_lock(&priv->action_mutex); 7243 if (!(priv->status & STATUS_INITIALIZED)) { 7244 err = -EIO; 7245 goto done; 7246 } 7247 7248 err = ipw2100_set_tx_power(priv, value); 7249 7250 IPW_DEBUG_WX("SET TX Power -> %d\n", value); 7251 7252 done: 7253 mutex_unlock(&priv->action_mutex); 7254 return err; 7255 } 7256 7257 static int ipw2100_wx_get_txpow(struct net_device *dev, 7258 struct iw_request_info *info, 7259 union iwreq_data *wrqu, char *extra) 7260 { 7261 /* 7262 * This can be called at any time. No action lock required 7263 */ 7264 7265 struct ipw2100_priv *priv = libipw_priv(dev); 7266 7267 wrqu->txpower.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0; 7268 7269 if (priv->tx_power == IPW_TX_POWER_DEFAULT) { 7270 wrqu->txpower.fixed = 0; 7271 wrqu->txpower.value = IPW_TX_POWER_MAX_DBM; 7272 } else { 7273 wrqu->txpower.fixed = 1; 7274 wrqu->txpower.value = priv->tx_power; 7275 } 7276 7277 wrqu->txpower.flags = IW_TXPOW_DBM; 7278 7279 IPW_DEBUG_WX("GET TX Power -> %d\n", wrqu->txpower.value); 7280 7281 return 0; 7282 } 7283 7284 static int ipw2100_wx_set_frag(struct net_device *dev, 7285 struct iw_request_info *info, 7286 union iwreq_data *wrqu, char *extra) 7287 { 7288 /* 7289 * This can be called at any time. No action lock required 7290 */ 7291 7292 struct ipw2100_priv *priv = libipw_priv(dev); 7293 7294 if (!wrqu->frag.fixed) 7295 return -EINVAL; 7296 7297 if (wrqu->frag.disabled) { 7298 priv->frag_threshold |= FRAG_DISABLED; 7299 priv->ieee->fts = DEFAULT_FTS; 7300 } else { 7301 if (wrqu->frag.value < MIN_FRAG_THRESHOLD || 7302 wrqu->frag.value > MAX_FRAG_THRESHOLD) 7303 return -EINVAL; 7304 7305 priv->ieee->fts = wrqu->frag.value & ~0x1; 7306 priv->frag_threshold = priv->ieee->fts; 7307 } 7308 7309 IPW_DEBUG_WX("SET Frag Threshold -> %d\n", priv->ieee->fts); 7310 7311 return 0; 7312 } 7313 7314 static int ipw2100_wx_get_frag(struct net_device *dev, 7315 struct iw_request_info *info, 7316 union iwreq_data *wrqu, char *extra) 7317 { 7318 /* 7319 * This can be called at any time. No action lock required 7320 */ 7321 7322 struct ipw2100_priv *priv = libipw_priv(dev); 7323 wrqu->frag.value = priv->frag_threshold & ~FRAG_DISABLED; 7324 wrqu->frag.fixed = 0; /* no auto select */ 7325 wrqu->frag.disabled = (priv->frag_threshold & FRAG_DISABLED) ? 1 : 0; 7326 7327 IPW_DEBUG_WX("GET Frag Threshold -> %d\n", wrqu->frag.value); 7328 7329 return 0; 7330 } 7331 7332 static int ipw2100_wx_set_retry(struct net_device *dev, 7333 struct iw_request_info *info, 7334 union iwreq_data *wrqu, char *extra) 7335 { 7336 struct ipw2100_priv *priv = libipw_priv(dev); 7337 int err = 0; 7338 7339 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled) 7340 return -EINVAL; 7341 7342 if (!(wrqu->retry.flags & IW_RETRY_LIMIT)) 7343 return 0; 7344 7345 mutex_lock(&priv->action_mutex); 7346 if (!(priv->status & STATUS_INITIALIZED)) { 7347 err = -EIO; 7348 goto done; 7349 } 7350 7351 if (wrqu->retry.flags & IW_RETRY_SHORT) { 7352 err = ipw2100_set_short_retry(priv, wrqu->retry.value); 7353 IPW_DEBUG_WX("SET Short Retry Limit -> %d\n", 7354 wrqu->retry.value); 7355 goto done; 7356 } 7357 7358 if (wrqu->retry.flags & IW_RETRY_LONG) { 7359 err = ipw2100_set_long_retry(priv, wrqu->retry.value); 7360 IPW_DEBUG_WX("SET Long Retry Limit -> %d\n", 7361 wrqu->retry.value); 7362 goto done; 7363 } 7364 7365 err = ipw2100_set_short_retry(priv, wrqu->retry.value); 7366 if (!err) 7367 err = ipw2100_set_long_retry(priv, wrqu->retry.value); 7368 7369 IPW_DEBUG_WX("SET Both Retry Limits -> %d\n", wrqu->retry.value); 7370 7371 done: 7372 mutex_unlock(&priv->action_mutex); 7373 return err; 7374 } 7375 7376 static int ipw2100_wx_get_retry(struct net_device *dev, 7377 struct iw_request_info *info, 7378 union iwreq_data *wrqu, char *extra) 7379 { 7380 /* 7381 * This can be called at any time. No action lock required 7382 */ 7383 7384 struct ipw2100_priv *priv = libipw_priv(dev); 7385 7386 wrqu->retry.disabled = 0; /* can't be disabled */ 7387 7388 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) 7389 return -EINVAL; 7390 7391 if (wrqu->retry.flags & IW_RETRY_LONG) { 7392 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG; 7393 wrqu->retry.value = priv->long_retry_limit; 7394 } else { 7395 wrqu->retry.flags = 7396 (priv->short_retry_limit != 7397 priv->long_retry_limit) ? 7398 IW_RETRY_LIMIT | IW_RETRY_SHORT : IW_RETRY_LIMIT; 7399 7400 wrqu->retry.value = priv->short_retry_limit; 7401 } 7402 7403 IPW_DEBUG_WX("GET Retry -> %d\n", wrqu->retry.value); 7404 7405 return 0; 7406 } 7407 7408 static int ipw2100_wx_set_scan(struct net_device *dev, 7409 struct iw_request_info *info, 7410 union iwreq_data *wrqu, char *extra) 7411 { 7412 struct ipw2100_priv *priv = libipw_priv(dev); 7413 int err = 0; 7414 7415 mutex_lock(&priv->action_mutex); 7416 if (!(priv->status & STATUS_INITIALIZED)) { 7417 err = -EIO; 7418 goto done; 7419 } 7420 7421 IPW_DEBUG_WX("Initiating scan...\n"); 7422 7423 priv->user_requested_scan = 1; 7424 if (ipw2100_set_scan_options(priv) || ipw2100_start_scan(priv)) { 7425 IPW_DEBUG_WX("Start scan failed.\n"); 7426 7427 /* TODO: Mark a scan as pending so when hardware initialized 7428 * a scan starts */ 7429 } 7430 7431 done: 7432 mutex_unlock(&priv->action_mutex); 7433 return err; 7434 } 7435 7436 static int ipw2100_wx_get_scan(struct net_device *dev, 7437 struct iw_request_info *info, 7438 union iwreq_data *wrqu, char *extra) 7439 { 7440 /* 7441 * This can be called at any time. No action lock required 7442 */ 7443 7444 struct ipw2100_priv *priv = libipw_priv(dev); 7445 return libipw_wx_get_scan(priv->ieee, info, wrqu, extra); 7446 } 7447 7448 /* 7449 * Implementation based on code in hostap-driver v0.1.3 hostap_ioctl.c 7450 */ 7451 static int ipw2100_wx_set_encode(struct net_device *dev, 7452 struct iw_request_info *info, 7453 union iwreq_data *wrqu, char *key) 7454 { 7455 /* 7456 * No check of STATUS_INITIALIZED required 7457 */ 7458 7459 struct ipw2100_priv *priv = libipw_priv(dev); 7460 return libipw_wx_set_encode(priv->ieee, info, wrqu, key); 7461 } 7462 7463 static int ipw2100_wx_get_encode(struct net_device *dev, 7464 struct iw_request_info *info, 7465 union iwreq_data *wrqu, char *key) 7466 { 7467 /* 7468 * This can be called at any time. No action lock required 7469 */ 7470 7471 struct ipw2100_priv *priv = libipw_priv(dev); 7472 return libipw_wx_get_encode(priv->ieee, info, wrqu, key); 7473 } 7474 7475 static int ipw2100_wx_set_power(struct net_device *dev, 7476 struct iw_request_info *info, 7477 union iwreq_data *wrqu, char *extra) 7478 { 7479 struct ipw2100_priv *priv = libipw_priv(dev); 7480 int err = 0; 7481 7482 mutex_lock(&priv->action_mutex); 7483 if (!(priv->status & STATUS_INITIALIZED)) { 7484 err = -EIO; 7485 goto done; 7486 } 7487 7488 if (wrqu->power.disabled) { 7489 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode); 7490 err = ipw2100_set_power_mode(priv, IPW_POWER_MODE_CAM); 7491 IPW_DEBUG_WX("SET Power Management Mode -> off\n"); 7492 goto done; 7493 } 7494 7495 switch (wrqu->power.flags & IW_POWER_MODE) { 7496 case IW_POWER_ON: /* If not specified */ 7497 case IW_POWER_MODE: /* If set all mask */ 7498 case IW_POWER_ALL_R: /* If explicitly state all */ 7499 break; 7500 default: /* Otherwise we don't support it */ 7501 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n", 7502 wrqu->power.flags); 7503 err = -EOPNOTSUPP; 7504 goto done; 7505 } 7506 7507 /* If the user hasn't specified a power management mode yet, default 7508 * to BATTERY */ 7509 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode; 7510 err = ipw2100_set_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode)); 7511 7512 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode); 7513 7514 done: 7515 mutex_unlock(&priv->action_mutex); 7516 return err; 7517 7518 } 7519 7520 static int ipw2100_wx_get_power(struct net_device *dev, 7521 struct iw_request_info *info, 7522 union iwreq_data *wrqu, char *extra) 7523 { 7524 /* 7525 * This can be called at any time. No action lock required 7526 */ 7527 7528 struct ipw2100_priv *priv = libipw_priv(dev); 7529 7530 if (!(priv->power_mode & IPW_POWER_ENABLED)) 7531 wrqu->power.disabled = 1; 7532 else { 7533 wrqu->power.disabled = 0; 7534 wrqu->power.flags = 0; 7535 } 7536 7537 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode); 7538 7539 return 0; 7540 } 7541 7542 /* 7543 * WE-18 WPA support 7544 */ 7545 7546 /* SIOCSIWGENIE */ 7547 static int ipw2100_wx_set_genie(struct net_device *dev, 7548 struct iw_request_info *info, 7549 union iwreq_data *wrqu, char *extra) 7550 { 7551 7552 struct ipw2100_priv *priv = libipw_priv(dev); 7553 struct libipw_device *ieee = priv->ieee; 7554 u8 *buf; 7555 7556 if (!ieee->wpa_enabled) 7557 return -EOPNOTSUPP; 7558 7559 if (wrqu->data.length > MAX_WPA_IE_LEN || 7560 (wrqu->data.length && extra == NULL)) 7561 return -EINVAL; 7562 7563 if (wrqu->data.length) { 7564 buf = kmemdup(extra, wrqu->data.length, GFP_KERNEL); 7565 if (buf == NULL) 7566 return -ENOMEM; 7567 7568 kfree(ieee->wpa_ie); 7569 ieee->wpa_ie = buf; 7570 ieee->wpa_ie_len = wrqu->data.length; 7571 } else { 7572 kfree(ieee->wpa_ie); 7573 ieee->wpa_ie = NULL; 7574 ieee->wpa_ie_len = 0; 7575 } 7576 7577 ipw2100_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len); 7578 7579 return 0; 7580 } 7581 7582 /* SIOCGIWGENIE */ 7583 static int ipw2100_wx_get_genie(struct net_device *dev, 7584 struct iw_request_info *info, 7585 union iwreq_data *wrqu, char *extra) 7586 { 7587 struct ipw2100_priv *priv = libipw_priv(dev); 7588 struct libipw_device *ieee = priv->ieee; 7589 7590 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) { 7591 wrqu->data.length = 0; 7592 return 0; 7593 } 7594 7595 if (wrqu->data.length < ieee->wpa_ie_len) 7596 return -E2BIG; 7597 7598 wrqu->data.length = ieee->wpa_ie_len; 7599 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len); 7600 7601 return 0; 7602 } 7603 7604 /* SIOCSIWAUTH */ 7605 static int ipw2100_wx_set_auth(struct net_device *dev, 7606 struct iw_request_info *info, 7607 union iwreq_data *wrqu, char *extra) 7608 { 7609 struct ipw2100_priv *priv = libipw_priv(dev); 7610 struct libipw_device *ieee = priv->ieee; 7611 struct iw_param *param = &wrqu->param; 7612 struct lib80211_crypt_data *crypt; 7613 unsigned long flags; 7614 int ret = 0; 7615 7616 switch (param->flags & IW_AUTH_INDEX) { 7617 case IW_AUTH_WPA_VERSION: 7618 case IW_AUTH_CIPHER_PAIRWISE: 7619 case IW_AUTH_CIPHER_GROUP: 7620 case IW_AUTH_KEY_MGMT: 7621 /* 7622 * ipw2200 does not use these parameters 7623 */ 7624 break; 7625 7626 case IW_AUTH_TKIP_COUNTERMEASURES: 7627 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx]; 7628 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags) 7629 break; 7630 7631 flags = crypt->ops->get_flags(crypt->priv); 7632 7633 if (param->value) 7634 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES; 7635 else 7636 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES; 7637 7638 crypt->ops->set_flags(flags, crypt->priv); 7639 7640 break; 7641 7642 case IW_AUTH_DROP_UNENCRYPTED:{ 7643 /* HACK: 7644 * 7645 * wpa_supplicant calls set_wpa_enabled when the driver 7646 * is loaded and unloaded, regardless of if WPA is being 7647 * used. No other calls are made which can be used to 7648 * determine if encryption will be used or not prior to 7649 * association being expected. If encryption is not being 7650 * used, drop_unencrypted is set to false, else true -- we 7651 * can use this to determine if the CAP_PRIVACY_ON bit should 7652 * be set. 7653 */ 7654 struct libipw_security sec = { 7655 .flags = SEC_ENABLED, 7656 .enabled = param->value, 7657 }; 7658 priv->ieee->drop_unencrypted = param->value; 7659 /* We only change SEC_LEVEL for open mode. Others 7660 * are set by ipw_wpa_set_encryption. 7661 */ 7662 if (!param->value) { 7663 sec.flags |= SEC_LEVEL; 7664 sec.level = SEC_LEVEL_0; 7665 } else { 7666 sec.flags |= SEC_LEVEL; 7667 sec.level = SEC_LEVEL_1; 7668 } 7669 if (priv->ieee->set_security) 7670 priv->ieee->set_security(priv->ieee->dev, &sec); 7671 break; 7672 } 7673 7674 case IW_AUTH_80211_AUTH_ALG: 7675 ret = ipw2100_wpa_set_auth_algs(priv, param->value); 7676 break; 7677 7678 case IW_AUTH_WPA_ENABLED: 7679 ret = ipw2100_wpa_enable(priv, param->value); 7680 break; 7681 7682 case IW_AUTH_RX_UNENCRYPTED_EAPOL: 7683 ieee->ieee802_1x = param->value; 7684 break; 7685 7686 //case IW_AUTH_ROAMING_CONTROL: 7687 case IW_AUTH_PRIVACY_INVOKED: 7688 ieee->privacy_invoked = param->value; 7689 break; 7690 7691 default: 7692 return -EOPNOTSUPP; 7693 } 7694 return ret; 7695 } 7696 7697 /* SIOCGIWAUTH */ 7698 static int ipw2100_wx_get_auth(struct net_device *dev, 7699 struct iw_request_info *info, 7700 union iwreq_data *wrqu, char *extra) 7701 { 7702 struct ipw2100_priv *priv = libipw_priv(dev); 7703 struct libipw_device *ieee = priv->ieee; 7704 struct lib80211_crypt_data *crypt; 7705 struct iw_param *param = &wrqu->param; 7706 7707 switch (param->flags & IW_AUTH_INDEX) { 7708 case IW_AUTH_WPA_VERSION: 7709 case IW_AUTH_CIPHER_PAIRWISE: 7710 case IW_AUTH_CIPHER_GROUP: 7711 case IW_AUTH_KEY_MGMT: 7712 /* 7713 * wpa_supplicant will control these internally 7714 */ 7715 break; 7716 7717 case IW_AUTH_TKIP_COUNTERMEASURES: 7718 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx]; 7719 if (!crypt || !crypt->ops->get_flags) { 7720 IPW_DEBUG_WARNING("Can't get TKIP countermeasures: " 7721 "crypt not set!\n"); 7722 break; 7723 } 7724 7725 param->value = (crypt->ops->get_flags(crypt->priv) & 7726 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0; 7727 7728 break; 7729 7730 case IW_AUTH_DROP_UNENCRYPTED: 7731 param->value = ieee->drop_unencrypted; 7732 break; 7733 7734 case IW_AUTH_80211_AUTH_ALG: 7735 param->value = priv->ieee->sec.auth_mode; 7736 break; 7737 7738 case IW_AUTH_WPA_ENABLED: 7739 param->value = ieee->wpa_enabled; 7740 break; 7741 7742 case IW_AUTH_RX_UNENCRYPTED_EAPOL: 7743 param->value = ieee->ieee802_1x; 7744 break; 7745 7746 case IW_AUTH_ROAMING_CONTROL: 7747 case IW_AUTH_PRIVACY_INVOKED: 7748 param->value = ieee->privacy_invoked; 7749 break; 7750 7751 default: 7752 return -EOPNOTSUPP; 7753 } 7754 return 0; 7755 } 7756 7757 /* SIOCSIWENCODEEXT */ 7758 static int ipw2100_wx_set_encodeext(struct net_device *dev, 7759 struct iw_request_info *info, 7760 union iwreq_data *wrqu, char *extra) 7761 { 7762 struct ipw2100_priv *priv = libipw_priv(dev); 7763 return libipw_wx_set_encodeext(priv->ieee, info, wrqu, extra); 7764 } 7765 7766 /* SIOCGIWENCODEEXT */ 7767 static int ipw2100_wx_get_encodeext(struct net_device *dev, 7768 struct iw_request_info *info, 7769 union iwreq_data *wrqu, char *extra) 7770 { 7771 struct ipw2100_priv *priv = libipw_priv(dev); 7772 return libipw_wx_get_encodeext(priv->ieee, info, wrqu, extra); 7773 } 7774 7775 /* SIOCSIWMLME */ 7776 static int ipw2100_wx_set_mlme(struct net_device *dev, 7777 struct iw_request_info *info, 7778 union iwreq_data *wrqu, char *extra) 7779 { 7780 struct ipw2100_priv *priv = libipw_priv(dev); 7781 struct iw_mlme *mlme = (struct iw_mlme *)extra; 7782 7783 switch (mlme->cmd) { 7784 case IW_MLME_DEAUTH: 7785 // silently ignore 7786 break; 7787 7788 case IW_MLME_DISASSOC: 7789 ipw2100_disassociate_bssid(priv); 7790 break; 7791 7792 default: 7793 return -EOPNOTSUPP; 7794 } 7795 return 0; 7796 } 7797 7798 /* 7799 * 7800 * IWPRIV handlers 7801 * 7802 */ 7803 #ifdef CONFIG_IPW2100_MONITOR 7804 static int ipw2100_wx_set_promisc(struct net_device *dev, 7805 struct iw_request_info *info, 7806 union iwreq_data *wrqu, char *extra) 7807 { 7808 struct ipw2100_priv *priv = libipw_priv(dev); 7809 int *parms = (int *)extra; 7810 int enable = (parms[0] > 0); 7811 int err = 0; 7812 7813 mutex_lock(&priv->action_mutex); 7814 if (!(priv->status & STATUS_INITIALIZED)) { 7815 err = -EIO; 7816 goto done; 7817 } 7818 7819 if (enable) { 7820 if (priv->ieee->iw_mode == IW_MODE_MONITOR) { 7821 err = ipw2100_set_channel(priv, parms[1], 0); 7822 goto done; 7823 } 7824 priv->channel = parms[1]; 7825 err = ipw2100_switch_mode(priv, IW_MODE_MONITOR); 7826 } else { 7827 if (priv->ieee->iw_mode == IW_MODE_MONITOR) 7828 err = ipw2100_switch_mode(priv, priv->last_mode); 7829 } 7830 done: 7831 mutex_unlock(&priv->action_mutex); 7832 return err; 7833 } 7834 7835 static int ipw2100_wx_reset(struct net_device *dev, 7836 struct iw_request_info *info, 7837 union iwreq_data *wrqu, char *extra) 7838 { 7839 struct ipw2100_priv *priv = libipw_priv(dev); 7840 if (priv->status & STATUS_INITIALIZED) 7841 schedule_reset(priv); 7842 return 0; 7843 } 7844 7845 #endif 7846 7847 static int ipw2100_wx_set_powermode(struct net_device *dev, 7848 struct iw_request_info *info, 7849 union iwreq_data *wrqu, char *extra) 7850 { 7851 struct ipw2100_priv *priv = libipw_priv(dev); 7852 int err = 0, mode = *(int *)extra; 7853 7854 mutex_lock(&priv->action_mutex); 7855 if (!(priv->status & STATUS_INITIALIZED)) { 7856 err = -EIO; 7857 goto done; 7858 } 7859 7860 if ((mode < 0) || (mode > POWER_MODES)) 7861 mode = IPW_POWER_AUTO; 7862 7863 if (IPW_POWER_LEVEL(priv->power_mode) != mode) 7864 err = ipw2100_set_power_mode(priv, mode); 7865 done: 7866 mutex_unlock(&priv->action_mutex); 7867 return err; 7868 } 7869 7870 #define MAX_POWER_STRING 80 7871 static int ipw2100_wx_get_powermode(struct net_device *dev, 7872 struct iw_request_info *info, 7873 union iwreq_data *wrqu, char *extra) 7874 { 7875 /* 7876 * This can be called at any time. No action lock required 7877 */ 7878 7879 struct ipw2100_priv *priv = libipw_priv(dev); 7880 int level = IPW_POWER_LEVEL(priv->power_mode); 7881 s32 timeout, period; 7882 7883 if (!(priv->power_mode & IPW_POWER_ENABLED)) { 7884 snprintf(extra, MAX_POWER_STRING, 7885 "Power save level: %d (Off)", level); 7886 } else { 7887 switch (level) { 7888 case IPW_POWER_MODE_CAM: 7889 snprintf(extra, MAX_POWER_STRING, 7890 "Power save level: %d (None)", level); 7891 break; 7892 case IPW_POWER_AUTO: 7893 snprintf(extra, MAX_POWER_STRING, 7894 "Power save level: %d (Auto)", level); 7895 break; 7896 default: 7897 timeout = timeout_duration[level - 1] / 1000; 7898 period = period_duration[level - 1] / 1000; 7899 snprintf(extra, MAX_POWER_STRING, 7900 "Power save level: %d " 7901 "(Timeout %dms, Period %dms)", 7902 level, timeout, period); 7903 } 7904 } 7905 7906 wrqu->data.length = strlen(extra) + 1; 7907 7908 return 0; 7909 } 7910 7911 static int ipw2100_wx_set_preamble(struct net_device *dev, 7912 struct iw_request_info *info, 7913 union iwreq_data *wrqu, char *extra) 7914 { 7915 struct ipw2100_priv *priv = libipw_priv(dev); 7916 int err, mode = *(int *)extra; 7917 7918 mutex_lock(&priv->action_mutex); 7919 if (!(priv->status & STATUS_INITIALIZED)) { 7920 err = -EIO; 7921 goto done; 7922 } 7923 7924 if (mode == 1) 7925 priv->config |= CFG_LONG_PREAMBLE; 7926 else if (mode == 0) 7927 priv->config &= ~CFG_LONG_PREAMBLE; 7928 else { 7929 err = -EINVAL; 7930 goto done; 7931 } 7932 7933 err = ipw2100_system_config(priv, 0); 7934 7935 done: 7936 mutex_unlock(&priv->action_mutex); 7937 return err; 7938 } 7939 7940 static int ipw2100_wx_get_preamble(struct net_device *dev, 7941 struct iw_request_info *info, 7942 union iwreq_data *wrqu, char *extra) 7943 { 7944 /* 7945 * This can be called at any time. No action lock required 7946 */ 7947 7948 struct ipw2100_priv *priv = libipw_priv(dev); 7949 7950 if (priv->config & CFG_LONG_PREAMBLE) 7951 snprintf(wrqu->name, IFNAMSIZ, "long (1)"); 7952 else 7953 snprintf(wrqu->name, IFNAMSIZ, "auto (0)"); 7954 7955 return 0; 7956 } 7957 7958 #ifdef CONFIG_IPW2100_MONITOR 7959 static int ipw2100_wx_set_crc_check(struct net_device *dev, 7960 struct iw_request_info *info, 7961 union iwreq_data *wrqu, char *extra) 7962 { 7963 struct ipw2100_priv *priv = libipw_priv(dev); 7964 int err, mode = *(int *)extra; 7965 7966 mutex_lock(&priv->action_mutex); 7967 if (!(priv->status & STATUS_INITIALIZED)) { 7968 err = -EIO; 7969 goto done; 7970 } 7971 7972 if (mode == 1) 7973 priv->config |= CFG_CRC_CHECK; 7974 else if (mode == 0) 7975 priv->config &= ~CFG_CRC_CHECK; 7976 else { 7977 err = -EINVAL; 7978 goto done; 7979 } 7980 err = 0; 7981 7982 done: 7983 mutex_unlock(&priv->action_mutex); 7984 return err; 7985 } 7986 7987 static int ipw2100_wx_get_crc_check(struct net_device *dev, 7988 struct iw_request_info *info, 7989 union iwreq_data *wrqu, char *extra) 7990 { 7991 /* 7992 * This can be called at any time. No action lock required 7993 */ 7994 7995 struct ipw2100_priv *priv = libipw_priv(dev); 7996 7997 if (priv->config & CFG_CRC_CHECK) 7998 snprintf(wrqu->name, IFNAMSIZ, "CRC checked (1)"); 7999 else 8000 snprintf(wrqu->name, IFNAMSIZ, "CRC ignored (0)"); 8001 8002 return 0; 8003 } 8004 #endif /* CONFIG_IPW2100_MONITOR */ 8005 8006 static iw_handler ipw2100_wx_handlers[] = { 8007 IW_HANDLER(SIOCGIWNAME, ipw2100_wx_get_name), 8008 IW_HANDLER(SIOCSIWFREQ, ipw2100_wx_set_freq), 8009 IW_HANDLER(SIOCGIWFREQ, ipw2100_wx_get_freq), 8010 IW_HANDLER(SIOCSIWMODE, ipw2100_wx_set_mode), 8011 IW_HANDLER(SIOCGIWMODE, ipw2100_wx_get_mode), 8012 IW_HANDLER(SIOCGIWRANGE, ipw2100_wx_get_range), 8013 IW_HANDLER(SIOCSIWAP, ipw2100_wx_set_wap), 8014 IW_HANDLER(SIOCGIWAP, ipw2100_wx_get_wap), 8015 IW_HANDLER(SIOCSIWMLME, ipw2100_wx_set_mlme), 8016 IW_HANDLER(SIOCSIWSCAN, ipw2100_wx_set_scan), 8017 IW_HANDLER(SIOCGIWSCAN, ipw2100_wx_get_scan), 8018 IW_HANDLER(SIOCSIWESSID, ipw2100_wx_set_essid), 8019 IW_HANDLER(SIOCGIWESSID, ipw2100_wx_get_essid), 8020 IW_HANDLER(SIOCSIWNICKN, ipw2100_wx_set_nick), 8021 IW_HANDLER(SIOCGIWNICKN, ipw2100_wx_get_nick), 8022 IW_HANDLER(SIOCSIWRATE, ipw2100_wx_set_rate), 8023 IW_HANDLER(SIOCGIWRATE, ipw2100_wx_get_rate), 8024 IW_HANDLER(SIOCSIWRTS, ipw2100_wx_set_rts), 8025 IW_HANDLER(SIOCGIWRTS, ipw2100_wx_get_rts), 8026 IW_HANDLER(SIOCSIWFRAG, ipw2100_wx_set_frag), 8027 IW_HANDLER(SIOCGIWFRAG, ipw2100_wx_get_frag), 8028 IW_HANDLER(SIOCSIWTXPOW, ipw2100_wx_set_txpow), 8029 IW_HANDLER(SIOCGIWTXPOW, ipw2100_wx_get_txpow), 8030 IW_HANDLER(SIOCSIWRETRY, ipw2100_wx_set_retry), 8031 IW_HANDLER(SIOCGIWRETRY, ipw2100_wx_get_retry), 8032 IW_HANDLER(SIOCSIWENCODE, ipw2100_wx_set_encode), 8033 IW_HANDLER(SIOCGIWENCODE, ipw2100_wx_get_encode), 8034 IW_HANDLER(SIOCSIWPOWER, ipw2100_wx_set_power), 8035 IW_HANDLER(SIOCGIWPOWER, ipw2100_wx_get_power), 8036 IW_HANDLER(SIOCSIWGENIE, ipw2100_wx_set_genie), 8037 IW_HANDLER(SIOCGIWGENIE, ipw2100_wx_get_genie), 8038 IW_HANDLER(SIOCSIWAUTH, ipw2100_wx_set_auth), 8039 IW_HANDLER(SIOCGIWAUTH, ipw2100_wx_get_auth), 8040 IW_HANDLER(SIOCSIWENCODEEXT, ipw2100_wx_set_encodeext), 8041 IW_HANDLER(SIOCGIWENCODEEXT, ipw2100_wx_get_encodeext), 8042 }; 8043 8044 #define IPW2100_PRIV_SET_MONITOR SIOCIWFIRSTPRIV 8045 #define IPW2100_PRIV_RESET SIOCIWFIRSTPRIV+1 8046 #define IPW2100_PRIV_SET_POWER SIOCIWFIRSTPRIV+2 8047 #define IPW2100_PRIV_GET_POWER SIOCIWFIRSTPRIV+3 8048 #define IPW2100_PRIV_SET_LONGPREAMBLE SIOCIWFIRSTPRIV+4 8049 #define IPW2100_PRIV_GET_LONGPREAMBLE SIOCIWFIRSTPRIV+5 8050 #define IPW2100_PRIV_SET_CRC_CHECK SIOCIWFIRSTPRIV+6 8051 #define IPW2100_PRIV_GET_CRC_CHECK SIOCIWFIRSTPRIV+7 8052 8053 static const struct iw_priv_args ipw2100_private_args[] = { 8054 8055 #ifdef CONFIG_IPW2100_MONITOR 8056 { 8057 IPW2100_PRIV_SET_MONITOR, 8058 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"}, 8059 { 8060 IPW2100_PRIV_RESET, 8061 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"}, 8062 #endif /* CONFIG_IPW2100_MONITOR */ 8063 8064 { 8065 IPW2100_PRIV_SET_POWER, 8066 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_power"}, 8067 { 8068 IPW2100_PRIV_GET_POWER, 8069 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_POWER_STRING, 8070 "get_power"}, 8071 { 8072 IPW2100_PRIV_SET_LONGPREAMBLE, 8073 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_preamble"}, 8074 { 8075 IPW2100_PRIV_GET_LONGPREAMBLE, 8076 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_preamble"}, 8077 #ifdef CONFIG_IPW2100_MONITOR 8078 { 8079 IPW2100_PRIV_SET_CRC_CHECK, 8080 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_crc_check"}, 8081 { 8082 IPW2100_PRIV_GET_CRC_CHECK, 8083 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_crc_check"}, 8084 #endif /* CONFIG_IPW2100_MONITOR */ 8085 }; 8086 8087 static iw_handler ipw2100_private_handler[] = { 8088 #ifdef CONFIG_IPW2100_MONITOR 8089 ipw2100_wx_set_promisc, 8090 ipw2100_wx_reset, 8091 #else /* CONFIG_IPW2100_MONITOR */ 8092 NULL, 8093 NULL, 8094 #endif /* CONFIG_IPW2100_MONITOR */ 8095 ipw2100_wx_set_powermode, 8096 ipw2100_wx_get_powermode, 8097 ipw2100_wx_set_preamble, 8098 ipw2100_wx_get_preamble, 8099 #ifdef CONFIG_IPW2100_MONITOR 8100 ipw2100_wx_set_crc_check, 8101 ipw2100_wx_get_crc_check, 8102 #else /* CONFIG_IPW2100_MONITOR */ 8103 NULL, 8104 NULL, 8105 #endif /* CONFIG_IPW2100_MONITOR */ 8106 }; 8107 8108 /* 8109 * Get wireless statistics. 8110 * Called by /proc/net/wireless 8111 * Also called by SIOCGIWSTATS 8112 */ 8113 static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev) 8114 { 8115 enum { 8116 POOR = 30, 8117 FAIR = 60, 8118 GOOD = 80, 8119 VERY_GOOD = 90, 8120 EXCELLENT = 95, 8121 PERFECT = 100 8122 }; 8123 int rssi_qual; 8124 int tx_qual; 8125 int beacon_qual; 8126 int quality; 8127 8128 struct ipw2100_priv *priv = libipw_priv(dev); 8129 struct iw_statistics *wstats; 8130 u32 rssi, tx_retries, missed_beacons, tx_failures; 8131 u32 ord_len = sizeof(u32); 8132 8133 if (!priv) 8134 return (struct iw_statistics *)NULL; 8135 8136 wstats = &priv->wstats; 8137 8138 /* if hw is disabled, then ipw2100_get_ordinal() can't be called. 8139 * ipw2100_wx_wireless_stats seems to be called before fw is 8140 * initialized. STATUS_ASSOCIATED will only be set if the hw is up 8141 * and associated; if not associcated, the values are all meaningless 8142 * anyway, so set them all to NULL and INVALID */ 8143 if (!(priv->status & STATUS_ASSOCIATED)) { 8144 wstats->miss.beacon = 0; 8145 wstats->discard.retries = 0; 8146 wstats->qual.qual = 0; 8147 wstats->qual.level = 0; 8148 wstats->qual.noise = 0; 8149 wstats->qual.updated = 7; 8150 wstats->qual.updated |= IW_QUAL_NOISE_INVALID | 8151 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID; 8152 return wstats; 8153 } 8154 8155 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_MISSED_BCNS, 8156 &missed_beacons, &ord_len)) 8157 goto fail_get_ordinal; 8158 8159 /* If we don't have a connection the quality and level is 0 */ 8160 if (!(priv->status & STATUS_ASSOCIATED)) { 8161 wstats->qual.qual = 0; 8162 wstats->qual.level = 0; 8163 } else { 8164 if (ipw2100_get_ordinal(priv, IPW_ORD_RSSI_AVG_CURR, 8165 &rssi, &ord_len)) 8166 goto fail_get_ordinal; 8167 wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM; 8168 if (rssi < 10) 8169 rssi_qual = rssi * POOR / 10; 8170 else if (rssi < 15) 8171 rssi_qual = (rssi - 10) * (FAIR - POOR) / 5 + POOR; 8172 else if (rssi < 20) 8173 rssi_qual = (rssi - 15) * (GOOD - FAIR) / 5 + FAIR; 8174 else if (rssi < 30) 8175 rssi_qual = (rssi - 20) * (VERY_GOOD - GOOD) / 8176 10 + GOOD; 8177 else 8178 rssi_qual = (rssi - 30) * (PERFECT - VERY_GOOD) / 8179 10 + VERY_GOOD; 8180 8181 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_RETRIES, 8182 &tx_retries, &ord_len)) 8183 goto fail_get_ordinal; 8184 8185 if (tx_retries > 75) 8186 tx_qual = (90 - tx_retries) * POOR / 15; 8187 else if (tx_retries > 70) 8188 tx_qual = (75 - tx_retries) * (FAIR - POOR) / 5 + POOR; 8189 else if (tx_retries > 65) 8190 tx_qual = (70 - tx_retries) * (GOOD - FAIR) / 5 + FAIR; 8191 else if (tx_retries > 50) 8192 tx_qual = (65 - tx_retries) * (VERY_GOOD - GOOD) / 8193 15 + GOOD; 8194 else 8195 tx_qual = (50 - tx_retries) * 8196 (PERFECT - VERY_GOOD) / 50 + VERY_GOOD; 8197 8198 if (missed_beacons > 50) 8199 beacon_qual = (60 - missed_beacons) * POOR / 10; 8200 else if (missed_beacons > 40) 8201 beacon_qual = (50 - missed_beacons) * (FAIR - POOR) / 8202 10 + POOR; 8203 else if (missed_beacons > 32) 8204 beacon_qual = (40 - missed_beacons) * (GOOD - FAIR) / 8205 18 + FAIR; 8206 else if (missed_beacons > 20) 8207 beacon_qual = (32 - missed_beacons) * 8208 (VERY_GOOD - GOOD) / 20 + GOOD; 8209 else 8210 beacon_qual = (20 - missed_beacons) * 8211 (PERFECT - VERY_GOOD) / 20 + VERY_GOOD; 8212 8213 quality = min(tx_qual, rssi_qual); 8214 quality = min(beacon_qual, quality); 8215 8216 #ifdef CONFIG_IPW2100_DEBUG 8217 if (beacon_qual == quality) 8218 IPW_DEBUG_WX("Quality clamped by Missed Beacons\n"); 8219 else if (tx_qual == quality) 8220 IPW_DEBUG_WX("Quality clamped by Tx Retries\n"); 8221 else if (quality != 100) 8222 IPW_DEBUG_WX("Quality clamped by Signal Strength\n"); 8223 else 8224 IPW_DEBUG_WX("Quality not clamped.\n"); 8225 #endif 8226 8227 wstats->qual.qual = quality; 8228 wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM; 8229 } 8230 8231 wstats->qual.noise = 0; 8232 wstats->qual.updated = 7; 8233 wstats->qual.updated |= IW_QUAL_NOISE_INVALID; 8234 8235 /* FIXME: this is percent and not a # */ 8236 wstats->miss.beacon = missed_beacons; 8237 8238 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURES, 8239 &tx_failures, &ord_len)) 8240 goto fail_get_ordinal; 8241 wstats->discard.retries = tx_failures; 8242 8243 return wstats; 8244 8245 fail_get_ordinal: 8246 IPW_DEBUG_WX("failed querying ordinals.\n"); 8247 8248 return (struct iw_statistics *)NULL; 8249 } 8250 8251 static const struct iw_handler_def ipw2100_wx_handler_def = { 8252 .standard = ipw2100_wx_handlers, 8253 .num_standard = ARRAY_SIZE(ipw2100_wx_handlers), 8254 .num_private = ARRAY_SIZE(ipw2100_private_handler), 8255 .num_private_args = ARRAY_SIZE(ipw2100_private_args), 8256 .private = (iw_handler *) ipw2100_private_handler, 8257 .private_args = (struct iw_priv_args *)ipw2100_private_args, 8258 .get_wireless_stats = ipw2100_wx_wireless_stats, 8259 }; 8260 8261 static void ipw2100_wx_event_work(struct work_struct *work) 8262 { 8263 struct ipw2100_priv *priv = 8264 container_of(work, struct ipw2100_priv, wx_event_work.work); 8265 union iwreq_data wrqu; 8266 unsigned int len = ETH_ALEN; 8267 8268 if (priv->status & STATUS_STOPPING) 8269 return; 8270 8271 mutex_lock(&priv->action_mutex); 8272 8273 IPW_DEBUG_WX("enter\n"); 8274 8275 mutex_unlock(&priv->action_mutex); 8276 8277 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 8278 8279 /* Fetch BSSID from the hardware */ 8280 if (!(priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) || 8281 priv->status & STATUS_RF_KILL_MASK || 8282 ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID, 8283 &priv->bssid, &len)) { 8284 eth_zero_addr(wrqu.ap_addr.sa_data); 8285 } else { 8286 /* We now have the BSSID, so can finish setting to the full 8287 * associated state */ 8288 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN); 8289 memcpy(priv->ieee->bssid, priv->bssid, ETH_ALEN); 8290 priv->status &= ~STATUS_ASSOCIATING; 8291 priv->status |= STATUS_ASSOCIATED; 8292 netif_carrier_on(priv->net_dev); 8293 netif_wake_queue(priv->net_dev); 8294 } 8295 8296 if (!(priv->status & STATUS_ASSOCIATED)) { 8297 IPW_DEBUG_WX("Configuring ESSID\n"); 8298 mutex_lock(&priv->action_mutex); 8299 /* This is a disassociation event, so kick the firmware to 8300 * look for another AP */ 8301 if (priv->config & CFG_STATIC_ESSID) 8302 ipw2100_set_essid(priv, priv->essid, priv->essid_len, 8303 0); 8304 else 8305 ipw2100_set_essid(priv, NULL, 0, 0); 8306 mutex_unlock(&priv->action_mutex); 8307 } 8308 8309 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL); 8310 } 8311 8312 #define IPW2100_FW_MAJOR_VERSION 1 8313 #define IPW2100_FW_MINOR_VERSION 3 8314 8315 #define IPW2100_FW_MINOR(x) ((x & 0xff) >> 8) 8316 #define IPW2100_FW_MAJOR(x) (x & 0xff) 8317 8318 #define IPW2100_FW_VERSION ((IPW2100_FW_MINOR_VERSION << 8) | \ 8319 IPW2100_FW_MAJOR_VERSION) 8320 8321 #define IPW2100_FW_PREFIX "ipw2100-" __stringify(IPW2100_FW_MAJOR_VERSION) \ 8322 "." __stringify(IPW2100_FW_MINOR_VERSION) 8323 8324 #define IPW2100_FW_NAME(x) IPW2100_FW_PREFIX "" x ".fw" 8325 8326 /* 8327 8328 BINARY FIRMWARE HEADER FORMAT 8329 8330 offset length desc 8331 0 2 version 8332 2 2 mode == 0:BSS,1:IBSS,2:MONITOR 8333 4 4 fw_len 8334 8 4 uc_len 8335 C fw_len firmware data 8336 12 + fw_len uc_len microcode data 8337 8338 */ 8339 8340 struct ipw2100_fw_header { 8341 short version; 8342 short mode; 8343 unsigned int fw_size; 8344 unsigned int uc_size; 8345 } __packed; 8346 8347 static int ipw2100_mod_firmware_load(struct ipw2100_fw *fw) 8348 { 8349 struct ipw2100_fw_header *h = 8350 (struct ipw2100_fw_header *)fw->fw_entry->data; 8351 8352 if (IPW2100_FW_MAJOR(h->version) != IPW2100_FW_MAJOR_VERSION) { 8353 printk(KERN_WARNING DRV_NAME ": Firmware image not compatible " 8354 "(detected version id of %u). " 8355 "See Documentation/networking/device_drivers/intel/ipw2100.txt\n", 8356 h->version); 8357 return 1; 8358 } 8359 8360 fw->version = h->version; 8361 fw->fw.data = fw->fw_entry->data + sizeof(struct ipw2100_fw_header); 8362 fw->fw.size = h->fw_size; 8363 fw->uc.data = fw->fw.data + h->fw_size; 8364 fw->uc.size = h->uc_size; 8365 8366 return 0; 8367 } 8368 8369 static int ipw2100_get_firmware(struct ipw2100_priv *priv, 8370 struct ipw2100_fw *fw) 8371 { 8372 char *fw_name; 8373 int rc; 8374 8375 IPW_DEBUG_INFO("%s: Using hotplug firmware load.\n", 8376 priv->net_dev->name); 8377 8378 switch (priv->ieee->iw_mode) { 8379 case IW_MODE_ADHOC: 8380 fw_name = IPW2100_FW_NAME("-i"); 8381 break; 8382 #ifdef CONFIG_IPW2100_MONITOR 8383 case IW_MODE_MONITOR: 8384 fw_name = IPW2100_FW_NAME("-p"); 8385 break; 8386 #endif 8387 case IW_MODE_INFRA: 8388 default: 8389 fw_name = IPW2100_FW_NAME(""); 8390 break; 8391 } 8392 8393 rc = request_firmware(&fw->fw_entry, fw_name, &priv->pci_dev->dev); 8394 8395 if (rc < 0) { 8396 printk(KERN_ERR DRV_NAME ": " 8397 "%s: Firmware '%s' not available or load failed.\n", 8398 priv->net_dev->name, fw_name); 8399 return rc; 8400 } 8401 IPW_DEBUG_INFO("firmware data %p size %zd\n", fw->fw_entry->data, 8402 fw->fw_entry->size); 8403 8404 ipw2100_mod_firmware_load(fw); 8405 8406 return 0; 8407 } 8408 8409 MODULE_FIRMWARE(IPW2100_FW_NAME("-i")); 8410 #ifdef CONFIG_IPW2100_MONITOR 8411 MODULE_FIRMWARE(IPW2100_FW_NAME("-p")); 8412 #endif 8413 MODULE_FIRMWARE(IPW2100_FW_NAME("")); 8414 8415 static void ipw2100_release_firmware(struct ipw2100_priv *priv, 8416 struct ipw2100_fw *fw) 8417 { 8418 fw->version = 0; 8419 release_firmware(fw->fw_entry); 8420 fw->fw_entry = NULL; 8421 } 8422 8423 static int ipw2100_get_fwversion(struct ipw2100_priv *priv, char *buf, 8424 size_t max) 8425 { 8426 char ver[MAX_FW_VERSION_LEN]; 8427 u32 len = MAX_FW_VERSION_LEN; 8428 u32 tmp; 8429 int i; 8430 /* firmware version is an ascii string (max len of 14) */ 8431 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_FW_VER_NUM, ver, &len)) 8432 return -EIO; 8433 tmp = max; 8434 if (len >= max) 8435 len = max - 1; 8436 for (i = 0; i < len; i++) 8437 buf[i] = ver[i]; 8438 buf[i] = '\0'; 8439 return tmp; 8440 } 8441 8442 static int ipw2100_get_ucodeversion(struct ipw2100_priv *priv, char *buf, 8443 size_t max) 8444 { 8445 u32 ver; 8446 u32 len = sizeof(ver); 8447 /* microcode version is a 32 bit integer */ 8448 if (ipw2100_get_ordinal(priv, IPW_ORD_UCODE_VERSION, &ver, &len)) 8449 return -EIO; 8450 return snprintf(buf, max, "%08X", ver); 8451 } 8452 8453 /* 8454 * On exit, the firmware will have been freed from the fw list 8455 */ 8456 static int ipw2100_fw_download(struct ipw2100_priv *priv, struct ipw2100_fw *fw) 8457 { 8458 /* firmware is constructed of N contiguous entries, each entry is 8459 * structured as: 8460 * 8461 * offset sie desc 8462 * 0 4 address to write to 8463 * 4 2 length of data run 8464 * 6 length data 8465 */ 8466 unsigned int addr; 8467 unsigned short len; 8468 8469 const unsigned char *firmware_data = fw->fw.data; 8470 unsigned int firmware_data_left = fw->fw.size; 8471 8472 while (firmware_data_left > 0) { 8473 addr = *(u32 *) (firmware_data); 8474 firmware_data += 4; 8475 firmware_data_left -= 4; 8476 8477 len = *(u16 *) (firmware_data); 8478 firmware_data += 2; 8479 firmware_data_left -= 2; 8480 8481 if (len > 32) { 8482 printk(KERN_ERR DRV_NAME ": " 8483 "Invalid firmware run-length of %d bytes\n", 8484 len); 8485 return -EINVAL; 8486 } 8487 8488 write_nic_memory(priv->net_dev, addr, len, firmware_data); 8489 firmware_data += len; 8490 firmware_data_left -= len; 8491 } 8492 8493 return 0; 8494 } 8495 8496 struct symbol_alive_response { 8497 u8 cmd_id; 8498 u8 seq_num; 8499 u8 ucode_rev; 8500 u8 eeprom_valid; 8501 u16 valid_flags; 8502 u8 IEEE_addr[6]; 8503 u16 flags; 8504 u16 pcb_rev; 8505 u16 clock_settle_time; // 1us LSB 8506 u16 powerup_settle_time; // 1us LSB 8507 u16 hop_settle_time; // 1us LSB 8508 u8 date[3]; // month, day, year 8509 u8 time[2]; // hours, minutes 8510 u8 ucode_valid; 8511 }; 8512 8513 static int ipw2100_ucode_download(struct ipw2100_priv *priv, 8514 struct ipw2100_fw *fw) 8515 { 8516 struct net_device *dev = priv->net_dev; 8517 const unsigned char *microcode_data = fw->uc.data; 8518 unsigned int microcode_data_left = fw->uc.size; 8519 void __iomem *reg = priv->ioaddr; 8520 8521 struct symbol_alive_response response; 8522 int i, j; 8523 u8 data; 8524 8525 /* Symbol control */ 8526 write_nic_word(dev, IPW2100_CONTROL_REG, 0x703); 8527 readl(reg); 8528 write_nic_word(dev, IPW2100_CONTROL_REG, 0x707); 8529 readl(reg); 8530 8531 /* HW config */ 8532 write_nic_byte(dev, 0x210014, 0x72); /* fifo width =16 */ 8533 readl(reg); 8534 write_nic_byte(dev, 0x210014, 0x72); /* fifo width =16 */ 8535 readl(reg); 8536 8537 /* EN_CS_ACCESS bit to reset control store pointer */ 8538 write_nic_byte(dev, 0x210000, 0x40); 8539 readl(reg); 8540 write_nic_byte(dev, 0x210000, 0x0); 8541 readl(reg); 8542 write_nic_byte(dev, 0x210000, 0x40); 8543 readl(reg); 8544 8545 /* copy microcode from buffer into Symbol */ 8546 8547 while (microcode_data_left > 0) { 8548 write_nic_byte(dev, 0x210010, *microcode_data++); 8549 write_nic_byte(dev, 0x210010, *microcode_data++); 8550 microcode_data_left -= 2; 8551 } 8552 8553 /* EN_CS_ACCESS bit to reset the control store pointer */ 8554 write_nic_byte(dev, 0x210000, 0x0); 8555 readl(reg); 8556 8557 /* Enable System (Reg 0) 8558 * first enable causes garbage in RX FIFO */ 8559 write_nic_byte(dev, 0x210000, 0x0); 8560 readl(reg); 8561 write_nic_byte(dev, 0x210000, 0x80); 8562 readl(reg); 8563 8564 /* Reset External Baseband Reg */ 8565 write_nic_word(dev, IPW2100_CONTROL_REG, 0x703); 8566 readl(reg); 8567 write_nic_word(dev, IPW2100_CONTROL_REG, 0x707); 8568 readl(reg); 8569 8570 /* HW Config (Reg 5) */ 8571 write_nic_byte(dev, 0x210014, 0x72); // fifo width =16 8572 readl(reg); 8573 write_nic_byte(dev, 0x210014, 0x72); // fifo width =16 8574 readl(reg); 8575 8576 /* Enable System (Reg 0) 8577 * second enable should be OK */ 8578 write_nic_byte(dev, 0x210000, 0x00); // clear enable system 8579 readl(reg); 8580 write_nic_byte(dev, 0x210000, 0x80); // set enable system 8581 8582 /* check Symbol is enabled - upped this from 5 as it wasn't always 8583 * catching the update */ 8584 for (i = 0; i < 10; i++) { 8585 udelay(10); 8586 8587 /* check Dino is enabled bit */ 8588 read_nic_byte(dev, 0x210000, &data); 8589 if (data & 0x1) 8590 break; 8591 } 8592 8593 if (i == 10) { 8594 printk(KERN_ERR DRV_NAME ": %s: Error initializing Symbol\n", 8595 dev->name); 8596 return -EIO; 8597 } 8598 8599 /* Get Symbol alive response */ 8600 for (i = 0; i < 30; i++) { 8601 /* Read alive response structure */ 8602 for (j = 0; 8603 j < (sizeof(struct symbol_alive_response) >> 1); j++) 8604 read_nic_word(dev, 0x210004, ((u16 *) & response) + j); 8605 8606 if ((response.cmd_id == 1) && (response.ucode_valid == 0x1)) 8607 break; 8608 udelay(10); 8609 } 8610 8611 if (i == 30) { 8612 printk(KERN_ERR DRV_NAME 8613 ": %s: No response from Symbol - hw not alive\n", 8614 dev->name); 8615 printk_buf(IPW_DL_ERROR, (u8 *) & response, sizeof(response)); 8616 return -EIO; 8617 } 8618 8619 return 0; 8620 } 8621