drivers/net/wireless/intel/ipw2x00/ipw2100.c

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