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

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