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