drivers/net/wireless/ipw2x00/ipw2100.c

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