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(struct ipw2100_priv *priv) 3210 { 3211 struct net_device *dev = priv->net_dev; 3212 unsigned long flags; 3213 u32 inta, tmp; 3214 3215 spin_lock_irqsave(&priv->low_lock, flags); 3216 ipw2100_disable_interrupts(priv); 3217 3218 read_register(dev, IPW_REG_INTA, &inta); 3219 3220 IPW_DEBUG_ISR("enter - INTA: 0x%08lX\n", 3221 (unsigned long)inta & IPW_INTERRUPT_MASK); 3222 3223 priv->in_isr++; 3224 priv->interrupts++; 3225 3226 /* We do not loop and keep polling for more interrupts as this 3227 * is frowned upon and doesn't play nicely with other potentially 3228 * chained IRQs */ 3229 IPW_DEBUG_ISR("INTA: 0x%08lX\n", 3230 (unsigned long)inta & IPW_INTERRUPT_MASK); 3231 3232 if (inta & IPW2100_INTA_FATAL_ERROR) { 3233 printk(KERN_WARNING DRV_NAME 3234 ": Fatal interrupt. Scheduling firmware restart.\n"); 3235 priv->inta_other++; 3236 write_register(dev, IPW_REG_INTA, IPW2100_INTA_FATAL_ERROR); 3237 3238 read_nic_dword(dev, IPW_NIC_FATAL_ERROR, &priv->fatal_error); 3239 IPW_DEBUG_INFO("%s: Fatal error value: 0x%08X\n", 3240 priv->net_dev->name, priv->fatal_error); 3241 3242 read_nic_dword(dev, IPW_ERROR_ADDR(priv->fatal_error), &tmp); 3243 IPW_DEBUG_INFO("%s: Fatal error address value: 0x%08X\n", 3244 priv->net_dev->name, tmp); 3245 3246 /* Wake up any sleeping jobs */ 3247 schedule_reset(priv); 3248 } 3249 3250 if (inta & IPW2100_INTA_PARITY_ERROR) { 3251 printk(KERN_ERR DRV_NAME 3252 ": ***** PARITY ERROR INTERRUPT !!!!\n"); 3253 priv->inta_other++; 3254 write_register(dev, IPW_REG_INTA, IPW2100_INTA_PARITY_ERROR); 3255 } 3256 3257 if (inta & IPW2100_INTA_RX_TRANSFER) { 3258 IPW_DEBUG_ISR("RX interrupt\n"); 3259 3260 priv->rx_interrupts++; 3261 3262 write_register(dev, IPW_REG_INTA, IPW2100_INTA_RX_TRANSFER); 3263 3264 __ipw2100_rx_process(priv); 3265 __ipw2100_tx_complete(priv); 3266 } 3267 3268 if (inta & IPW2100_INTA_TX_TRANSFER) { 3269 IPW_DEBUG_ISR("TX interrupt\n"); 3270 3271 priv->tx_interrupts++; 3272 3273 write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_TRANSFER); 3274 3275 __ipw2100_tx_complete(priv); 3276 ipw2100_tx_send_commands(priv); 3277 ipw2100_tx_send_data(priv); 3278 } 3279 3280 if (inta & IPW2100_INTA_TX_COMPLETE) { 3281 IPW_DEBUG_ISR("TX complete\n"); 3282 priv->inta_other++; 3283 write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_COMPLETE); 3284 3285 __ipw2100_tx_complete(priv); 3286 } 3287 3288 if (inta & IPW2100_INTA_EVENT_INTERRUPT) { 3289 /* ipw2100_handle_event(dev); */ 3290 priv->inta_other++; 3291 write_register(dev, IPW_REG_INTA, IPW2100_INTA_EVENT_INTERRUPT); 3292 } 3293 3294 if (inta & IPW2100_INTA_FW_INIT_DONE) { 3295 IPW_DEBUG_ISR("FW init done interrupt\n"); 3296 priv->inta_other++; 3297 3298 read_register(dev, IPW_REG_INTA, &tmp); 3299 if (tmp & (IPW2100_INTA_FATAL_ERROR | 3300 IPW2100_INTA_PARITY_ERROR)) { 3301 write_register(dev, IPW_REG_INTA, 3302 IPW2100_INTA_FATAL_ERROR | 3303 IPW2100_INTA_PARITY_ERROR); 3304 } 3305 3306 write_register(dev, IPW_REG_INTA, IPW2100_INTA_FW_INIT_DONE); 3307 } 3308 3309 if (inta & IPW2100_INTA_STATUS_CHANGE) { 3310 IPW_DEBUG_ISR("Status change interrupt\n"); 3311 priv->inta_other++; 3312 write_register(dev, IPW_REG_INTA, IPW2100_INTA_STATUS_CHANGE); 3313 } 3314 3315 if (inta & IPW2100_INTA_SLAVE_MODE_HOST_COMMAND_DONE) { 3316 IPW_DEBUG_ISR("slave host mode interrupt\n"); 3317 priv->inta_other++; 3318 write_register(dev, IPW_REG_INTA, 3319 IPW2100_INTA_SLAVE_MODE_HOST_COMMAND_DONE); 3320 } 3321 3322 priv->in_isr--; 3323 ipw2100_enable_interrupts(priv); 3324 3325 spin_unlock_irqrestore(&priv->low_lock, flags); 3326 3327 IPW_DEBUG_ISR("exit\n"); 3328 } 3329 3330 static irqreturn_t ipw2100_interrupt(int irq, void *data) 3331 { 3332 struct ipw2100_priv *priv = data; 3333 u32 inta, inta_mask; 3334 3335 if (!data) 3336 return IRQ_NONE; 3337 3338 spin_lock(&priv->low_lock); 3339 3340 /* We check to see if we should be ignoring interrupts before 3341 * we touch the hardware. During ucode load if we try and handle 3342 * an interrupt we can cause keyboard problems as well as cause 3343 * the ucode to fail to initialize */ 3344 if (!(priv->status & STATUS_INT_ENABLED)) { 3345 /* Shared IRQ */ 3346 goto none; 3347 } 3348 3349 read_register(priv->net_dev, IPW_REG_INTA_MASK, &inta_mask); 3350 read_register(priv->net_dev, IPW_REG_INTA, &inta); 3351 3352 if (inta == 0xFFFFFFFF) { 3353 /* Hardware disappeared */ 3354 printk(KERN_WARNING DRV_NAME ": IRQ INTA == 0xFFFFFFFF\n"); 3355 goto none; 3356 } 3357 3358 inta &= IPW_INTERRUPT_MASK; 3359 3360 if (!(inta & inta_mask)) { 3361 /* Shared interrupt */ 3362 goto none; 3363 } 3364 3365 /* We disable the hardware interrupt here just to prevent unneeded 3366 * calls to be made. We disable this again within the actual 3367 * work tasklet, so if another part of the code re-enables the 3368 * interrupt, that is fine */ 3369 ipw2100_disable_interrupts(priv); 3370 3371 tasklet_schedule(&priv->irq_tasklet); 3372 spin_unlock(&priv->low_lock); 3373 3374 return IRQ_HANDLED; 3375 none: 3376 spin_unlock(&priv->low_lock); 3377 return IRQ_NONE; 3378 } 3379 3380 static netdev_tx_t ipw2100_tx(struct libipw_txb *txb, 3381 struct net_device *dev, int pri) 3382 { 3383 struct ipw2100_priv *priv = libipw_priv(dev); 3384 struct list_head *element; 3385 struct ipw2100_tx_packet *packet; 3386 unsigned long flags; 3387 3388 spin_lock_irqsave(&priv->low_lock, flags); 3389 3390 if (!(priv->status & STATUS_ASSOCIATED)) { 3391 IPW_DEBUG_INFO("Can not transmit when not connected.\n"); 3392 priv->net_dev->stats.tx_carrier_errors++; 3393 netif_stop_queue(dev); 3394 goto fail_unlock; 3395 } 3396 3397 if (list_empty(&priv->tx_free_list)) 3398 goto fail_unlock; 3399 3400 element = priv->tx_free_list.next; 3401 packet = list_entry(element, struct ipw2100_tx_packet, list); 3402 3403 packet->info.d_struct.txb = txb; 3404 3405 IPW_DEBUG_TX("Sending fragment (%d bytes):\n", txb->fragments[0]->len); 3406 printk_buf(IPW_DL_TX, txb->fragments[0]->data, txb->fragments[0]->len); 3407 3408 packet->jiffy_start = jiffies; 3409 3410 list_del(element); 3411 DEC_STAT(&priv->tx_free_stat); 3412 3413 list_add_tail(element, &priv->tx_pend_list); 3414 INC_STAT(&priv->tx_pend_stat); 3415 3416 ipw2100_tx_send_data(priv); 3417 3418 spin_unlock_irqrestore(&priv->low_lock, flags); 3419 return NETDEV_TX_OK; 3420 3421 fail_unlock: 3422 netif_stop_queue(dev); 3423 spin_unlock_irqrestore(&priv->low_lock, flags); 3424 return NETDEV_TX_BUSY; 3425 } 3426 3427 static int ipw2100_msg_allocate(struct ipw2100_priv *priv) 3428 { 3429 int i, j, err = -EINVAL; 3430 void *v; 3431 dma_addr_t p; 3432 3433 priv->msg_buffers = 3434 kmalloc_array(IPW_COMMAND_POOL_SIZE, 3435 sizeof(struct ipw2100_tx_packet), 3436 GFP_KERNEL); 3437 if (!priv->msg_buffers) 3438 return -ENOMEM; 3439 3440 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) { 3441 v = pci_zalloc_consistent(priv->pci_dev, 3442 sizeof(struct ipw2100_cmd_header), 3443 &p); 3444 if (!v) { 3445 printk(KERN_ERR DRV_NAME ": " 3446 "%s: PCI alloc failed for msg " 3447 "buffers.\n", priv->net_dev->name); 3448 err = -ENOMEM; 3449 break; 3450 } 3451 3452 priv->msg_buffers[i].type = COMMAND; 3453 priv->msg_buffers[i].info.c_struct.cmd = 3454 (struct ipw2100_cmd_header *)v; 3455 priv->msg_buffers[i].info.c_struct.cmd_phys = p; 3456 } 3457 3458 if (i == IPW_COMMAND_POOL_SIZE) 3459 return 0; 3460 3461 for (j = 0; j < i; j++) { 3462 pci_free_consistent(priv->pci_dev, 3463 sizeof(struct ipw2100_cmd_header), 3464 priv->msg_buffers[j].info.c_struct.cmd, 3465 priv->msg_buffers[j].info.c_struct. 3466 cmd_phys); 3467 } 3468 3469 kfree(priv->msg_buffers); 3470 priv->msg_buffers = NULL; 3471 3472 return err; 3473 } 3474 3475 static int ipw2100_msg_initialize(struct ipw2100_priv *priv) 3476 { 3477 int i; 3478 3479 INIT_LIST_HEAD(&priv->msg_free_list); 3480 INIT_LIST_HEAD(&priv->msg_pend_list); 3481 3482 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) 3483 list_add_tail(&priv->msg_buffers[i].list, &priv->msg_free_list); 3484 SET_STAT(&priv->msg_free_stat, i); 3485 3486 return 0; 3487 } 3488 3489 static void ipw2100_msg_free(struct ipw2100_priv *priv) 3490 { 3491 int i; 3492 3493 if (!priv->msg_buffers) 3494 return; 3495 3496 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) { 3497 pci_free_consistent(priv->pci_dev, 3498 sizeof(struct ipw2100_cmd_header), 3499 priv->msg_buffers[i].info.c_struct.cmd, 3500 priv->msg_buffers[i].info.c_struct. 3501 cmd_phys); 3502 } 3503 3504 kfree(priv->msg_buffers); 3505 priv->msg_buffers = NULL; 3506 } 3507 3508 static ssize_t show_pci(struct device *d, struct device_attribute *attr, 3509 char *buf) 3510 { 3511 struct pci_dev *pci_dev = to_pci_dev(d); 3512 char *out = buf; 3513 int i, j; 3514 u32 val; 3515 3516 for (i = 0; i < 16; i++) { 3517 out += sprintf(out, "[%08X] ", i * 16); 3518 for (j = 0; j < 16; j += 4) { 3519 pci_read_config_dword(pci_dev, i * 16 + j, &val); 3520 out += sprintf(out, "%08X ", val); 3521 } 3522 out += sprintf(out, "\n"); 3523 } 3524 3525 return out - buf; 3526 } 3527 3528 static DEVICE_ATTR(pci, 0444, show_pci, NULL); 3529 3530 static ssize_t show_cfg(struct device *d, struct device_attribute *attr, 3531 char *buf) 3532 { 3533 struct ipw2100_priv *p = dev_get_drvdata(d); 3534 return sprintf(buf, "0x%08x\n", (int)p->config); 3535 } 3536 3537 static DEVICE_ATTR(cfg, 0444, show_cfg, NULL); 3538 3539 static ssize_t show_status(struct device *d, struct device_attribute *attr, 3540 char *buf) 3541 { 3542 struct ipw2100_priv *p = dev_get_drvdata(d); 3543 return sprintf(buf, "0x%08x\n", (int)p->status); 3544 } 3545 3546 static DEVICE_ATTR(status, 0444, show_status, NULL); 3547 3548 static ssize_t show_capability(struct device *d, struct device_attribute *attr, 3549 char *buf) 3550 { 3551 struct ipw2100_priv *p = dev_get_drvdata(d); 3552 return sprintf(buf, "0x%08x\n", (int)p->capability); 3553 } 3554 3555 static DEVICE_ATTR(capability, 0444, show_capability, NULL); 3556 3557 #define IPW2100_REG(x) { IPW_ ##x, #x } 3558 static const struct { 3559 u32 addr; 3560 const char *name; 3561 } hw_data[] = { 3562 IPW2100_REG(REG_GP_CNTRL), 3563 IPW2100_REG(REG_GPIO), 3564 IPW2100_REG(REG_INTA), 3565 IPW2100_REG(REG_INTA_MASK), IPW2100_REG(REG_RESET_REG),}; 3566 #define IPW2100_NIC(x, s) { x, #x, s } 3567 static const struct { 3568 u32 addr; 3569 const char *name; 3570 size_t size; 3571 } nic_data[] = { 3572 IPW2100_NIC(IPW2100_CONTROL_REG, 2), 3573 IPW2100_NIC(0x210014, 1), IPW2100_NIC(0x210000, 1),}; 3574 #define IPW2100_ORD(x, d) { IPW_ORD_ ##x, #x, d } 3575 static const struct { 3576 u8 index; 3577 const char *name; 3578 const char *desc; 3579 } ord_data[] = { 3580 IPW2100_ORD(STAT_TX_HOST_REQUESTS, "requested Host Tx's (MSDU)"), 3581 IPW2100_ORD(STAT_TX_HOST_COMPLETE, 3582 "successful Host Tx's (MSDU)"), 3583 IPW2100_ORD(STAT_TX_DIR_DATA, 3584 "successful Directed Tx's (MSDU)"), 3585 IPW2100_ORD(STAT_TX_DIR_DATA1, 3586 "successful Directed Tx's (MSDU) @ 1MB"), 3587 IPW2100_ORD(STAT_TX_DIR_DATA2, 3588 "successful Directed Tx's (MSDU) @ 2MB"), 3589 IPW2100_ORD(STAT_TX_DIR_DATA5_5, 3590 "successful Directed Tx's (MSDU) @ 5_5MB"), 3591 IPW2100_ORD(STAT_TX_DIR_DATA11, 3592 "successful Directed Tx's (MSDU) @ 11MB"), 3593 IPW2100_ORD(STAT_TX_NODIR_DATA1, 3594 "successful Non_Directed Tx's (MSDU) @ 1MB"), 3595 IPW2100_ORD(STAT_TX_NODIR_DATA2, 3596 "successful Non_Directed Tx's (MSDU) @ 2MB"), 3597 IPW2100_ORD(STAT_TX_NODIR_DATA5_5, 3598 "successful Non_Directed Tx's (MSDU) @ 5.5MB"), 3599 IPW2100_ORD(STAT_TX_NODIR_DATA11, 3600 "successful Non_Directed Tx's (MSDU) @ 11MB"), 3601 IPW2100_ORD(STAT_NULL_DATA, "successful NULL data Tx's"), 3602 IPW2100_ORD(STAT_TX_RTS, "successful Tx RTS"), 3603 IPW2100_ORD(STAT_TX_CTS, "successful Tx CTS"), 3604 IPW2100_ORD(STAT_TX_ACK, "successful Tx ACK"), 3605 IPW2100_ORD(STAT_TX_ASSN, "successful Association Tx's"), 3606 IPW2100_ORD(STAT_TX_ASSN_RESP, 3607 "successful Association response Tx's"), 3608 IPW2100_ORD(STAT_TX_REASSN, 3609 "successful Reassociation Tx's"), 3610 IPW2100_ORD(STAT_TX_REASSN_RESP, 3611 "successful Reassociation response Tx's"), 3612 IPW2100_ORD(STAT_TX_PROBE, 3613 "probes successfully transmitted"), 3614 IPW2100_ORD(STAT_TX_PROBE_RESP, 3615 "probe responses successfully transmitted"), 3616 IPW2100_ORD(STAT_TX_BEACON, "tx beacon"), 3617 IPW2100_ORD(STAT_TX_ATIM, "Tx ATIM"), 3618 IPW2100_ORD(STAT_TX_DISASSN, 3619 "successful Disassociation TX"), 3620 IPW2100_ORD(STAT_TX_AUTH, "successful Authentication Tx"), 3621 IPW2100_ORD(STAT_TX_DEAUTH, 3622 "successful Deauthentication TX"), 3623 IPW2100_ORD(STAT_TX_TOTAL_BYTES, 3624 "Total successful Tx data bytes"), 3625 IPW2100_ORD(STAT_TX_RETRIES, "Tx retries"), 3626 IPW2100_ORD(STAT_TX_RETRY1, "Tx retries at 1MBPS"), 3627 IPW2100_ORD(STAT_TX_RETRY2, "Tx retries at 2MBPS"), 3628 IPW2100_ORD(STAT_TX_RETRY5_5, "Tx retries at 5.5MBPS"), 3629 IPW2100_ORD(STAT_TX_RETRY11, "Tx retries at 11MBPS"), 3630 IPW2100_ORD(STAT_TX_FAILURES, "Tx Failures"), 3631 IPW2100_ORD(STAT_TX_MAX_TRIES_IN_HOP, 3632 "times max tries in a hop failed"), 3633 IPW2100_ORD(STAT_TX_DISASSN_FAIL, 3634 "times disassociation failed"), 3635 IPW2100_ORD(STAT_TX_ERR_CTS, "missed/bad CTS frames"), 3636 IPW2100_ORD(STAT_TX_ERR_ACK, "tx err due to acks"), 3637 IPW2100_ORD(STAT_RX_HOST, "packets passed to host"), 3638 IPW2100_ORD(STAT_RX_DIR_DATA, "directed packets"), 3639 IPW2100_ORD(STAT_RX_DIR_DATA1, "directed packets at 1MB"), 3640 IPW2100_ORD(STAT_RX_DIR_DATA2, "directed packets at 2MB"), 3641 IPW2100_ORD(STAT_RX_DIR_DATA5_5, 3642 "directed packets at 5.5MB"), 3643 IPW2100_ORD(STAT_RX_DIR_DATA11, "directed packets at 11MB"), 3644 IPW2100_ORD(STAT_RX_NODIR_DATA, "nondirected packets"), 3645 IPW2100_ORD(STAT_RX_NODIR_DATA1, 3646 "nondirected packets at 1MB"), 3647 IPW2100_ORD(STAT_RX_NODIR_DATA2, 3648 "nondirected packets at 2MB"), 3649 IPW2100_ORD(STAT_RX_NODIR_DATA5_5, 3650 "nondirected packets at 5.5MB"), 3651 IPW2100_ORD(STAT_RX_NODIR_DATA11, 3652 "nondirected packets at 11MB"), 3653 IPW2100_ORD(STAT_RX_NULL_DATA, "null data rx's"), 3654 IPW2100_ORD(STAT_RX_RTS, "Rx RTS"), IPW2100_ORD(STAT_RX_CTS, 3655 "Rx CTS"), 3656 IPW2100_ORD(STAT_RX_ACK, "Rx ACK"), 3657 IPW2100_ORD(STAT_RX_CFEND, "Rx CF End"), 3658 IPW2100_ORD(STAT_RX_CFEND_ACK, "Rx CF End + CF Ack"), 3659 IPW2100_ORD(STAT_RX_ASSN, "Association Rx's"), 3660 IPW2100_ORD(STAT_RX_ASSN_RESP, "Association response Rx's"), 3661 IPW2100_ORD(STAT_RX_REASSN, "Reassociation Rx's"), 3662 IPW2100_ORD(STAT_RX_REASSN_RESP, 3663 "Reassociation response Rx's"), 3664 IPW2100_ORD(STAT_RX_PROBE, "probe Rx's"), 3665 IPW2100_ORD(STAT_RX_PROBE_RESP, "probe response Rx's"), 3666 IPW2100_ORD(STAT_RX_BEACON, "Rx beacon"), 3667 IPW2100_ORD(STAT_RX_ATIM, "Rx ATIM"), 3668 IPW2100_ORD(STAT_RX_DISASSN, "disassociation Rx"), 3669 IPW2100_ORD(STAT_RX_AUTH, "authentication Rx"), 3670 IPW2100_ORD(STAT_RX_DEAUTH, "deauthentication Rx"), 3671 IPW2100_ORD(STAT_RX_TOTAL_BYTES, 3672 "Total rx data bytes received"), 3673 IPW2100_ORD(STAT_RX_ERR_CRC, "packets with Rx CRC error"), 3674 IPW2100_ORD(STAT_RX_ERR_CRC1, "Rx CRC errors at 1MB"), 3675 IPW2100_ORD(STAT_RX_ERR_CRC2, "Rx CRC errors at 2MB"), 3676 IPW2100_ORD(STAT_RX_ERR_CRC5_5, "Rx CRC errors at 5.5MB"), 3677 IPW2100_ORD(STAT_RX_ERR_CRC11, "Rx CRC errors at 11MB"), 3678 IPW2100_ORD(STAT_RX_DUPLICATE1, 3679 "duplicate rx packets at 1MB"), 3680 IPW2100_ORD(STAT_RX_DUPLICATE2, 3681 "duplicate rx packets at 2MB"), 3682 IPW2100_ORD(STAT_RX_DUPLICATE5_5, 3683 "duplicate rx packets at 5.5MB"), 3684 IPW2100_ORD(STAT_RX_DUPLICATE11, 3685 "duplicate rx packets at 11MB"), 3686 IPW2100_ORD(STAT_RX_DUPLICATE, "duplicate rx packets"), 3687 IPW2100_ORD(PERS_DB_LOCK, "locking fw permanent db"), 3688 IPW2100_ORD(PERS_DB_SIZE, "size of fw permanent db"), 3689 IPW2100_ORD(PERS_DB_ADDR, "address of fw permanent db"), 3690 IPW2100_ORD(STAT_RX_INVALID_PROTOCOL, 3691 "rx frames with invalid protocol"), 3692 IPW2100_ORD(SYS_BOOT_TIME, "Boot time"), 3693 IPW2100_ORD(STAT_RX_NO_BUFFER, 3694 "rx frames rejected due to no buffer"), 3695 IPW2100_ORD(STAT_RX_MISSING_FRAG, 3696 "rx frames dropped due to missing fragment"), 3697 IPW2100_ORD(STAT_RX_ORPHAN_FRAG, 3698 "rx frames dropped due to non-sequential fragment"), 3699 IPW2100_ORD(STAT_RX_ORPHAN_FRAME, 3700 "rx frames dropped due to unmatched 1st frame"), 3701 IPW2100_ORD(STAT_RX_FRAG_AGEOUT, 3702 "rx frames dropped due to uncompleted frame"), 3703 IPW2100_ORD(STAT_RX_ICV_ERRORS, 3704 "ICV errors during decryption"), 3705 IPW2100_ORD(STAT_PSP_SUSPENSION, "times adapter suspended"), 3706 IPW2100_ORD(STAT_PSP_BCN_TIMEOUT, "beacon timeout"), 3707 IPW2100_ORD(STAT_PSP_POLL_TIMEOUT, 3708 "poll response timeouts"), 3709 IPW2100_ORD(STAT_PSP_NONDIR_TIMEOUT, 3710 "timeouts waiting for last {broad,multi}cast pkt"), 3711 IPW2100_ORD(STAT_PSP_RX_DTIMS, "PSP DTIMs received"), 3712 IPW2100_ORD(STAT_PSP_RX_TIMS, "PSP TIMs received"), 3713 IPW2100_ORD(STAT_PSP_STATION_ID, "PSP Station ID"), 3714 IPW2100_ORD(LAST_ASSN_TIME, "RTC time of last association"), 3715 IPW2100_ORD(STAT_PERCENT_MISSED_BCNS, 3716 "current calculation of % missed beacons"), 3717 IPW2100_ORD(STAT_PERCENT_RETRIES, 3718 "current calculation of % missed tx retries"), 3719 IPW2100_ORD(ASSOCIATED_AP_PTR, 3720 "0 if not associated, else pointer to AP table entry"), 3721 IPW2100_ORD(AVAILABLE_AP_CNT, 3722 "AP's described in the AP table"), 3723 IPW2100_ORD(AP_LIST_PTR, "Ptr to list of available APs"), 3724 IPW2100_ORD(STAT_AP_ASSNS, "associations"), 3725 IPW2100_ORD(STAT_ASSN_FAIL, "association failures"), 3726 IPW2100_ORD(STAT_ASSN_RESP_FAIL, 3727 "failures due to response fail"), 3728 IPW2100_ORD(STAT_FULL_SCANS, "full scans"), 3729 IPW2100_ORD(CARD_DISABLED, "Card Disabled"), 3730 IPW2100_ORD(STAT_ROAM_INHIBIT, 3731 "times roaming was inhibited due to activity"), 3732 IPW2100_ORD(RSSI_AT_ASSN, 3733 "RSSI of associated AP at time of association"), 3734 IPW2100_ORD(STAT_ASSN_CAUSE1, 3735 "reassociation: no probe response or TX on hop"), 3736 IPW2100_ORD(STAT_ASSN_CAUSE2, 3737 "reassociation: poor tx/rx quality"), 3738 IPW2100_ORD(STAT_ASSN_CAUSE3, 3739 "reassociation: tx/rx quality (excessive AP load"), 3740 IPW2100_ORD(STAT_ASSN_CAUSE4, 3741 "reassociation: AP RSSI level"), 3742 IPW2100_ORD(STAT_ASSN_CAUSE5, 3743 "reassociations due to load leveling"), 3744 IPW2100_ORD(STAT_AUTH_FAIL, "times authentication failed"), 3745 IPW2100_ORD(STAT_AUTH_RESP_FAIL, 3746 "times authentication response failed"), 3747 IPW2100_ORD(STATION_TABLE_CNT, 3748 "entries in association table"), 3749 IPW2100_ORD(RSSI_AVG_CURR, "Current avg RSSI"), 3750 IPW2100_ORD(POWER_MGMT_MODE, "Power mode - 0=CAM, 1=PSP"), 3751 IPW2100_ORD(COUNTRY_CODE, 3752 "IEEE country code as recv'd from beacon"), 3753 IPW2100_ORD(COUNTRY_CHANNELS, 3754 "channels supported by country"), 3755 IPW2100_ORD(RESET_CNT, "adapter resets (warm)"), 3756 IPW2100_ORD(BEACON_INTERVAL, "Beacon interval"), 3757 IPW2100_ORD(ANTENNA_DIVERSITY, 3758 "TRUE if antenna diversity is disabled"), 3759 IPW2100_ORD(DTIM_PERIOD, "beacon intervals between DTIMs"), 3760 IPW2100_ORD(OUR_FREQ, 3761 "current radio freq lower digits - channel ID"), 3762 IPW2100_ORD(RTC_TIME, "current RTC time"), 3763 IPW2100_ORD(PORT_TYPE, "operating mode"), 3764 IPW2100_ORD(CURRENT_TX_RATE, "current tx rate"), 3765 IPW2100_ORD(SUPPORTED_RATES, "supported tx rates"), 3766 IPW2100_ORD(ATIM_WINDOW, "current ATIM Window"), 3767 IPW2100_ORD(BASIC_RATES, "basic tx rates"), 3768 IPW2100_ORD(NIC_HIGHEST_RATE, "NIC highest tx rate"), 3769 IPW2100_ORD(AP_HIGHEST_RATE, "AP highest tx rate"), 3770 IPW2100_ORD(CAPABILITIES, 3771 "Management frame capability field"), 3772 IPW2100_ORD(AUTH_TYPE, "Type of authentication"), 3773 IPW2100_ORD(RADIO_TYPE, "Adapter card platform type"), 3774 IPW2100_ORD(RTS_THRESHOLD, 3775 "Min packet length for RTS handshaking"), 3776 IPW2100_ORD(INT_MODE, "International mode"), 3777 IPW2100_ORD(FRAGMENTATION_THRESHOLD, 3778 "protocol frag threshold"), 3779 IPW2100_ORD(EEPROM_SRAM_DB_BLOCK_START_ADDRESS, 3780 "EEPROM offset in SRAM"), 3781 IPW2100_ORD(EEPROM_SRAM_DB_BLOCK_SIZE, 3782 "EEPROM size in SRAM"), 3783 IPW2100_ORD(EEPROM_SKU_CAPABILITY, "EEPROM SKU Capability"), 3784 IPW2100_ORD(EEPROM_IBSS_11B_CHANNELS, 3785 "EEPROM IBSS 11b channel set"), 3786 IPW2100_ORD(MAC_VERSION, "MAC Version"), 3787 IPW2100_ORD(MAC_REVISION, "MAC Revision"), 3788 IPW2100_ORD(RADIO_VERSION, "Radio Version"), 3789 IPW2100_ORD(NIC_MANF_DATE_TIME, "MANF Date/Time STAMP"), 3790 IPW2100_ORD(UCODE_VERSION, "Ucode Version"),}; 3791 3792 static ssize_t show_registers(struct device *d, struct device_attribute *attr, 3793 char *buf) 3794 { 3795 int i; 3796 struct ipw2100_priv *priv = dev_get_drvdata(d); 3797 struct net_device *dev = priv->net_dev; 3798 char *out = buf; 3799 u32 val = 0; 3800 3801 out += sprintf(out, "%30s [Address ] : Hex\n", "Register"); 3802 3803 for (i = 0; i < ARRAY_SIZE(hw_data); i++) { 3804 read_register(dev, hw_data[i].addr, &val); 3805 out += sprintf(out, "%30s [%08X] : %08X\n", 3806 hw_data[i].name, hw_data[i].addr, val); 3807 } 3808 3809 return out - buf; 3810 } 3811 3812 static DEVICE_ATTR(registers, 0444, show_registers, NULL); 3813 3814 static ssize_t show_hardware(struct device *d, struct device_attribute *attr, 3815 char *buf) 3816 { 3817 struct ipw2100_priv *priv = dev_get_drvdata(d); 3818 struct net_device *dev = priv->net_dev; 3819 char *out = buf; 3820 int i; 3821 3822 out += sprintf(out, "%30s [Address ] : Hex\n", "NIC entry"); 3823 3824 for (i = 0; i < ARRAY_SIZE(nic_data); i++) { 3825 u8 tmp8; 3826 u16 tmp16; 3827 u32 tmp32; 3828 3829 switch (nic_data[i].size) { 3830 case 1: 3831 read_nic_byte(dev, nic_data[i].addr, &tmp8); 3832 out += sprintf(out, "%30s [%08X] : %02X\n", 3833 nic_data[i].name, nic_data[i].addr, 3834 tmp8); 3835 break; 3836 case 2: 3837 read_nic_word(dev, nic_data[i].addr, &tmp16); 3838 out += sprintf(out, "%30s [%08X] : %04X\n", 3839 nic_data[i].name, nic_data[i].addr, 3840 tmp16); 3841 break; 3842 case 4: 3843 read_nic_dword(dev, nic_data[i].addr, &tmp32); 3844 out += sprintf(out, "%30s [%08X] : %08X\n", 3845 nic_data[i].name, nic_data[i].addr, 3846 tmp32); 3847 break; 3848 } 3849 } 3850 return out - buf; 3851 } 3852 3853 static DEVICE_ATTR(hardware, 0444, show_hardware, NULL); 3854 3855 static ssize_t show_memory(struct device *d, struct device_attribute *attr, 3856 char *buf) 3857 { 3858 struct ipw2100_priv *priv = dev_get_drvdata(d); 3859 struct net_device *dev = priv->net_dev; 3860 static unsigned long loop = 0; 3861 int len = 0; 3862 u32 buffer[4]; 3863 int i; 3864 char line[81]; 3865 3866 if (loop >= 0x30000) 3867 loop = 0; 3868 3869 /* sysfs provides us PAGE_SIZE buffer */ 3870 while (len < PAGE_SIZE - 128 && loop < 0x30000) { 3871 3872 if (priv->snapshot[0]) 3873 for (i = 0; i < 4; i++) 3874 buffer[i] = 3875 *(u32 *) SNAPSHOT_ADDR(loop + i * 4); 3876 else 3877 for (i = 0; i < 4; i++) 3878 read_nic_dword(dev, loop + i * 4, &buffer[i]); 3879 3880 if (priv->dump_raw) 3881 len += sprintf(buf + len, 3882 "%c%c%c%c" 3883 "%c%c%c%c" 3884 "%c%c%c%c" 3885 "%c%c%c%c", 3886 ((u8 *) buffer)[0x0], 3887 ((u8 *) buffer)[0x1], 3888 ((u8 *) buffer)[0x2], 3889 ((u8 *) buffer)[0x3], 3890 ((u8 *) buffer)[0x4], 3891 ((u8 *) buffer)[0x5], 3892 ((u8 *) buffer)[0x6], 3893 ((u8 *) buffer)[0x7], 3894 ((u8 *) buffer)[0x8], 3895 ((u8 *) buffer)[0x9], 3896 ((u8 *) buffer)[0xa], 3897 ((u8 *) buffer)[0xb], 3898 ((u8 *) buffer)[0xc], 3899 ((u8 *) buffer)[0xd], 3900 ((u8 *) buffer)[0xe], 3901 ((u8 *) buffer)[0xf]); 3902 else 3903 len += sprintf(buf + len, "%s\n", 3904 snprint_line(line, sizeof(line), 3905 (u8 *) buffer, 16, loop)); 3906 loop += 16; 3907 } 3908 3909 return len; 3910 } 3911 3912 static ssize_t store_memory(struct device *d, struct device_attribute *attr, 3913 const char *buf, size_t count) 3914 { 3915 struct ipw2100_priv *priv = dev_get_drvdata(d); 3916 struct net_device *dev = priv->net_dev; 3917 const char *p = buf; 3918 3919 (void)dev; /* kill unused-var warning for debug-only code */ 3920 3921 if (count < 1) 3922 return count; 3923 3924 if (p[0] == '1' || 3925 (count >= 2 && tolower(p[0]) == 'o' && tolower(p[1]) == 'n')) { 3926 IPW_DEBUG_INFO("%s: Setting memory dump to RAW mode.\n", 3927 dev->name); 3928 priv->dump_raw = 1; 3929 3930 } else if (p[0] == '0' || (count >= 2 && tolower(p[0]) == 'o' && 3931 tolower(p[1]) == 'f')) { 3932 IPW_DEBUG_INFO("%s: Setting memory dump to HEX mode.\n", 3933 dev->name); 3934 priv->dump_raw = 0; 3935 3936 } else if (tolower(p[0]) == 'r') { 3937 IPW_DEBUG_INFO("%s: Resetting firmware snapshot.\n", dev->name); 3938 ipw2100_snapshot_free(priv); 3939 3940 } else 3941 IPW_DEBUG_INFO("%s: Usage: 0|on = HEX, 1|off = RAW, " 3942 "reset = clear memory snapshot\n", dev->name); 3943 3944 return count; 3945 } 3946 3947 static DEVICE_ATTR(memory, 0644, show_memory, store_memory); 3948 3949 static ssize_t show_ordinals(struct device *d, struct device_attribute *attr, 3950 char *buf) 3951 { 3952 struct ipw2100_priv *priv = dev_get_drvdata(d); 3953 u32 val = 0; 3954 int len = 0; 3955 u32 val_len; 3956 static int loop = 0; 3957 3958 if (priv->status & STATUS_RF_KILL_MASK) 3959 return 0; 3960 3961 if (loop >= ARRAY_SIZE(ord_data)) 3962 loop = 0; 3963 3964 /* sysfs provides us PAGE_SIZE buffer */ 3965 while (len < PAGE_SIZE - 128 && loop < ARRAY_SIZE(ord_data)) { 3966 val_len = sizeof(u32); 3967 3968 if (ipw2100_get_ordinal(priv, ord_data[loop].index, &val, 3969 &val_len)) 3970 len += sprintf(buf + len, "[0x%02X] = ERROR %s\n", 3971 ord_data[loop].index, 3972 ord_data[loop].desc); 3973 else 3974 len += sprintf(buf + len, "[0x%02X] = 0x%08X %s\n", 3975 ord_data[loop].index, val, 3976 ord_data[loop].desc); 3977 loop++; 3978 } 3979 3980 return len; 3981 } 3982 3983 static DEVICE_ATTR(ordinals, 0444, show_ordinals, NULL); 3984 3985 static ssize_t show_stats(struct device *d, struct device_attribute *attr, 3986 char *buf) 3987 { 3988 struct ipw2100_priv *priv = dev_get_drvdata(d); 3989 char *out = buf; 3990 3991 out += sprintf(out, "interrupts: %d {tx: %d, rx: %d, other: %d}\n", 3992 priv->interrupts, priv->tx_interrupts, 3993 priv->rx_interrupts, priv->inta_other); 3994 out += sprintf(out, "firmware resets: %d\n", priv->resets); 3995 out += sprintf(out, "firmware hangs: %d\n", priv->hangs); 3996 #ifdef CONFIG_IPW2100_DEBUG 3997 out += sprintf(out, "packet mismatch image: %s\n", 3998 priv->snapshot[0] ? "YES" : "NO"); 3999 #endif 4000 4001 return out - buf; 4002 } 4003 4004 static DEVICE_ATTR(stats, 0444, show_stats, NULL); 4005 4006 static int ipw2100_switch_mode(struct ipw2100_priv *priv, u32 mode) 4007 { 4008 int err; 4009 4010 if (mode == priv->ieee->iw_mode) 4011 return 0; 4012 4013 err = ipw2100_disable_adapter(priv); 4014 if (err) { 4015 printk(KERN_ERR DRV_NAME ": %s: Could not disable adapter %d\n", 4016 priv->net_dev->name, err); 4017 return err; 4018 } 4019 4020 switch (mode) { 4021 case IW_MODE_INFRA: 4022 priv->net_dev->type = ARPHRD_ETHER; 4023 break; 4024 case IW_MODE_ADHOC: 4025 priv->net_dev->type = ARPHRD_ETHER; 4026 break; 4027 #ifdef CONFIG_IPW2100_MONITOR 4028 case IW_MODE_MONITOR: 4029 priv->last_mode = priv->ieee->iw_mode; 4030 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP; 4031 break; 4032 #endif /* CONFIG_IPW2100_MONITOR */ 4033 } 4034 4035 priv->ieee->iw_mode = mode; 4036 4037 #ifdef CONFIG_PM 4038 /* Indicate ipw2100_download_firmware download firmware 4039 * from disk instead of memory. */ 4040 ipw2100_firmware.version = 0; 4041 #endif 4042 4043 printk(KERN_INFO "%s: Resetting on mode change.\n", priv->net_dev->name); 4044 priv->reset_backoff = 0; 4045 schedule_reset(priv); 4046 4047 return 0; 4048 } 4049 4050 static ssize_t show_internals(struct device *d, struct device_attribute *attr, 4051 char *buf) 4052 { 4053 struct ipw2100_priv *priv = dev_get_drvdata(d); 4054 int len = 0; 4055 4056 #define DUMP_VAR(x,y) len += sprintf(buf + len, # x ": %" y "\n", priv-> x) 4057 4058 if (priv->status & STATUS_ASSOCIATED) 4059 len += sprintf(buf + len, "connected: %llu\n", 4060 ktime_get_boottime_seconds() - priv->connect_start); 4061 else 4062 len += sprintf(buf + len, "not connected\n"); 4063 4064 DUMP_VAR(ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx], "p"); 4065 DUMP_VAR(status, "08lx"); 4066 DUMP_VAR(config, "08lx"); 4067 DUMP_VAR(capability, "08lx"); 4068 4069 len += 4070 sprintf(buf + len, "last_rtc: %lu\n", 4071 (unsigned long)priv->last_rtc); 4072 4073 DUMP_VAR(fatal_error, "d"); 4074 DUMP_VAR(stop_hang_check, "d"); 4075 DUMP_VAR(stop_rf_kill, "d"); 4076 DUMP_VAR(messages_sent, "d"); 4077 4078 DUMP_VAR(tx_pend_stat.value, "d"); 4079 DUMP_VAR(tx_pend_stat.hi, "d"); 4080 4081 DUMP_VAR(tx_free_stat.value, "d"); 4082 DUMP_VAR(tx_free_stat.lo, "d"); 4083 4084 DUMP_VAR(msg_free_stat.value, "d"); 4085 DUMP_VAR(msg_free_stat.lo, "d"); 4086 4087 DUMP_VAR(msg_pend_stat.value, "d"); 4088 DUMP_VAR(msg_pend_stat.hi, "d"); 4089 4090 DUMP_VAR(fw_pend_stat.value, "d"); 4091 DUMP_VAR(fw_pend_stat.hi, "d"); 4092 4093 DUMP_VAR(txq_stat.value, "d"); 4094 DUMP_VAR(txq_stat.lo, "d"); 4095 4096 DUMP_VAR(ieee->scans, "d"); 4097 DUMP_VAR(reset_backoff, "lld"); 4098 4099 return len; 4100 } 4101 4102 static DEVICE_ATTR(internals, 0444, show_internals, NULL); 4103 4104 static ssize_t show_bssinfo(struct device *d, struct device_attribute *attr, 4105 char *buf) 4106 { 4107 struct ipw2100_priv *priv = dev_get_drvdata(d); 4108 char essid[IW_ESSID_MAX_SIZE + 1]; 4109 u8 bssid[ETH_ALEN]; 4110 u32 chan = 0; 4111 char *out = buf; 4112 unsigned int length; 4113 int ret; 4114 4115 if (priv->status & STATUS_RF_KILL_MASK) 4116 return 0; 4117 4118 memset(essid, 0, sizeof(essid)); 4119 memset(bssid, 0, sizeof(bssid)); 4120 4121 length = IW_ESSID_MAX_SIZE; 4122 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_SSID, essid, &length); 4123 if (ret) 4124 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 4125 __LINE__); 4126 4127 length = sizeof(bssid); 4128 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID, 4129 bssid, &length); 4130 if (ret) 4131 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 4132 __LINE__); 4133 4134 length = sizeof(u32); 4135 ret = ipw2100_get_ordinal(priv, IPW_ORD_OUR_FREQ, &chan, &length); 4136 if (ret) 4137 IPW_DEBUG_INFO("failed querying ordinals at line %d\n", 4138 __LINE__); 4139 4140 out += sprintf(out, "ESSID: %s\n", essid); 4141 out += sprintf(out, "BSSID: %pM\n", bssid); 4142 out += sprintf(out, "Channel: %d\n", chan); 4143 4144 return out - buf; 4145 } 4146 4147 static DEVICE_ATTR(bssinfo, 0444, show_bssinfo, NULL); 4148 4149 #ifdef CONFIG_IPW2100_DEBUG 4150 static ssize_t debug_level_show(struct device_driver *d, char *buf) 4151 { 4152 return sprintf(buf, "0x%08X\n", ipw2100_debug_level); 4153 } 4154 4155 static ssize_t debug_level_store(struct device_driver *d, 4156 const char *buf, size_t count) 4157 { 4158 u32 val; 4159 int ret; 4160 4161 ret = kstrtou32(buf, 0, &val); 4162 if (ret) 4163 IPW_DEBUG_INFO(": %s is not in hex or decimal form.\n", buf); 4164 else 4165 ipw2100_debug_level = val; 4166 4167 return strnlen(buf, count); 4168 } 4169 static DRIVER_ATTR_RW(debug_level); 4170 #endif /* CONFIG_IPW2100_DEBUG */ 4171 4172 static ssize_t show_fatal_error(struct device *d, 4173 struct device_attribute *attr, char *buf) 4174 { 4175 struct ipw2100_priv *priv = dev_get_drvdata(d); 4176 char *out = buf; 4177 int i; 4178 4179 if (priv->fatal_error) 4180 out += sprintf(out, "0x%08X\n", priv->fatal_error); 4181 else 4182 out += sprintf(out, "0\n"); 4183 4184 for (i = 1; i <= IPW2100_ERROR_QUEUE; i++) { 4185 if (!priv->fatal_errors[(priv->fatal_index - i) % 4186 IPW2100_ERROR_QUEUE]) 4187 continue; 4188 4189 out += sprintf(out, "%d. 0x%08X\n", i, 4190 priv->fatal_errors[(priv->fatal_index - i) % 4191 IPW2100_ERROR_QUEUE]); 4192 } 4193 4194 return out - buf; 4195 } 4196 4197 static ssize_t store_fatal_error(struct device *d, 4198 struct device_attribute *attr, const char *buf, 4199 size_t count) 4200 { 4201 struct ipw2100_priv *priv = dev_get_drvdata(d); 4202 schedule_reset(priv); 4203 return count; 4204 } 4205 4206 static DEVICE_ATTR(fatal_error, 0644, show_fatal_error, store_fatal_error); 4207 4208 static ssize_t show_scan_age(struct device *d, struct device_attribute *attr, 4209 char *buf) 4210 { 4211 struct ipw2100_priv *priv = dev_get_drvdata(d); 4212 return sprintf(buf, "%d\n", priv->ieee->scan_age); 4213 } 4214 4215 static ssize_t store_scan_age(struct device *d, struct device_attribute *attr, 4216 const char *buf, size_t count) 4217 { 4218 struct ipw2100_priv *priv = dev_get_drvdata(d); 4219 struct net_device *dev = priv->net_dev; 4220 unsigned long val; 4221 int ret; 4222 4223 (void)dev; /* kill unused-var warning for debug-only code */ 4224 4225 IPW_DEBUG_INFO("enter\n"); 4226 4227 ret = kstrtoul(buf, 0, &val); 4228 if (ret) { 4229 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name); 4230 } else { 4231 priv->ieee->scan_age = val; 4232 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age); 4233 } 4234 4235 IPW_DEBUG_INFO("exit\n"); 4236 return strnlen(buf, count); 4237 } 4238 4239 static DEVICE_ATTR(scan_age, 0644, show_scan_age, store_scan_age); 4240 4241 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr, 4242 char *buf) 4243 { 4244 /* 0 - RF kill not enabled 4245 1 - SW based RF kill active (sysfs) 4246 2 - HW based RF kill active 4247 3 - Both HW and SW baed RF kill active */ 4248 struct ipw2100_priv *priv = dev_get_drvdata(d); 4249 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) | 4250 (rf_kill_active(priv) ? 0x2 : 0x0); 4251 return sprintf(buf, "%i\n", val); 4252 } 4253 4254 static int ipw_radio_kill_sw(struct ipw2100_priv *priv, int disable_radio) 4255 { 4256 if ((disable_radio ? 1 : 0) == 4257 (priv->status & STATUS_RF_KILL_SW ? 1 : 0)) 4258 return 0; 4259 4260 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n", 4261 disable_radio ? "OFF" : "ON"); 4262 4263 mutex_lock(&priv->action_mutex); 4264 4265 if (disable_radio) { 4266 priv->status |= STATUS_RF_KILL_SW; 4267 ipw2100_down(priv); 4268 } else { 4269 priv->status &= ~STATUS_RF_KILL_SW; 4270 if (rf_kill_active(priv)) { 4271 IPW_DEBUG_RF_KILL("Can not turn radio back on - " 4272 "disabled by HW switch\n"); 4273 /* Make sure the RF_KILL check timer is running */ 4274 priv->stop_rf_kill = 0; 4275 mod_delayed_work(system_wq, &priv->rf_kill, 4276 round_jiffies_relative(HZ)); 4277 } else 4278 schedule_reset(priv); 4279 } 4280 4281 mutex_unlock(&priv->action_mutex); 4282 return 1; 4283 } 4284 4285 static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr, 4286 const char *buf, size_t count) 4287 { 4288 struct ipw2100_priv *priv = dev_get_drvdata(d); 4289 ipw_radio_kill_sw(priv, buf[0] == '1'); 4290 return count; 4291 } 4292 4293 static DEVICE_ATTR(rf_kill, 0644, show_rf_kill, store_rf_kill); 4294 4295 static struct attribute *ipw2100_sysfs_entries[] = { 4296 &dev_attr_hardware.attr, 4297 &dev_attr_registers.attr, 4298 &dev_attr_ordinals.attr, 4299 &dev_attr_pci.attr, 4300 &dev_attr_stats.attr, 4301 &dev_attr_internals.attr, 4302 &dev_attr_bssinfo.attr, 4303 &dev_attr_memory.attr, 4304 &dev_attr_scan_age.attr, 4305 &dev_attr_fatal_error.attr, 4306 &dev_attr_rf_kill.attr, 4307 &dev_attr_cfg.attr, 4308 &dev_attr_status.attr, 4309 &dev_attr_capability.attr, 4310 NULL, 4311 }; 4312 4313 static const struct attribute_group ipw2100_attribute_group = { 4314 .attrs = ipw2100_sysfs_entries, 4315 }; 4316 4317 static int status_queue_allocate(struct ipw2100_priv *priv, int entries) 4318 { 4319 struct ipw2100_status_queue *q = &priv->status_queue; 4320 4321 IPW_DEBUG_INFO("enter\n"); 4322 4323 q->size = entries * sizeof(struct ipw2100_status); 4324 q->drv = pci_zalloc_consistent(priv->pci_dev, q->size, &q->nic); 4325 if (!q->drv) { 4326 IPW_DEBUG_WARNING("Can not allocate status queue.\n"); 4327 return -ENOMEM; 4328 } 4329 4330 IPW_DEBUG_INFO("exit\n"); 4331 4332 return 0; 4333 } 4334 4335 static void status_queue_free(struct ipw2100_priv *priv) 4336 { 4337 IPW_DEBUG_INFO("enter\n"); 4338 4339 if (priv->status_queue.drv) { 4340 pci_free_consistent(priv->pci_dev, priv->status_queue.size, 4341 priv->status_queue.drv, 4342 priv->status_queue.nic); 4343 priv->status_queue.drv = NULL; 4344 } 4345 4346 IPW_DEBUG_INFO("exit\n"); 4347 } 4348 4349 static int bd_queue_allocate(struct ipw2100_priv *priv, 4350 struct ipw2100_bd_queue *q, int entries) 4351 { 4352 IPW_DEBUG_INFO("enter\n"); 4353 4354 memset(q, 0, sizeof(struct ipw2100_bd_queue)); 4355 4356 q->entries = entries; 4357 q->size = entries * sizeof(struct ipw2100_bd); 4358 q->drv = pci_zalloc_consistent(priv->pci_dev, q->size, &q->nic); 4359 if (!q->drv) { 4360 IPW_DEBUG_INFO 4361 ("can't allocate shared memory for buffer descriptors\n"); 4362 return -ENOMEM; 4363 } 4364 4365 IPW_DEBUG_INFO("exit\n"); 4366 4367 return 0; 4368 } 4369 4370 static void bd_queue_free(struct ipw2100_priv *priv, struct ipw2100_bd_queue *q) 4371 { 4372 IPW_DEBUG_INFO("enter\n"); 4373 4374 if (!q) 4375 return; 4376 4377 if (q->drv) { 4378 pci_free_consistent(priv->pci_dev, q->size, q->drv, q->nic); 4379 q->drv = NULL; 4380 } 4381 4382 IPW_DEBUG_INFO("exit\n"); 4383 } 4384 4385 static void bd_queue_initialize(struct ipw2100_priv *priv, 4386 struct ipw2100_bd_queue *q, u32 base, u32 size, 4387 u32 r, u32 w) 4388 { 4389 IPW_DEBUG_INFO("enter\n"); 4390 4391 IPW_DEBUG_INFO("initializing bd queue at virt=%p, phys=%08x\n", q->drv, 4392 (u32) q->nic); 4393 4394 write_register(priv->net_dev, base, q->nic); 4395 write_register(priv->net_dev, size, q->entries); 4396 write_register(priv->net_dev, r, q->oldest); 4397 write_register(priv->net_dev, w, q->next); 4398 4399 IPW_DEBUG_INFO("exit\n"); 4400 } 4401 4402 static void ipw2100_kill_works(struct ipw2100_priv *priv) 4403 { 4404 priv->stop_rf_kill = 1; 4405 priv->stop_hang_check = 1; 4406 cancel_delayed_work_sync(&priv->reset_work); 4407 cancel_delayed_work_sync(&priv->security_work); 4408 cancel_delayed_work_sync(&priv->wx_event_work); 4409 cancel_delayed_work_sync(&priv->hang_check); 4410 cancel_delayed_work_sync(&priv->rf_kill); 4411 cancel_delayed_work_sync(&priv->scan_event); 4412 } 4413 4414 static int ipw2100_tx_allocate(struct ipw2100_priv *priv) 4415 { 4416 int i, j, err; 4417 void *v; 4418 dma_addr_t p; 4419 4420 IPW_DEBUG_INFO("enter\n"); 4421 4422 err = bd_queue_allocate(priv, &priv->tx_queue, TX_QUEUE_LENGTH); 4423 if (err) { 4424 IPW_DEBUG_ERROR("%s: failed bd_queue_allocate\n", 4425 priv->net_dev->name); 4426 return err; 4427 } 4428 4429 priv->tx_buffers = kmalloc_array(TX_PENDED_QUEUE_LENGTH, 4430 sizeof(struct ipw2100_tx_packet), 4431 GFP_ATOMIC); 4432 if (!priv->tx_buffers) { 4433 bd_queue_free(priv, &priv->tx_queue); 4434 return -ENOMEM; 4435 } 4436 4437 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) { 4438 v = pci_alloc_consistent(priv->pci_dev, 4439 sizeof(struct ipw2100_data_header), 4440 &p); 4441 if (!v) { 4442 printk(KERN_ERR DRV_NAME 4443 ": %s: PCI alloc failed for tx " "buffers.\n", 4444 priv->net_dev->name); 4445 err = -ENOMEM; 4446 break; 4447 } 4448 4449 priv->tx_buffers[i].type = DATA; 4450 priv->tx_buffers[i].info.d_struct.data = 4451 (struct ipw2100_data_header *)v; 4452 priv->tx_buffers[i].info.d_struct.data_phys = p; 4453 priv->tx_buffers[i].info.d_struct.txb = NULL; 4454 } 4455 4456 if (i == TX_PENDED_QUEUE_LENGTH) 4457 return 0; 4458 4459 for (j = 0; j < i; j++) { 4460 pci_free_consistent(priv->pci_dev, 4461 sizeof(struct ipw2100_data_header), 4462 priv->tx_buffers[j].info.d_struct.data, 4463 priv->tx_buffers[j].info.d_struct. 4464 data_phys); 4465 } 4466 4467 kfree(priv->tx_buffers); 4468 priv->tx_buffers = NULL; 4469 4470 return err; 4471 } 4472 4473 static void ipw2100_tx_initialize(struct ipw2100_priv *priv) 4474 { 4475 int i; 4476 4477 IPW_DEBUG_INFO("enter\n"); 4478 4479 /* 4480 * reinitialize packet info lists 4481 */ 4482 INIT_LIST_HEAD(&priv->fw_pend_list); 4483 INIT_STAT(&priv->fw_pend_stat); 4484 4485 /* 4486 * reinitialize lists 4487 */ 4488 INIT_LIST_HEAD(&priv->tx_pend_list); 4489 INIT_LIST_HEAD(&priv->tx_free_list); 4490 INIT_STAT(&priv->tx_pend_stat); 4491 INIT_STAT(&priv->tx_free_stat); 4492 4493 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) { 4494 /* We simply drop any SKBs that have been queued for 4495 * transmit */ 4496 if (priv->tx_buffers[i].info.d_struct.txb) { 4497 libipw_txb_free(priv->tx_buffers[i].info.d_struct. 4498 txb); 4499 priv->tx_buffers[i].info.d_struct.txb = NULL; 4500 } 4501 4502 list_add_tail(&priv->tx_buffers[i].list, &priv->tx_free_list); 4503 } 4504 4505 SET_STAT(&priv->tx_free_stat, i); 4506 4507 priv->tx_queue.oldest = 0; 4508 priv->tx_queue.available = priv->tx_queue.entries; 4509 priv->tx_queue.next = 0; 4510 INIT_STAT(&priv->txq_stat); 4511 SET_STAT(&priv->txq_stat, priv->tx_queue.available); 4512 4513 bd_queue_initialize(priv, &priv->tx_queue, 4514 IPW_MEM_HOST_SHARED_TX_QUEUE_BD_BASE, 4515 IPW_MEM_HOST_SHARED_TX_QUEUE_BD_SIZE, 4516 IPW_MEM_HOST_SHARED_TX_QUEUE_READ_INDEX, 4517 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX); 4518 4519 IPW_DEBUG_INFO("exit\n"); 4520 4521 } 4522 4523 static void ipw2100_tx_free(struct ipw2100_priv *priv) 4524 { 4525 int i; 4526 4527 IPW_DEBUG_INFO("enter\n"); 4528 4529 bd_queue_free(priv, &priv->tx_queue); 4530 4531 if (!priv->tx_buffers) 4532 return; 4533 4534 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) { 4535 if (priv->tx_buffers[i].info.d_struct.txb) { 4536 libipw_txb_free(priv->tx_buffers[i].info.d_struct. 4537 txb); 4538 priv->tx_buffers[i].info.d_struct.txb = NULL; 4539 } 4540 if (priv->tx_buffers[i].info.d_struct.data) 4541 pci_free_consistent(priv->pci_dev, 4542 sizeof(struct ipw2100_data_header), 4543 priv->tx_buffers[i].info.d_struct. 4544 data, 4545 priv->tx_buffers[i].info.d_struct. 4546 data_phys); 4547 } 4548 4549 kfree(priv->tx_buffers); 4550 priv->tx_buffers = NULL; 4551 4552 IPW_DEBUG_INFO("exit\n"); 4553 } 4554 4555 static int ipw2100_rx_allocate(struct ipw2100_priv *priv) 4556 { 4557 int i, j, err = -EINVAL; 4558 4559 IPW_DEBUG_INFO("enter\n"); 4560 4561 err = bd_queue_allocate(priv, &priv->rx_queue, RX_QUEUE_LENGTH); 4562 if (err) { 4563 IPW_DEBUG_INFO("failed bd_queue_allocate\n"); 4564 return err; 4565 } 4566 4567 err = status_queue_allocate(priv, RX_QUEUE_LENGTH); 4568 if (err) { 4569 IPW_DEBUG_INFO("failed status_queue_allocate\n"); 4570 bd_queue_free(priv, &priv->rx_queue); 4571 return err; 4572 } 4573 4574 /* 4575 * allocate packets 4576 */ 4577 priv->rx_buffers = kmalloc_array(RX_QUEUE_LENGTH, 4578 sizeof(struct ipw2100_rx_packet), 4579 GFP_KERNEL); 4580 if (!priv->rx_buffers) { 4581 IPW_DEBUG_INFO("can't allocate rx packet buffer table\n"); 4582 4583 bd_queue_free(priv, &priv->rx_queue); 4584 4585 status_queue_free(priv); 4586 4587 return -ENOMEM; 4588 } 4589 4590 for (i = 0; i < RX_QUEUE_LENGTH; i++) { 4591 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i]; 4592 4593 err = ipw2100_alloc_skb(priv, packet); 4594 if (unlikely(err)) { 4595 err = -ENOMEM; 4596 break; 4597 } 4598 4599 /* The BD holds the cache aligned address */ 4600 priv->rx_queue.drv[i].host_addr = packet->dma_addr; 4601 priv->rx_queue.drv[i].buf_length = IPW_RX_NIC_BUFFER_LENGTH; 4602 priv->status_queue.drv[i].status_fields = 0; 4603 } 4604 4605 if (i == RX_QUEUE_LENGTH) 4606 return 0; 4607 4608 for (j = 0; j < i; j++) { 4609 pci_unmap_single(priv->pci_dev, priv->rx_buffers[j].dma_addr, 4610 sizeof(struct ipw2100_rx_packet), 4611 PCI_DMA_FROMDEVICE); 4612 dev_kfree_skb(priv->rx_buffers[j].skb); 4613 } 4614 4615 kfree(priv->rx_buffers); 4616 priv->rx_buffers = NULL; 4617 4618 bd_queue_free(priv, &priv->rx_queue); 4619 4620 status_queue_free(priv); 4621 4622 return err; 4623 } 4624 4625 static void ipw2100_rx_initialize(struct ipw2100_priv *priv) 4626 { 4627 IPW_DEBUG_INFO("enter\n"); 4628 4629 priv->rx_queue.oldest = 0; 4630 priv->rx_queue.available = priv->rx_queue.entries - 1; 4631 priv->rx_queue.next = priv->rx_queue.entries - 1; 4632 4633 INIT_STAT(&priv->rxq_stat); 4634 SET_STAT(&priv->rxq_stat, priv->rx_queue.available); 4635 4636 bd_queue_initialize(priv, &priv->rx_queue, 4637 IPW_MEM_HOST_SHARED_RX_BD_BASE, 4638 IPW_MEM_HOST_SHARED_RX_BD_SIZE, 4639 IPW_MEM_HOST_SHARED_RX_READ_INDEX, 4640 IPW_MEM_HOST_SHARED_RX_WRITE_INDEX); 4641 4642 /* set up the status queue */ 4643 write_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_STATUS_BASE, 4644 priv->status_queue.nic); 4645 4646 IPW_DEBUG_INFO("exit\n"); 4647 } 4648 4649 static void ipw2100_rx_free(struct ipw2100_priv *priv) 4650 { 4651 int i; 4652 4653 IPW_DEBUG_INFO("enter\n"); 4654 4655 bd_queue_free(priv, &priv->rx_queue); 4656 status_queue_free(priv); 4657 4658 if (!priv->rx_buffers) 4659 return; 4660 4661 for (i = 0; i < RX_QUEUE_LENGTH; i++) { 4662 if (priv->rx_buffers[i].rxp) { 4663 pci_unmap_single(priv->pci_dev, 4664 priv->rx_buffers[i].dma_addr, 4665 sizeof(struct ipw2100_rx), 4666 PCI_DMA_FROMDEVICE); 4667 dev_kfree_skb(priv->rx_buffers[i].skb); 4668 } 4669 } 4670 4671 kfree(priv->rx_buffers); 4672 priv->rx_buffers = NULL; 4673 4674 IPW_DEBUG_INFO("exit\n"); 4675 } 4676 4677 static int ipw2100_read_mac_address(struct ipw2100_priv *priv) 4678 { 4679 u32 length = ETH_ALEN; 4680 u8 addr[ETH_ALEN]; 4681 4682 int err; 4683 4684 err = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ADAPTER_MAC, addr, &length); 4685 if (err) { 4686 IPW_DEBUG_INFO("MAC address read failed\n"); 4687 return -EIO; 4688 } 4689 4690 memcpy(priv->net_dev->dev_addr, addr, ETH_ALEN); 4691 IPW_DEBUG_INFO("card MAC is %pM\n", priv->net_dev->dev_addr); 4692 4693 return 0; 4694 } 4695 4696 /******************************************************************** 4697 * 4698 * Firmware Commands 4699 * 4700 ********************************************************************/ 4701 4702 static int ipw2100_set_mac_address(struct ipw2100_priv *priv, int batch_mode) 4703 { 4704 struct host_command cmd = { 4705 .host_command = ADAPTER_ADDRESS, 4706 .host_command_sequence = 0, 4707 .host_command_length = ETH_ALEN 4708 }; 4709 int err; 4710 4711 IPW_DEBUG_HC("SET_MAC_ADDRESS\n"); 4712 4713 IPW_DEBUG_INFO("enter\n"); 4714 4715 if (priv->config & CFG_CUSTOM_MAC) { 4716 memcpy(cmd.host_command_parameters, priv->mac_addr, ETH_ALEN); 4717 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN); 4718 } else 4719 memcpy(cmd.host_command_parameters, priv->net_dev->dev_addr, 4720 ETH_ALEN); 4721 4722 err = ipw2100_hw_send_command(priv, &cmd); 4723 4724 IPW_DEBUG_INFO("exit\n"); 4725 return err; 4726 } 4727 4728 static int ipw2100_set_port_type(struct ipw2100_priv *priv, u32 port_type, 4729 int batch_mode) 4730 { 4731 struct host_command cmd = { 4732 .host_command = PORT_TYPE, 4733 .host_command_sequence = 0, 4734 .host_command_length = sizeof(u32) 4735 }; 4736 int err; 4737 4738 switch (port_type) { 4739 case IW_MODE_INFRA: 4740 cmd.host_command_parameters[0] = IPW_BSS; 4741 break; 4742 case IW_MODE_ADHOC: 4743 cmd.host_command_parameters[0] = IPW_IBSS; 4744 break; 4745 } 4746 4747 IPW_DEBUG_HC("PORT_TYPE: %s\n", 4748 port_type == IPW_IBSS ? "Ad-Hoc" : "Managed"); 4749 4750 if (!batch_mode) { 4751 err = ipw2100_disable_adapter(priv); 4752 if (err) { 4753 printk(KERN_ERR DRV_NAME 4754 ": %s: Could not disable adapter %d\n", 4755 priv->net_dev->name, err); 4756 return err; 4757 } 4758 } 4759 4760 /* send cmd to firmware */ 4761 err = ipw2100_hw_send_command(priv, &cmd); 4762 4763 if (!batch_mode) 4764 ipw2100_enable_adapter(priv); 4765 4766 return err; 4767 } 4768 4769 static int ipw2100_set_channel(struct ipw2100_priv *priv, u32 channel, 4770 int batch_mode) 4771 { 4772 struct host_command cmd = { 4773 .host_command = CHANNEL, 4774 .host_command_sequence = 0, 4775 .host_command_length = sizeof(u32) 4776 }; 4777 int err; 4778 4779 cmd.host_command_parameters[0] = channel; 4780 4781 IPW_DEBUG_HC("CHANNEL: %d\n", channel); 4782 4783 /* If BSS then we don't support channel selection */ 4784 if (priv->ieee->iw_mode == IW_MODE_INFRA) 4785 return 0; 4786 4787 if ((channel != 0) && 4788 ((channel < REG_MIN_CHANNEL) || (channel > REG_MAX_CHANNEL))) 4789 return -EINVAL; 4790 4791 if (!batch_mode) { 4792 err = ipw2100_disable_adapter(priv); 4793 if (err) 4794 return err; 4795 } 4796 4797 err = ipw2100_hw_send_command(priv, &cmd); 4798 if (err) { 4799 IPW_DEBUG_INFO("Failed to set channel to %d", channel); 4800 return err; 4801 } 4802 4803 if (channel) 4804 priv->config |= CFG_STATIC_CHANNEL; 4805 else 4806 priv->config &= ~CFG_STATIC_CHANNEL; 4807 4808 priv->channel = channel; 4809 4810 if (!batch_mode) { 4811 err = ipw2100_enable_adapter(priv); 4812 if (err) 4813 return err; 4814 } 4815 4816 return 0; 4817 } 4818 4819 static int ipw2100_system_config(struct ipw2100_priv *priv, int batch_mode) 4820 { 4821 struct host_command cmd = { 4822 .host_command = SYSTEM_CONFIG, 4823 .host_command_sequence = 0, 4824 .host_command_length = 12, 4825 }; 4826 u32 ibss_mask, len = sizeof(u32); 4827 int err; 4828 4829 /* Set system configuration */ 4830 4831 if (!batch_mode) { 4832 err = ipw2100_disable_adapter(priv); 4833 if (err) 4834 return err; 4835 } 4836 4837 if (priv->ieee->iw_mode == IW_MODE_ADHOC) 4838 cmd.host_command_parameters[0] |= IPW_CFG_IBSS_AUTO_START; 4839 4840 cmd.host_command_parameters[0] |= IPW_CFG_IBSS_MASK | 4841 IPW_CFG_BSS_MASK | IPW_CFG_802_1x_ENABLE; 4842 4843 if (!(priv->config & CFG_LONG_PREAMBLE)) 4844 cmd.host_command_parameters[0] |= IPW_CFG_PREAMBLE_AUTO; 4845 4846 err = ipw2100_get_ordinal(priv, 4847 IPW_ORD_EEPROM_IBSS_11B_CHANNELS, 4848 &ibss_mask, &len); 4849 if (err) 4850 ibss_mask = IPW_IBSS_11B_DEFAULT_MASK; 4851 4852 cmd.host_command_parameters[1] = REG_CHANNEL_MASK; 4853 cmd.host_command_parameters[2] = REG_CHANNEL_MASK & ibss_mask; 4854 4855 /* 11b only */ 4856 /*cmd.host_command_parameters[0] |= DIVERSITY_ANTENNA_A; */ 4857 4858 err = ipw2100_hw_send_command(priv, &cmd); 4859 if (err) 4860 return err; 4861 4862 /* If IPv6 is configured in the kernel then we don't want to filter out all 4863 * of the multicast packets as IPv6 needs some. */ 4864 #if !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE) 4865 cmd.host_command = ADD_MULTICAST; 4866 cmd.host_command_sequence = 0; 4867 cmd.host_command_length = 0; 4868 4869 ipw2100_hw_send_command(priv, &cmd); 4870 #endif 4871 if (!batch_mode) { 4872 err = ipw2100_enable_adapter(priv); 4873 if (err) 4874 return err; 4875 } 4876 4877 return 0; 4878 } 4879 4880 static int ipw2100_set_tx_rates(struct ipw2100_priv *priv, u32 rate, 4881 int batch_mode) 4882 { 4883 struct host_command cmd = { 4884 .host_command = BASIC_TX_RATES, 4885 .host_command_sequence = 0, 4886 .host_command_length = 4 4887 }; 4888 int err; 4889 4890 cmd.host_command_parameters[0] = rate & TX_RATE_MASK; 4891 4892 if (!batch_mode) { 4893 err = ipw2100_disable_adapter(priv); 4894 if (err) 4895 return err; 4896 } 4897 4898 /* Set BASIC TX Rate first */ 4899 ipw2100_hw_send_command(priv, &cmd); 4900 4901 /* Set TX Rate */ 4902 cmd.host_command = TX_RATES; 4903 ipw2100_hw_send_command(priv, &cmd); 4904 4905 /* Set MSDU TX Rate */ 4906 cmd.host_command = MSDU_TX_RATES; 4907 ipw2100_hw_send_command(priv, &cmd); 4908 4909 if (!batch_mode) { 4910 err = ipw2100_enable_adapter(priv); 4911 if (err) 4912 return err; 4913 } 4914 4915 priv->tx_rates = rate; 4916 4917 return 0; 4918 } 4919 4920 static int ipw2100_set_power_mode(struct ipw2100_priv *priv, int power_level) 4921 { 4922 struct host_command cmd = { 4923 .host_command = POWER_MODE, 4924 .host_command_sequence = 0, 4925 .host_command_length = 4 4926 }; 4927 int err; 4928 4929 cmd.host_command_parameters[0] = power_level; 4930 4931 err = ipw2100_hw_send_command(priv, &cmd); 4932 if (err) 4933 return err; 4934 4935 if (power_level == IPW_POWER_MODE_CAM) 4936 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode); 4937 else 4938 priv->power_mode = IPW_POWER_ENABLED | power_level; 4939 4940 #ifdef IPW2100_TX_POWER 4941 if (priv->port_type == IBSS && priv->adhoc_power != DFTL_IBSS_TX_POWER) { 4942 /* Set beacon interval */ 4943 cmd.host_command = TX_POWER_INDEX; 4944 cmd.host_command_parameters[0] = (u32) priv->adhoc_power; 4945 4946 err = ipw2100_hw_send_command(priv, &cmd); 4947 if (err) 4948 return err; 4949 } 4950 #endif 4951 4952 return 0; 4953 } 4954 4955 static int ipw2100_set_rts_threshold(struct ipw2100_priv *priv, u32 threshold) 4956 { 4957 struct host_command cmd = { 4958 .host_command = RTS_THRESHOLD, 4959 .host_command_sequence = 0, 4960 .host_command_length = 4 4961 }; 4962 int err; 4963 4964 if (threshold & RTS_DISABLED) 4965 cmd.host_command_parameters[0] = MAX_RTS_THRESHOLD; 4966 else 4967 cmd.host_command_parameters[0] = threshold & ~RTS_DISABLED; 4968 4969 err = ipw2100_hw_send_command(priv, &cmd); 4970 if (err) 4971 return err; 4972 4973 priv->rts_threshold = threshold; 4974 4975 return 0; 4976 } 4977 4978 #if 0 4979 int ipw2100_set_fragmentation_threshold(struct ipw2100_priv *priv, 4980 u32 threshold, int batch_mode) 4981 { 4982 struct host_command cmd = { 4983 .host_command = FRAG_THRESHOLD, 4984 .host_command_sequence = 0, 4985 .host_command_length = 4, 4986 .host_command_parameters[0] = 0, 4987 }; 4988 int err; 4989 4990 if (!batch_mode) { 4991 err = ipw2100_disable_adapter(priv); 4992 if (err) 4993 return err; 4994 } 4995 4996 if (threshold == 0) 4997 threshold = DEFAULT_FRAG_THRESHOLD; 4998 else { 4999 threshold = max(threshold, MIN_FRAG_THRESHOLD); 5000 threshold = min(threshold, MAX_FRAG_THRESHOLD); 5001 } 5002 5003 cmd.host_command_parameters[0] = threshold; 5004 5005 IPW_DEBUG_HC("FRAG_THRESHOLD: %u\n", threshold); 5006 5007 err = ipw2100_hw_send_command(priv, &cmd); 5008 5009 if (!batch_mode) 5010 ipw2100_enable_adapter(priv); 5011 5012 if (!err) 5013 priv->frag_threshold = threshold; 5014 5015 return err; 5016 } 5017 #endif 5018 5019 static int ipw2100_set_short_retry(struct ipw2100_priv *priv, u32 retry) 5020 { 5021 struct host_command cmd = { 5022 .host_command = SHORT_RETRY_LIMIT, 5023 .host_command_sequence = 0, 5024 .host_command_length = 4 5025 }; 5026 int err; 5027 5028 cmd.host_command_parameters[0] = retry; 5029 5030 err = ipw2100_hw_send_command(priv, &cmd); 5031 if (err) 5032 return err; 5033 5034 priv->short_retry_limit = retry; 5035 5036 return 0; 5037 } 5038 5039 static int ipw2100_set_long_retry(struct ipw2100_priv *priv, u32 retry) 5040 { 5041 struct host_command cmd = { 5042 .host_command = LONG_RETRY_LIMIT, 5043 .host_command_sequence = 0, 5044 .host_command_length = 4 5045 }; 5046 int err; 5047 5048 cmd.host_command_parameters[0] = retry; 5049 5050 err = ipw2100_hw_send_command(priv, &cmd); 5051 if (err) 5052 return err; 5053 5054 priv->long_retry_limit = retry; 5055 5056 return 0; 5057 } 5058 5059 static int ipw2100_set_mandatory_bssid(struct ipw2100_priv *priv, u8 * bssid, 5060 int batch_mode) 5061 { 5062 struct host_command cmd = { 5063 .host_command = MANDATORY_BSSID, 5064 .host_command_sequence = 0, 5065 .host_command_length = (bssid == NULL) ? 0 : ETH_ALEN 5066 }; 5067 int err; 5068 5069 #ifdef CONFIG_IPW2100_DEBUG 5070 if (bssid != NULL) 5071 IPW_DEBUG_HC("MANDATORY_BSSID: %pM\n", bssid); 5072 else 5073 IPW_DEBUG_HC("MANDATORY_BSSID: <clear>\n"); 5074 #endif 5075 /* if BSSID is empty then we disable mandatory bssid mode */ 5076 if (bssid != NULL) 5077 memcpy(cmd.host_command_parameters, bssid, ETH_ALEN); 5078 5079 if (!batch_mode) { 5080 err = ipw2100_disable_adapter(priv); 5081 if (err) 5082 return err; 5083 } 5084 5085 err = ipw2100_hw_send_command(priv, &cmd); 5086 5087 if (!batch_mode) 5088 ipw2100_enable_adapter(priv); 5089 5090 return err; 5091 } 5092 5093 static int ipw2100_disassociate_bssid(struct ipw2100_priv *priv) 5094 { 5095 struct host_command cmd = { 5096 .host_command = DISASSOCIATION_BSSID, 5097 .host_command_sequence = 0, 5098 .host_command_length = ETH_ALEN 5099 }; 5100 int err; 5101 5102 IPW_DEBUG_HC("DISASSOCIATION_BSSID\n"); 5103 5104 /* The Firmware currently ignores the BSSID and just disassociates from 5105 * the currently associated AP -- but in the off chance that a future 5106 * firmware does use the BSSID provided here, we go ahead and try and 5107 * set it to the currently associated AP's BSSID */ 5108 memcpy(cmd.host_command_parameters, priv->bssid, ETH_ALEN); 5109 5110 err = ipw2100_hw_send_command(priv, &cmd); 5111 5112 return err; 5113 } 5114 5115 static int ipw2100_set_wpa_ie(struct ipw2100_priv *, 5116 struct ipw2100_wpa_assoc_frame *, int) 5117 __attribute__ ((unused)); 5118 5119 static int ipw2100_set_wpa_ie(struct ipw2100_priv *priv, 5120 struct ipw2100_wpa_assoc_frame *wpa_frame, 5121 int batch_mode) 5122 { 5123 struct host_command cmd = { 5124 .host_command = SET_WPA_IE, 5125 .host_command_sequence = 0, 5126 .host_command_length = sizeof(struct ipw2100_wpa_assoc_frame), 5127 }; 5128 int err; 5129 5130 IPW_DEBUG_HC("SET_WPA_IE\n"); 5131 5132 if (!batch_mode) { 5133 err = ipw2100_disable_adapter(priv); 5134 if (err) 5135 return err; 5136 } 5137 5138 memcpy(cmd.host_command_parameters, wpa_frame, 5139 sizeof(struct ipw2100_wpa_assoc_frame)); 5140 5141 err = ipw2100_hw_send_command(priv, &cmd); 5142 5143 if (!batch_mode) { 5144 if (ipw2100_enable_adapter(priv)) 5145 err = -EIO; 5146 } 5147 5148 return err; 5149 } 5150 5151 struct security_info_params { 5152 u32 allowed_ciphers; 5153 u16 version; 5154 u8 auth_mode; 5155 u8 replay_counters_number; 5156 u8 unicast_using_group; 5157 } __packed; 5158 5159 static int ipw2100_set_security_information(struct ipw2100_priv *priv, 5160 int auth_mode, 5161 int security_level, 5162 int unicast_using_group, 5163 int batch_mode) 5164 { 5165 struct host_command cmd = { 5166 .host_command = SET_SECURITY_INFORMATION, 5167 .host_command_sequence = 0, 5168 .host_command_length = sizeof(struct security_info_params) 5169 }; 5170 struct security_info_params *security = 5171 (struct security_info_params *)&cmd.host_command_parameters; 5172 int err; 5173 memset(security, 0, sizeof(*security)); 5174 5175 /* If shared key AP authentication is turned on, then we need to 5176 * configure the firmware to try and use it. 5177 * 5178 * Actual data encryption/decryption is handled by the host. */ 5179 security->auth_mode = auth_mode; 5180 security->unicast_using_group = unicast_using_group; 5181 5182 switch (security_level) { 5183 default: 5184 case SEC_LEVEL_0: 5185 security->allowed_ciphers = IPW_NONE_CIPHER; 5186 break; 5187 case SEC_LEVEL_1: 5188 security->allowed_ciphers = IPW_WEP40_CIPHER | 5189 IPW_WEP104_CIPHER; 5190 break; 5191 case SEC_LEVEL_2: 5192 security->allowed_ciphers = IPW_WEP40_CIPHER | 5193 IPW_WEP104_CIPHER | IPW_TKIP_CIPHER; 5194 break; 5195 case SEC_LEVEL_2_CKIP: 5196 security->allowed_ciphers = IPW_WEP40_CIPHER | 5197 IPW_WEP104_CIPHER | IPW_CKIP_CIPHER; 5198 break; 5199 case SEC_LEVEL_3: 5200 security->allowed_ciphers = IPW_WEP40_CIPHER | 5201 IPW_WEP104_CIPHER | IPW_TKIP_CIPHER | IPW_CCMP_CIPHER; 5202 break; 5203 } 5204 5205 IPW_DEBUG_HC 5206 ("SET_SECURITY_INFORMATION: auth:%d cipher:0x%02X (level %d)\n", 5207 security->auth_mode, security->allowed_ciphers, security_level); 5208 5209 security->replay_counters_number = 0; 5210 5211 if (!batch_mode) { 5212 err = ipw2100_disable_adapter(priv); 5213 if (err) 5214 return err; 5215 } 5216 5217 err = ipw2100_hw_send_command(priv, &cmd); 5218 5219 if (!batch_mode) 5220 ipw2100_enable_adapter(priv); 5221 5222 return err; 5223 } 5224 5225 static int ipw2100_set_tx_power(struct ipw2100_priv *priv, u32 tx_power) 5226 { 5227 struct host_command cmd = { 5228 .host_command = TX_POWER_INDEX, 5229 .host_command_sequence = 0, 5230 .host_command_length = 4 5231 }; 5232 int err = 0; 5233 u32 tmp = tx_power; 5234 5235 if (tx_power != IPW_TX_POWER_DEFAULT) 5236 tmp = (tx_power - IPW_TX_POWER_MIN_DBM) * 16 / 5237 (IPW_TX_POWER_MAX_DBM - IPW_TX_POWER_MIN_DBM); 5238 5239 cmd.host_command_parameters[0] = tmp; 5240 5241 if (priv->ieee->iw_mode == IW_MODE_ADHOC) 5242 err = ipw2100_hw_send_command(priv, &cmd); 5243 if (!err) 5244 priv->tx_power = tx_power; 5245 5246 return 0; 5247 } 5248 5249 static int ipw2100_set_ibss_beacon_interval(struct ipw2100_priv *priv, 5250 u32 interval, int batch_mode) 5251 { 5252 struct host_command cmd = { 5253 .host_command = BEACON_INTERVAL, 5254 .host_command_sequence = 0, 5255 .host_command_length = 4 5256 }; 5257 int err; 5258 5259 cmd.host_command_parameters[0] = interval; 5260 5261 IPW_DEBUG_INFO("enter\n"); 5262 5263 if (priv->ieee->iw_mode == IW_MODE_ADHOC) { 5264 if (!batch_mode) { 5265 err = ipw2100_disable_adapter(priv); 5266 if (err) 5267 return err; 5268 } 5269 5270 ipw2100_hw_send_command(priv, &cmd); 5271 5272 if (!batch_mode) { 5273 err = ipw2100_enable_adapter(priv); 5274 if (err) 5275 return err; 5276 } 5277 } 5278 5279 IPW_DEBUG_INFO("exit\n"); 5280 5281 return 0; 5282 } 5283 5284 static void ipw2100_queues_initialize(struct ipw2100_priv *priv) 5285 { 5286 ipw2100_tx_initialize(priv); 5287 ipw2100_rx_initialize(priv); 5288 ipw2100_msg_initialize(priv); 5289 } 5290 5291 static void ipw2100_queues_free(struct ipw2100_priv *priv) 5292 { 5293 ipw2100_tx_free(priv); 5294 ipw2100_rx_free(priv); 5295 ipw2100_msg_free(priv); 5296 } 5297 5298 static int ipw2100_queues_allocate(struct ipw2100_priv *priv) 5299 { 5300 if (ipw2100_tx_allocate(priv) || 5301 ipw2100_rx_allocate(priv) || ipw2100_msg_allocate(priv)) 5302 goto fail; 5303 5304 return 0; 5305 5306 fail: 5307 ipw2100_tx_free(priv); 5308 ipw2100_rx_free(priv); 5309 ipw2100_msg_free(priv); 5310 return -ENOMEM; 5311 } 5312 5313 #define IPW_PRIVACY_CAPABLE 0x0008 5314 5315 static int ipw2100_set_wep_flags(struct ipw2100_priv *priv, u32 flags, 5316 int batch_mode) 5317 { 5318 struct host_command cmd = { 5319 .host_command = WEP_FLAGS, 5320 .host_command_sequence = 0, 5321 .host_command_length = 4 5322 }; 5323 int err; 5324 5325 cmd.host_command_parameters[0] = flags; 5326 5327 IPW_DEBUG_HC("WEP_FLAGS: flags = 0x%08X\n", flags); 5328 5329 if (!batch_mode) { 5330 err = ipw2100_disable_adapter(priv); 5331 if (err) { 5332 printk(KERN_ERR DRV_NAME 5333 ": %s: Could not disable adapter %d\n", 5334 priv->net_dev->name, err); 5335 return err; 5336 } 5337 } 5338 5339 /* send cmd to firmware */ 5340 err = ipw2100_hw_send_command(priv, &cmd); 5341 5342 if (!batch_mode) 5343 ipw2100_enable_adapter(priv); 5344 5345 return err; 5346 } 5347 5348 struct ipw2100_wep_key { 5349 u8 idx; 5350 u8 len; 5351 u8 key[13]; 5352 }; 5353 5354 /* Macros to ease up priting WEP keys */ 5355 #define WEP_FMT_64 "%02X%02X%02X%02X-%02X" 5356 #define WEP_FMT_128 "%02X%02X%02X%02X-%02X%02X%02X%02X-%02X%02X%02X" 5357 #define WEP_STR_64(x) x[0],x[1],x[2],x[3],x[4] 5358 #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] 5359 5360 /** 5361 * Set a the wep key 5362 * 5363 * @priv: struct to work on 5364 * @idx: index of the key we want to set 5365 * @key: ptr to the key data to set 5366 * @len: length of the buffer at @key 5367 * @batch_mode: FIXME perform the operation in batch mode, not 5368 * disabling the device. 5369 * 5370 * @returns 0 if OK, < 0 errno code on error. 5371 * 5372 * Fill out a command structure with the new wep key, length an 5373 * index and send it down the wire. 5374 */ 5375 static int ipw2100_set_key(struct ipw2100_priv *priv, 5376 int idx, char *key, int len, int batch_mode) 5377 { 5378 int keylen = len ? (len <= 5 ? 5 : 13) : 0; 5379 struct host_command cmd = { 5380 .host_command = WEP_KEY_INFO, 5381 .host_command_sequence = 0, 5382 .host_command_length = sizeof(struct ipw2100_wep_key), 5383 }; 5384 struct ipw2100_wep_key *wep_key = (void *)cmd.host_command_parameters; 5385 int err; 5386 5387 IPW_DEBUG_HC("WEP_KEY_INFO: index = %d, len = %d/%d\n", 5388 idx, keylen, len); 5389 5390 /* NOTE: We don't check cached values in case the firmware was reset 5391 * or some other problem is occurring. If the user is setting the key, 5392 * then we push the change */ 5393 5394 wep_key->idx = idx; 5395 wep_key->len = keylen; 5396 5397 if (keylen) { 5398 memcpy(wep_key->key, key, len); 5399 memset(wep_key->key + len, 0, keylen - len); 5400 } 5401 5402 /* Will be optimized out on debug not being configured in */ 5403 if (keylen == 0) 5404 IPW_DEBUG_WEP("%s: Clearing key %d\n", 5405 priv->net_dev->name, wep_key->idx); 5406 else if (keylen == 5) 5407 IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_64 "\n", 5408 priv->net_dev->name, wep_key->idx, wep_key->len, 5409 WEP_STR_64(wep_key->key)); 5410 else 5411 IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_128 5412 "\n", 5413 priv->net_dev->name, wep_key->idx, wep_key->len, 5414 WEP_STR_128(wep_key->key)); 5415 5416 if (!batch_mode) { 5417 err = ipw2100_disable_adapter(priv); 5418 /* FIXME: IPG: shouldn't this prink be in _disable_adapter()? */ 5419 if (err) { 5420 printk(KERN_ERR DRV_NAME 5421 ": %s: Could not disable adapter %d\n", 5422 priv->net_dev->name, err); 5423 return err; 5424 } 5425 } 5426 5427 /* send cmd to firmware */ 5428 err = ipw2100_hw_send_command(priv, &cmd); 5429 5430 if (!batch_mode) { 5431 int err2 = ipw2100_enable_adapter(priv); 5432 if (err == 0) 5433 err = err2; 5434 } 5435 return err; 5436 } 5437 5438 static int ipw2100_set_key_index(struct ipw2100_priv *priv, 5439 int idx, int batch_mode) 5440 { 5441 struct host_command cmd = { 5442 .host_command = WEP_KEY_INDEX, 5443 .host_command_sequence = 0, 5444 .host_command_length = 4, 5445 .host_command_parameters = {idx}, 5446 }; 5447 int err; 5448 5449 IPW_DEBUG_HC("WEP_KEY_INDEX: index = %d\n", idx); 5450 5451 if (idx < 0 || idx > 3) 5452 return -EINVAL; 5453 5454 if (!batch_mode) { 5455 err = ipw2100_disable_adapter(priv); 5456 if (err) { 5457 printk(KERN_ERR DRV_NAME 5458 ": %s: Could not disable adapter %d\n", 5459 priv->net_dev->name, err); 5460 return err; 5461 } 5462 } 5463 5464 /* send cmd to firmware */ 5465 err = ipw2100_hw_send_command(priv, &cmd); 5466 5467 if (!batch_mode) 5468 ipw2100_enable_adapter(priv); 5469 5470 return err; 5471 } 5472 5473 static int ipw2100_configure_security(struct ipw2100_priv *priv, int batch_mode) 5474 { 5475 int i, err, auth_mode, sec_level, use_group; 5476 5477 if (!(priv->status & STATUS_RUNNING)) 5478 return 0; 5479 5480 if (!batch_mode) { 5481 err = ipw2100_disable_adapter(priv); 5482 if (err) 5483 return err; 5484 } 5485 5486 if (!priv->ieee->sec.enabled) { 5487 err = 5488 ipw2100_set_security_information(priv, IPW_AUTH_OPEN, 5489 SEC_LEVEL_0, 0, 1); 5490 } else { 5491 auth_mode = IPW_AUTH_OPEN; 5492 if (priv->ieee->sec.flags & SEC_AUTH_MODE) { 5493 if (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY) 5494 auth_mode = IPW_AUTH_SHARED; 5495 else if (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP) 5496 auth_mode = IPW_AUTH_LEAP_CISCO_ID; 5497 } 5498 5499 sec_level = SEC_LEVEL_0; 5500 if (priv->ieee->sec.flags & SEC_LEVEL) 5501 sec_level = priv->ieee->sec.level; 5502 5503 use_group = 0; 5504 if (priv->ieee->sec.flags & SEC_UNICAST_GROUP) 5505 use_group = priv->ieee->sec.unicast_uses_group; 5506 5507 err = 5508 ipw2100_set_security_information(priv, auth_mode, sec_level, 5509 use_group, 1); 5510 } 5511 5512 if (err) 5513 goto exit; 5514 5515 if (priv->ieee->sec.enabled) { 5516 for (i = 0; i < 4; i++) { 5517 if (!(priv->ieee->sec.flags & (1 << i))) { 5518 memset(priv->ieee->sec.keys[i], 0, WEP_KEY_LEN); 5519 priv->ieee->sec.key_sizes[i] = 0; 5520 } else { 5521 err = ipw2100_set_key(priv, i, 5522 priv->ieee->sec.keys[i], 5523 priv->ieee->sec. 5524 key_sizes[i], 1); 5525 if (err) 5526 goto exit; 5527 } 5528 } 5529 5530 ipw2100_set_key_index(priv, priv->ieee->crypt_info.tx_keyidx, 1); 5531 } 5532 5533 /* Always enable privacy so the Host can filter WEP packets if 5534 * encrypted data is sent up */ 5535 err = 5536 ipw2100_set_wep_flags(priv, 5537 priv->ieee->sec. 5538 enabled ? IPW_PRIVACY_CAPABLE : 0, 1); 5539 if (err) 5540 goto exit; 5541 5542 priv->status &= ~STATUS_SECURITY_UPDATED; 5543 5544 exit: 5545 if (!batch_mode) 5546 ipw2100_enable_adapter(priv); 5547 5548 return err; 5549 } 5550 5551 static void ipw2100_security_work(struct work_struct *work) 5552 { 5553 struct ipw2100_priv *priv = 5554 container_of(work, struct ipw2100_priv, security_work.work); 5555 5556 /* If we happen to have reconnected before we get a chance to 5557 * process this, then update the security settings--which causes 5558 * a disassociation to occur */ 5559 if (!(priv->status & STATUS_ASSOCIATED) && 5560 priv->status & STATUS_SECURITY_UPDATED) 5561 ipw2100_configure_security(priv, 0); 5562 } 5563 5564 static void shim__set_security(struct net_device *dev, 5565 struct libipw_security *sec) 5566 { 5567 struct ipw2100_priv *priv = libipw_priv(dev); 5568 int i; 5569 5570 mutex_lock(&priv->action_mutex); 5571 if (!(priv->status & STATUS_INITIALIZED)) 5572 goto done; 5573 5574 for (i = 0; i < 4; i++) { 5575 if (sec->flags & (1 << i)) { 5576 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i]; 5577 if (sec->key_sizes[i] == 0) 5578 priv->ieee->sec.flags &= ~(1 << i); 5579 else 5580 memcpy(priv->ieee->sec.keys[i], sec->keys[i], 5581 sec->key_sizes[i]); 5582 if (sec->level == SEC_LEVEL_1) { 5583 priv->ieee->sec.flags |= (1 << i); 5584 priv->status |= STATUS_SECURITY_UPDATED; 5585 } else 5586 priv->ieee->sec.flags &= ~(1 << i); 5587 } 5588 } 5589 5590 if ((sec->flags & SEC_ACTIVE_KEY) && 5591 priv->ieee->sec.active_key != sec->active_key) { 5592 priv->ieee->sec.active_key = sec->active_key; 5593 priv->ieee->sec.flags |= SEC_ACTIVE_KEY; 5594 priv->status |= STATUS_SECURITY_UPDATED; 5595 } 5596 5597 if ((sec->flags & SEC_AUTH_MODE) && 5598 (priv->ieee->sec.auth_mode != sec->auth_mode)) { 5599 priv->ieee->sec.auth_mode = sec->auth_mode; 5600 priv->ieee->sec.flags |= SEC_AUTH_MODE; 5601 priv->status |= STATUS_SECURITY_UPDATED; 5602 } 5603 5604 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) { 5605 priv->ieee->sec.flags |= SEC_ENABLED; 5606 priv->ieee->sec.enabled = sec->enabled; 5607 priv->status |= STATUS_SECURITY_UPDATED; 5608 } 5609 5610 if (sec->flags & SEC_ENCRYPT) 5611 priv->ieee->sec.encrypt = sec->encrypt; 5612 5613 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) { 5614 priv->ieee->sec.level = sec->level; 5615 priv->ieee->sec.flags |= SEC_LEVEL; 5616 priv->status |= STATUS_SECURITY_UPDATED; 5617 } 5618 5619 IPW_DEBUG_WEP("Security flags: %c %c%c%c%c %c%c%c%c\n", 5620 priv->ieee->sec.flags & (1 << 8) ? '1' : '0', 5621 priv->ieee->sec.flags & (1 << 7) ? '1' : '0', 5622 priv->ieee->sec.flags & (1 << 6) ? '1' : '0', 5623 priv->ieee->sec.flags & (1 << 5) ? '1' : '0', 5624 priv->ieee->sec.flags & (1 << 4) ? '1' : '0', 5625 priv->ieee->sec.flags & (1 << 3) ? '1' : '0', 5626 priv->ieee->sec.flags & (1 << 2) ? '1' : '0', 5627 priv->ieee->sec.flags & (1 << 1) ? '1' : '0', 5628 priv->ieee->sec.flags & (1 << 0) ? '1' : '0'); 5629 5630 /* As a temporary work around to enable WPA until we figure out why 5631 * wpa_supplicant toggles the security capability of the driver, which 5632 * forces a disassociation with force_update... 5633 * 5634 * if (force_update || !(priv->status & STATUS_ASSOCIATED))*/ 5635 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING))) 5636 ipw2100_configure_security(priv, 0); 5637 done: 5638 mutex_unlock(&priv->action_mutex); 5639 } 5640 5641 static int ipw2100_adapter_setup(struct ipw2100_priv *priv) 5642 { 5643 int err; 5644 int batch_mode = 1; 5645 u8 *bssid; 5646 5647 IPW_DEBUG_INFO("enter\n"); 5648 5649 err = ipw2100_disable_adapter(priv); 5650 if (err) 5651 return err; 5652 #ifdef CONFIG_IPW2100_MONITOR 5653 if (priv->ieee->iw_mode == IW_MODE_MONITOR) { 5654 err = ipw2100_set_channel(priv, priv->channel, batch_mode); 5655 if (err) 5656 return err; 5657 5658 IPW_DEBUG_INFO("exit\n"); 5659 5660 return 0; 5661 } 5662 #endif /* CONFIG_IPW2100_MONITOR */ 5663 5664 err = ipw2100_read_mac_address(priv); 5665 if (err) 5666 return -EIO; 5667 5668 err = ipw2100_set_mac_address(priv, batch_mode); 5669 if (err) 5670 return err; 5671 5672 err = ipw2100_set_port_type(priv, priv->ieee->iw_mode, batch_mode); 5673 if (err) 5674 return err; 5675 5676 if (priv->ieee->iw_mode == IW_MODE_ADHOC) { 5677 err = ipw2100_set_channel(priv, priv->channel, batch_mode); 5678 if (err) 5679 return err; 5680 } 5681 5682 err = ipw2100_system_config(priv, batch_mode); 5683 if (err) 5684 return err; 5685 5686 err = ipw2100_set_tx_rates(priv, priv->tx_rates, batch_mode); 5687 if (err) 5688 return err; 5689 5690 /* Default to power mode OFF */ 5691 err = ipw2100_set_power_mode(priv, IPW_POWER_MODE_CAM); 5692 if (err) 5693 return err; 5694 5695 err = ipw2100_set_rts_threshold(priv, priv->rts_threshold); 5696 if (err) 5697 return err; 5698 5699 if (priv->config & CFG_STATIC_BSSID) 5700 bssid = priv->bssid; 5701 else 5702 bssid = NULL; 5703 err = ipw2100_set_mandatory_bssid(priv, bssid, batch_mode); 5704 if (err) 5705 return err; 5706 5707 if (priv->config & CFG_STATIC_ESSID) 5708 err = ipw2100_set_essid(priv, priv->essid, priv->essid_len, 5709 batch_mode); 5710 else 5711 err = ipw2100_set_essid(priv, NULL, 0, batch_mode); 5712 if (err) 5713 return err; 5714 5715 err = ipw2100_configure_security(priv, batch_mode); 5716 if (err) 5717 return err; 5718 5719 if (priv->ieee->iw_mode == IW_MODE_ADHOC) { 5720 err = 5721 ipw2100_set_ibss_beacon_interval(priv, 5722 priv->beacon_interval, 5723 batch_mode); 5724 if (err) 5725 return err; 5726 5727 err = ipw2100_set_tx_power(priv, priv->tx_power); 5728 if (err) 5729 return err; 5730 } 5731 5732 /* 5733 err = ipw2100_set_fragmentation_threshold( 5734 priv, priv->frag_threshold, batch_mode); 5735 if (err) 5736 return err; 5737 */ 5738 5739 IPW_DEBUG_INFO("exit\n"); 5740 5741 return 0; 5742 } 5743 5744 /************************************************************************* 5745 * 5746 * EXTERNALLY CALLED METHODS 5747 * 5748 *************************************************************************/ 5749 5750 /* This method is called by the network layer -- not to be confused with 5751 * ipw2100_set_mac_address() declared above called by this driver (and this 5752 * method as well) to talk to the firmware */ 5753 static int ipw2100_set_address(struct net_device *dev, void *p) 5754 { 5755 struct ipw2100_priv *priv = libipw_priv(dev); 5756 struct sockaddr *addr = p; 5757 int err = 0; 5758 5759 if (!is_valid_ether_addr(addr->sa_data)) 5760 return -EADDRNOTAVAIL; 5761 5762 mutex_lock(&priv->action_mutex); 5763 5764 priv->config |= CFG_CUSTOM_MAC; 5765 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN); 5766 5767 err = ipw2100_set_mac_address(priv, 0); 5768 if (err) 5769 goto done; 5770 5771 priv->reset_backoff = 0; 5772 mutex_unlock(&priv->action_mutex); 5773 ipw2100_reset_adapter(&priv->reset_work.work); 5774 return 0; 5775 5776 done: 5777 mutex_unlock(&priv->action_mutex); 5778 return err; 5779 } 5780 5781 static int ipw2100_open(struct net_device *dev) 5782 { 5783 struct ipw2100_priv *priv = libipw_priv(dev); 5784 unsigned long flags; 5785 IPW_DEBUG_INFO("dev->open\n"); 5786 5787 spin_lock_irqsave(&priv->low_lock, flags); 5788 if (priv->status & STATUS_ASSOCIATED) { 5789 netif_carrier_on(dev); 5790 netif_start_queue(dev); 5791 } 5792 spin_unlock_irqrestore(&priv->low_lock, flags); 5793 5794 return 0; 5795 } 5796 5797 static int ipw2100_close(struct net_device *dev) 5798 { 5799 struct ipw2100_priv *priv = libipw_priv(dev); 5800 unsigned long flags; 5801 struct list_head *element; 5802 struct ipw2100_tx_packet *packet; 5803 5804 IPW_DEBUG_INFO("enter\n"); 5805 5806 spin_lock_irqsave(&priv->low_lock, flags); 5807 5808 if (priv->status & STATUS_ASSOCIATED) 5809 netif_carrier_off(dev); 5810 netif_stop_queue(dev); 5811 5812 /* Flush the TX queue ... */ 5813 while (!list_empty(&priv->tx_pend_list)) { 5814 element = priv->tx_pend_list.next; 5815 packet = list_entry(element, struct ipw2100_tx_packet, list); 5816 5817 list_del(element); 5818 DEC_STAT(&priv->tx_pend_stat); 5819 5820 libipw_txb_free(packet->info.d_struct.txb); 5821 packet->info.d_struct.txb = NULL; 5822 5823 list_add_tail(element, &priv->tx_free_list); 5824 INC_STAT(&priv->tx_free_stat); 5825 } 5826 spin_unlock_irqrestore(&priv->low_lock, flags); 5827 5828 IPW_DEBUG_INFO("exit\n"); 5829 5830 return 0; 5831 } 5832 5833 /* 5834 * TODO: Fix this function... its just wrong 5835 */ 5836 static void ipw2100_tx_timeout(struct net_device *dev) 5837 { 5838 struct ipw2100_priv *priv = libipw_priv(dev); 5839 5840 dev->stats.tx_errors++; 5841 5842 #ifdef CONFIG_IPW2100_MONITOR 5843 if (priv->ieee->iw_mode == IW_MODE_MONITOR) 5844 return; 5845 #endif 5846 5847 IPW_DEBUG_INFO("%s: TX timed out. Scheduling firmware restart.\n", 5848 dev->name); 5849 schedule_reset(priv); 5850 } 5851 5852 static int ipw2100_wpa_enable(struct ipw2100_priv *priv, int value) 5853 { 5854 /* This is called when wpa_supplicant loads and closes the driver 5855 * interface. */ 5856 priv->ieee->wpa_enabled = value; 5857 return 0; 5858 } 5859 5860 static int ipw2100_wpa_set_auth_algs(struct ipw2100_priv *priv, int value) 5861 { 5862 5863 struct libipw_device *ieee = priv->ieee; 5864 struct libipw_security sec = { 5865 .flags = SEC_AUTH_MODE, 5866 }; 5867 int ret = 0; 5868 5869 if (value & IW_AUTH_ALG_SHARED_KEY) { 5870 sec.auth_mode = WLAN_AUTH_SHARED_KEY; 5871 ieee->open_wep = 0; 5872 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) { 5873 sec.auth_mode = WLAN_AUTH_OPEN; 5874 ieee->open_wep = 1; 5875 } else if (value & IW_AUTH_ALG_LEAP) { 5876 sec.auth_mode = WLAN_AUTH_LEAP; 5877 ieee->open_wep = 1; 5878 } else 5879 return -EINVAL; 5880 5881 if (ieee->set_security) 5882 ieee->set_security(ieee->dev, &sec); 5883 else 5884 ret = -EOPNOTSUPP; 5885 5886 return ret; 5887 } 5888 5889 static void ipw2100_wpa_assoc_frame(struct ipw2100_priv *priv, 5890 char *wpa_ie, int wpa_ie_len) 5891 { 5892 5893 struct ipw2100_wpa_assoc_frame frame; 5894 5895 frame.fixed_ie_mask = 0; 5896 5897 /* copy WPA IE */ 5898 memcpy(frame.var_ie, wpa_ie, wpa_ie_len); 5899 frame.var_ie_len = wpa_ie_len; 5900 5901 /* make sure WPA is enabled */ 5902 ipw2100_wpa_enable(priv, 1); 5903 ipw2100_set_wpa_ie(priv, &frame, 0); 5904 } 5905 5906 static void ipw_ethtool_get_drvinfo(struct net_device *dev, 5907 struct ethtool_drvinfo *info) 5908 { 5909 struct ipw2100_priv *priv = libipw_priv(dev); 5910 char fw_ver[64], ucode_ver[64]; 5911 5912 strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 5913 strlcpy(info->version, DRV_VERSION, sizeof(info->version)); 5914 5915 ipw2100_get_fwversion(priv, fw_ver, sizeof(fw_ver)); 5916 ipw2100_get_ucodeversion(priv, ucode_ver, sizeof(ucode_ver)); 5917 5918 snprintf(info->fw_version, sizeof(info->fw_version), "%s:%d:%s", 5919 fw_ver, priv->eeprom_version, ucode_ver); 5920 5921 strlcpy(info->bus_info, pci_name(priv->pci_dev), 5922 sizeof(info->bus_info)); 5923 } 5924 5925 static u32 ipw2100_ethtool_get_link(struct net_device *dev) 5926 { 5927 struct ipw2100_priv *priv = libipw_priv(dev); 5928 return (priv->status & STATUS_ASSOCIATED) ? 1 : 0; 5929 } 5930 5931 static const struct ethtool_ops ipw2100_ethtool_ops = { 5932 .get_link = ipw2100_ethtool_get_link, 5933 .get_drvinfo = ipw_ethtool_get_drvinfo, 5934 }; 5935 5936 static void ipw2100_hang_check(struct work_struct *work) 5937 { 5938 struct ipw2100_priv *priv = 5939 container_of(work, struct ipw2100_priv, hang_check.work); 5940 unsigned long flags; 5941 u32 rtc = 0xa5a5a5a5; 5942 u32 len = sizeof(rtc); 5943 int restart = 0; 5944 5945 spin_lock_irqsave(&priv->low_lock, flags); 5946 5947 if (priv->fatal_error != 0) { 5948 /* If fatal_error is set then we need to restart */ 5949 IPW_DEBUG_INFO("%s: Hardware fatal error detected.\n", 5950 priv->net_dev->name); 5951 5952 restart = 1; 5953 } else if (ipw2100_get_ordinal(priv, IPW_ORD_RTC_TIME, &rtc, &len) || 5954 (rtc == priv->last_rtc)) { 5955 /* Check if firmware is hung */ 5956 IPW_DEBUG_INFO("%s: Firmware RTC stalled.\n", 5957 priv->net_dev->name); 5958 5959 restart = 1; 5960 } 5961 5962 if (restart) { 5963 /* Kill timer */ 5964 priv->stop_hang_check = 1; 5965 priv->hangs++; 5966 5967 /* Restart the NIC */ 5968 schedule_reset(priv); 5969 } 5970 5971 priv->last_rtc = rtc; 5972 5973 if (!priv->stop_hang_check) 5974 schedule_delayed_work(&priv->hang_check, HZ / 2); 5975 5976 spin_unlock_irqrestore(&priv->low_lock, flags); 5977 } 5978 5979 static void ipw2100_rf_kill(struct work_struct *work) 5980 { 5981 struct ipw2100_priv *priv = 5982 container_of(work, struct ipw2100_priv, rf_kill.work); 5983 unsigned long flags; 5984 5985 spin_lock_irqsave(&priv->low_lock, flags); 5986 5987 if (rf_kill_active(priv)) { 5988 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n"); 5989 if (!priv->stop_rf_kill) 5990 schedule_delayed_work(&priv->rf_kill, 5991 round_jiffies_relative(HZ)); 5992 goto exit_unlock; 5993 } 5994 5995 /* RF Kill is now disabled, so bring the device back up */ 5996 5997 if (!(priv->status & STATUS_RF_KILL_MASK)) { 5998 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting " 5999 "device\n"); 6000 schedule_reset(priv); 6001 } else 6002 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still " 6003 "enabled\n"); 6004 6005 exit_unlock: 6006 spin_unlock_irqrestore(&priv->low_lock, flags); 6007 } 6008 6009 static void ipw2100_irq_tasklet(struct ipw2100_priv *priv); 6010 6011 static const struct net_device_ops ipw2100_netdev_ops = { 6012 .ndo_open = ipw2100_open, 6013 .ndo_stop = ipw2100_close, 6014 .ndo_start_xmit = libipw_xmit, 6015 .ndo_tx_timeout = ipw2100_tx_timeout, 6016 .ndo_set_mac_address = ipw2100_set_address, 6017 .ndo_validate_addr = eth_validate_addr, 6018 }; 6019 6020 /* Look into using netdev destructor to shutdown libipw? */ 6021 6022 static struct net_device *ipw2100_alloc_device(struct pci_dev *pci_dev, 6023 void __iomem * ioaddr) 6024 { 6025 struct ipw2100_priv *priv; 6026 struct net_device *dev; 6027 6028 dev = alloc_libipw(sizeof(struct ipw2100_priv), 0); 6029 if (!dev) 6030 return NULL; 6031 priv = libipw_priv(dev); 6032 priv->ieee = netdev_priv(dev); 6033 priv->pci_dev = pci_dev; 6034 priv->net_dev = dev; 6035 priv->ioaddr = ioaddr; 6036 6037 priv->ieee->hard_start_xmit = ipw2100_tx; 6038 priv->ieee->set_security = shim__set_security; 6039 6040 priv->ieee->perfect_rssi = -20; 6041 priv->ieee->worst_rssi = -85; 6042 6043 dev->netdev_ops = &ipw2100_netdev_ops; 6044 dev->ethtool_ops = &ipw2100_ethtool_ops; 6045 dev->wireless_handlers = &ipw2100_wx_handler_def; 6046 priv->wireless_data.libipw = priv->ieee; 6047 dev->wireless_data = &priv->wireless_data; 6048 dev->watchdog_timeo = 3 * HZ; 6049 dev->irq = 0; 6050 dev->min_mtu = 68; 6051 dev->max_mtu = LIBIPW_DATA_LEN; 6052 6053 /* NOTE: We don't use the wireless_handlers hook 6054 * in dev as the system will start throwing WX requests 6055 * to us before we're actually initialized and it just 6056 * ends up causing problems. So, we just handle 6057 * the WX extensions through the ipw2100_ioctl interface */ 6058 6059 /* memset() puts everything to 0, so we only have explicitly set 6060 * those values that need to be something else */ 6061 6062 /* If power management is turned on, default to AUTO mode */ 6063 priv->power_mode = IPW_POWER_AUTO; 6064 6065 #ifdef CONFIG_IPW2100_MONITOR 6066 priv->config |= CFG_CRC_CHECK; 6067 #endif 6068 priv->ieee->wpa_enabled = 0; 6069 priv->ieee->drop_unencrypted = 0; 6070 priv->ieee->privacy_invoked = 0; 6071 priv->ieee->ieee802_1x = 1; 6072 6073 /* Set module parameters */ 6074 switch (network_mode) { 6075 case 1: 6076 priv->ieee->iw_mode = IW_MODE_ADHOC; 6077 break; 6078 #ifdef CONFIG_IPW2100_MONITOR 6079 case 2: 6080 priv->ieee->iw_mode = IW_MODE_MONITOR; 6081 break; 6082 #endif 6083 default: 6084 case 0: 6085 priv->ieee->iw_mode = IW_MODE_INFRA; 6086 break; 6087 } 6088 6089 if (disable == 1) 6090 priv->status |= STATUS_RF_KILL_SW; 6091 6092 if (channel != 0 && 6093 ((channel >= REG_MIN_CHANNEL) && (channel <= REG_MAX_CHANNEL))) { 6094 priv->config |= CFG_STATIC_CHANNEL; 6095 priv->channel = channel; 6096 } 6097 6098 if (associate) 6099 priv->config |= CFG_ASSOCIATE; 6100 6101 priv->beacon_interval = DEFAULT_BEACON_INTERVAL; 6102 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT; 6103 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT; 6104 priv->rts_threshold = DEFAULT_RTS_THRESHOLD | RTS_DISABLED; 6105 priv->frag_threshold = DEFAULT_FTS | FRAG_DISABLED; 6106 priv->tx_power = IPW_TX_POWER_DEFAULT; 6107 priv->tx_rates = DEFAULT_TX_RATES; 6108 6109 strcpy(priv->nick, "ipw2100"); 6110 6111 spin_lock_init(&priv->low_lock); 6112 mutex_init(&priv->action_mutex); 6113 mutex_init(&priv->adapter_mutex); 6114 6115 init_waitqueue_head(&priv->wait_command_queue); 6116 6117 netif_carrier_off(dev); 6118 6119 INIT_LIST_HEAD(&priv->msg_free_list); 6120 INIT_LIST_HEAD(&priv->msg_pend_list); 6121 INIT_STAT(&priv->msg_free_stat); 6122 INIT_STAT(&priv->msg_pend_stat); 6123 6124 INIT_LIST_HEAD(&priv->tx_free_list); 6125 INIT_LIST_HEAD(&priv->tx_pend_list); 6126 INIT_STAT(&priv->tx_free_stat); 6127 INIT_STAT(&priv->tx_pend_stat); 6128 6129 INIT_LIST_HEAD(&priv->fw_pend_list); 6130 INIT_STAT(&priv->fw_pend_stat); 6131 6132 INIT_DELAYED_WORK(&priv->reset_work, ipw2100_reset_adapter); 6133 INIT_DELAYED_WORK(&priv->security_work, ipw2100_security_work); 6134 INIT_DELAYED_WORK(&priv->wx_event_work, ipw2100_wx_event_work); 6135 INIT_DELAYED_WORK(&priv->hang_check, ipw2100_hang_check); 6136 INIT_DELAYED_WORK(&priv->rf_kill, ipw2100_rf_kill); 6137 INIT_DELAYED_WORK(&priv->scan_event, ipw2100_scan_event); 6138 6139 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long)) 6140 ipw2100_irq_tasklet, (unsigned long)priv); 6141 6142 /* NOTE: We do not start the deferred work for status checks yet */ 6143 priv->stop_rf_kill = 1; 6144 priv->stop_hang_check = 1; 6145 6146 return dev; 6147 } 6148 6149 static int ipw2100_pci_init_one(struct pci_dev *pci_dev, 6150 const struct pci_device_id *ent) 6151 { 6152 void __iomem *ioaddr; 6153 struct net_device *dev = NULL; 6154 struct ipw2100_priv *priv = NULL; 6155 int err = 0; 6156 int registered = 0; 6157 u32 val; 6158 6159 IPW_DEBUG_INFO("enter\n"); 6160 6161 if (!(pci_resource_flags(pci_dev, 0) & IORESOURCE_MEM)) { 6162 IPW_DEBUG_INFO("weird - resource type is not memory\n"); 6163 err = -ENODEV; 6164 goto out; 6165 } 6166 6167 ioaddr = pci_iomap(pci_dev, 0, 0); 6168 if (!ioaddr) { 6169 printk(KERN_WARNING DRV_NAME 6170 "Error calling ioremap_nocache.\n"); 6171 err = -EIO; 6172 goto fail; 6173 } 6174 6175 /* allocate and initialize our net_device */ 6176 dev = ipw2100_alloc_device(pci_dev, ioaddr); 6177 if (!dev) { 6178 printk(KERN_WARNING DRV_NAME 6179 "Error calling ipw2100_alloc_device.\n"); 6180 err = -ENOMEM; 6181 goto fail; 6182 } 6183 6184 /* set up PCI mappings for device */ 6185 err = pci_enable_device(pci_dev); 6186 if (err) { 6187 printk(KERN_WARNING DRV_NAME 6188 "Error calling pci_enable_device.\n"); 6189 return err; 6190 } 6191 6192 priv = libipw_priv(dev); 6193 6194 pci_set_master(pci_dev); 6195 pci_set_drvdata(pci_dev, priv); 6196 6197 err = pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32)); 6198 if (err) { 6199 printk(KERN_WARNING DRV_NAME 6200 "Error calling pci_set_dma_mask.\n"); 6201 pci_disable_device(pci_dev); 6202 return err; 6203 } 6204 6205 err = pci_request_regions(pci_dev, DRV_NAME); 6206 if (err) { 6207 printk(KERN_WARNING DRV_NAME 6208 "Error calling pci_request_regions.\n"); 6209 pci_disable_device(pci_dev); 6210 return err; 6211 } 6212 6213 /* We disable the RETRY_TIMEOUT register (0x41) to keep 6214 * PCI Tx retries from interfering with C3 CPU state */ 6215 pci_read_config_dword(pci_dev, 0x40, &val); 6216 if ((val & 0x0000ff00) != 0) 6217 pci_write_config_dword(pci_dev, 0x40, val & 0xffff00ff); 6218 6219 if (!ipw2100_hw_is_adapter_in_system(dev)) { 6220 printk(KERN_WARNING DRV_NAME 6221 "Device not found via register read.\n"); 6222 err = -ENODEV; 6223 goto fail; 6224 } 6225 6226 SET_NETDEV_DEV(dev, &pci_dev->dev); 6227 6228 /* Force interrupts to be shut off on the device */ 6229 priv->status |= STATUS_INT_ENABLED; 6230 ipw2100_disable_interrupts(priv); 6231 6232 /* Allocate and initialize the Tx/Rx queues and lists */ 6233 if (ipw2100_queues_allocate(priv)) { 6234 printk(KERN_WARNING DRV_NAME 6235 "Error calling ipw2100_queues_allocate.\n"); 6236 err = -ENOMEM; 6237 goto fail; 6238 } 6239 ipw2100_queues_initialize(priv); 6240 6241 err = request_irq(pci_dev->irq, 6242 ipw2100_interrupt, IRQF_SHARED, dev->name, priv); 6243 if (err) { 6244 printk(KERN_WARNING DRV_NAME 6245 "Error calling request_irq: %d.\n", pci_dev->irq); 6246 goto fail; 6247 } 6248 dev->irq = pci_dev->irq; 6249 6250 IPW_DEBUG_INFO("Attempting to register device...\n"); 6251 6252 printk(KERN_INFO DRV_NAME 6253 ": Detected Intel PRO/Wireless 2100 Network Connection\n"); 6254 6255 err = ipw2100_up(priv, 1); 6256 if (err) 6257 goto fail; 6258 6259 err = ipw2100_wdev_init(dev); 6260 if (err) 6261 goto fail; 6262 registered = 1; 6263 6264 /* Bring up the interface. Pre 0.46, after we registered the 6265 * network device we would call ipw2100_up. This introduced a race 6266 * condition with newer hotplug configurations (network was coming 6267 * up and making calls before the device was initialized). 6268 */ 6269 err = register_netdev(dev); 6270 if (err) { 6271 printk(KERN_WARNING DRV_NAME 6272 "Error calling register_netdev.\n"); 6273 goto fail; 6274 } 6275 registered = 2; 6276 6277 mutex_lock(&priv->action_mutex); 6278 6279 IPW_DEBUG_INFO("%s: Bound to %s\n", dev->name, pci_name(pci_dev)); 6280 6281 /* perform this after register_netdev so that dev->name is set */ 6282 err = sysfs_create_group(&pci_dev->dev.kobj, &ipw2100_attribute_group); 6283 if (err) 6284 goto fail_unlock; 6285 6286 /* If the RF Kill switch is disabled, go ahead and complete the 6287 * startup sequence */ 6288 if (!(priv->status & STATUS_RF_KILL_MASK)) { 6289 /* Enable the adapter - sends HOST_COMPLETE */ 6290 if (ipw2100_enable_adapter(priv)) { 6291 printk(KERN_WARNING DRV_NAME 6292 ": %s: failed in call to enable adapter.\n", 6293 priv->net_dev->name); 6294 ipw2100_hw_stop_adapter(priv); 6295 err = -EIO; 6296 goto fail_unlock; 6297 } 6298 6299 /* Start a scan . . . */ 6300 ipw2100_set_scan_options(priv); 6301 ipw2100_start_scan(priv); 6302 } 6303 6304 IPW_DEBUG_INFO("exit\n"); 6305 6306 priv->status |= STATUS_INITIALIZED; 6307 6308 mutex_unlock(&priv->action_mutex); 6309 out: 6310 return err; 6311 6312 fail_unlock: 6313 mutex_unlock(&priv->action_mutex); 6314 fail: 6315 if (dev) { 6316 if (registered >= 2) 6317 unregister_netdev(dev); 6318 6319 if (registered) { 6320 wiphy_unregister(priv->ieee->wdev.wiphy); 6321 kfree(priv->ieee->bg_band.channels); 6322 } 6323 6324 ipw2100_hw_stop_adapter(priv); 6325 6326 ipw2100_disable_interrupts(priv); 6327 6328 if (dev->irq) 6329 free_irq(dev->irq, priv); 6330 6331 ipw2100_kill_works(priv); 6332 6333 /* These are safe to call even if they weren't allocated */ 6334 ipw2100_queues_free(priv); 6335 sysfs_remove_group(&pci_dev->dev.kobj, 6336 &ipw2100_attribute_group); 6337 6338 free_libipw(dev, 0); 6339 } 6340 6341 pci_iounmap(pci_dev, ioaddr); 6342 6343 pci_release_regions(pci_dev); 6344 pci_disable_device(pci_dev); 6345 goto out; 6346 } 6347 6348 static void ipw2100_pci_remove_one(struct pci_dev *pci_dev) 6349 { 6350 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev); 6351 struct net_device *dev = priv->net_dev; 6352 6353 mutex_lock(&priv->action_mutex); 6354 6355 priv->status &= ~STATUS_INITIALIZED; 6356 6357 sysfs_remove_group(&pci_dev->dev.kobj, &ipw2100_attribute_group); 6358 6359 #ifdef CONFIG_PM 6360 if (ipw2100_firmware.version) 6361 ipw2100_release_firmware(priv, &ipw2100_firmware); 6362 #endif 6363 /* Take down the hardware */ 6364 ipw2100_down(priv); 6365 6366 /* Release the mutex so that the network subsystem can 6367 * complete any needed calls into the driver... */ 6368 mutex_unlock(&priv->action_mutex); 6369 6370 /* Unregister the device first - this results in close() 6371 * being called if the device is open. If we free storage 6372 * first, then close() will crash. 6373 * FIXME: remove the comment above. */ 6374 unregister_netdev(dev); 6375 6376 ipw2100_kill_works(priv); 6377 6378 ipw2100_queues_free(priv); 6379 6380 /* Free potential debugging firmware snapshot */ 6381 ipw2100_snapshot_free(priv); 6382 6383 free_irq(dev->irq, priv); 6384 6385 pci_iounmap(pci_dev, priv->ioaddr); 6386 6387 /* wiphy_unregister needs to be here, before free_libipw */ 6388 wiphy_unregister(priv->ieee->wdev.wiphy); 6389 kfree(priv->ieee->bg_band.channels); 6390 free_libipw(dev, 0); 6391 6392 pci_release_regions(pci_dev); 6393 pci_disable_device(pci_dev); 6394 6395 IPW_DEBUG_INFO("exit\n"); 6396 } 6397 6398 #ifdef CONFIG_PM 6399 static int ipw2100_suspend(struct pci_dev *pci_dev, pm_message_t state) 6400 { 6401 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev); 6402 struct net_device *dev = priv->net_dev; 6403 6404 IPW_DEBUG_INFO("%s: Going into suspend...\n", dev->name); 6405 6406 mutex_lock(&priv->action_mutex); 6407 if (priv->status & STATUS_INITIALIZED) { 6408 /* Take down the device; powers it off, etc. */ 6409 ipw2100_down(priv); 6410 } 6411 6412 /* Remove the PRESENT state of the device */ 6413 netif_device_detach(dev); 6414 6415 pci_save_state(pci_dev); 6416 pci_disable_device(pci_dev); 6417 pci_set_power_state(pci_dev, PCI_D3hot); 6418 6419 priv->suspend_at = ktime_get_boottime_seconds(); 6420 6421 mutex_unlock(&priv->action_mutex); 6422 6423 return 0; 6424 } 6425 6426 static int ipw2100_resume(struct pci_dev *pci_dev) 6427 { 6428 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev); 6429 struct net_device *dev = priv->net_dev; 6430 int err; 6431 u32 val; 6432 6433 if (IPW2100_PM_DISABLED) 6434 return 0; 6435 6436 mutex_lock(&priv->action_mutex); 6437 6438 IPW_DEBUG_INFO("%s: Coming out of suspend...\n", dev->name); 6439 6440 pci_set_power_state(pci_dev, PCI_D0); 6441 err = pci_enable_device(pci_dev); 6442 if (err) { 6443 printk(KERN_ERR "%s: pci_enable_device failed on resume\n", 6444 dev->name); 6445 mutex_unlock(&priv->action_mutex); 6446 return err; 6447 } 6448 pci_restore_state(pci_dev); 6449 6450 /* 6451 * Suspend/Resume resets the PCI configuration space, so we have to 6452 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries 6453 * from interfering with C3 CPU state. pci_restore_state won't help 6454 * here since it only restores the first 64 bytes pci config header. 6455 */ 6456 pci_read_config_dword(pci_dev, 0x40, &val); 6457 if ((val & 0x0000ff00) != 0) 6458 pci_write_config_dword(pci_dev, 0x40, val & 0xffff00ff); 6459 6460 /* Set the device back into the PRESENT state; this will also wake 6461 * the queue of needed */ 6462 netif_device_attach(dev); 6463 6464 priv->suspend_time = ktime_get_boottime_seconds() - priv->suspend_at; 6465 6466 /* Bring the device back up */ 6467 if (!(priv->status & STATUS_RF_KILL_SW)) 6468 ipw2100_up(priv, 0); 6469 6470 mutex_unlock(&priv->action_mutex); 6471 6472 return 0; 6473 } 6474 #endif 6475 6476 static void ipw2100_shutdown(struct pci_dev *pci_dev) 6477 { 6478 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev); 6479 6480 /* Take down the device; powers it off, etc. */ 6481 ipw2100_down(priv); 6482 6483 pci_disable_device(pci_dev); 6484 } 6485 6486 #define IPW2100_DEV_ID(x) { PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, x } 6487 6488 static const struct pci_device_id ipw2100_pci_id_table[] = { 6489 IPW2100_DEV_ID(0x2520), /* IN 2100A mPCI 3A */ 6490 IPW2100_DEV_ID(0x2521), /* IN 2100A mPCI 3B */ 6491 IPW2100_DEV_ID(0x2524), /* IN 2100A mPCI 3B */ 6492 IPW2100_DEV_ID(0x2525), /* IN 2100A mPCI 3B */ 6493 IPW2100_DEV_ID(0x2526), /* IN 2100A mPCI Gen A3 */ 6494 IPW2100_DEV_ID(0x2522), /* IN 2100 mPCI 3B */ 6495 IPW2100_DEV_ID(0x2523), /* IN 2100 mPCI 3A */ 6496 IPW2100_DEV_ID(0x2527), /* IN 2100 mPCI 3B */ 6497 IPW2100_DEV_ID(0x2528), /* IN 2100 mPCI 3B */ 6498 IPW2100_DEV_ID(0x2529), /* IN 2100 mPCI 3B */ 6499 IPW2100_DEV_ID(0x252B), /* IN 2100 mPCI 3A */ 6500 IPW2100_DEV_ID(0x252C), /* IN 2100 mPCI 3A */ 6501 IPW2100_DEV_ID(0x252D), /* IN 2100 mPCI 3A */ 6502 6503 IPW2100_DEV_ID(0x2550), /* IB 2100A mPCI 3B */ 6504 IPW2100_DEV_ID(0x2551), /* IB 2100 mPCI 3B */ 6505 IPW2100_DEV_ID(0x2553), /* IB 2100 mPCI 3B */ 6506 IPW2100_DEV_ID(0x2554), /* IB 2100 mPCI 3B */ 6507 IPW2100_DEV_ID(0x2555), /* IB 2100 mPCI 3B */ 6508 6509 IPW2100_DEV_ID(0x2560), /* DE 2100A mPCI 3A */ 6510 IPW2100_DEV_ID(0x2562), /* DE 2100A mPCI 3A */ 6511 IPW2100_DEV_ID(0x2563), /* DE 2100A mPCI 3A */ 6512 IPW2100_DEV_ID(0x2561), /* DE 2100 mPCI 3A */ 6513 IPW2100_DEV_ID(0x2565), /* DE 2100 mPCI 3A */ 6514 IPW2100_DEV_ID(0x2566), /* DE 2100 mPCI 3A */ 6515 IPW2100_DEV_ID(0x2567), /* DE 2100 mPCI 3A */ 6516 6517 IPW2100_DEV_ID(0x2570), /* GA 2100 mPCI 3B */ 6518 6519 IPW2100_DEV_ID(0x2580), /* TO 2100A mPCI 3B */ 6520 IPW2100_DEV_ID(0x2582), /* TO 2100A mPCI 3B */ 6521 IPW2100_DEV_ID(0x2583), /* TO 2100A mPCI 3B */ 6522 IPW2100_DEV_ID(0x2581), /* TO 2100 mPCI 3B */ 6523 IPW2100_DEV_ID(0x2585), /* TO 2100 mPCI 3B */ 6524 IPW2100_DEV_ID(0x2586), /* TO 2100 mPCI 3B */ 6525 IPW2100_DEV_ID(0x2587), /* TO 2100 mPCI 3B */ 6526 6527 IPW2100_DEV_ID(0x2590), /* SO 2100A mPCI 3B */ 6528 IPW2100_DEV_ID(0x2592), /* SO 2100A mPCI 3B */ 6529 IPW2100_DEV_ID(0x2591), /* SO 2100 mPCI 3B */ 6530 IPW2100_DEV_ID(0x2593), /* SO 2100 mPCI 3B */ 6531 IPW2100_DEV_ID(0x2596), /* SO 2100 mPCI 3B */ 6532 IPW2100_DEV_ID(0x2598), /* SO 2100 mPCI 3B */ 6533 6534 IPW2100_DEV_ID(0x25A0), /* HP 2100 mPCI 3B */ 6535 {0,}, 6536 }; 6537 6538 MODULE_DEVICE_TABLE(pci, ipw2100_pci_id_table); 6539 6540 static struct pci_driver ipw2100_pci_driver = { 6541 .name = DRV_NAME, 6542 .id_table = ipw2100_pci_id_table, 6543 .probe = ipw2100_pci_init_one, 6544 .remove = ipw2100_pci_remove_one, 6545 #ifdef CONFIG_PM 6546 .suspend = ipw2100_suspend, 6547 .resume = ipw2100_resume, 6548 #endif 6549 .shutdown = ipw2100_shutdown, 6550 }; 6551 6552 /** 6553 * Initialize the ipw2100 driver/module 6554 * 6555 * @returns 0 if ok, < 0 errno node con error. 6556 * 6557 * Note: we cannot init the /proc stuff until the PCI driver is there, 6558 * or we risk an unlikely race condition on someone accessing 6559 * uninitialized data in the PCI dev struct through /proc. 6560 */ 6561 static int __init ipw2100_init(void) 6562 { 6563 int ret; 6564 6565 printk(KERN_INFO DRV_NAME ": %s, %s\n", DRV_DESCRIPTION, DRV_VERSION); 6566 printk(KERN_INFO DRV_NAME ": %s\n", DRV_COPYRIGHT); 6567 6568 pm_qos_add_request(&ipw2100_pm_qos_req, PM_QOS_CPU_DMA_LATENCY, 6569 PM_QOS_DEFAULT_VALUE); 6570 6571 ret = pci_register_driver(&ipw2100_pci_driver); 6572 if (ret) 6573 goto out; 6574 6575 #ifdef CONFIG_IPW2100_DEBUG 6576 ipw2100_debug_level = debug; 6577 ret = driver_create_file(&ipw2100_pci_driver.driver, 6578 &driver_attr_debug_level); 6579 #endif 6580 6581 out: 6582 return ret; 6583 } 6584 6585 /** 6586 * Cleanup ipw2100 driver registration 6587 */ 6588 static void __exit ipw2100_exit(void) 6589 { 6590 /* FIXME: IPG: check that we have no instances of the devices open */ 6591 #ifdef CONFIG_IPW2100_DEBUG 6592 driver_remove_file(&ipw2100_pci_driver.driver, 6593 &driver_attr_debug_level); 6594 #endif 6595 pci_unregister_driver(&ipw2100_pci_driver); 6596 pm_qos_remove_request(&ipw2100_pm_qos_req); 6597 } 6598 6599 module_init(ipw2100_init); 6600 module_exit(ipw2100_exit); 6601 6602 static int ipw2100_wx_get_name(struct net_device *dev, 6603 struct iw_request_info *info, 6604 union iwreq_data *wrqu, char *extra) 6605 { 6606 /* 6607 * This can be called at any time. No action lock required 6608 */ 6609 6610 struct ipw2100_priv *priv = libipw_priv(dev); 6611 if (!(priv->status & STATUS_ASSOCIATED)) 6612 strcpy(wrqu->name, "unassociated"); 6613 else 6614 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11b"); 6615 6616 IPW_DEBUG_WX("Name: %s\n", wrqu->name); 6617 return 0; 6618 } 6619 6620 static int ipw2100_wx_set_freq(struct net_device *dev, 6621 struct iw_request_info *info, 6622 union iwreq_data *wrqu, char *extra) 6623 { 6624 struct ipw2100_priv *priv = libipw_priv(dev); 6625 struct iw_freq *fwrq = &wrqu->freq; 6626 int err = 0; 6627 6628 if (priv->ieee->iw_mode == IW_MODE_INFRA) 6629 return -EOPNOTSUPP; 6630 6631 mutex_lock(&priv->action_mutex); 6632 if (!(priv->status & STATUS_INITIALIZED)) { 6633 err = -EIO; 6634 goto done; 6635 } 6636 6637 /* if setting by freq convert to channel */ 6638 if (fwrq->e == 1) { 6639 if ((fwrq->m >= (int)2.412e8 && fwrq->m <= (int)2.487e8)) { 6640 int f = fwrq->m / 100000; 6641 int c = 0; 6642 6643 while ((c < REG_MAX_CHANNEL) && 6644 (f != ipw2100_frequencies[c])) 6645 c++; 6646 6647 /* hack to fall through */ 6648 fwrq->e = 0; 6649 fwrq->m = c + 1; 6650 } 6651 } 6652 6653 if (fwrq->e > 0 || fwrq->m > 1000) { 6654 err = -EOPNOTSUPP; 6655 goto done; 6656 } else { /* Set the channel */ 6657 IPW_DEBUG_WX("SET Freq/Channel -> %d\n", fwrq->m); 6658 err = ipw2100_set_channel(priv, fwrq->m, 0); 6659 } 6660 6661 done: 6662 mutex_unlock(&priv->action_mutex); 6663 return err; 6664 } 6665 6666 static int ipw2100_wx_get_freq(struct net_device *dev, 6667 struct iw_request_info *info, 6668 union iwreq_data *wrqu, char *extra) 6669 { 6670 /* 6671 * This can be called at any time. No action lock required 6672 */ 6673 6674 struct ipw2100_priv *priv = libipw_priv(dev); 6675 6676 wrqu->freq.e = 0; 6677 6678 /* If we are associated, trying to associate, or have a statically 6679 * configured CHANNEL then return that; otherwise return ANY */ 6680 if (priv->config & CFG_STATIC_CHANNEL || 6681 priv->status & STATUS_ASSOCIATED) 6682 wrqu->freq.m = priv->channel; 6683 else 6684 wrqu->freq.m = 0; 6685 6686 IPW_DEBUG_WX("GET Freq/Channel -> %d\n", priv->channel); 6687 return 0; 6688 6689 } 6690 6691 static int ipw2100_wx_set_mode(struct net_device *dev, 6692 struct iw_request_info *info, 6693 union iwreq_data *wrqu, char *extra) 6694 { 6695 struct ipw2100_priv *priv = libipw_priv(dev); 6696 int err = 0; 6697 6698 IPW_DEBUG_WX("SET Mode -> %d\n", wrqu->mode); 6699 6700 if (wrqu->mode == priv->ieee->iw_mode) 6701 return 0; 6702 6703 mutex_lock(&priv->action_mutex); 6704 if (!(priv->status & STATUS_INITIALIZED)) { 6705 err = -EIO; 6706 goto done; 6707 } 6708 6709 switch (wrqu->mode) { 6710 #ifdef CONFIG_IPW2100_MONITOR 6711 case IW_MODE_MONITOR: 6712 err = ipw2100_switch_mode(priv, IW_MODE_MONITOR); 6713 break; 6714 #endif /* CONFIG_IPW2100_MONITOR */ 6715 case IW_MODE_ADHOC: 6716 err = ipw2100_switch_mode(priv, IW_MODE_ADHOC); 6717 break; 6718 case IW_MODE_INFRA: 6719 case IW_MODE_AUTO: 6720 default: 6721 err = ipw2100_switch_mode(priv, IW_MODE_INFRA); 6722 break; 6723 } 6724 6725 done: 6726 mutex_unlock(&priv->action_mutex); 6727 return err; 6728 } 6729 6730 static int ipw2100_wx_get_mode(struct net_device *dev, 6731 struct iw_request_info *info, 6732 union iwreq_data *wrqu, char *extra) 6733 { 6734 /* 6735 * This can be called at any time. No action lock required 6736 */ 6737 6738 struct ipw2100_priv *priv = libipw_priv(dev); 6739 6740 wrqu->mode = priv->ieee->iw_mode; 6741 IPW_DEBUG_WX("GET Mode -> %d\n", wrqu->mode); 6742 6743 return 0; 6744 } 6745 6746 #define POWER_MODES 5 6747 6748 /* Values are in microsecond */ 6749 static const s32 timeout_duration[POWER_MODES] = { 6750 350000, 6751 250000, 6752 75000, 6753 37000, 6754 25000, 6755 }; 6756 6757 static const s32 period_duration[POWER_MODES] = { 6758 400000, 6759 700000, 6760 1000000, 6761 1000000, 6762 1000000 6763 }; 6764 6765 static int ipw2100_wx_get_range(struct net_device *dev, 6766 struct iw_request_info *info, 6767 union iwreq_data *wrqu, char *extra) 6768 { 6769 /* 6770 * This can be called at any time. No action lock required 6771 */ 6772 6773 struct ipw2100_priv *priv = libipw_priv(dev); 6774 struct iw_range *range = (struct iw_range *)extra; 6775 u16 val; 6776 int i, level; 6777 6778 wrqu->data.length = sizeof(*range); 6779 memset(range, 0, sizeof(*range)); 6780 6781 /* Let's try to keep this struct in the same order as in 6782 * linux/include/wireless.h 6783 */ 6784 6785 /* TODO: See what values we can set, and remove the ones we can't 6786 * set, or fill them with some default data. 6787 */ 6788 6789 /* ~5 Mb/s real (802.11b) */ 6790 range->throughput = 5 * 1000 * 1000; 6791 6792 // range->sensitivity; /* signal level threshold range */ 6793 6794 range->max_qual.qual = 100; 6795 /* TODO: Find real max RSSI and stick here */ 6796 range->max_qual.level = 0; 6797 range->max_qual.noise = 0; 6798 range->max_qual.updated = 7; /* Updated all three */ 6799 6800 range->avg_qual.qual = 70; /* > 8% missed beacons is 'bad' */ 6801 /* TODO: Find real 'good' to 'bad' threshold value for RSSI */ 6802 range->avg_qual.level = 20 + IPW2100_RSSI_TO_DBM; 6803 range->avg_qual.noise = 0; 6804 range->avg_qual.updated = 7; /* Updated all three */ 6805 6806 range->num_bitrates = RATE_COUNT; 6807 6808 for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++) { 6809 range->bitrate[i] = ipw2100_bg_rates[i].bitrate * 100 * 1000; 6810 } 6811 6812 range->min_rts = MIN_RTS_THRESHOLD; 6813 range->max_rts = MAX_RTS_THRESHOLD; 6814 range->min_frag = MIN_FRAG_THRESHOLD; 6815 range->max_frag = MAX_FRAG_THRESHOLD; 6816 6817 range->min_pmp = period_duration[0]; /* Minimal PM period */ 6818 range->max_pmp = period_duration[POWER_MODES - 1]; /* Maximal PM period */ 6819 range->min_pmt = timeout_duration[POWER_MODES - 1]; /* Minimal PM timeout */ 6820 range->max_pmt = timeout_duration[0]; /* Maximal PM timeout */ 6821 6822 /* How to decode max/min PM period */ 6823 range->pmp_flags = IW_POWER_PERIOD; 6824 /* How to decode max/min PM period */ 6825 range->pmt_flags = IW_POWER_TIMEOUT; 6826 /* What PM options are supported */ 6827 range->pm_capa = IW_POWER_TIMEOUT | IW_POWER_PERIOD; 6828 6829 range->encoding_size[0] = 5; 6830 range->encoding_size[1] = 13; /* Different token sizes */ 6831 range->num_encoding_sizes = 2; /* Number of entry in the list */ 6832 range->max_encoding_tokens = WEP_KEYS; /* Max number of tokens */ 6833 // range->encoding_login_index; /* token index for login token */ 6834 6835 if (priv->ieee->iw_mode == IW_MODE_ADHOC) { 6836 range->txpower_capa = IW_TXPOW_DBM; 6837 range->num_txpower = IW_MAX_TXPOWER; 6838 for (i = 0, level = (IPW_TX_POWER_MAX_DBM * 16); 6839 i < IW_MAX_TXPOWER; 6840 i++, level -= 6841 ((IPW_TX_POWER_MAX_DBM - 6842 IPW_TX_POWER_MIN_DBM) * 16) / (IW_MAX_TXPOWER - 1)) 6843 range->txpower[i] = level / 16; 6844 } else { 6845 range->txpower_capa = 0; 6846 range->num_txpower = 0; 6847 } 6848 6849 /* Set the Wireless Extension versions */ 6850 range->we_version_compiled = WIRELESS_EXT; 6851 range->we_version_source = 18; 6852 6853 // range->retry_capa; /* What retry options are supported */ 6854 // range->retry_flags; /* How to decode max/min retry limit */ 6855 // range->r_time_flags; /* How to decode max/min retry life */ 6856 // range->min_retry; /* Minimal number of retries */ 6857 // range->max_retry; /* Maximal number of retries */ 6858 // range->min_r_time; /* Minimal retry lifetime */ 6859 // range->max_r_time; /* Maximal retry lifetime */ 6860 6861 range->num_channels = FREQ_COUNT; 6862 6863 val = 0; 6864 for (i = 0; i < FREQ_COUNT; i++) { 6865 // TODO: Include only legal frequencies for some countries 6866 // if (local->channel_mask & (1 << i)) { 6867 range->freq[val].i = i + 1; 6868 range->freq[val].m = ipw2100_frequencies[i] * 100000; 6869 range->freq[val].e = 1; 6870 val++; 6871 // } 6872 if (val == IW_MAX_FREQUENCIES) 6873 break; 6874 } 6875 range->num_frequency = val; 6876 6877 /* Event capability (kernel + driver) */ 6878 range->event_capa[0] = (IW_EVENT_CAPA_K_0 | 6879 IW_EVENT_CAPA_MASK(SIOCGIWAP)); 6880 range->event_capa[1] = IW_EVENT_CAPA_K_1; 6881 6882 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 | 6883 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP; 6884 6885 IPW_DEBUG_WX("GET Range\n"); 6886 6887 return 0; 6888 } 6889 6890 static int ipw2100_wx_set_wap(struct net_device *dev, 6891 struct iw_request_info *info, 6892 union iwreq_data *wrqu, char *extra) 6893 { 6894 struct ipw2100_priv *priv = libipw_priv(dev); 6895 int err = 0; 6896 6897 // sanity checks 6898 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER) 6899 return -EINVAL; 6900 6901 mutex_lock(&priv->action_mutex); 6902 if (!(priv->status & STATUS_INITIALIZED)) { 6903 err = -EIO; 6904 goto done; 6905 } 6906 6907 if (is_broadcast_ether_addr(wrqu->ap_addr.sa_data) || 6908 is_zero_ether_addr(wrqu->ap_addr.sa_data)) { 6909 /* we disable mandatory BSSID association */ 6910 IPW_DEBUG_WX("exit - disable mandatory BSSID\n"); 6911 priv->config &= ~CFG_STATIC_BSSID; 6912 err = ipw2100_set_mandatory_bssid(priv, NULL, 0); 6913 goto done; 6914 } 6915 6916 priv->config |= CFG_STATIC_BSSID; 6917 memcpy(priv->mandatory_bssid_mac, wrqu->ap_addr.sa_data, ETH_ALEN); 6918 6919 err = ipw2100_set_mandatory_bssid(priv, wrqu->ap_addr.sa_data, 0); 6920 6921 IPW_DEBUG_WX("SET BSSID -> %pM\n", wrqu->ap_addr.sa_data); 6922 6923 done: 6924 mutex_unlock(&priv->action_mutex); 6925 return err; 6926 } 6927 6928 static int ipw2100_wx_get_wap(struct net_device *dev, 6929 struct iw_request_info *info, 6930 union iwreq_data *wrqu, char *extra) 6931 { 6932 /* 6933 * This can be called at any time. No action lock required 6934 */ 6935 6936 struct ipw2100_priv *priv = libipw_priv(dev); 6937 6938 /* If we are associated, trying to associate, or have a statically 6939 * configured BSSID then return that; otherwise return ANY */ 6940 if (priv->config & CFG_STATIC_BSSID || priv->status & STATUS_ASSOCIATED) { 6941 wrqu->ap_addr.sa_family = ARPHRD_ETHER; 6942 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN); 6943 } else 6944 eth_zero_addr(wrqu->ap_addr.sa_data); 6945 6946 IPW_DEBUG_WX("Getting WAP BSSID: %pM\n", wrqu->ap_addr.sa_data); 6947 return 0; 6948 } 6949 6950 static int ipw2100_wx_set_essid(struct net_device *dev, 6951 struct iw_request_info *info, 6952 union iwreq_data *wrqu, char *extra) 6953 { 6954 struct ipw2100_priv *priv = libipw_priv(dev); 6955 char *essid = ""; /* ANY */ 6956 int length = 0; 6957 int err = 0; 6958 6959 mutex_lock(&priv->action_mutex); 6960 if (!(priv->status & STATUS_INITIALIZED)) { 6961 err = -EIO; 6962 goto done; 6963 } 6964 6965 if (wrqu->essid.flags && wrqu->essid.length) { 6966 length = wrqu->essid.length; 6967 essid = extra; 6968 } 6969 6970 if (length == 0) { 6971 IPW_DEBUG_WX("Setting ESSID to ANY\n"); 6972 priv->config &= ~CFG_STATIC_ESSID; 6973 err = ipw2100_set_essid(priv, NULL, 0, 0); 6974 goto done; 6975 } 6976 6977 length = min(length, IW_ESSID_MAX_SIZE); 6978 6979 priv->config |= CFG_STATIC_ESSID; 6980 6981 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) { 6982 IPW_DEBUG_WX("ESSID set to current ESSID.\n"); 6983 err = 0; 6984 goto done; 6985 } 6986 6987 IPW_DEBUG_WX("Setting ESSID: '%*pE' (%d)\n", length, essid, length); 6988 6989 priv->essid_len = length; 6990 memcpy(priv->essid, essid, priv->essid_len); 6991 6992 err = ipw2100_set_essid(priv, essid, length, 0); 6993 6994 done: 6995 mutex_unlock(&priv->action_mutex); 6996 return err; 6997 } 6998 6999 static int ipw2100_wx_get_essid(struct net_device *dev, 7000 struct iw_request_info *info, 7001 union iwreq_data *wrqu, char *extra) 7002 { 7003 /* 7004 * This can be called at any time. No action lock required 7005 */ 7006 7007 struct ipw2100_priv *priv = libipw_priv(dev); 7008 7009 /* If we are associated, trying to associate, or have a statically 7010 * configured ESSID then return that; otherwise return ANY */ 7011 if (priv->config & CFG_STATIC_ESSID || priv->status & STATUS_ASSOCIATED) { 7012 IPW_DEBUG_WX("Getting essid: '%*pE'\n", 7013 priv->essid_len, priv->essid); 7014 memcpy(extra, priv->essid, priv->essid_len); 7015 wrqu->essid.length = priv->essid_len; 7016 wrqu->essid.flags = 1; /* active */ 7017 } else { 7018 IPW_DEBUG_WX("Getting essid: ANY\n"); 7019 wrqu->essid.length = 0; 7020 wrqu->essid.flags = 0; /* active */ 7021 } 7022 7023 return 0; 7024 } 7025 7026 static int ipw2100_wx_set_nick(struct net_device *dev, 7027 struct iw_request_info *info, 7028 union iwreq_data *wrqu, char *extra) 7029 { 7030 /* 7031 * This can be called at any time. No action lock required 7032 */ 7033 7034 struct ipw2100_priv *priv = libipw_priv(dev); 7035 7036 if (wrqu->data.length > IW_ESSID_MAX_SIZE) 7037 return -E2BIG; 7038 7039 wrqu->data.length = min_t(size_t, wrqu->data.length, sizeof(priv->nick)); 7040 memset(priv->nick, 0, sizeof(priv->nick)); 7041 memcpy(priv->nick, extra, wrqu->data.length); 7042 7043 IPW_DEBUG_WX("SET Nickname -> %s\n", priv->nick); 7044 7045 return 0; 7046 } 7047 7048 static int ipw2100_wx_get_nick(struct net_device *dev, 7049 struct iw_request_info *info, 7050 union iwreq_data *wrqu, char *extra) 7051 { 7052 /* 7053 * This can be called at any time. No action lock required 7054 */ 7055 7056 struct ipw2100_priv *priv = libipw_priv(dev); 7057 7058 wrqu->data.length = strlen(priv->nick); 7059 memcpy(extra, priv->nick, wrqu->data.length); 7060 wrqu->data.flags = 1; /* active */ 7061 7062 IPW_DEBUG_WX("GET Nickname -> %s\n", extra); 7063 7064 return 0; 7065 } 7066 7067 static int ipw2100_wx_set_rate(struct net_device *dev, 7068 struct iw_request_info *info, 7069 union iwreq_data *wrqu, char *extra) 7070 { 7071 struct ipw2100_priv *priv = libipw_priv(dev); 7072 u32 target_rate = wrqu->bitrate.value; 7073 u32 rate; 7074 int err = 0; 7075 7076 mutex_lock(&priv->action_mutex); 7077 if (!(priv->status & STATUS_INITIALIZED)) { 7078 err = -EIO; 7079 goto done; 7080 } 7081 7082 rate = 0; 7083 7084 if (target_rate == 1000000 || 7085 (!wrqu->bitrate.fixed && target_rate > 1000000)) 7086 rate |= TX_RATE_1_MBIT; 7087 if (target_rate == 2000000 || 7088 (!wrqu->bitrate.fixed && target_rate > 2000000)) 7089 rate |= TX_RATE_2_MBIT; 7090 if (target_rate == 5500000 || 7091 (!wrqu->bitrate.fixed && target_rate > 5500000)) 7092 rate |= TX_RATE_5_5_MBIT; 7093 if (target_rate == 11000000 || 7094 (!wrqu->bitrate.fixed && target_rate > 11000000)) 7095 rate |= TX_RATE_11_MBIT; 7096 if (rate == 0) 7097 rate = DEFAULT_TX_RATES; 7098 7099 err = ipw2100_set_tx_rates(priv, rate, 0); 7100 7101 IPW_DEBUG_WX("SET Rate -> %04X\n", rate); 7102 done: 7103 mutex_unlock(&priv->action_mutex); 7104 return err; 7105 } 7106 7107 static int ipw2100_wx_get_rate(struct net_device *dev, 7108 struct iw_request_info *info, 7109 union iwreq_data *wrqu, char *extra) 7110 { 7111 struct ipw2100_priv *priv = libipw_priv(dev); 7112 int val; 7113 unsigned int len = sizeof(val); 7114 int err = 0; 7115 7116 if (!(priv->status & STATUS_ENABLED) || 7117 priv->status & STATUS_RF_KILL_MASK || 7118 !(priv->status & STATUS_ASSOCIATED)) { 7119 wrqu->bitrate.value = 0; 7120 return 0; 7121 } 7122 7123 mutex_lock(&priv->action_mutex); 7124 if (!(priv->status & STATUS_INITIALIZED)) { 7125 err = -EIO; 7126 goto done; 7127 } 7128 7129 err = ipw2100_get_ordinal(priv, IPW_ORD_CURRENT_TX_RATE, &val, &len); 7130 if (err) { 7131 IPW_DEBUG_WX("failed querying ordinals.\n"); 7132 goto done; 7133 } 7134 7135 switch (val & TX_RATE_MASK) { 7136 case TX_RATE_1_MBIT: 7137 wrqu->bitrate.value = 1000000; 7138 break; 7139 case TX_RATE_2_MBIT: 7140 wrqu->bitrate.value = 2000000; 7141 break; 7142 case TX_RATE_5_5_MBIT: 7143 wrqu->bitrate.value = 5500000; 7144 break; 7145 case TX_RATE_11_MBIT: 7146 wrqu->bitrate.value = 11000000; 7147 break; 7148 default: 7149 wrqu->bitrate.value = 0; 7150 } 7151 7152 IPW_DEBUG_WX("GET Rate -> %d\n", wrqu->bitrate.value); 7153 7154 done: 7155 mutex_unlock(&priv->action_mutex); 7156 return err; 7157 } 7158 7159 static int ipw2100_wx_set_rts(struct net_device *dev, 7160 struct iw_request_info *info, 7161 union iwreq_data *wrqu, char *extra) 7162 { 7163 struct ipw2100_priv *priv = libipw_priv(dev); 7164 int value, err; 7165 7166 /* Auto RTS not yet supported */ 7167 if (wrqu->rts.fixed == 0) 7168 return -EINVAL; 7169 7170 mutex_lock(&priv->action_mutex); 7171 if (!(priv->status & STATUS_INITIALIZED)) { 7172 err = -EIO; 7173 goto done; 7174 } 7175 7176 if (wrqu->rts.disabled) 7177 value = priv->rts_threshold | RTS_DISABLED; 7178 else { 7179 if (wrqu->rts.value < 1 || wrqu->rts.value > 2304) { 7180 err = -EINVAL; 7181 goto done; 7182 } 7183 value = wrqu->rts.value; 7184 } 7185 7186 err = ipw2100_set_rts_threshold(priv, value); 7187 7188 IPW_DEBUG_WX("SET RTS Threshold -> 0x%08X\n", value); 7189 done: 7190 mutex_unlock(&priv->action_mutex); 7191 return err; 7192 } 7193 7194 static int ipw2100_wx_get_rts(struct net_device *dev, 7195 struct iw_request_info *info, 7196 union iwreq_data *wrqu, char *extra) 7197 { 7198 /* 7199 * This can be called at any time. No action lock required 7200 */ 7201 7202 struct ipw2100_priv *priv = libipw_priv(dev); 7203 7204 wrqu->rts.value = priv->rts_threshold & ~RTS_DISABLED; 7205 wrqu->rts.fixed = 1; /* no auto select */ 7206 7207 /* If RTS is set to the default value, then it is disabled */ 7208 wrqu->rts.disabled = (priv->rts_threshold & RTS_DISABLED) ? 1 : 0; 7209 7210 IPW_DEBUG_WX("GET RTS Threshold -> 0x%08X\n", wrqu->rts.value); 7211 7212 return 0; 7213 } 7214 7215 static int ipw2100_wx_set_txpow(struct net_device *dev, 7216 struct iw_request_info *info, 7217 union iwreq_data *wrqu, char *extra) 7218 { 7219 struct ipw2100_priv *priv = libipw_priv(dev); 7220 int err = 0, value; 7221 7222 if (ipw_radio_kill_sw(priv, wrqu->txpower.disabled)) 7223 return -EINPROGRESS; 7224 7225 if (priv->ieee->iw_mode != IW_MODE_ADHOC) 7226 return 0; 7227 7228 if ((wrqu->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM) 7229 return -EINVAL; 7230 7231 if (wrqu->txpower.fixed == 0) 7232 value = IPW_TX_POWER_DEFAULT; 7233 else { 7234 if (wrqu->txpower.value < IPW_TX_POWER_MIN_DBM || 7235 wrqu->txpower.value > IPW_TX_POWER_MAX_DBM) 7236 return -EINVAL; 7237 7238 value = wrqu->txpower.value; 7239 } 7240 7241 mutex_lock(&priv->action_mutex); 7242 if (!(priv->status & STATUS_INITIALIZED)) { 7243 err = -EIO; 7244 goto done; 7245 } 7246 7247 err = ipw2100_set_tx_power(priv, value); 7248 7249 IPW_DEBUG_WX("SET TX Power -> %d\n", value); 7250 7251 done: 7252 mutex_unlock(&priv->action_mutex); 7253 return err; 7254 } 7255 7256 static int ipw2100_wx_get_txpow(struct net_device *dev, 7257 struct iw_request_info *info, 7258 union iwreq_data *wrqu, char *extra) 7259 { 7260 /* 7261 * This can be called at any time. No action lock required 7262 */ 7263 7264 struct ipw2100_priv *priv = libipw_priv(dev); 7265 7266 wrqu->txpower.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0; 7267 7268 if (priv->tx_power == IPW_TX_POWER_DEFAULT) { 7269 wrqu->txpower.fixed = 0; 7270 wrqu->txpower.value = IPW_TX_POWER_MAX_DBM; 7271 } else { 7272 wrqu->txpower.fixed = 1; 7273 wrqu->txpower.value = priv->tx_power; 7274 } 7275 7276 wrqu->txpower.flags = IW_TXPOW_DBM; 7277 7278 IPW_DEBUG_WX("GET TX Power -> %d\n", wrqu->txpower.value); 7279 7280 return 0; 7281 } 7282 7283 static int ipw2100_wx_set_frag(struct net_device *dev, 7284 struct iw_request_info *info, 7285 union iwreq_data *wrqu, char *extra) 7286 { 7287 /* 7288 * This can be called at any time. No action lock required 7289 */ 7290 7291 struct ipw2100_priv *priv = libipw_priv(dev); 7292 7293 if (!wrqu->frag.fixed) 7294 return -EINVAL; 7295 7296 if (wrqu->frag.disabled) { 7297 priv->frag_threshold |= FRAG_DISABLED; 7298 priv->ieee->fts = DEFAULT_FTS; 7299 } else { 7300 if (wrqu->frag.value < MIN_FRAG_THRESHOLD || 7301 wrqu->frag.value > MAX_FRAG_THRESHOLD) 7302 return -EINVAL; 7303 7304 priv->ieee->fts = wrqu->frag.value & ~0x1; 7305 priv->frag_threshold = priv->ieee->fts; 7306 } 7307 7308 IPW_DEBUG_WX("SET Frag Threshold -> %d\n", priv->ieee->fts); 7309 7310 return 0; 7311 } 7312 7313 static int ipw2100_wx_get_frag(struct net_device *dev, 7314 struct iw_request_info *info, 7315 union iwreq_data *wrqu, char *extra) 7316 { 7317 /* 7318 * This can be called at any time. No action lock required 7319 */ 7320 7321 struct ipw2100_priv *priv = libipw_priv(dev); 7322 wrqu->frag.value = priv->frag_threshold & ~FRAG_DISABLED; 7323 wrqu->frag.fixed = 0; /* no auto select */ 7324 wrqu->frag.disabled = (priv->frag_threshold & FRAG_DISABLED) ? 1 : 0; 7325 7326 IPW_DEBUG_WX("GET Frag Threshold -> %d\n", wrqu->frag.value); 7327 7328 return 0; 7329 } 7330 7331 static int ipw2100_wx_set_retry(struct net_device *dev, 7332 struct iw_request_info *info, 7333 union iwreq_data *wrqu, char *extra) 7334 { 7335 struct ipw2100_priv *priv = libipw_priv(dev); 7336 int err = 0; 7337 7338 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled) 7339 return -EINVAL; 7340 7341 if (!(wrqu->retry.flags & IW_RETRY_LIMIT)) 7342 return 0; 7343 7344 mutex_lock(&priv->action_mutex); 7345 if (!(priv->status & STATUS_INITIALIZED)) { 7346 err = -EIO; 7347 goto done; 7348 } 7349 7350 if (wrqu->retry.flags & IW_RETRY_SHORT) { 7351 err = ipw2100_set_short_retry(priv, wrqu->retry.value); 7352 IPW_DEBUG_WX("SET Short Retry Limit -> %d\n", 7353 wrqu->retry.value); 7354 goto done; 7355 } 7356 7357 if (wrqu->retry.flags & IW_RETRY_LONG) { 7358 err = ipw2100_set_long_retry(priv, wrqu->retry.value); 7359 IPW_DEBUG_WX("SET Long Retry Limit -> %d\n", 7360 wrqu->retry.value); 7361 goto done; 7362 } 7363 7364 err = ipw2100_set_short_retry(priv, wrqu->retry.value); 7365 if (!err) 7366 err = ipw2100_set_long_retry(priv, wrqu->retry.value); 7367 7368 IPW_DEBUG_WX("SET Both Retry Limits -> %d\n", wrqu->retry.value); 7369 7370 done: 7371 mutex_unlock(&priv->action_mutex); 7372 return err; 7373 } 7374 7375 static int ipw2100_wx_get_retry(struct net_device *dev, 7376 struct iw_request_info *info, 7377 union iwreq_data *wrqu, char *extra) 7378 { 7379 /* 7380 * This can be called at any time. No action lock required 7381 */ 7382 7383 struct ipw2100_priv *priv = libipw_priv(dev); 7384 7385 wrqu->retry.disabled = 0; /* can't be disabled */ 7386 7387 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) 7388 return -EINVAL; 7389 7390 if (wrqu->retry.flags & IW_RETRY_LONG) { 7391 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG; 7392 wrqu->retry.value = priv->long_retry_limit; 7393 } else { 7394 wrqu->retry.flags = 7395 (priv->short_retry_limit != 7396 priv->long_retry_limit) ? 7397 IW_RETRY_LIMIT | IW_RETRY_SHORT : IW_RETRY_LIMIT; 7398 7399 wrqu->retry.value = priv->short_retry_limit; 7400 } 7401 7402 IPW_DEBUG_WX("GET Retry -> %d\n", wrqu->retry.value); 7403 7404 return 0; 7405 } 7406 7407 static int ipw2100_wx_set_scan(struct net_device *dev, 7408 struct iw_request_info *info, 7409 union iwreq_data *wrqu, char *extra) 7410 { 7411 struct ipw2100_priv *priv = libipw_priv(dev); 7412 int err = 0; 7413 7414 mutex_lock(&priv->action_mutex); 7415 if (!(priv->status & STATUS_INITIALIZED)) { 7416 err = -EIO; 7417 goto done; 7418 } 7419 7420 IPW_DEBUG_WX("Initiating scan...\n"); 7421 7422 priv->user_requested_scan = 1; 7423 if (ipw2100_set_scan_options(priv) || ipw2100_start_scan(priv)) { 7424 IPW_DEBUG_WX("Start scan failed.\n"); 7425 7426 /* TODO: Mark a scan as pending so when hardware initialized 7427 * a scan starts */ 7428 } 7429 7430 done: 7431 mutex_unlock(&priv->action_mutex); 7432 return err; 7433 } 7434 7435 static int ipw2100_wx_get_scan(struct net_device *dev, 7436 struct iw_request_info *info, 7437 union iwreq_data *wrqu, char *extra) 7438 { 7439 /* 7440 * This can be called at any time. No action lock required 7441 */ 7442 7443 struct ipw2100_priv *priv = libipw_priv(dev); 7444 return libipw_wx_get_scan(priv->ieee, info, wrqu, extra); 7445 } 7446 7447 /* 7448 * Implementation based on code in hostap-driver v0.1.3 hostap_ioctl.c 7449 */ 7450 static int ipw2100_wx_set_encode(struct net_device *dev, 7451 struct iw_request_info *info, 7452 union iwreq_data *wrqu, char *key) 7453 { 7454 /* 7455 * No check of STATUS_INITIALIZED required 7456 */ 7457 7458 struct ipw2100_priv *priv = libipw_priv(dev); 7459 return libipw_wx_set_encode(priv->ieee, info, wrqu, key); 7460 } 7461 7462 static int ipw2100_wx_get_encode(struct net_device *dev, 7463 struct iw_request_info *info, 7464 union iwreq_data *wrqu, char *key) 7465 { 7466 /* 7467 * This can be called at any time. No action lock required 7468 */ 7469 7470 struct ipw2100_priv *priv = libipw_priv(dev); 7471 return libipw_wx_get_encode(priv->ieee, info, wrqu, key); 7472 } 7473 7474 static int ipw2100_wx_set_power(struct net_device *dev, 7475 struct iw_request_info *info, 7476 union iwreq_data *wrqu, char *extra) 7477 { 7478 struct ipw2100_priv *priv = libipw_priv(dev); 7479 int err = 0; 7480 7481 mutex_lock(&priv->action_mutex); 7482 if (!(priv->status & STATUS_INITIALIZED)) { 7483 err = -EIO; 7484 goto done; 7485 } 7486 7487 if (wrqu->power.disabled) { 7488 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode); 7489 err = ipw2100_set_power_mode(priv, IPW_POWER_MODE_CAM); 7490 IPW_DEBUG_WX("SET Power Management Mode -> off\n"); 7491 goto done; 7492 } 7493 7494 switch (wrqu->power.flags & IW_POWER_MODE) { 7495 case IW_POWER_ON: /* If not specified */ 7496 case IW_POWER_MODE: /* If set all mask */ 7497 case IW_POWER_ALL_R: /* If explicitly state all */ 7498 break; 7499 default: /* Otherwise we don't support it */ 7500 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n", 7501 wrqu->power.flags); 7502 err = -EOPNOTSUPP; 7503 goto done; 7504 } 7505 7506 /* If the user hasn't specified a power management mode yet, default 7507 * to BATTERY */ 7508 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode; 7509 err = ipw2100_set_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode)); 7510 7511 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode); 7512 7513 done: 7514 mutex_unlock(&priv->action_mutex); 7515 return err; 7516 7517 } 7518 7519 static int ipw2100_wx_get_power(struct net_device *dev, 7520 struct iw_request_info *info, 7521 union iwreq_data *wrqu, char *extra) 7522 { 7523 /* 7524 * This can be called at any time. No action lock required 7525 */ 7526 7527 struct ipw2100_priv *priv = libipw_priv(dev); 7528 7529 if (!(priv->power_mode & IPW_POWER_ENABLED)) 7530 wrqu->power.disabled = 1; 7531 else { 7532 wrqu->power.disabled = 0; 7533 wrqu->power.flags = 0; 7534 } 7535 7536 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode); 7537 7538 return 0; 7539 } 7540 7541 /* 7542 * WE-18 WPA support 7543 */ 7544 7545 /* SIOCSIWGENIE */ 7546 static int ipw2100_wx_set_genie(struct net_device *dev, 7547 struct iw_request_info *info, 7548 union iwreq_data *wrqu, char *extra) 7549 { 7550 7551 struct ipw2100_priv *priv = libipw_priv(dev); 7552 struct libipw_device *ieee = priv->ieee; 7553 u8 *buf; 7554 7555 if (!ieee->wpa_enabled) 7556 return -EOPNOTSUPP; 7557 7558 if (wrqu->data.length > MAX_WPA_IE_LEN || 7559 (wrqu->data.length && extra == NULL)) 7560 return -EINVAL; 7561 7562 if (wrqu->data.length) { 7563 buf = kmemdup(extra, wrqu->data.length, GFP_KERNEL); 7564 if (buf == NULL) 7565 return -ENOMEM; 7566 7567 kfree(ieee->wpa_ie); 7568 ieee->wpa_ie = buf; 7569 ieee->wpa_ie_len = wrqu->data.length; 7570 } else { 7571 kfree(ieee->wpa_ie); 7572 ieee->wpa_ie = NULL; 7573 ieee->wpa_ie_len = 0; 7574 } 7575 7576 ipw2100_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len); 7577 7578 return 0; 7579 } 7580 7581 /* SIOCGIWGENIE */ 7582 static int ipw2100_wx_get_genie(struct net_device *dev, 7583 struct iw_request_info *info, 7584 union iwreq_data *wrqu, char *extra) 7585 { 7586 struct ipw2100_priv *priv = libipw_priv(dev); 7587 struct libipw_device *ieee = priv->ieee; 7588 7589 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) { 7590 wrqu->data.length = 0; 7591 return 0; 7592 } 7593 7594 if (wrqu->data.length < ieee->wpa_ie_len) 7595 return -E2BIG; 7596 7597 wrqu->data.length = ieee->wpa_ie_len; 7598 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len); 7599 7600 return 0; 7601 } 7602 7603 /* SIOCSIWAUTH */ 7604 static int ipw2100_wx_set_auth(struct net_device *dev, 7605 struct iw_request_info *info, 7606 union iwreq_data *wrqu, char *extra) 7607 { 7608 struct ipw2100_priv *priv = libipw_priv(dev); 7609 struct libipw_device *ieee = priv->ieee; 7610 struct iw_param *param = &wrqu->param; 7611 struct lib80211_crypt_data *crypt; 7612 unsigned long flags; 7613 int ret = 0; 7614 7615 switch (param->flags & IW_AUTH_INDEX) { 7616 case IW_AUTH_WPA_VERSION: 7617 case IW_AUTH_CIPHER_PAIRWISE: 7618 case IW_AUTH_CIPHER_GROUP: 7619 case IW_AUTH_KEY_MGMT: 7620 /* 7621 * ipw2200 does not use these parameters 7622 */ 7623 break; 7624 7625 case IW_AUTH_TKIP_COUNTERMEASURES: 7626 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx]; 7627 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags) 7628 break; 7629 7630 flags = crypt->ops->get_flags(crypt->priv); 7631 7632 if (param->value) 7633 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES; 7634 else 7635 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES; 7636 7637 crypt->ops->set_flags(flags, crypt->priv); 7638 7639 break; 7640 7641 case IW_AUTH_DROP_UNENCRYPTED:{ 7642 /* HACK: 7643 * 7644 * wpa_supplicant calls set_wpa_enabled when the driver 7645 * is loaded and unloaded, regardless of if WPA is being 7646 * used. No other calls are made which can be used to 7647 * determine if encryption will be used or not prior to 7648 * association being expected. If encryption is not being 7649 * used, drop_unencrypted is set to false, else true -- we 7650 * can use this to determine if the CAP_PRIVACY_ON bit should 7651 * be set. 7652 */ 7653 struct libipw_security sec = { 7654 .flags = SEC_ENABLED, 7655 .enabled = param->value, 7656 }; 7657 priv->ieee->drop_unencrypted = param->value; 7658 /* We only change SEC_LEVEL for open mode. Others 7659 * are set by ipw_wpa_set_encryption. 7660 */ 7661 if (!param->value) { 7662 sec.flags |= SEC_LEVEL; 7663 sec.level = SEC_LEVEL_0; 7664 } else { 7665 sec.flags |= SEC_LEVEL; 7666 sec.level = SEC_LEVEL_1; 7667 } 7668 if (priv->ieee->set_security) 7669 priv->ieee->set_security(priv->ieee->dev, &sec); 7670 break; 7671 } 7672 7673 case IW_AUTH_80211_AUTH_ALG: 7674 ret = ipw2100_wpa_set_auth_algs(priv, param->value); 7675 break; 7676 7677 case IW_AUTH_WPA_ENABLED: 7678 ret = ipw2100_wpa_enable(priv, param->value); 7679 break; 7680 7681 case IW_AUTH_RX_UNENCRYPTED_EAPOL: 7682 ieee->ieee802_1x = param->value; 7683 break; 7684 7685 //case IW_AUTH_ROAMING_CONTROL: 7686 case IW_AUTH_PRIVACY_INVOKED: 7687 ieee->privacy_invoked = param->value; 7688 break; 7689 7690 default: 7691 return -EOPNOTSUPP; 7692 } 7693 return ret; 7694 } 7695 7696 /* SIOCGIWAUTH */ 7697 static int ipw2100_wx_get_auth(struct net_device *dev, 7698 struct iw_request_info *info, 7699 union iwreq_data *wrqu, char *extra) 7700 { 7701 struct ipw2100_priv *priv = libipw_priv(dev); 7702 struct libipw_device *ieee = priv->ieee; 7703 struct lib80211_crypt_data *crypt; 7704 struct iw_param *param = &wrqu->param; 7705 7706 switch (param->flags & IW_AUTH_INDEX) { 7707 case IW_AUTH_WPA_VERSION: 7708 case IW_AUTH_CIPHER_PAIRWISE: 7709 case IW_AUTH_CIPHER_GROUP: 7710 case IW_AUTH_KEY_MGMT: 7711 /* 7712 * wpa_supplicant will control these internally 7713 */ 7714 break; 7715 7716 case IW_AUTH_TKIP_COUNTERMEASURES: 7717 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx]; 7718 if (!crypt || !crypt->ops->get_flags) { 7719 IPW_DEBUG_WARNING("Can't get TKIP countermeasures: " 7720 "crypt not set!\n"); 7721 break; 7722 } 7723 7724 param->value = (crypt->ops->get_flags(crypt->priv) & 7725 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0; 7726 7727 break; 7728 7729 case IW_AUTH_DROP_UNENCRYPTED: 7730 param->value = ieee->drop_unencrypted; 7731 break; 7732 7733 case IW_AUTH_80211_AUTH_ALG: 7734 param->value = priv->ieee->sec.auth_mode; 7735 break; 7736 7737 case IW_AUTH_WPA_ENABLED: 7738 param->value = ieee->wpa_enabled; 7739 break; 7740 7741 case IW_AUTH_RX_UNENCRYPTED_EAPOL: 7742 param->value = ieee->ieee802_1x; 7743 break; 7744 7745 case IW_AUTH_ROAMING_CONTROL: 7746 case IW_AUTH_PRIVACY_INVOKED: 7747 param->value = ieee->privacy_invoked; 7748 break; 7749 7750 default: 7751 return -EOPNOTSUPP; 7752 } 7753 return 0; 7754 } 7755 7756 /* SIOCSIWENCODEEXT */ 7757 static int ipw2100_wx_set_encodeext(struct net_device *dev, 7758 struct iw_request_info *info, 7759 union iwreq_data *wrqu, char *extra) 7760 { 7761 struct ipw2100_priv *priv = libipw_priv(dev); 7762 return libipw_wx_set_encodeext(priv->ieee, info, wrqu, extra); 7763 } 7764 7765 /* SIOCGIWENCODEEXT */ 7766 static int ipw2100_wx_get_encodeext(struct net_device *dev, 7767 struct iw_request_info *info, 7768 union iwreq_data *wrqu, char *extra) 7769 { 7770 struct ipw2100_priv *priv = libipw_priv(dev); 7771 return libipw_wx_get_encodeext(priv->ieee, info, wrqu, extra); 7772 } 7773 7774 /* SIOCSIWMLME */ 7775 static int ipw2100_wx_set_mlme(struct net_device *dev, 7776 struct iw_request_info *info, 7777 union iwreq_data *wrqu, char *extra) 7778 { 7779 struct ipw2100_priv *priv = libipw_priv(dev); 7780 struct iw_mlme *mlme = (struct iw_mlme *)extra; 7781 7782 switch (mlme->cmd) { 7783 case IW_MLME_DEAUTH: 7784 // silently ignore 7785 break; 7786 7787 case IW_MLME_DISASSOC: 7788 ipw2100_disassociate_bssid(priv); 7789 break; 7790 7791 default: 7792 return -EOPNOTSUPP; 7793 } 7794 return 0; 7795 } 7796 7797 /* 7798 * 7799 * IWPRIV handlers 7800 * 7801 */ 7802 #ifdef CONFIG_IPW2100_MONITOR 7803 static int ipw2100_wx_set_promisc(struct net_device *dev, 7804 struct iw_request_info *info, 7805 union iwreq_data *wrqu, char *extra) 7806 { 7807 struct ipw2100_priv *priv = libipw_priv(dev); 7808 int *parms = (int *)extra; 7809 int enable = (parms[0] > 0); 7810 int err = 0; 7811 7812 mutex_lock(&priv->action_mutex); 7813 if (!(priv->status & STATUS_INITIALIZED)) { 7814 err = -EIO; 7815 goto done; 7816 } 7817 7818 if (enable) { 7819 if (priv->ieee->iw_mode == IW_MODE_MONITOR) { 7820 err = ipw2100_set_channel(priv, parms[1], 0); 7821 goto done; 7822 } 7823 priv->channel = parms[1]; 7824 err = ipw2100_switch_mode(priv, IW_MODE_MONITOR); 7825 } else { 7826 if (priv->ieee->iw_mode == IW_MODE_MONITOR) 7827 err = ipw2100_switch_mode(priv, priv->last_mode); 7828 } 7829 done: 7830 mutex_unlock(&priv->action_mutex); 7831 return err; 7832 } 7833 7834 static int ipw2100_wx_reset(struct net_device *dev, 7835 struct iw_request_info *info, 7836 union iwreq_data *wrqu, char *extra) 7837 { 7838 struct ipw2100_priv *priv = libipw_priv(dev); 7839 if (priv->status & STATUS_INITIALIZED) 7840 schedule_reset(priv); 7841 return 0; 7842 } 7843 7844 #endif 7845 7846 static int ipw2100_wx_set_powermode(struct net_device *dev, 7847 struct iw_request_info *info, 7848 union iwreq_data *wrqu, char *extra) 7849 { 7850 struct ipw2100_priv *priv = libipw_priv(dev); 7851 int err = 0, mode = *(int *)extra; 7852 7853 mutex_lock(&priv->action_mutex); 7854 if (!(priv->status & STATUS_INITIALIZED)) { 7855 err = -EIO; 7856 goto done; 7857 } 7858 7859 if ((mode < 0) || (mode > POWER_MODES)) 7860 mode = IPW_POWER_AUTO; 7861 7862 if (IPW_POWER_LEVEL(priv->power_mode) != mode) 7863 err = ipw2100_set_power_mode(priv, mode); 7864 done: 7865 mutex_unlock(&priv->action_mutex); 7866 return err; 7867 } 7868 7869 #define MAX_POWER_STRING 80 7870 static int ipw2100_wx_get_powermode(struct net_device *dev, 7871 struct iw_request_info *info, 7872 union iwreq_data *wrqu, char *extra) 7873 { 7874 /* 7875 * This can be called at any time. No action lock required 7876 */ 7877 7878 struct ipw2100_priv *priv = libipw_priv(dev); 7879 int level = IPW_POWER_LEVEL(priv->power_mode); 7880 s32 timeout, period; 7881 7882 if (!(priv->power_mode & IPW_POWER_ENABLED)) { 7883 snprintf(extra, MAX_POWER_STRING, 7884 "Power save level: %d (Off)", level); 7885 } else { 7886 switch (level) { 7887 case IPW_POWER_MODE_CAM: 7888 snprintf(extra, MAX_POWER_STRING, 7889 "Power save level: %d (None)", level); 7890 break; 7891 case IPW_POWER_AUTO: 7892 snprintf(extra, MAX_POWER_STRING, 7893 "Power save level: %d (Auto)", level); 7894 break; 7895 default: 7896 timeout = timeout_duration[level - 1] / 1000; 7897 period = period_duration[level - 1] / 1000; 7898 snprintf(extra, MAX_POWER_STRING, 7899 "Power save level: %d " 7900 "(Timeout %dms, Period %dms)", 7901 level, timeout, period); 7902 } 7903 } 7904 7905 wrqu->data.length = strlen(extra) + 1; 7906 7907 return 0; 7908 } 7909 7910 static int ipw2100_wx_set_preamble(struct net_device *dev, 7911 struct iw_request_info *info, 7912 union iwreq_data *wrqu, char *extra) 7913 { 7914 struct ipw2100_priv *priv = libipw_priv(dev); 7915 int err, mode = *(int *)extra; 7916 7917 mutex_lock(&priv->action_mutex); 7918 if (!(priv->status & STATUS_INITIALIZED)) { 7919 err = -EIO; 7920 goto done; 7921 } 7922 7923 if (mode == 1) 7924 priv->config |= CFG_LONG_PREAMBLE; 7925 else if (mode == 0) 7926 priv->config &= ~CFG_LONG_PREAMBLE; 7927 else { 7928 err = -EINVAL; 7929 goto done; 7930 } 7931 7932 err = ipw2100_system_config(priv, 0); 7933 7934 done: 7935 mutex_unlock(&priv->action_mutex); 7936 return err; 7937 } 7938 7939 static int ipw2100_wx_get_preamble(struct net_device *dev, 7940 struct iw_request_info *info, 7941 union iwreq_data *wrqu, char *extra) 7942 { 7943 /* 7944 * This can be called at any time. No action lock required 7945 */ 7946 7947 struct ipw2100_priv *priv = libipw_priv(dev); 7948 7949 if (priv->config & CFG_LONG_PREAMBLE) 7950 snprintf(wrqu->name, IFNAMSIZ, "long (1)"); 7951 else 7952 snprintf(wrqu->name, IFNAMSIZ, "auto (0)"); 7953 7954 return 0; 7955 } 7956 7957 #ifdef CONFIG_IPW2100_MONITOR 7958 static int ipw2100_wx_set_crc_check(struct net_device *dev, 7959 struct iw_request_info *info, 7960 union iwreq_data *wrqu, char *extra) 7961 { 7962 struct ipw2100_priv *priv = libipw_priv(dev); 7963 int err, mode = *(int *)extra; 7964 7965 mutex_lock(&priv->action_mutex); 7966 if (!(priv->status & STATUS_INITIALIZED)) { 7967 err = -EIO; 7968 goto done; 7969 } 7970 7971 if (mode == 1) 7972 priv->config |= CFG_CRC_CHECK; 7973 else if (mode == 0) 7974 priv->config &= ~CFG_CRC_CHECK; 7975 else { 7976 err = -EINVAL; 7977 goto done; 7978 } 7979 err = 0; 7980 7981 done: 7982 mutex_unlock(&priv->action_mutex); 7983 return err; 7984 } 7985 7986 static int ipw2100_wx_get_crc_check(struct net_device *dev, 7987 struct iw_request_info *info, 7988 union iwreq_data *wrqu, char *extra) 7989 { 7990 /* 7991 * This can be called at any time. No action lock required 7992 */ 7993 7994 struct ipw2100_priv *priv = libipw_priv(dev); 7995 7996 if (priv->config & CFG_CRC_CHECK) 7997 snprintf(wrqu->name, IFNAMSIZ, "CRC checked (1)"); 7998 else 7999 snprintf(wrqu->name, IFNAMSIZ, "CRC ignored (0)"); 8000 8001 return 0; 8002 } 8003 #endif /* CONFIG_IPW2100_MONITOR */ 8004 8005 static iw_handler ipw2100_wx_handlers[] = { 8006 IW_HANDLER(SIOCGIWNAME, ipw2100_wx_get_name), 8007 IW_HANDLER(SIOCSIWFREQ, ipw2100_wx_set_freq), 8008 IW_HANDLER(SIOCGIWFREQ, ipw2100_wx_get_freq), 8009 IW_HANDLER(SIOCSIWMODE, ipw2100_wx_set_mode), 8010 IW_HANDLER(SIOCGIWMODE, ipw2100_wx_get_mode), 8011 IW_HANDLER(SIOCGIWRANGE, ipw2100_wx_get_range), 8012 IW_HANDLER(SIOCSIWAP, ipw2100_wx_set_wap), 8013 IW_HANDLER(SIOCGIWAP, ipw2100_wx_get_wap), 8014 IW_HANDLER(SIOCSIWMLME, ipw2100_wx_set_mlme), 8015 IW_HANDLER(SIOCSIWSCAN, ipw2100_wx_set_scan), 8016 IW_HANDLER(SIOCGIWSCAN, ipw2100_wx_get_scan), 8017 IW_HANDLER(SIOCSIWESSID, ipw2100_wx_set_essid), 8018 IW_HANDLER(SIOCGIWESSID, ipw2100_wx_get_essid), 8019 IW_HANDLER(SIOCSIWNICKN, ipw2100_wx_set_nick), 8020 IW_HANDLER(SIOCGIWNICKN, ipw2100_wx_get_nick), 8021 IW_HANDLER(SIOCSIWRATE, ipw2100_wx_set_rate), 8022 IW_HANDLER(SIOCGIWRATE, ipw2100_wx_get_rate), 8023 IW_HANDLER(SIOCSIWRTS, ipw2100_wx_set_rts), 8024 IW_HANDLER(SIOCGIWRTS, ipw2100_wx_get_rts), 8025 IW_HANDLER(SIOCSIWFRAG, ipw2100_wx_set_frag), 8026 IW_HANDLER(SIOCGIWFRAG, ipw2100_wx_get_frag), 8027 IW_HANDLER(SIOCSIWTXPOW, ipw2100_wx_set_txpow), 8028 IW_HANDLER(SIOCGIWTXPOW, ipw2100_wx_get_txpow), 8029 IW_HANDLER(SIOCSIWRETRY, ipw2100_wx_set_retry), 8030 IW_HANDLER(SIOCGIWRETRY, ipw2100_wx_get_retry), 8031 IW_HANDLER(SIOCSIWENCODE, ipw2100_wx_set_encode), 8032 IW_HANDLER(SIOCGIWENCODE, ipw2100_wx_get_encode), 8033 IW_HANDLER(SIOCSIWPOWER, ipw2100_wx_set_power), 8034 IW_HANDLER(SIOCGIWPOWER, ipw2100_wx_get_power), 8035 IW_HANDLER(SIOCSIWGENIE, ipw2100_wx_set_genie), 8036 IW_HANDLER(SIOCGIWGENIE, ipw2100_wx_get_genie), 8037 IW_HANDLER(SIOCSIWAUTH, ipw2100_wx_set_auth), 8038 IW_HANDLER(SIOCGIWAUTH, ipw2100_wx_get_auth), 8039 IW_HANDLER(SIOCSIWENCODEEXT, ipw2100_wx_set_encodeext), 8040 IW_HANDLER(SIOCGIWENCODEEXT, ipw2100_wx_get_encodeext), 8041 }; 8042 8043 #define IPW2100_PRIV_SET_MONITOR SIOCIWFIRSTPRIV 8044 #define IPW2100_PRIV_RESET SIOCIWFIRSTPRIV+1 8045 #define IPW2100_PRIV_SET_POWER SIOCIWFIRSTPRIV+2 8046 #define IPW2100_PRIV_GET_POWER SIOCIWFIRSTPRIV+3 8047 #define IPW2100_PRIV_SET_LONGPREAMBLE SIOCIWFIRSTPRIV+4 8048 #define IPW2100_PRIV_GET_LONGPREAMBLE SIOCIWFIRSTPRIV+5 8049 #define IPW2100_PRIV_SET_CRC_CHECK SIOCIWFIRSTPRIV+6 8050 #define IPW2100_PRIV_GET_CRC_CHECK SIOCIWFIRSTPRIV+7 8051 8052 static const struct iw_priv_args ipw2100_private_args[] = { 8053 8054 #ifdef CONFIG_IPW2100_MONITOR 8055 { 8056 IPW2100_PRIV_SET_MONITOR, 8057 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"}, 8058 { 8059 IPW2100_PRIV_RESET, 8060 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"}, 8061 #endif /* CONFIG_IPW2100_MONITOR */ 8062 8063 { 8064 IPW2100_PRIV_SET_POWER, 8065 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_power"}, 8066 { 8067 IPW2100_PRIV_GET_POWER, 8068 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_POWER_STRING, 8069 "get_power"}, 8070 { 8071 IPW2100_PRIV_SET_LONGPREAMBLE, 8072 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_preamble"}, 8073 { 8074 IPW2100_PRIV_GET_LONGPREAMBLE, 8075 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_preamble"}, 8076 #ifdef CONFIG_IPW2100_MONITOR 8077 { 8078 IPW2100_PRIV_SET_CRC_CHECK, 8079 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_crc_check"}, 8080 { 8081 IPW2100_PRIV_GET_CRC_CHECK, 8082 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_crc_check"}, 8083 #endif /* CONFIG_IPW2100_MONITOR */ 8084 }; 8085 8086 static iw_handler ipw2100_private_handler[] = { 8087 #ifdef CONFIG_IPW2100_MONITOR 8088 ipw2100_wx_set_promisc, 8089 ipw2100_wx_reset, 8090 #else /* CONFIG_IPW2100_MONITOR */ 8091 NULL, 8092 NULL, 8093 #endif /* CONFIG_IPW2100_MONITOR */ 8094 ipw2100_wx_set_powermode, 8095 ipw2100_wx_get_powermode, 8096 ipw2100_wx_set_preamble, 8097 ipw2100_wx_get_preamble, 8098 #ifdef CONFIG_IPW2100_MONITOR 8099 ipw2100_wx_set_crc_check, 8100 ipw2100_wx_get_crc_check, 8101 #else /* CONFIG_IPW2100_MONITOR */ 8102 NULL, 8103 NULL, 8104 #endif /* CONFIG_IPW2100_MONITOR */ 8105 }; 8106 8107 /* 8108 * Get wireless statistics. 8109 * Called by /proc/net/wireless 8110 * Also called by SIOCGIWSTATS 8111 */ 8112 static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev) 8113 { 8114 enum { 8115 POOR = 30, 8116 FAIR = 60, 8117 GOOD = 80, 8118 VERY_GOOD = 90, 8119 EXCELLENT = 95, 8120 PERFECT = 100 8121 }; 8122 int rssi_qual; 8123 int tx_qual; 8124 int beacon_qual; 8125 int quality; 8126 8127 struct ipw2100_priv *priv = libipw_priv(dev); 8128 struct iw_statistics *wstats; 8129 u32 rssi, tx_retries, missed_beacons, tx_failures; 8130 u32 ord_len = sizeof(u32); 8131 8132 if (!priv) 8133 return (struct iw_statistics *)NULL; 8134 8135 wstats = &priv->wstats; 8136 8137 /* if hw is disabled, then ipw2100_get_ordinal() can't be called. 8138 * ipw2100_wx_wireless_stats seems to be called before fw is 8139 * initialized. STATUS_ASSOCIATED will only be set if the hw is up 8140 * and associated; if not associcated, the values are all meaningless 8141 * anyway, so set them all to NULL and INVALID */ 8142 if (!(priv->status & STATUS_ASSOCIATED)) { 8143 wstats->miss.beacon = 0; 8144 wstats->discard.retries = 0; 8145 wstats->qual.qual = 0; 8146 wstats->qual.level = 0; 8147 wstats->qual.noise = 0; 8148 wstats->qual.updated = 7; 8149 wstats->qual.updated |= IW_QUAL_NOISE_INVALID | 8150 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID; 8151 return wstats; 8152 } 8153 8154 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_MISSED_BCNS, 8155 &missed_beacons, &ord_len)) 8156 goto fail_get_ordinal; 8157 8158 /* If we don't have a connection the quality and level is 0 */ 8159 if (!(priv->status & STATUS_ASSOCIATED)) { 8160 wstats->qual.qual = 0; 8161 wstats->qual.level = 0; 8162 } else { 8163 if (ipw2100_get_ordinal(priv, IPW_ORD_RSSI_AVG_CURR, 8164 &rssi, &ord_len)) 8165 goto fail_get_ordinal; 8166 wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM; 8167 if (rssi < 10) 8168 rssi_qual = rssi * POOR / 10; 8169 else if (rssi < 15) 8170 rssi_qual = (rssi - 10) * (FAIR - POOR) / 5 + POOR; 8171 else if (rssi < 20) 8172 rssi_qual = (rssi - 15) * (GOOD - FAIR) / 5 + FAIR; 8173 else if (rssi < 30) 8174 rssi_qual = (rssi - 20) * (VERY_GOOD - GOOD) / 8175 10 + GOOD; 8176 else 8177 rssi_qual = (rssi - 30) * (PERFECT - VERY_GOOD) / 8178 10 + VERY_GOOD; 8179 8180 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_RETRIES, 8181 &tx_retries, &ord_len)) 8182 goto fail_get_ordinal; 8183 8184 if (tx_retries > 75) 8185 tx_qual = (90 - tx_retries) * POOR / 15; 8186 else if (tx_retries > 70) 8187 tx_qual = (75 - tx_retries) * (FAIR - POOR) / 5 + POOR; 8188 else if (tx_retries > 65) 8189 tx_qual = (70 - tx_retries) * (GOOD - FAIR) / 5 + FAIR; 8190 else if (tx_retries > 50) 8191 tx_qual = (65 - tx_retries) * (VERY_GOOD - GOOD) / 8192 15 + GOOD; 8193 else 8194 tx_qual = (50 - tx_retries) * 8195 (PERFECT - VERY_GOOD) / 50 + VERY_GOOD; 8196 8197 if (missed_beacons > 50) 8198 beacon_qual = (60 - missed_beacons) * POOR / 10; 8199 else if (missed_beacons > 40) 8200 beacon_qual = (50 - missed_beacons) * (FAIR - POOR) / 8201 10 + POOR; 8202 else if (missed_beacons > 32) 8203 beacon_qual = (40 - missed_beacons) * (GOOD - FAIR) / 8204 18 + FAIR; 8205 else if (missed_beacons > 20) 8206 beacon_qual = (32 - missed_beacons) * 8207 (VERY_GOOD - GOOD) / 20 + GOOD; 8208 else 8209 beacon_qual = (20 - missed_beacons) * 8210 (PERFECT - VERY_GOOD) / 20 + VERY_GOOD; 8211 8212 quality = min(tx_qual, rssi_qual); 8213 quality = min(beacon_qual, quality); 8214 8215 #ifdef CONFIG_IPW2100_DEBUG 8216 if (beacon_qual == quality) 8217 IPW_DEBUG_WX("Quality clamped by Missed Beacons\n"); 8218 else if (tx_qual == quality) 8219 IPW_DEBUG_WX("Quality clamped by Tx Retries\n"); 8220 else if (quality != 100) 8221 IPW_DEBUG_WX("Quality clamped by Signal Strength\n"); 8222 else 8223 IPW_DEBUG_WX("Quality not clamped.\n"); 8224 #endif 8225 8226 wstats->qual.qual = quality; 8227 wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM; 8228 } 8229 8230 wstats->qual.noise = 0; 8231 wstats->qual.updated = 7; 8232 wstats->qual.updated |= IW_QUAL_NOISE_INVALID; 8233 8234 /* FIXME: this is percent and not a # */ 8235 wstats->miss.beacon = missed_beacons; 8236 8237 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURES, 8238 &tx_failures, &ord_len)) 8239 goto fail_get_ordinal; 8240 wstats->discard.retries = tx_failures; 8241 8242 return wstats; 8243 8244 fail_get_ordinal: 8245 IPW_DEBUG_WX("failed querying ordinals.\n"); 8246 8247 return (struct iw_statistics *)NULL; 8248 } 8249 8250 static const struct iw_handler_def ipw2100_wx_handler_def = { 8251 .standard = ipw2100_wx_handlers, 8252 .num_standard = ARRAY_SIZE(ipw2100_wx_handlers), 8253 .num_private = ARRAY_SIZE(ipw2100_private_handler), 8254 .num_private_args = ARRAY_SIZE(ipw2100_private_args), 8255 .private = (iw_handler *) ipw2100_private_handler, 8256 .private_args = (struct iw_priv_args *)ipw2100_private_args, 8257 .get_wireless_stats = ipw2100_wx_wireless_stats, 8258 }; 8259 8260 static void ipw2100_wx_event_work(struct work_struct *work) 8261 { 8262 struct ipw2100_priv *priv = 8263 container_of(work, struct ipw2100_priv, wx_event_work.work); 8264 union iwreq_data wrqu; 8265 unsigned int len = ETH_ALEN; 8266 8267 if (priv->status & STATUS_STOPPING) 8268 return; 8269 8270 mutex_lock(&priv->action_mutex); 8271 8272 IPW_DEBUG_WX("enter\n"); 8273 8274 mutex_unlock(&priv->action_mutex); 8275 8276 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 8277 8278 /* Fetch BSSID from the hardware */ 8279 if (!(priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) || 8280 priv->status & STATUS_RF_KILL_MASK || 8281 ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID, 8282 &priv->bssid, &len)) { 8283 eth_zero_addr(wrqu.ap_addr.sa_data); 8284 } else { 8285 /* We now have the BSSID, so can finish setting to the full 8286 * associated state */ 8287 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN); 8288 memcpy(priv->ieee->bssid, priv->bssid, ETH_ALEN); 8289 priv->status &= ~STATUS_ASSOCIATING; 8290 priv->status |= STATUS_ASSOCIATED; 8291 netif_carrier_on(priv->net_dev); 8292 netif_wake_queue(priv->net_dev); 8293 } 8294 8295 if (!(priv->status & STATUS_ASSOCIATED)) { 8296 IPW_DEBUG_WX("Configuring ESSID\n"); 8297 mutex_lock(&priv->action_mutex); 8298 /* This is a disassociation event, so kick the firmware to 8299 * look for another AP */ 8300 if (priv->config & CFG_STATIC_ESSID) 8301 ipw2100_set_essid(priv, priv->essid, priv->essid_len, 8302 0); 8303 else 8304 ipw2100_set_essid(priv, NULL, 0, 0); 8305 mutex_unlock(&priv->action_mutex); 8306 } 8307 8308 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL); 8309 } 8310 8311 #define IPW2100_FW_MAJOR_VERSION 1 8312 #define IPW2100_FW_MINOR_VERSION 3 8313 8314 #define IPW2100_FW_MINOR(x) ((x & 0xff) >> 8) 8315 #define IPW2100_FW_MAJOR(x) (x & 0xff) 8316 8317 #define IPW2100_FW_VERSION ((IPW2100_FW_MINOR_VERSION << 8) | \ 8318 IPW2100_FW_MAJOR_VERSION) 8319 8320 #define IPW2100_FW_PREFIX "ipw2100-" __stringify(IPW2100_FW_MAJOR_VERSION) \ 8321 "." __stringify(IPW2100_FW_MINOR_VERSION) 8322 8323 #define IPW2100_FW_NAME(x) IPW2100_FW_PREFIX "" x ".fw" 8324 8325 /* 8326 8327 BINARY FIRMWARE HEADER FORMAT 8328 8329 offset length desc 8330 0 2 version 8331 2 2 mode == 0:BSS,1:IBSS,2:MONITOR 8332 4 4 fw_len 8333 8 4 uc_len 8334 C fw_len firmware data 8335 12 + fw_len uc_len microcode data 8336 8337 */ 8338 8339 struct ipw2100_fw_header { 8340 short version; 8341 short mode; 8342 unsigned int fw_size; 8343 unsigned int uc_size; 8344 } __packed; 8345 8346 static int ipw2100_mod_firmware_load(struct ipw2100_fw *fw) 8347 { 8348 struct ipw2100_fw_header *h = 8349 (struct ipw2100_fw_header *)fw->fw_entry->data; 8350 8351 if (IPW2100_FW_MAJOR(h->version) != IPW2100_FW_MAJOR_VERSION) { 8352 printk(KERN_WARNING DRV_NAME ": Firmware image not compatible " 8353 "(detected version id of %u). " 8354 "See Documentation/networking/device_drivers/intel/ipw2100.txt\n", 8355 h->version); 8356 return 1; 8357 } 8358 8359 fw->version = h->version; 8360 fw->fw.data = fw->fw_entry->data + sizeof(struct ipw2100_fw_header); 8361 fw->fw.size = h->fw_size; 8362 fw->uc.data = fw->fw.data + h->fw_size; 8363 fw->uc.size = h->uc_size; 8364 8365 return 0; 8366 } 8367 8368 static int ipw2100_get_firmware(struct ipw2100_priv *priv, 8369 struct ipw2100_fw *fw) 8370 { 8371 char *fw_name; 8372 int rc; 8373 8374 IPW_DEBUG_INFO("%s: Using hotplug firmware load.\n", 8375 priv->net_dev->name); 8376 8377 switch (priv->ieee->iw_mode) { 8378 case IW_MODE_ADHOC: 8379 fw_name = IPW2100_FW_NAME("-i"); 8380 break; 8381 #ifdef CONFIG_IPW2100_MONITOR 8382 case IW_MODE_MONITOR: 8383 fw_name = IPW2100_FW_NAME("-p"); 8384 break; 8385 #endif 8386 case IW_MODE_INFRA: 8387 default: 8388 fw_name = IPW2100_FW_NAME(""); 8389 break; 8390 } 8391 8392 rc = request_firmware(&fw->fw_entry, fw_name, &priv->pci_dev->dev); 8393 8394 if (rc < 0) { 8395 printk(KERN_ERR DRV_NAME ": " 8396 "%s: Firmware '%s' not available or load failed.\n", 8397 priv->net_dev->name, fw_name); 8398 return rc; 8399 } 8400 IPW_DEBUG_INFO("firmware data %p size %zd\n", fw->fw_entry->data, 8401 fw->fw_entry->size); 8402 8403 ipw2100_mod_firmware_load(fw); 8404 8405 return 0; 8406 } 8407 8408 MODULE_FIRMWARE(IPW2100_FW_NAME("-i")); 8409 #ifdef CONFIG_IPW2100_MONITOR 8410 MODULE_FIRMWARE(IPW2100_FW_NAME("-p")); 8411 #endif 8412 MODULE_FIRMWARE(IPW2100_FW_NAME("")); 8413 8414 static void ipw2100_release_firmware(struct ipw2100_priv *priv, 8415 struct ipw2100_fw *fw) 8416 { 8417 fw->version = 0; 8418 release_firmware(fw->fw_entry); 8419 fw->fw_entry = NULL; 8420 } 8421 8422 static int ipw2100_get_fwversion(struct ipw2100_priv *priv, char *buf, 8423 size_t max) 8424 { 8425 char ver[MAX_FW_VERSION_LEN]; 8426 u32 len = MAX_FW_VERSION_LEN; 8427 u32 tmp; 8428 int i; 8429 /* firmware version is an ascii string (max len of 14) */ 8430 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_FW_VER_NUM, ver, &len)) 8431 return -EIO; 8432 tmp = max; 8433 if (len >= max) 8434 len = max - 1; 8435 for (i = 0; i < len; i++) 8436 buf[i] = ver[i]; 8437 buf[i] = '\0'; 8438 return tmp; 8439 } 8440 8441 static int ipw2100_get_ucodeversion(struct ipw2100_priv *priv, char *buf, 8442 size_t max) 8443 { 8444 u32 ver; 8445 u32 len = sizeof(ver); 8446 /* microcode version is a 32 bit integer */ 8447 if (ipw2100_get_ordinal(priv, IPW_ORD_UCODE_VERSION, &ver, &len)) 8448 return -EIO; 8449 return snprintf(buf, max, "%08X", ver); 8450 } 8451 8452 /* 8453 * On exit, the firmware will have been freed from the fw list 8454 */ 8455 static int ipw2100_fw_download(struct ipw2100_priv *priv, struct ipw2100_fw *fw) 8456 { 8457 /* firmware is constructed of N contiguous entries, each entry is 8458 * structured as: 8459 * 8460 * offset sie desc 8461 * 0 4 address to write to 8462 * 4 2 length of data run 8463 * 6 length data 8464 */ 8465 unsigned int addr; 8466 unsigned short len; 8467 8468 const unsigned char *firmware_data = fw->fw.data; 8469 unsigned int firmware_data_left = fw->fw.size; 8470 8471 while (firmware_data_left > 0) { 8472 addr = *(u32 *) (firmware_data); 8473 firmware_data += 4; 8474 firmware_data_left -= 4; 8475 8476 len = *(u16 *) (firmware_data); 8477 firmware_data += 2; 8478 firmware_data_left -= 2; 8479 8480 if (len > 32) { 8481 printk(KERN_ERR DRV_NAME ": " 8482 "Invalid firmware run-length of %d bytes\n", 8483 len); 8484 return -EINVAL; 8485 } 8486 8487 write_nic_memory(priv->net_dev, addr, len, firmware_data); 8488 firmware_data += len; 8489 firmware_data_left -= len; 8490 } 8491 8492 return 0; 8493 } 8494 8495 struct symbol_alive_response { 8496 u8 cmd_id; 8497 u8 seq_num; 8498 u8 ucode_rev; 8499 u8 eeprom_valid; 8500 u16 valid_flags; 8501 u8 IEEE_addr[6]; 8502 u16 flags; 8503 u16 pcb_rev; 8504 u16 clock_settle_time; // 1us LSB 8505 u16 powerup_settle_time; // 1us LSB 8506 u16 hop_settle_time; // 1us LSB 8507 u8 date[3]; // month, day, year 8508 u8 time[2]; // hours, minutes 8509 u8 ucode_valid; 8510 }; 8511 8512 static int ipw2100_ucode_download(struct ipw2100_priv *priv, 8513 struct ipw2100_fw *fw) 8514 { 8515 struct net_device *dev = priv->net_dev; 8516 const unsigned char *microcode_data = fw->uc.data; 8517 unsigned int microcode_data_left = fw->uc.size; 8518 void __iomem *reg = priv->ioaddr; 8519 8520 struct symbol_alive_response response; 8521 int i, j; 8522 u8 data; 8523 8524 /* Symbol control */ 8525 write_nic_word(dev, IPW2100_CONTROL_REG, 0x703); 8526 readl(reg); 8527 write_nic_word(dev, IPW2100_CONTROL_REG, 0x707); 8528 readl(reg); 8529 8530 /* HW config */ 8531 write_nic_byte(dev, 0x210014, 0x72); /* fifo width =16 */ 8532 readl(reg); 8533 write_nic_byte(dev, 0x210014, 0x72); /* fifo width =16 */ 8534 readl(reg); 8535 8536 /* EN_CS_ACCESS bit to reset control store pointer */ 8537 write_nic_byte(dev, 0x210000, 0x40); 8538 readl(reg); 8539 write_nic_byte(dev, 0x210000, 0x0); 8540 readl(reg); 8541 write_nic_byte(dev, 0x210000, 0x40); 8542 readl(reg); 8543 8544 /* copy microcode from buffer into Symbol */ 8545 8546 while (microcode_data_left > 0) { 8547 write_nic_byte(dev, 0x210010, *microcode_data++); 8548 write_nic_byte(dev, 0x210010, *microcode_data++); 8549 microcode_data_left -= 2; 8550 } 8551 8552 /* EN_CS_ACCESS bit to reset the control store pointer */ 8553 write_nic_byte(dev, 0x210000, 0x0); 8554 readl(reg); 8555 8556 /* Enable System (Reg 0) 8557 * first enable causes garbage in RX FIFO */ 8558 write_nic_byte(dev, 0x210000, 0x0); 8559 readl(reg); 8560 write_nic_byte(dev, 0x210000, 0x80); 8561 readl(reg); 8562 8563 /* Reset External Baseband Reg */ 8564 write_nic_word(dev, IPW2100_CONTROL_REG, 0x703); 8565 readl(reg); 8566 write_nic_word(dev, IPW2100_CONTROL_REG, 0x707); 8567 readl(reg); 8568 8569 /* HW Config (Reg 5) */ 8570 write_nic_byte(dev, 0x210014, 0x72); // fifo width =16 8571 readl(reg); 8572 write_nic_byte(dev, 0x210014, 0x72); // fifo width =16 8573 readl(reg); 8574 8575 /* Enable System (Reg 0) 8576 * second enable should be OK */ 8577 write_nic_byte(dev, 0x210000, 0x00); // clear enable system 8578 readl(reg); 8579 write_nic_byte(dev, 0x210000, 0x80); // set enable system 8580 8581 /* check Symbol is enabled - upped this from 5 as it wasn't always 8582 * catching the update */ 8583 for (i = 0; i < 10; i++) { 8584 udelay(10); 8585 8586 /* check Dino is enabled bit */ 8587 read_nic_byte(dev, 0x210000, &data); 8588 if (data & 0x1) 8589 break; 8590 } 8591 8592 if (i == 10) { 8593 printk(KERN_ERR DRV_NAME ": %s: Error initializing Symbol\n", 8594 dev->name); 8595 return -EIO; 8596 } 8597 8598 /* Get Symbol alive response */ 8599 for (i = 0; i < 30; i++) { 8600 /* Read alive response structure */ 8601 for (j = 0; 8602 j < (sizeof(struct symbol_alive_response) >> 1); j++) 8603 read_nic_word(dev, 0x210004, ((u16 *) & response) + j); 8604 8605 if ((response.cmd_id == 1) && (response.ucode_valid == 0x1)) 8606 break; 8607 udelay(10); 8608 } 8609 8610 if (i == 30) { 8611 printk(KERN_ERR DRV_NAME 8612 ": %s: No response from Symbol - hw not alive\n", 8613 dev->name); 8614 printk_buf(IPW_DL_ERROR, (u8 *) & response, sizeof(response)); 8615 return -EIO; 8616 } 8617 8618 return 0; 8619 } 8620