git.oblomov.eu Git - linux-2.6/blob - drivers/net/wireless/ipw2100.c

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