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                 return err;
6446         }
6447         pci_restore_state(pci_dev);
6448
6449         /*
6450          * Suspend/Resume resets the PCI configuration space, so we have to
6451          * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
6452          * from interfering with C3 CPU state. pci_restore_state won't help
6453          * here since it only restores the first 64 bytes pci config header.
6454          */
6455         pci_read_config_dword(pci_dev, 0x40, &val);
6456         if ((val & 0x0000ff00) != 0)
6457                 pci_write_config_dword(pci_dev, 0x40, val & 0xffff00ff);
6458
6459         /* Set the device back into the PRESENT state; this will also wake
6460          * the queue of needed */
6461         netif_device_attach(dev);
6462
6463         /* Bring the device back up */
6464         if (!(priv->status & STATUS_RF_KILL_SW))
6465                 ipw2100_up(priv, 0);
6466
6467         mutex_unlock(&priv->action_mutex);
6468
6469         return 0;
6470 }
6471 #endif
6472
6473 #define IPW2100_DEV_ID(x) { PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, x }
6474
6475 static struct pci_device_id ipw2100_pci_id_table[] __devinitdata = {
6476         IPW2100_DEV_ID(0x2520), /* IN 2100A mPCI 3A */
6477         IPW2100_DEV_ID(0x2521), /* IN 2100A mPCI 3B */
6478         IPW2100_DEV_ID(0x2524), /* IN 2100A mPCI 3B */
6479         IPW2100_DEV_ID(0x2525), /* IN 2100A mPCI 3B */
6480         IPW2100_DEV_ID(0x2526), /* IN 2100A mPCI Gen A3 */
6481         IPW2100_DEV_ID(0x2522), /* IN 2100 mPCI 3B */
6482         IPW2100_DEV_ID(0x2523), /* IN 2100 mPCI 3A */
6483         IPW2100_DEV_ID(0x2527), /* IN 2100 mPCI 3B */
6484         IPW2100_DEV_ID(0x2528), /* IN 2100 mPCI 3B */
6485         IPW2100_DEV_ID(0x2529), /* IN 2100 mPCI 3B */
6486         IPW2100_DEV_ID(0x252B), /* IN 2100 mPCI 3A */
6487         IPW2100_DEV_ID(0x252C), /* IN 2100 mPCI 3A */
6488         IPW2100_DEV_ID(0x252D), /* IN 2100 mPCI 3A */
6489
6490         IPW2100_DEV_ID(0x2550), /* IB 2100A mPCI 3B */
6491         IPW2100_DEV_ID(0x2551), /* IB 2100 mPCI 3B */
6492         IPW2100_DEV_ID(0x2553), /* IB 2100 mPCI 3B */
6493         IPW2100_DEV_ID(0x2554), /* IB 2100 mPCI 3B */
6494         IPW2100_DEV_ID(0x2555), /* IB 2100 mPCI 3B */
6495
6496         IPW2100_DEV_ID(0x2560), /* DE 2100A mPCI 3A */
6497         IPW2100_DEV_ID(0x2562), /* DE 2100A mPCI 3A */
6498         IPW2100_DEV_ID(0x2563), /* DE 2100A mPCI 3A */
6499         IPW2100_DEV_ID(0x2561), /* DE 2100 mPCI 3A */
6500         IPW2100_DEV_ID(0x2565), /* DE 2100 mPCI 3A */
6501         IPW2100_DEV_ID(0x2566), /* DE 2100 mPCI 3A */
6502         IPW2100_DEV_ID(0x2567), /* DE 2100 mPCI 3A */
6503
6504         IPW2100_DEV_ID(0x2570), /* GA 2100 mPCI 3B */
6505
6506         IPW2100_DEV_ID(0x2580), /* TO 2100A mPCI 3B */
6507         IPW2100_DEV_ID(0x2582), /* TO 2100A mPCI 3B */
6508         IPW2100_DEV_ID(0x2583), /* TO 2100A mPCI 3B */
6509         IPW2100_DEV_ID(0x2581), /* TO 2100 mPCI 3B */
6510         IPW2100_DEV_ID(0x2585), /* TO 2100 mPCI 3B */
6511         IPW2100_DEV_ID(0x2586), /* TO 2100 mPCI 3B */
6512         IPW2100_DEV_ID(0x2587), /* TO 2100 mPCI 3B */
6513
6514         IPW2100_DEV_ID(0x2590), /* SO 2100A mPCI 3B */
6515         IPW2100_DEV_ID(0x2592), /* SO 2100A mPCI 3B */
6516         IPW2100_DEV_ID(0x2591), /* SO 2100 mPCI 3B */
6517         IPW2100_DEV_ID(0x2593), /* SO 2100 mPCI 3B */
6518         IPW2100_DEV_ID(0x2596), /* SO 2100 mPCI 3B */
6519         IPW2100_DEV_ID(0x2598), /* SO 2100 mPCI 3B */
6520
6521         IPW2100_DEV_ID(0x25A0), /* HP 2100 mPCI 3B */
6522         {0,},
6523 };
6524
6525 MODULE_DEVICE_TABLE(pci, ipw2100_pci_id_table);
6526
6527 static struct pci_driver ipw2100_pci_driver = {
6528         .name = DRV_NAME,
6529         .id_table = ipw2100_pci_id_table,
6530         .probe = ipw2100_pci_init_one,
6531         .remove = __devexit_p(ipw2100_pci_remove_one),
6532 #ifdef CONFIG_PM
6533         .suspend = ipw2100_suspend,
6534         .resume = ipw2100_resume,
6535 #endif
6536 };
6537
6538 /**
6539  * Initialize the ipw2100 driver/module
6540  *
6541  * @returns 0 if ok, < 0 errno node con error.
6542  *
6543  * Note: we cannot init the /proc stuff until the PCI driver is there,
6544  * or we risk an unlikely race condition on someone accessing
6545  * uninitialized data in the PCI dev struct through /proc.
6546  */
6547 static int __init ipw2100_init(void)
6548 {
6549         int ret;
6550
6551         printk(KERN_INFO DRV_NAME ": %s, %s\n", DRV_DESCRIPTION, DRV_VERSION);
6552         printk(KERN_INFO DRV_NAME ": %s\n", DRV_COPYRIGHT);
6553
6554         ret = pci_register_driver(&ipw2100_pci_driver);
6555         if (ret)
6556                 goto out;
6557
6558         pm_qos_add_requirement(PM_QOS_CPU_DMA_LATENCY, "ipw2100",
6559                         PM_QOS_DEFAULT_VALUE);
6560 #ifdef CONFIG_IPW2100_DEBUG
6561         ipw2100_debug_level = debug;
6562         ret = driver_create_file(&ipw2100_pci_driver.driver,
6563                                  &driver_attr_debug_level);
6564 #endif
6565
6566 out:
6567         return ret;
6568 }
6569
6570 /**
6571  * Cleanup ipw2100 driver registration
6572  */
6573 static void __exit ipw2100_exit(void)
6574 {
6575         /* FIXME: IPG: check that we have no instances of the devices open */
6576 #ifdef CONFIG_IPW2100_DEBUG
6577         driver_remove_file(&ipw2100_pci_driver.driver,
6578                            &driver_attr_debug_level);
6579 #endif
6580         pci_unregister_driver(&ipw2100_pci_driver);
6581         pm_qos_remove_requirement(PM_QOS_CPU_DMA_LATENCY, "ipw2100");
6582 }
6583
6584 module_init(ipw2100_init);
6585 module_exit(ipw2100_exit);
6586
6587 #define WEXT_USECHANNELS 1
6588
6589 static const long ipw2100_frequencies[] = {
6590         2412, 2417, 2422, 2427,
6591         2432, 2437, 2442, 2447,
6592         2452, 2457, 2462, 2467,
6593         2472, 2484
6594 };
6595
6596 #define FREQ_COUNT      ARRAY_SIZE(ipw2100_frequencies)
6597
6598 static const long ipw2100_rates_11b[] = {
6599         1000000,
6600         2000000,
6601         5500000,
6602         11000000
6603 };
6604
6605 #define RATE_COUNT ARRAY_SIZE(ipw2100_rates_11b)
6606
6607 static int ipw2100_wx_get_name(struct net_device *dev,
6608                                struct iw_request_info *info,
6609                                union iwreq_data *wrqu, char *extra)
6610 {
6611         /*
6612          * This can be called at any time.  No action lock required
6613          */
6614
6615         struct ipw2100_priv *priv = ieee80211_priv(dev);
6616         if (!(priv->status & STATUS_ASSOCIATED))
6617                 strcpy(wrqu->name, "unassociated");
6618         else
6619                 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11b");
6620
6621         IPW_DEBUG_WX("Name: %s\n", wrqu->name);
6622         return 0;
6623 }
6624
6625 static int ipw2100_wx_set_freq(struct net_device *dev,
6626                                struct iw_request_info *info,
6627                                union iwreq_data *wrqu, char *extra)
6628 {
6629         struct ipw2100_priv *priv = ieee80211_priv(dev);
6630         struct iw_freq *fwrq = &wrqu->freq;
6631         int err = 0;
6632
6633         if (priv->ieee->iw_mode == IW_MODE_INFRA)
6634                 return -EOPNOTSUPP;
6635
6636         mutex_lock(&priv->action_mutex);
6637         if (!(priv->status & STATUS_INITIALIZED)) {
6638                 err = -EIO;
6639                 goto done;
6640         }
6641
6642         /* if setting by freq convert to channel */
6643         if (fwrq->e == 1) {
6644                 if ((fwrq->m >= (int)2.412e8 && fwrq->m <= (int)2.487e8)) {
6645                         int f = fwrq->m / 100000;
6646                         int c = 0;
6647
6648                         while ((c < REG_MAX_CHANNEL) &&
6649                                (f != ipw2100_frequencies[c]))
6650                                 c++;
6651
6652                         /* hack to fall through */
6653                         fwrq->e = 0;
6654                         fwrq->m = c + 1;
6655                 }
6656         }
6657
6658         if (fwrq->e > 0 || fwrq->m > 1000) {
6659                 err = -EOPNOTSUPP;
6660                 goto done;
6661         } else {                /* Set the channel */
6662                 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
6663                 err = ipw2100_set_channel(priv, fwrq->m, 0);
6664         }
6665
6666       done:
6667         mutex_unlock(&priv->action_mutex);
6668         return err;
6669 }
6670
6671 static int ipw2100_wx_get_freq(struct net_device *dev,
6672                                struct iw_request_info *info,
6673                                union iwreq_data *wrqu, char *extra)
6674 {
6675         /*
6676          * This can be called at any time.  No action lock required
6677          */
6678
6679         struct ipw2100_priv *priv = ieee80211_priv(dev);
6680
6681         wrqu->freq.e = 0;
6682
6683         /* If we are associated, trying to associate, or have a statically
6684          * configured CHANNEL then return that; otherwise return ANY */
6685         if (priv->config & CFG_STATIC_CHANNEL ||
6686             priv->status & STATUS_ASSOCIATED)
6687                 wrqu->freq.m = priv->channel;
6688         else
6689                 wrqu->freq.m = 0;
6690
6691         IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
6692         return 0;
6693
6694 }
6695
6696 static int ipw2100_wx_set_mode(struct net_device *dev,
6697                                struct iw_request_info *info,
6698                                union iwreq_data *wrqu, char *extra)
6699 {
6700         struct ipw2100_priv *priv = ieee80211_priv(dev);
6701         int err = 0;
6702
6703         IPW_DEBUG_WX("SET Mode -> %d \n", wrqu->mode);
6704
6705         if (wrqu->mode == priv->ieee->iw_mode)
6706                 return 0;
6707
6708         mutex_lock(&priv->action_mutex);
6709         if (!(priv->status & STATUS_INITIALIZED)) {
6710                 err = -EIO;
6711                 goto done;
6712         }
6713
6714         switch (wrqu->mode) {
6715 #ifdef CONFIG_IPW2100_MONITOR
6716         case IW_MODE_MONITOR:
6717                 err = ipw2100_switch_mode(priv, IW_MODE_MONITOR);
6718                 break;
6719 #endif                          /* CONFIG_IPW2100_MONITOR */
6720         case IW_MODE_ADHOC:
6721                 err = ipw2100_switch_mode(priv, IW_MODE_ADHOC);
6722                 break;
6723         case IW_MODE_INFRA:
6724         case IW_MODE_AUTO:
6725         default:
6726                 err = ipw2100_switch_mode(priv, IW_MODE_INFRA);
6727                 break;
6728         }
6729
6730       done:
6731         mutex_unlock(&priv->action_mutex);
6732         return err;
6733 }
6734
6735 static int ipw2100_wx_get_mode(struct net_device *dev,
6736                                struct iw_request_info *info,
6737                                union iwreq_data *wrqu, char *extra)
6738 {
6739         /*
6740          * This can be called at any time.  No action lock required
6741          */
6742
6743         struct ipw2100_priv *priv = ieee80211_priv(dev);
6744
6745         wrqu->mode = priv->ieee->iw_mode;
6746         IPW_DEBUG_WX("GET Mode -> %d\n", wrqu->mode);
6747
6748         return 0;
6749 }
6750
6751 #define POWER_MODES 5
6752
6753 /* Values are in microsecond */
6754 static const s32 timeout_duration[POWER_MODES] = {
6755         350000,
6756         250000,
6757         75000,
6758         37000,
6759         25000,
6760 };
6761
6762 static const s32 period_duration[POWER_MODES] = {
6763         400000,
6764         700000,
6765         1000000,
6766         1000000,
6767         1000000
6768 };
6769
6770 static int ipw2100_wx_get_range(struct net_device *dev,
6771                                 struct iw_request_info *info,
6772                                 union iwreq_data *wrqu, char *extra)
6773 {
6774         /*
6775          * This can be called at any time.  No action lock required
6776          */
6777
6778         struct ipw2100_priv *priv = ieee80211_priv(dev);
6779         struct iw_range *range = (struct iw_range *)extra;
6780         u16 val;
6781         int i, level;
6782
6783         wrqu->data.length = sizeof(*range);
6784         memset(range, 0, sizeof(*range));
6785
6786         /* Let's try to keep this struct in the same order as in
6787          * linux/include/wireless.h
6788          */
6789
6790         /* TODO: See what values we can set, and remove the ones we can't
6791          * set, or fill them with some default data.
6792          */
6793
6794         /* ~5 Mb/s real (802.11b) */
6795         range->throughput = 5 * 1000 * 1000;
6796
6797 //      range->sensitivity;     /* signal level threshold range */
6798
6799         range->max_qual.qual = 100;
6800         /* TODO: Find real max RSSI and stick here */
6801         range->max_qual.level = 0;
6802         range->max_qual.noise = 0;
6803         range->max_qual.updated = 7;    /* Updated all three */
6804
6805         range->avg_qual.qual = 70;      /* > 8% missed beacons is 'bad' */
6806         /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
6807         range->avg_qual.level = 20 + IPW2100_RSSI_TO_DBM;
6808         range->avg_qual.noise = 0;
6809         range->avg_qual.updated = 7;    /* Updated all three */
6810
6811         range->num_bitrates = RATE_COUNT;
6812
6813         for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++) {
6814                 range->bitrate[i] = ipw2100_rates_11b[i];
6815         }
6816
6817         range->min_rts = MIN_RTS_THRESHOLD;
6818         range->max_rts = MAX_RTS_THRESHOLD;
6819         range->min_frag = MIN_FRAG_THRESHOLD;
6820         range->max_frag = MAX_FRAG_THRESHOLD;
6821
6822         range->min_pmp = period_duration[0];    /* Minimal PM period */
6823         range->max_pmp = period_duration[POWER_MODES - 1];      /* Maximal PM period */
6824         range->min_pmt = timeout_duration[POWER_MODES - 1];     /* Minimal PM timeout */
6825         range->max_pmt = timeout_duration[0];   /* Maximal PM timeout */
6826
6827         /* How to decode max/min PM period */
6828         range->pmp_flags = IW_POWER_PERIOD;
6829         /* How to decode max/min PM period */
6830         range->pmt_flags = IW_POWER_TIMEOUT;
6831         /* What PM options are supported */
6832         range->pm_capa = IW_POWER_TIMEOUT | IW_POWER_PERIOD;
6833
6834         range->encoding_size[0] = 5;
6835         range->encoding_size[1] = 13;   /* Different token sizes */
6836         range->num_encoding_sizes = 2;  /* Number of entry in the list */
6837         range->max_encoding_tokens = WEP_KEYS;  /* Max number of tokens */
6838 //      range->encoding_login_index;            /* token index for login token */
6839
6840         if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6841                 range->txpower_capa = IW_TXPOW_DBM;
6842                 range->num_txpower = IW_MAX_TXPOWER;
6843                 for (i = 0, level = (IPW_TX_POWER_MAX_DBM * 16);
6844                      i < IW_MAX_TXPOWER;
6845                      i++, level -=
6846                      ((IPW_TX_POWER_MAX_DBM -
6847                        IPW_TX_POWER_MIN_DBM) * 16) / (IW_MAX_TXPOWER - 1))
6848                         range->txpower[i] = level / 16;
6849         } else {
6850                 range->txpower_capa = 0;
6851                 range->num_txpower = 0;
6852         }
6853
6854         /* Set the Wireless Extension versions */
6855         range->we_version_compiled = WIRELESS_EXT;
6856         range->we_version_source = 18;
6857
6858 //      range->retry_capa;      /* What retry options are supported */
6859 //      range->retry_flags;     /* How to decode max/min retry limit */
6860 //      range->r_time_flags;    /* How to decode max/min retry life */
6861 //      range->min_retry;       /* Minimal number of retries */
6862 //      range->max_retry;       /* Maximal number of retries */
6863 //      range->min_r_time;      /* Minimal retry lifetime */
6864 //      range->max_r_time;      /* Maximal retry lifetime */
6865
6866         range->num_channels = FREQ_COUNT;
6867
6868         val = 0;
6869         for (i = 0; i < FREQ_COUNT; i++) {
6870                 // TODO: Include only legal frequencies for some countries
6871 //              if (local->channel_mask & (1 << i)) {
6872                 range->freq[val].i = i + 1;
6873                 range->freq[val].m = ipw2100_frequencies[i] * 100000;
6874                 range->freq[val].e = 1;
6875                 val++;
6876 //              }
6877                 if (val == IW_MAX_FREQUENCIES)
6878                         break;
6879         }
6880         range->num_frequency = val;
6881
6882         /* Event capability (kernel + driver) */
6883         range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
6884                                 IW_EVENT_CAPA_MASK(SIOCGIWAP));
6885         range->event_capa[1] = IW_EVENT_CAPA_K_1;
6886
6887         range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
6888                 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
6889
6890         IPW_DEBUG_WX("GET Range\n");
6891
6892         return 0;
6893 }
6894
6895 static int ipw2100_wx_set_wap(struct net_device *dev,
6896                               struct iw_request_info *info,
6897                               union iwreq_data *wrqu, char *extra)
6898 {
6899         struct ipw2100_priv *priv = ieee80211_priv(dev);
6900         int err = 0;
6901
6902         static const unsigned char any[] = {
6903                 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
6904         };
6905         static const unsigned char off[] = {
6906                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
6907         };
6908         DECLARE_MAC_BUF(mac);
6909
6910         // sanity checks
6911         if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
6912                 return -EINVAL;
6913
6914         mutex_lock(&priv->action_mutex);
6915         if (!(priv->status & STATUS_INITIALIZED)) {
6916                 err = -EIO;
6917                 goto done;
6918         }
6919
6920         if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
6921             !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
6922                 /* we disable mandatory BSSID association */
6923                 IPW_DEBUG_WX("exit - disable mandatory BSSID\n");
6924                 priv->config &= ~CFG_STATIC_BSSID;
6925                 err = ipw2100_set_mandatory_bssid(priv, NULL, 0);
6926                 goto done;
6927         }
6928
6929         priv->config |= CFG_STATIC_BSSID;
6930         memcpy(priv->mandatory_bssid_mac, wrqu->ap_addr.sa_data, ETH_ALEN);
6931
6932         err = ipw2100_set_mandatory_bssid(priv, wrqu->ap_addr.sa_data, 0);
6933
6934         IPW_DEBUG_WX("SET BSSID -> %s\n",
6935                      print_mac(mac, wrqu->ap_addr.sa_data));
6936
6937       done:
6938         mutex_unlock(&priv->action_mutex);
6939         return err;
6940 }
6941
6942 static int ipw2100_wx_get_wap(struct net_device *dev,
6943                               struct iw_request_info *info,
6944                               union iwreq_data *wrqu, char *extra)
6945 {
6946         /*
6947          * This can be called at any time.  No action lock required
6948          */
6949
6950         struct ipw2100_priv *priv = ieee80211_priv(dev);
6951         DECLARE_MAC_BUF(mac);
6952
6953         /* If we are associated, trying to associate, or have a statically
6954          * configured BSSID then return that; otherwise return ANY */
6955         if (priv->config & CFG_STATIC_BSSID || priv->status & STATUS_ASSOCIATED) {
6956                 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
6957                 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
6958         } else
6959                 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
6960
6961         IPW_DEBUG_WX("Getting WAP BSSID: %s\n",
6962                      print_mac(mac, wrqu->ap_addr.sa_data));
6963         return 0;
6964 }
6965
6966 static int ipw2100_wx_set_essid(struct net_device *dev,
6967                                 struct iw_request_info *info,
6968                                 union iwreq_data *wrqu, char *extra)
6969 {
6970         struct ipw2100_priv *priv = ieee80211_priv(dev);
6971         char *essid = "";       /* ANY */
6972         int length = 0;
6973         int err = 0;
6974
6975         mutex_lock(&priv->action_mutex);
6976         if (!(priv->status & STATUS_INITIALIZED)) {
6977                 err = -EIO;
6978                 goto done;
6979         }
6980
6981         if (wrqu->essid.flags && wrqu->essid.length) {
6982                 length = wrqu->essid.length;
6983                 essid = extra;
6984         }
6985
6986         if (length == 0) {
6987                 IPW_DEBUG_WX("Setting ESSID to ANY\n");
6988                 priv->config &= ~CFG_STATIC_ESSID;
6989                 err = ipw2100_set_essid(priv, NULL, 0, 0);
6990                 goto done;
6991         }
6992
6993         length = min(length, IW_ESSID_MAX_SIZE);
6994
6995         priv->config |= CFG_STATIC_ESSID;
6996
6997         if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
6998                 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
6999                 err = 0;
7000                 goto done;
7001         }
7002
7003         IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n", escape_essid(essid, length),
7004                      length);
7005
7006         priv->essid_len = length;
7007         memcpy(priv->essid, essid, priv->essid_len);
7008
7009         err = ipw2100_set_essid(priv, essid, length, 0);
7010
7011       done:
7012         mutex_unlock(&priv->action_mutex);
7013         return err;
7014 }
7015
7016 static int ipw2100_wx_get_essid(struct net_device *dev,
7017                                 struct iw_request_info *info,
7018                                 union iwreq_data *wrqu, char *extra)
7019 {
7020         /*
7021          * This can be called at any time.  No action lock required
7022          */
7023
7024         struct ipw2100_priv *priv = ieee80211_priv(dev);
7025
7026         /* If we are associated, trying to associate, or have a statically
7027          * configured ESSID then return that; otherwise return ANY */
7028         if (priv->config & CFG_STATIC_ESSID || priv->status & STATUS_ASSOCIATED) {
7029                 IPW_DEBUG_WX("Getting essid: '%s'\n",
7030                              escape_essid(priv->essid, priv->essid_len));
7031                 memcpy(extra, priv->essid, priv->essid_len);
7032                 wrqu->essid.length = priv->essid_len;
7033                 wrqu->essid.flags = 1;  /* active */
7034         } else {
7035                 IPW_DEBUG_WX("Getting essid: ANY\n");
7036                 wrqu->essid.length = 0;
7037                 wrqu->essid.flags = 0;  /* active */
7038         }
7039
7040         return 0;
7041 }
7042
7043 static int ipw2100_wx_set_nick(struct net_device *dev,
7044                                struct iw_request_info *info,
7045                                union iwreq_data *wrqu, char *extra)
7046 {
7047         /*
7048          * This can be called at any time.  No action lock required
7049          */
7050
7051         struct ipw2100_priv *priv = ieee80211_priv(dev);
7052
7053         if (wrqu->data.length > IW_ESSID_MAX_SIZE)
7054                 return -E2BIG;
7055
7056         wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
7057         memset(priv->nick, 0, sizeof(priv->nick));
7058         memcpy(priv->nick, extra, wrqu->data.length);
7059
7060         IPW_DEBUG_WX("SET Nickname -> %s \n", priv->nick);
7061
7062         return 0;
7063 }
7064
7065 static int ipw2100_wx_get_nick(struct net_device *dev,
7066                                struct iw_request_info *info,
7067                                union iwreq_data *wrqu, char *extra)
7068 {
7069         /*
7070          * This can be called at any time.  No action lock required
7071          */
7072
7073         struct ipw2100_priv *priv = ieee80211_priv(dev);
7074
7075         wrqu->data.length = strlen(priv->nick);
7076         memcpy(extra, priv->nick, wrqu->data.length);
7077         wrqu->data.flags = 1;   /* active */
7078
7079         IPW_DEBUG_WX("GET Nickname -> %s \n", extra);
7080
7081         return 0;
7082 }
7083
7084 static int ipw2100_wx_set_rate(struct net_device *dev,
7085                                struct iw_request_info *info,
7086                                union iwreq_data *wrqu, char *extra)
7087 {
7088         struct ipw2100_priv *priv = ieee80211_priv(dev);
7089         u32 target_rate = wrqu->bitrate.value;
7090         u32 rate;
7091         int err = 0;
7092
7093         mutex_lock(&priv->action_mutex);
7094         if (!(priv->status & STATUS_INITIALIZED)) {
7095                 err = -EIO;
7096                 goto done;
7097         }
7098
7099         rate = 0;
7100
7101         if (target_rate == 1000000 ||
7102             (!wrqu->bitrate.fixed && target_rate > 1000000))
7103                 rate |= TX_RATE_1_MBIT;
7104         if (target_rate == 2000000 ||
7105             (!wrqu->bitrate.fixed && target_rate > 2000000))
7106                 rate |= TX_RATE_2_MBIT;
7107         if (target_rate == 5500000 ||
7108             (!wrqu->bitrate.fixed && target_rate > 5500000))
7109                 rate |= TX_RATE_5_5_MBIT;
7110         if (target_rate == 11000000 ||
7111             (!wrqu->bitrate.fixed && target_rate > 11000000))
7112                 rate |= TX_RATE_11_MBIT;
7113         if (rate == 0)
7114                 rate = DEFAULT_TX_RATES;
7115
7116         err = ipw2100_set_tx_rates(priv, rate, 0);
7117
7118         IPW_DEBUG_WX("SET Rate -> %04X \n", rate);
7119       done:
7120         mutex_unlock(&priv->action_mutex);
7121         return err;
7122 }
7123
7124 static int ipw2100_wx_get_rate(struct net_device *dev,
7125                                struct iw_request_info *info,
7126                                union iwreq_data *wrqu, char *extra)
7127 {
7128         struct ipw2100_priv *priv = ieee80211_priv(dev);
7129         int val;
7130         int len = sizeof(val);
7131         int err = 0;
7132
7133         if (!(priv->status & STATUS_ENABLED) ||
7134             priv->status & STATUS_RF_KILL_MASK ||
7135             !(priv->status & STATUS_ASSOCIATED)) {
7136                 wrqu->bitrate.value = 0;
7137                 return 0;
7138         }
7139
7140         mutex_lock(&priv->action_mutex);
7141         if (!(priv->status & STATUS_INITIALIZED)) {
7142                 err = -EIO;
7143                 goto done;
7144         }
7145
7146         err = ipw2100_get_ordinal(priv, IPW_ORD_CURRENT_TX_RATE, &val, &len);
7147         if (err) {
7148                 IPW_DEBUG_WX("failed querying ordinals.\n");
7149                 return err;
7150         }
7151
7152         switch (val & TX_RATE_MASK) {
7153         case TX_RATE_1_MBIT:
7154                 wrqu->bitrate.value = 1000000;
7155                 break;
7156         case TX_RATE_2_MBIT:
7157                 wrqu->bitrate.value = 2000000;
7158                 break;
7159         case TX_RATE_5_5_MBIT:
7160                 wrqu->bitrate.value = 5500000;
7161                 break;
7162         case TX_RATE_11_MBIT:
7163                 wrqu->bitrate.value = 11000000;
7164                 break;
7165         default:
7166                 wrqu->bitrate.value = 0;
7167         }
7168
7169         IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
7170
7171       done:
7172         mutex_unlock(&priv->action_mutex);
7173         return err;
7174 }
7175
7176 static int ipw2100_wx_set_rts(struct net_device *dev,
7177                               struct iw_request_info *info,
7178                               union iwreq_data *wrqu, char *extra)
7179 {
7180         struct ipw2100_priv *priv = ieee80211_priv(dev);
7181         int value, err;
7182
7183         /* Auto RTS not yet supported */
7184         if (wrqu->rts.fixed == 0)
7185                 return -EINVAL;
7186
7187         mutex_lock(&priv->action_mutex);
7188         if (!(priv->status & STATUS_INITIALIZED)) {
7189                 err = -EIO;
7190                 goto done;
7191         }
7192
7193         if (wrqu->rts.disabled)
7194                 value = priv->rts_threshold | RTS_DISABLED;
7195         else {
7196                 if (wrqu->rts.value < 1 || wrqu->rts.value > 2304) {
7197                         err = -EINVAL;
7198                         goto done;
7199                 }
7200                 value = wrqu->rts.value;
7201         }
7202
7203         err = ipw2100_set_rts_threshold(priv, value);
7204
7205         IPW_DEBUG_WX("SET RTS Threshold -> 0x%08X \n", value);
7206       done:
7207         mutex_unlock(&priv->action_mutex);
7208         return err;
7209 }
7210
7211 static int ipw2100_wx_get_rts(struct net_device *dev,
7212                               struct iw_request_info *info,
7213                               union iwreq_data *wrqu, char *extra)
7214 {
7215         /*
7216          * This can be called at any time.  No action lock required
7217          */
7218
7219         struct ipw2100_priv *priv = ieee80211_priv(dev);
7220
7221         wrqu->rts.value = priv->rts_threshold & ~RTS_DISABLED;
7222         wrqu->rts.fixed = 1;    /* no auto select */
7223
7224         /* If RTS is set to the default value, then it is disabled */
7225         wrqu->rts.disabled = (priv->rts_threshold & RTS_DISABLED) ? 1 : 0;
7226
7227         IPW_DEBUG_WX("GET RTS Threshold -> 0x%08X \n", wrqu->rts.value);
7228
7229         return 0;
7230 }
7231
7232 static int ipw2100_wx_set_txpow(struct net_device *dev,
7233                                 struct iw_request_info *info,
7234                                 union iwreq_data *wrqu, char *extra)
7235 {
7236         struct ipw2100_priv *priv = ieee80211_priv(dev);
7237         int err = 0, value;
7238
7239         if (ipw_radio_kill_sw(priv, wrqu->txpower.disabled))
7240                 return -EINPROGRESS;
7241
7242         if (priv->ieee->iw_mode != IW_MODE_ADHOC)
7243                 return 0;
7244
7245         if ((wrqu->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM)
7246                 return -EINVAL;
7247
7248         if (wrqu->txpower.fixed == 0)
7249                 value = IPW_TX_POWER_DEFAULT;
7250         else {
7251                 if (wrqu->txpower.value < IPW_TX_POWER_MIN_DBM ||
7252                     wrqu->txpower.value > IPW_TX_POWER_MAX_DBM)
7253                         return -EINVAL;
7254
7255                 value = wrqu->txpower.value;
7256         }
7257
7258         mutex_lock(&priv->action_mutex);
7259         if (!(priv->status & STATUS_INITIALIZED)) {
7260                 err = -EIO;
7261                 goto done;
7262         }
7263
7264         err = ipw2100_set_tx_power(priv, value);
7265
7266         IPW_DEBUG_WX("SET TX Power -> %d \n", value);
7267
7268       done:
7269         mutex_unlock(&priv->action_mutex);
7270         return err;
7271 }
7272
7273 static int ipw2100_wx_get_txpow(struct net_device *dev,
7274                                 struct iw_request_info *info,
7275                                 union iwreq_data *wrqu, char *extra)
7276 {
7277         /*
7278          * This can be called at any time.  No action lock required
7279          */
7280
7281         struct ipw2100_priv *priv = ieee80211_priv(dev);
7282
7283         wrqu->txpower.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
7284
7285         if (priv->tx_power == IPW_TX_POWER_DEFAULT) {
7286                 wrqu->txpower.fixed = 0;
7287                 wrqu->txpower.value = IPW_TX_POWER_MAX_DBM;
7288         } else {
7289                 wrqu->txpower.fixed = 1;
7290                 wrqu->txpower.value = priv->tx_power;
7291         }
7292
7293         wrqu->txpower.flags = IW_TXPOW_DBM;
7294
7295         IPW_DEBUG_WX("GET TX Power -> %d \n", wrqu->txpower.value);
7296
7297         return 0;
7298 }
7299
7300 static int ipw2100_wx_set_frag(struct net_device *dev,
7301                                struct iw_request_info *info,
7302                                union iwreq_data *wrqu, char *extra)
7303 {
7304         /*
7305          * This can be called at any time.  No action lock required
7306          */
7307
7308         struct ipw2100_priv *priv = ieee80211_priv(dev);
7309
7310         if (!wrqu->frag.fixed)
7311                 return -EINVAL;
7312
7313         if (wrqu->frag.disabled) {
7314                 priv->frag_threshold |= FRAG_DISABLED;
7315                 priv->ieee->fts = DEFAULT_FTS;
7316         } else {
7317                 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
7318                     wrqu->frag.value > MAX_FRAG_THRESHOLD)
7319                         return -EINVAL;
7320
7321                 priv->ieee->fts = wrqu->frag.value & ~0x1;
7322                 priv->frag_threshold = priv->ieee->fts;
7323         }
7324
7325         IPW_DEBUG_WX("SET Frag Threshold -> %d \n", priv->ieee->fts);
7326
7327         return 0;
7328 }
7329
7330 static int ipw2100_wx_get_frag(struct net_device *dev,
7331                                struct iw_request_info *info,
7332                                union iwreq_data *wrqu, char *extra)
7333 {
7334         /*
7335          * This can be called at any time.  No action lock required
7336          */
7337
7338         struct ipw2100_priv *priv = ieee80211_priv(dev);
7339         wrqu->frag.value = priv->frag_threshold & ~FRAG_DISABLED;
7340         wrqu->frag.fixed = 0;   /* no auto select */
7341         wrqu->frag.disabled = (priv->frag_threshold & FRAG_DISABLED) ? 1 : 0;
7342
7343         IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
7344
7345         return 0;
7346 }
7347
7348 static int ipw2100_wx_set_retry(struct net_device *dev,
7349                                 struct iw_request_info *info,
7350                                 union iwreq_data *wrqu, char *extra)
7351 {
7352         struct ipw2100_priv *priv = ieee80211_priv(dev);
7353         int err = 0;
7354
7355         if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
7356                 return -EINVAL;
7357
7358         if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
7359                 return 0;
7360
7361         mutex_lock(&priv->action_mutex);
7362         if (!(priv->status & STATUS_INITIALIZED)) {
7363                 err = -EIO;
7364                 goto done;
7365         }
7366
7367         if (wrqu->retry.flags & IW_RETRY_SHORT) {
7368                 err = ipw2100_set_short_retry(priv, wrqu->retry.value);
7369                 IPW_DEBUG_WX("SET Short Retry Limit -> %d \n",
7370                              wrqu->retry.value);
7371                 goto done;
7372         }
7373
7374         if (wrqu->retry.flags & IW_RETRY_LONG) {
7375                 err = ipw2100_set_long_retry(priv, wrqu->retry.value);
7376                 IPW_DEBUG_WX("SET Long Retry Limit -> %d \n",
7377                              wrqu->retry.value);
7378                 goto done;
7379         }
7380
7381         err = ipw2100_set_short_retry(priv, wrqu->retry.value);
7382         if (!err)
7383                 err = ipw2100_set_long_retry(priv, wrqu->retry.value);
7384
7385         IPW_DEBUG_WX("SET Both Retry Limits -> %d \n", wrqu->retry.value);
7386
7387       done:
7388         mutex_unlock(&priv->action_mutex);
7389         return err;
7390 }
7391
7392 static int ipw2100_wx_get_retry(struct net_device *dev,
7393                                 struct iw_request_info *info,
7394                                 union iwreq_data *wrqu, char *extra)
7395 {
7396         /*
7397          * This can be called at any time.  No action lock required
7398          */
7399
7400         struct ipw2100_priv *priv = ieee80211_priv(dev);
7401
7402         wrqu->retry.disabled = 0;       /* can't be disabled */
7403
7404         if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME)
7405                 return -EINVAL;
7406
7407         if (wrqu->retry.flags & IW_RETRY_LONG) {
7408                 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
7409                 wrqu->retry.value = priv->long_retry_limit;
7410         } else {
7411                 wrqu->retry.flags =
7412                     (priv->short_retry_limit !=
7413                      priv->long_retry_limit) ?
7414                     IW_RETRY_LIMIT | IW_RETRY_SHORT : IW_RETRY_LIMIT;
7415
7416                 wrqu->retry.value = priv->short_retry_limit;
7417         }
7418
7419         IPW_DEBUG_WX("GET Retry -> %d \n", wrqu->retry.value);
7420
7421         return 0;
7422 }
7423
7424 static int ipw2100_wx_set_scan(struct net_device *dev,
7425                                struct iw_request_info *info,
7426                                union iwreq_data *wrqu, char *extra)
7427 {
7428         struct ipw2100_priv *priv = ieee80211_priv(dev);
7429         int err = 0;
7430
7431         mutex_lock(&priv->action_mutex);
7432         if (!(priv->status & STATUS_INITIALIZED)) {
7433                 err = -EIO;
7434                 goto done;
7435         }
7436
7437         IPW_DEBUG_WX("Initiating scan...\n");
7438
7439         priv->user_requested_scan = 1;
7440         if (ipw2100_set_scan_options(priv) || ipw2100_start_scan(priv)) {
7441                 IPW_DEBUG_WX("Start scan failed.\n");
7442
7443                 /* TODO: Mark a scan as pending so when hardware initialized
7444                  *       a scan starts */
7445         }
7446
7447       done:
7448         mutex_unlock(&priv->action_mutex);
7449         return err;
7450 }
7451
7452 static int ipw2100_wx_get_scan(struct net_device *dev,
7453                                struct iw_request_info *info,
7454                                union iwreq_data *wrqu, char *extra)
7455 {
7456         /*
7457          * This can be called at any time.  No action lock required
7458          */
7459
7460         struct ipw2100_priv *priv = ieee80211_priv(dev);
7461         return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
7462 }
7463
7464 /*
7465  * Implementation based on code in hostap-driver v0.1.3 hostap_ioctl.c
7466  */
7467 static int ipw2100_wx_set_encode(struct net_device *dev,
7468                                  struct iw_request_info *info,
7469                                  union iwreq_data *wrqu, char *key)
7470 {
7471         /*
7472          * No check of STATUS_INITIALIZED required
7473          */
7474
7475         struct ipw2100_priv *priv = ieee80211_priv(dev);
7476         return ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
7477 }
7478
7479 static int ipw2100_wx_get_encode(struct net_device *dev,
7480                                  struct iw_request_info *info,
7481                                  union iwreq_data *wrqu, char *key)
7482 {
7483         /*
7484          * This can be called at any time.  No action lock required
7485          */
7486
7487         struct ipw2100_priv *priv = ieee80211_priv(dev);
7488         return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
7489 }
7490
7491 static int ipw2100_wx_set_power(struct net_device *dev,
7492                                 struct iw_request_info *info,
7493                                 union iwreq_data *wrqu, char *extra)
7494 {
7495         struct ipw2100_priv *priv = ieee80211_priv(dev);
7496         int err = 0;
7497
7498         mutex_lock(&priv->action_mutex);
7499         if (!(priv->status & STATUS_INITIALIZED)) {
7500                 err = -EIO;
7501                 goto done;
7502         }
7503
7504         if (wrqu->power.disabled) {
7505                 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
7506                 err = ipw2100_set_power_mode(priv, IPW_POWER_MODE_CAM);
7507                 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
7508                 goto done;
7509         }
7510
7511         switch (wrqu->power.flags & IW_POWER_MODE) {
7512         case IW_POWER_ON:       /* If not specified */
7513         case IW_POWER_MODE:     /* If set all mask */
7514         case IW_POWER_ALL_R:    /* If explicitly state all */
7515                 break;
7516         default:                /* Otherwise we don't support it */
7517                 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
7518                              wrqu->power.flags);
7519                 err = -EOPNOTSUPP;
7520                 goto done;
7521         }
7522
7523         /* If the user hasn't specified a power management mode yet, default
7524          * to BATTERY */
7525         priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
7526         err = ipw2100_set_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
7527
7528         IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
7529
7530       done:
7531         mutex_unlock(&priv->action_mutex);
7532         return err;
7533
7534 }
7535
7536 static int ipw2100_wx_get_power(struct net_device *dev,
7537                                 struct iw_request_info *info,
7538                                 union iwreq_data *wrqu, char *extra)
7539 {
7540         /*
7541          * This can be called at any time.  No action lock required
7542          */
7543
7544         struct ipw2100_priv *priv = ieee80211_priv(dev);
7545
7546         if (!(priv->power_mode & IPW_POWER_ENABLED))
7547                 wrqu->power.disabled = 1;
7548         else {
7549                 wrqu->power.disabled = 0;
7550                 wrqu->power.flags = 0;
7551         }
7552
7553         IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
7554
7555         return 0;
7556 }
7557
7558 /*
7559  * WE-18 WPA support
7560  */
7561
7562 /* SIOCSIWGENIE */
7563 static int ipw2100_wx_set_genie(struct net_device *dev,
7564                                 struct iw_request_info *info,
7565                                 union iwreq_data *wrqu, char *extra)
7566 {
7567
7568         struct ipw2100_priv *priv = ieee80211_priv(dev);
7569         struct ieee80211_device *ieee = priv->ieee;
7570         u8 *buf;
7571
7572         if (!ieee->wpa_enabled)
7573                 return -EOPNOTSUPP;
7574
7575         if (wrqu->data.length > MAX_WPA_IE_LEN ||
7576             (wrqu->data.length && extra == NULL))
7577                 return -EINVAL;
7578
7579         if (wrqu->data.length) {
7580                 buf = kmemdup(extra, wrqu->data.length, GFP_KERNEL);
7581                 if (buf == NULL)
7582                         return -ENOMEM;
7583
7584                 kfree(ieee->wpa_ie);
7585                 ieee->wpa_ie = buf;
7586                 ieee->wpa_ie_len = wrqu->data.length;
7587         } else {
7588                 kfree(ieee->wpa_ie);
7589                 ieee->wpa_ie = NULL;
7590                 ieee->wpa_ie_len = 0;
7591         }
7592
7593         ipw2100_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
7594
7595         return 0;
7596 }
7597
7598 /* SIOCGIWGENIE */
7599 static int ipw2100_wx_get_genie(struct net_device *dev,
7600                                 struct iw_request_info *info,
7601                                 union iwreq_data *wrqu, char *extra)
7602 {
7603         struct ipw2100_priv *priv = ieee80211_priv(dev);
7604         struct ieee80211_device *ieee = priv->ieee;
7605
7606         if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
7607                 wrqu->data.length = 0;
7608                 return 0;
7609         }
7610
7611         if (wrqu->data.length < ieee->wpa_ie_len)
7612                 return -E2BIG;
7613
7614         wrqu->data.length = ieee->wpa_ie_len;
7615         memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
7616
7617         return 0;
7618 }
7619
7620 /* SIOCSIWAUTH */
7621 static int ipw2100_wx_set_auth(struct net_device *dev,
7622                                struct iw_request_info *info,
7623                                union iwreq_data *wrqu, char *extra)
7624 {
7625         struct ipw2100_priv *priv = ieee80211_priv(dev);
7626         struct ieee80211_device *ieee = priv->ieee;
7627         struct iw_param *param = &wrqu->param;
7628         struct ieee80211_crypt_data *crypt;
7629         unsigned long flags;
7630         int ret = 0;
7631
7632         switch (param->flags & IW_AUTH_INDEX) {
7633         case IW_AUTH_WPA_VERSION:
7634         case IW_AUTH_CIPHER_PAIRWISE:
7635         case IW_AUTH_CIPHER_GROUP:
7636         case IW_AUTH_KEY_MGMT:
7637                 /*
7638                  * ipw2200 does not use these parameters
7639                  */
7640                 break;
7641
7642         case IW_AUTH_TKIP_COUNTERMEASURES:
7643                 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
7644                 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
7645                         break;
7646
7647                 flags = crypt->ops->get_flags(crypt->priv);
7648
7649                 if (param->value)
7650                         flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
7651                 else
7652                         flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
7653
7654                 crypt->ops->set_flags(flags, crypt->priv);
7655
7656                 break;
7657
7658         case IW_AUTH_DROP_UNENCRYPTED:{
7659                         /* HACK:
7660                          *
7661                          * wpa_supplicant calls set_wpa_enabled when the driver
7662                          * is loaded and unloaded, regardless of if WPA is being
7663                          * used.  No other calls are made which can be used to
7664                          * determine if encryption will be used or not prior to
7665                          * association being expected.  If encryption is not being
7666                          * used, drop_unencrypted is set to false, else true -- we
7667                          * can use this to determine if the CAP_PRIVACY_ON bit should
7668                          * be set.
7669                          */
7670                         struct ieee80211_security sec = {
7671                                 .flags = SEC_ENABLED,
7672                                 .enabled = param->value,
7673                         };
7674                         priv->ieee->drop_unencrypted = param->value;
7675                         /* We only change SEC_LEVEL for open mode. Others
7676                          * are set by ipw_wpa_set_encryption.
7677                          */
7678                         if (!param->value) {
7679                                 sec.flags |= SEC_LEVEL;
7680                                 sec.level = SEC_LEVEL_0;
7681                         } else {
7682                                 sec.flags |= SEC_LEVEL;
7683                                 sec.level = SEC_LEVEL_1;
7684                         }
7685                         if (priv->ieee->set_security)
7686                                 priv->ieee->set_security(priv->ieee->dev, &sec);
7687                         break;
7688                 }
7689
7690         case IW_AUTH_80211_AUTH_ALG:
7691                 ret = ipw2100_wpa_set_auth_algs(priv, param->value);
7692                 break;
7693
7694         case IW_AUTH_WPA_ENABLED:
7695                 ret = ipw2100_wpa_enable(priv, param->value);
7696                 break;
7697
7698         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
7699                 ieee->ieee802_1x = param->value;
7700                 break;
7701
7702                 //case IW_AUTH_ROAMING_CONTROL:
7703         case IW_AUTH_PRIVACY_INVOKED:
7704                 ieee->privacy_invoked = param->value;
7705                 break;
7706
7707         default:
7708                 return -EOPNOTSUPP;
7709         }
7710         return ret;
7711 }
7712
7713 /* SIOCGIWAUTH */
7714 static int ipw2100_wx_get_auth(struct net_device *dev,
7715                                struct iw_request_info *info,
7716                                union iwreq_data *wrqu, char *extra)
7717 {
7718         struct ipw2100_priv *priv = ieee80211_priv(dev);
7719         struct ieee80211_device *ieee = priv->ieee;
7720         struct ieee80211_crypt_data *crypt;
7721         struct iw_param *param = &wrqu->param;
7722         int ret = 0;
7723
7724         switch (param->flags & IW_AUTH_INDEX) {
7725         case IW_AUTH_WPA_VERSION:
7726         case IW_AUTH_CIPHER_PAIRWISE:
7727         case IW_AUTH_CIPHER_GROUP:
7728         case IW_AUTH_KEY_MGMT:
7729                 /*
7730                  * wpa_supplicant will control these internally
7731                  */
7732                 ret = -EOPNOTSUPP;
7733                 break;
7734
7735         case IW_AUTH_TKIP_COUNTERMEASURES:
7736                 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
7737                 if (!crypt || !crypt->ops->get_flags) {
7738                         IPW_DEBUG_WARNING("Can't get TKIP countermeasures: "
7739                                           "crypt not set!\n");
7740                         break;
7741                 }
7742
7743                 param->value = (crypt->ops->get_flags(crypt->priv) &
7744                                 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
7745
7746                 break;
7747
7748         case IW_AUTH_DROP_UNENCRYPTED:
7749                 param->value = ieee->drop_unencrypted;
7750                 break;
7751
7752         case IW_AUTH_80211_AUTH_ALG:
7753                 param->value = priv->ieee->sec.auth_mode;
7754                 break;
7755
7756         case IW_AUTH_WPA_ENABLED:
7757                 param->value = ieee->wpa_enabled;
7758                 break;
7759
7760         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
7761                 param->value = ieee->ieee802_1x;
7762                 break;
7763
7764         case IW_AUTH_ROAMING_CONTROL:
7765         case IW_AUTH_PRIVACY_INVOKED:
7766                 param->value = ieee->privacy_invoked;
7767                 break;
7768
7769         default:
7770                 return -EOPNOTSUPP;
7771         }
7772         return 0;
7773 }
7774
7775 /* SIOCSIWENCODEEXT */
7776 static int ipw2100_wx_set_encodeext(struct net_device *dev,
7777                                     struct iw_request_info *info,
7778                                     union iwreq_data *wrqu, char *extra)
7779 {
7780         struct ipw2100_priv *priv = ieee80211_priv(dev);
7781         return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
7782 }
7783
7784 /* SIOCGIWENCODEEXT */
7785 static int ipw2100_wx_get_encodeext(struct net_device *dev,
7786                                     struct iw_request_info *info,
7787                                     union iwreq_data *wrqu, char *extra)
7788 {
7789         struct ipw2100_priv *priv = ieee80211_priv(dev);
7790         return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
7791 }
7792
7793 /* SIOCSIWMLME */
7794 static int ipw2100_wx_set_mlme(struct net_device *dev,
7795                                struct iw_request_info *info,
7796                                union iwreq_data *wrqu, char *extra)
7797 {
7798         struct ipw2100_priv *priv = ieee80211_priv(dev);
7799         struct iw_mlme *mlme = (struct iw_mlme *)extra;
7800         __le16 reason;
7801
7802         reason = cpu_to_le16(mlme->reason_code);
7803
7804         switch (mlme->cmd) {
7805         case IW_MLME_DEAUTH:
7806                 // silently ignore
7807                 break;
7808
7809         case IW_MLME_DISASSOC:
7810                 ipw2100_disassociate_bssid(priv);
7811                 break;
7812
7813         default:
7814                 return -EOPNOTSUPP;
7815         }
7816         return 0;
7817 }
7818
7819 /*
7820  *
7821  * IWPRIV handlers
7822  *
7823  */
7824 #ifdef CONFIG_IPW2100_MONITOR
7825 static int ipw2100_wx_set_promisc(struct net_device *dev,
7826                                   struct iw_request_info *info,
7827                                   union iwreq_data *wrqu, char *extra)
7828 {
7829         struct ipw2100_priv *priv = ieee80211_priv(dev);
7830         int *parms = (int *)extra;
7831         int enable = (parms[0] > 0);
7832         int err = 0;
7833
7834         mutex_lock(&priv->action_mutex);
7835         if (!(priv->status & STATUS_INITIALIZED)) {
7836                 err = -EIO;
7837                 goto done;
7838         }
7839
7840         if (enable) {
7841                 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7842                         err = ipw2100_set_channel(priv, parms[1], 0);
7843                         goto done;
7844                 }
7845                 priv->channel = parms[1];
7846                 err = ipw2100_switch_mode(priv, IW_MODE_MONITOR);
7847         } else {
7848                 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
7849                         err = ipw2100_switch_mode(priv, priv->last_mode);
7850         }
7851       done:
7852         mutex_unlock(&priv->action_mutex);
7853         return err;
7854 }
7855
7856 static int ipw2100_wx_reset(struct net_device *dev,
7857                             struct iw_request_info *info,
7858                             union iwreq_data *wrqu, char *extra)
7859 {
7860         struct ipw2100_priv *priv = ieee80211_priv(dev);
7861         if (priv->status & STATUS_INITIALIZED)
7862                 schedule_reset(priv);
7863         return 0;
7864 }
7865
7866 #endif
7867
7868 static int ipw2100_wx_set_powermode(struct net_device *dev,
7869                                     struct iw_request_info *info,
7870                                     union iwreq_data *wrqu, char *extra)
7871 {
7872         struct ipw2100_priv *priv = ieee80211_priv(dev);
7873         int err = 0, mode = *(int *)extra;
7874
7875         mutex_lock(&priv->action_mutex);
7876         if (!(priv->status & STATUS_INITIALIZED)) {
7877                 err = -EIO;
7878                 goto done;
7879         }
7880
7881         if ((mode < 0) || (mode > POWER_MODES))
7882                 mode = IPW_POWER_AUTO;
7883
7884         if (IPW_POWER_LEVEL(priv->power_mode) != mode)
7885                 err = ipw2100_set_power_mode(priv, mode);
7886       done:
7887         mutex_unlock(&priv->action_mutex);
7888         return err;
7889 }
7890
7891 #define MAX_POWER_STRING 80
7892 static int ipw2100_wx_get_powermode(struct net_device *dev,
7893                                     struct iw_request_info *info,
7894                                     union iwreq_data *wrqu, char *extra)
7895 {
7896         /*
7897          * This can be called at any time.  No action lock required
7898          */
7899
7900         struct ipw2100_priv *priv = ieee80211_priv(dev);
7901         int level = IPW_POWER_LEVEL(priv->power_mode);
7902         s32 timeout, period;
7903
7904         if (!(priv->power_mode & IPW_POWER_ENABLED)) {
7905                 snprintf(extra, MAX_POWER_STRING,
7906                          "Power save level: %d (Off)", level);
7907         } else {
7908                 switch (level) {
7909                 case IPW_POWER_MODE_CAM:
7910                         snprintf(extra, MAX_POWER_STRING,
7911                                  "Power save level: %d (None)", level);
7912                         break;
7913                 case IPW_POWER_AUTO:
7914                         snprintf(extra, MAX_POWER_STRING,
7915                                  "Power save level: %d (Auto)", level);
7916                         break;
7917                 default:
7918                         timeout = timeout_duration[level - 1] / 1000;
7919                         period = period_duration[level - 1] / 1000;
7920                         snprintf(extra, MAX_POWER_STRING,
7921                                  "Power save level: %d "
7922                                  "(Timeout %dms, Period %dms)",
7923                                  level, timeout, period);
7924                 }
7925         }
7926
7927         wrqu->data.length = strlen(extra) + 1;
7928
7929         return 0;
7930 }
7931
7932 static int ipw2100_wx_set_preamble(struct net_device *dev,
7933                                    struct iw_request_info *info,
7934                                    union iwreq_data *wrqu, char *extra)
7935 {
7936         struct ipw2100_priv *priv = ieee80211_priv(dev);
7937         int err, mode = *(int *)extra;
7938
7939         mutex_lock(&priv->action_mutex);
7940         if (!(priv->status & STATUS_INITIALIZED)) {
7941                 err = -EIO;
7942                 goto done;
7943         }
7944
7945         if (mode == 1)
7946                 priv->config |= CFG_LONG_PREAMBLE;
7947         else if (mode == 0)
7948                 priv->config &= ~CFG_LONG_PREAMBLE;
7949         else {
7950                 err = -EINVAL;
7951                 goto done;
7952         }
7953
7954         err = ipw2100_system_config(priv, 0);
7955
7956       done:
7957         mutex_unlock(&priv->action_mutex);
7958         return err;
7959 }
7960
7961 static int ipw2100_wx_get_preamble(struct net_device *dev,
7962                                    struct iw_request_info *info,
7963                                    union iwreq_data *wrqu, char *extra)
7964 {
7965         /*
7966          * This can be called at any time.  No action lock required
7967          */
7968
7969         struct ipw2100_priv *priv = ieee80211_priv(dev);
7970
7971         if (priv->config & CFG_LONG_PREAMBLE)
7972                 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
7973         else
7974                 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
7975
7976         return 0;
7977 }
7978
7979 #ifdef CONFIG_IPW2100_MONITOR
7980 static int ipw2100_wx_set_crc_check(struct net_device *dev,
7981                                     struct iw_request_info *info,
7982                                     union iwreq_data *wrqu, char *extra)
7983 {
7984         struct ipw2100_priv *priv = ieee80211_priv(dev);
7985         int err, mode = *(int *)extra;
7986
7987         mutex_lock(&priv->action_mutex);
7988         if (!(priv->status & STATUS_INITIALIZED)) {
7989                 err = -EIO;
7990                 goto done;
7991         }
7992
7993         if (mode == 1)
7994                 priv->config |= CFG_CRC_CHECK;
7995         else if (mode == 0)
7996                 priv->config &= ~CFG_CRC_CHECK;
7997         else {
7998                 err = -EINVAL;
7999                 goto done;
8000         }
8001         err = 0;
8002
8003       done:
8004         mutex_unlock(&priv->action_mutex);
8005         return err;
8006 }
8007
8008 static int ipw2100_wx_get_crc_check(struct net_device *dev,
8009                                     struct iw_request_info *info,
8010                                     union iwreq_data *wrqu, char *extra)
8011 {
8012         /*
8013          * This can be called at any time.  No action lock required
8014          */
8015
8016         struct ipw2100_priv *priv = ieee80211_priv(dev);
8017
8018         if (priv->config & CFG_CRC_CHECK)
8019                 snprintf(wrqu->name, IFNAMSIZ, "CRC checked (1)");
8020         else
8021                 snprintf(wrqu->name, IFNAMSIZ, "CRC ignored (0)");
8022
8023         return 0;
8024 }
8025 #endif                          /* CONFIG_IPW2100_MONITOR */
8026
8027 static iw_handler ipw2100_wx_handlers[] = {
8028         NULL,                   /* SIOCSIWCOMMIT */
8029         ipw2100_wx_get_name,    /* SIOCGIWNAME */
8030         NULL,                   /* SIOCSIWNWID */
8031         NULL,                   /* SIOCGIWNWID */
8032         ipw2100_wx_set_freq,    /* SIOCSIWFREQ */
8033         ipw2100_wx_get_freq,    /* SIOCGIWFREQ */
8034         ipw2100_wx_set_mode,    /* SIOCSIWMODE */
8035         ipw2100_wx_get_mode,    /* SIOCGIWMODE */
8036         NULL,                   /* SIOCSIWSENS */
8037         NULL,                   /* SIOCGIWSENS */
8038         NULL,                   /* SIOCSIWRANGE */
8039         ipw2100_wx_get_range,   /* SIOCGIWRANGE */
8040         NULL,                   /* SIOCSIWPRIV */
8041         NULL,                   /* SIOCGIWPRIV */
8042         NULL,                   /* SIOCSIWSTATS */
8043         NULL,                   /* SIOCGIWSTATS */
8044         NULL,                   /* SIOCSIWSPY */
8045         NULL,                   /* SIOCGIWSPY */
8046         NULL,                   /* SIOCGIWTHRSPY */
8047         NULL,                   /* SIOCWIWTHRSPY */
8048         ipw2100_wx_set_wap,     /* SIOCSIWAP */
8049         ipw2100_wx_get_wap,     /* SIOCGIWAP */
8050         ipw2100_wx_set_mlme,    /* SIOCSIWMLME */
8051         NULL,                   /* SIOCGIWAPLIST -- deprecated */
8052         ipw2100_wx_set_scan,    /* SIOCSIWSCAN */
8053         ipw2100_wx_get_scan,    /* SIOCGIWSCAN */
8054         ipw2100_wx_set_essid,   /* SIOCSIWESSID */
8055         ipw2100_wx_get_essid,   /* SIOCGIWESSID */
8056         ipw2100_wx_set_nick,    /* SIOCSIWNICKN */
8057         ipw2100_wx_get_nick,    /* SIOCGIWNICKN */
8058         NULL,                   /* -- hole -- */
8059         NULL,                   /* -- hole -- */
8060         ipw2100_wx_set_rate,    /* SIOCSIWRATE */
8061         ipw2100_wx_get_rate,    /* SIOCGIWRATE */
8062         ipw2100_wx_set_rts,     /* SIOCSIWRTS */
8063         ipw2100_wx_get_rts,     /* SIOCGIWRTS */
8064         ipw2100_wx_set_frag,    /* SIOCSIWFRAG */
8065         ipw2100_wx_get_frag,    /* SIOCGIWFRAG */
8066         ipw2100_wx_set_txpow,   /* SIOCSIWTXPOW */
8067         ipw2100_wx_get_txpow,   /* SIOCGIWTXPOW */
8068         ipw2100_wx_set_retry,   /* SIOCSIWRETRY */
8069         ipw2100_wx_get_retry,   /* SIOCGIWRETRY */
8070         ipw2100_wx_set_encode,  /* SIOCSIWENCODE */
8071         ipw2100_wx_get_encode,  /* SIOCGIWENCODE */
8072         ipw2100_wx_set_power,   /* SIOCSIWPOWER */
8073         ipw2100_wx_get_power,   /* SIOCGIWPOWER */
8074         NULL,                   /* -- hole -- */
8075         NULL,                   /* -- hole -- */
8076         ipw2100_wx_set_genie,   /* SIOCSIWGENIE */
8077         ipw2100_wx_get_genie,   /* SIOCGIWGENIE */
8078         ipw2100_wx_set_auth,    /* SIOCSIWAUTH */
8079         ipw2100_wx_get_auth,    /* SIOCGIWAUTH */
8080         ipw2100_wx_set_encodeext,       /* SIOCSIWENCODEEXT */
8081         ipw2100_wx_get_encodeext,       /* SIOCGIWENCODEEXT */
8082         NULL,                   /* SIOCSIWPMKSA */
8083 };
8084
8085 #define IPW2100_PRIV_SET_MONITOR        SIOCIWFIRSTPRIV
8086 #define IPW2100_PRIV_RESET              SIOCIWFIRSTPRIV+1
8087 #define IPW2100_PRIV_SET_POWER          SIOCIWFIRSTPRIV+2
8088 #define IPW2100_PRIV_GET_POWER          SIOCIWFIRSTPRIV+3
8089 #define IPW2100_PRIV_SET_LONGPREAMBLE   SIOCIWFIRSTPRIV+4
8090 #define IPW2100_PRIV_GET_LONGPREAMBLE   SIOCIWFIRSTPRIV+5
8091 #define IPW2100_PRIV_SET_CRC_CHECK      SIOCIWFIRSTPRIV+6
8092 #define IPW2100_PRIV_GET_CRC_CHECK      SIOCIWFIRSTPRIV+7
8093
8094 static const struct iw_priv_args ipw2100_private_args[] = {
8095
8096 #ifdef CONFIG_IPW2100_MONITOR
8097         {
8098          IPW2100_PRIV_SET_MONITOR,
8099          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
8100         {
8101          IPW2100_PRIV_RESET,
8102          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
8103 #endif                          /* CONFIG_IPW2100_MONITOR */
8104
8105         {
8106          IPW2100_PRIV_SET_POWER,
8107          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_power"},
8108         {
8109          IPW2100_PRIV_GET_POWER,
8110          0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_POWER_STRING,
8111          "get_power"},
8112         {
8113          IPW2100_PRIV_SET_LONGPREAMBLE,
8114          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_preamble"},
8115         {
8116          IPW2100_PRIV_GET_LONGPREAMBLE,
8117          0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_preamble"},
8118 #ifdef CONFIG_IPW2100_MONITOR
8119         {
8120          IPW2100_PRIV_SET_CRC_CHECK,
8121          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_crc_check"},
8122         {
8123          IPW2100_PRIV_GET_CRC_CHECK,
8124          0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_crc_check"},
8125 #endif                          /* CONFIG_IPW2100_MONITOR */
8126 };
8127
8128 static iw_handler ipw2100_private_handler[] = {
8129 #ifdef CONFIG_IPW2100_MONITOR
8130         ipw2100_wx_set_promisc,
8131         ipw2100_wx_reset,
8132 #else                           /* CONFIG_IPW2100_MONITOR */
8133         NULL,
8134         NULL,
8135 #endif                          /* CONFIG_IPW2100_MONITOR */
8136         ipw2100_wx_set_powermode,
8137         ipw2100_wx_get_powermode,
8138         ipw2100_wx_set_preamble,
8139         ipw2100_wx_get_preamble,
8140 #ifdef CONFIG_IPW2100_MONITOR
8141         ipw2100_wx_set_crc_check,
8142         ipw2100_wx_get_crc_check,
8143 #else                           /* CONFIG_IPW2100_MONITOR */
8144         NULL,
8145         NULL,
8146 #endif                          /* CONFIG_IPW2100_MONITOR */
8147 };
8148
8149 /*
8150  * Get wireless statistics.
8151  * Called by /proc/net/wireless
8152  * Also called by SIOCGIWSTATS
8153  */
8154 static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev)
8155 {
8156         enum {
8157                 POOR = 30,
8158                 FAIR = 60,
8159                 GOOD = 80,
8160                 VERY_GOOD = 90,
8161                 EXCELLENT = 95,
8162                 PERFECT = 100
8163         };
8164         int rssi_qual;
8165         int tx_qual;
8166         int beacon_qual;
8167
8168         struct ipw2100_priv *priv = ieee80211_priv(dev);
8169         struct iw_statistics *wstats;
8170         u32 rssi, quality, tx_retries, missed_beacons, tx_failures;
8171         u32 ord_len = sizeof(u32);
8172
8173         if (!priv)
8174                 return (struct iw_statistics *)NULL;
8175
8176         wstats = &priv->wstats;
8177
8178         /* if hw is disabled, then ipw2100_get_ordinal() can't be called.
8179          * ipw2100_wx_wireless_stats seems to be called before fw is
8180          * initialized.  STATUS_ASSOCIATED will only be set if the hw is up
8181          * and associated; if not associcated, the values are all meaningless
8182          * anyway, so set them all to NULL and INVALID */
8183         if (!(priv->status & STATUS_ASSOCIATED)) {
8184                 wstats->miss.beacon = 0;
8185                 wstats->discard.retries = 0;
8186                 wstats->qual.qual = 0;
8187                 wstats->qual.level = 0;
8188                 wstats->qual.noise = 0;
8189                 wstats->qual.updated = 7;
8190                 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
8191                     IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
8192                 return wstats;
8193         }
8194
8195         if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_MISSED_BCNS,
8196                                 &missed_beacons, &ord_len))
8197                 goto fail_get_ordinal;
8198
8199         /* If we don't have a connection the quality and level is 0 */
8200         if (!(priv->status & STATUS_ASSOCIATED)) {
8201                 wstats->qual.qual = 0;
8202                 wstats->qual.level = 0;
8203         } else {
8204                 if (ipw2100_get_ordinal(priv, IPW_ORD_RSSI_AVG_CURR,
8205                                         &rssi, &ord_len))
8206                         goto fail_get_ordinal;
8207                 wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM;
8208                 if (rssi < 10)
8209                         rssi_qual = rssi * POOR / 10;
8210                 else if (rssi < 15)
8211                         rssi_qual = (rssi - 10) * (FAIR - POOR) / 5 + POOR;
8212                 else if (rssi < 20)
8213                         rssi_qual = (rssi - 15) * (GOOD - FAIR) / 5 + FAIR;
8214                 else if (rssi < 30)
8215                         rssi_qual = (rssi - 20) * (VERY_GOOD - GOOD) /
8216                             10 + GOOD;
8217                 else
8218                         rssi_qual = (rssi - 30) * (PERFECT - VERY_GOOD) /
8219                             10 + VERY_GOOD;
8220
8221                 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_RETRIES,
8222                                         &tx_retries, &ord_len))
8223                         goto fail_get_ordinal;
8224
8225                 if (tx_retries > 75)
8226                         tx_qual = (90 - tx_retries) * POOR / 15;
8227                 else if (tx_retries > 70)
8228                         tx_qual = (75 - tx_retries) * (FAIR - POOR) / 5 + POOR;
8229                 else if (tx_retries > 65)
8230                         tx_qual = (70 - tx_retries) * (GOOD - FAIR) / 5 + FAIR;
8231                 else if (tx_retries > 50)
8232                         tx_qual = (65 - tx_retries) * (VERY_GOOD - GOOD) /
8233                             15 + GOOD;
8234                 else
8235                         tx_qual = (50 - tx_retries) *
8236                             (PERFECT - VERY_GOOD) / 50 + VERY_GOOD;
8237
8238                 if (missed_beacons > 50)
8239                         beacon_qual = (60 - missed_beacons) * POOR / 10;
8240                 else if (missed_beacons > 40)
8241                         beacon_qual = (50 - missed_beacons) * (FAIR - POOR) /
8242                             10 + POOR;
8243                 else if (missed_beacons > 32)
8244                         beacon_qual = (40 - missed_beacons) * (GOOD - FAIR) /
8245                             18 + FAIR;
8246                 else if (missed_beacons > 20)
8247                         beacon_qual = (32 - missed_beacons) *
8248                             (VERY_GOOD - GOOD) / 20 + GOOD;
8249                 else
8250                         beacon_qual = (20 - missed_beacons) *
8251                             (PERFECT - VERY_GOOD) / 20 + VERY_GOOD;
8252
8253                 quality = min(beacon_qual, min(tx_qual, rssi_qual));
8254
8255 #ifdef CONFIG_IPW2100_DEBUG
8256                 if (beacon_qual == quality)
8257                         IPW_DEBUG_WX("Quality clamped by Missed Beacons\n");
8258                 else if (tx_qual == quality)
8259                         IPW_DEBUG_WX("Quality clamped by Tx Retries\n");
8260                 else if (quality != 100)
8261                         IPW_DEBUG_WX("Quality clamped by Signal Strength\n");
8262                 else
8263                         IPW_DEBUG_WX("Quality not clamped.\n");
8264 #endif
8265
8266                 wstats->qual.qual = quality;
8267                 wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM;
8268         }
8269
8270         wstats->qual.noise = 0;
8271         wstats->qual.updated = 7;
8272         wstats->qual.updated |= IW_QUAL_NOISE_INVALID;
8273
8274         /* FIXME: this is percent and not a # */
8275         wstats->miss.beacon = missed_beacons;
8276
8277         if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURES,
8278                                 &tx_failures, &ord_len))
8279                 goto fail_get_ordinal;
8280         wstats->discard.retries = tx_failures;
8281
8282         return wstats;
8283
8284       fail_get_ordinal:
8285         IPW_DEBUG_WX("failed querying ordinals.\n");
8286
8287         return (struct iw_statistics *)NULL;
8288 }
8289
8290 static struct iw_handler_def ipw2100_wx_handler_def = {
8291         .standard = ipw2100_wx_handlers,
8292         .num_standard = ARRAY_SIZE(ipw2100_wx_handlers),
8293         .num_private = ARRAY_SIZE(ipw2100_private_handler),
8294         .num_private_args = ARRAY_SIZE(ipw2100_private_args),
8295         .private = (iw_handler *) ipw2100_private_handler,
8296         .private_args = (struct iw_priv_args *)ipw2100_private_args,
8297         .get_wireless_stats = ipw2100_wx_wireless_stats,
8298 };
8299
8300 static void ipw2100_wx_event_work(struct work_struct *work)
8301 {
8302         struct ipw2100_priv *priv =
8303                 container_of(work, struct ipw2100_priv, wx_event_work.work);
8304         union iwreq_data wrqu;
8305         int len = ETH_ALEN;
8306
8307         if (priv->status & STATUS_STOPPING)
8308                 return;
8309
8310         mutex_lock(&priv->action_mutex);
8311
8312         IPW_DEBUG_WX("enter\n");
8313
8314         mutex_unlock(&priv->action_mutex);
8315
8316         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
8317
8318         /* Fetch BSSID from the hardware */
8319         if (!(priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) ||
8320             priv->status & STATUS_RF_KILL_MASK ||
8321             ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID,
8322                                 &priv->bssid, &len)) {
8323                 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
8324         } else {
8325                 /* We now have the BSSID, so can finish setting to the full
8326                  * associated state */
8327                 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
8328                 memcpy(priv->ieee->bssid, priv->bssid, ETH_ALEN);
8329                 priv->status &= ~STATUS_ASSOCIATING;
8330                 priv->status |= STATUS_ASSOCIATED;
8331                 netif_carrier_on(priv->net_dev);
8332                 netif_wake_queue(priv->net_dev);
8333         }
8334
8335         if (!(priv->status & STATUS_ASSOCIATED)) {
8336                 IPW_DEBUG_WX("Configuring ESSID\n");
8337                 mutex_lock(&priv->action_mutex);
8338                 /* This is a disassociation event, so kick the firmware to
8339                  * look for another AP */
8340                 if (priv->config & CFG_STATIC_ESSID)
8341                         ipw2100_set_essid(priv, priv->essid, priv->essid_len,
8342                                           0);
8343                 else
8344                         ipw2100_set_essid(priv, NULL, 0, 0);
8345                 mutex_unlock(&priv->action_mutex);
8346         }
8347
8348         wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
8349 }
8350
8351 #define IPW2100_FW_MAJOR_VERSION 1
8352 #define IPW2100_FW_MINOR_VERSION 3
8353
8354 #define IPW2100_FW_MINOR(x) ((x & 0xff) >> 8)
8355 #define IPW2100_FW_MAJOR(x) (x & 0xff)
8356
8357 #define IPW2100_FW_VERSION ((IPW2100_FW_MINOR_VERSION << 8) | \
8358                              IPW2100_FW_MAJOR_VERSION)
8359
8360 #define IPW2100_FW_PREFIX "ipw2100-" __stringify(IPW2100_FW_MAJOR_VERSION) \
8361 "." __stringify(IPW2100_FW_MINOR_VERSION)
8362
8363 #define IPW2100_FW_NAME(x) IPW2100_FW_PREFIX "" x ".fw"
8364
8365 /*
8366
8367 BINARY FIRMWARE HEADER FORMAT
8368
8369 offset      length   desc
8370 0           2        version
8371 2           2        mode == 0:BSS,1:IBSS,2:MONITOR
8372 4           4        fw_len
8373 8           4        uc_len
8374 C           fw_len   firmware data
8375 12 + fw_len uc_len   microcode data
8376
8377 */
8378
8379 struct ipw2100_fw_header {
8380         short version;
8381         short mode;
8382         unsigned int fw_size;
8383         unsigned int uc_size;
8384 } __attribute__ ((packed));
8385
8386 static int ipw2100_mod_firmware_load(struct ipw2100_fw *fw)
8387 {
8388         struct ipw2100_fw_header *h =
8389             (struct ipw2100_fw_header *)fw->fw_entry->data;
8390
8391         if (IPW2100_FW_MAJOR(h->version) != IPW2100_FW_MAJOR_VERSION) {
8392                 printk(KERN_WARNING DRV_NAME ": Firmware image not compatible "
8393                        "(detected version id of %u). "
8394                        "See Documentation/networking/README.ipw2100\n",
8395                        h->version);
8396                 return 1;
8397         }
8398
8399         fw->version = h->version;
8400         fw->fw.data = fw->fw_entry->data + sizeof(struct ipw2100_fw_header);
8401         fw->fw.size = h->fw_size;
8402         fw->uc.data = fw->fw.data + h->fw_size;
8403         fw->uc.size = h->uc_size;
8404
8405         return 0;
8406 }
8407
8408 static int ipw2100_get_firmware(struct ipw2100_priv *priv,
8409                                 struct ipw2100_fw *fw)
8410 {
8411         char *fw_name;
8412         int rc;
8413
8414         IPW_DEBUG_INFO("%s: Using hotplug firmware load.\n",
8415                        priv->net_dev->name);
8416
8417         switch (priv->ieee->iw_mode) {
8418         case IW_MODE_ADHOC:
8419                 fw_name = IPW2100_FW_NAME("-i");
8420                 break;
8421 #ifdef CONFIG_IPW2100_MONITOR
8422         case IW_MODE_MONITOR:
8423                 fw_name = IPW2100_FW_NAME("-p");
8424                 break;
8425 #endif
8426         case IW_MODE_INFRA:
8427         default:
8428                 fw_name = IPW2100_FW_NAME("");
8429                 break;
8430         }
8431
8432         rc = request_firmware(&fw->fw_entry, fw_name, &priv->pci_dev->dev);
8433
8434         if (rc < 0) {
8435                 printk(KERN_ERR DRV_NAME ": "
8436                        "%s: Firmware '%s' not available or load failed.\n",
8437                        priv->net_dev->name, fw_name);
8438                 return rc;
8439         }
8440         IPW_DEBUG_INFO("firmware data %p size %zd\n", fw->fw_entry->data,
8441                        fw->fw_entry->size);
8442
8443         ipw2100_mod_firmware_load(fw);
8444
8445         return 0;
8446 }
8447
8448 static void ipw2100_release_firmware(struct ipw2100_priv *priv,
8449                                      struct ipw2100_fw *fw)
8450 {
8451         fw->version = 0;
8452         if (fw->fw_entry)
8453                 release_firmware(fw->fw_entry);
8454         fw->fw_entry = NULL;
8455 }
8456
8457 static int ipw2100_get_fwversion(struct ipw2100_priv *priv, char *buf,
8458                                  size_t max)
8459 {
8460         char ver[MAX_FW_VERSION_LEN];
8461         u32 len = MAX_FW_VERSION_LEN;
8462         u32 tmp;
8463         int i;
8464         /* firmware version is an ascii string (max len of 14) */
8465         if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_FW_VER_NUM, ver, &len))
8466                 return -EIO;
8467         tmp = max;
8468         if (len >= max)
8469                 len = max - 1;
8470         for (i = 0; i < len; i++)
8471                 buf[i] = ver[i];
8472         buf[i] = '\0';
8473         return tmp;
8474 }
8475
8476 static int ipw2100_get_ucodeversion(struct ipw2100_priv *priv, char *buf,
8477                                     size_t max)
8478 {
8479         u32 ver;
8480         u32 len = sizeof(ver);
8481         /* microcode version is a 32 bit integer */
8482         if (ipw2100_get_ordinal(priv, IPW_ORD_UCODE_VERSION, &ver, &len))
8483                 return -EIO;
8484         return snprintf(buf, max, "%08X", ver);
8485 }
8486
8487 /*
8488  * On exit, the firmware will have been freed from the fw list
8489  */
8490 static int ipw2100_fw_download(struct ipw2100_priv *priv, struct ipw2100_fw *fw)
8491 {
8492         /* firmware is constructed of N contiguous entries, each entry is
8493          * structured as:
8494          *
8495          * offset    sie         desc
8496          * 0         4           address to write to
8497          * 4         2           length of data run
8498          * 6         length      data
8499          */
8500         unsigned int addr;
8501         unsigned short len;
8502
8503         const unsigned char *firmware_data = fw->fw.data;
8504         unsigned int firmware_data_left = fw->fw.size;
8505
8506         while (firmware_data_left > 0) {
8507                 addr = *(u32 *) (firmware_data);
8508                 firmware_data += 4;
8509                 firmware_data_left -= 4;
8510
8511                 len = *(u16 *) (firmware_data);
8512                 firmware_data += 2;
8513                 firmware_data_left -= 2;
8514
8515                 if (len > 32) {
8516                         printk(KERN_ERR DRV_NAME ": "
8517                                "Invalid firmware run-length of %d bytes\n",
8518                                len);
8519                         return -EINVAL;
8520                 }
8521
8522                 write_nic_memory(priv->net_dev, addr, len, firmware_data);
8523                 firmware_data += len;
8524                 firmware_data_left -= len;
8525         }
8526
8527         return 0;
8528 }
8529
8530 struct symbol_alive_response {
8531         u8 cmd_id;
8532         u8 seq_num;
8533         u8 ucode_rev;
8534         u8 eeprom_valid;
8535         u16 valid_flags;
8536         u8 IEEE_addr[6];
8537         u16 flags;
8538         u16 pcb_rev;
8539         u16 clock_settle_time;  // 1us LSB
8540         u16 powerup_settle_time;        // 1us LSB
8541         u16 hop_settle_time;    // 1us LSB
8542         u8 date[3];             // month, day, year
8543         u8 time[2];             // hours, minutes
8544         u8 ucode_valid;
8545 };
8546
8547 static int ipw2100_ucode_download(struct ipw2100_priv *priv,
8548                                   struct ipw2100_fw *fw)
8549 {
8550         struct net_device *dev = priv->net_dev;
8551         const unsigned char *microcode_data = fw->uc.data;
8552         unsigned int microcode_data_left = fw->uc.size;
8553         void __iomem *reg = (void __iomem *)dev->base_addr;
8554
8555         struct symbol_alive_response response;
8556         int i, j;
8557         u8 data;
8558
8559         /* Symbol control */
8560         write_nic_word(dev, IPW2100_CONTROL_REG, 0x703);
8561         readl(reg);
8562         write_nic_word(dev, IPW2100_CONTROL_REG, 0x707);
8563         readl(reg);
8564
8565         /* HW config */
8566         write_nic_byte(dev, 0x210014, 0x72);    /* fifo width =16 */
8567         readl(reg);
8568         write_nic_byte(dev, 0x210014, 0x72);    /* fifo width =16 */
8569         readl(reg);
8570
8571         /* EN_CS_ACCESS bit to reset control store pointer */
8572         write_nic_byte(dev, 0x210000, 0x40);
8573         readl(reg);
8574         write_nic_byte(dev, 0x210000, 0x0);
8575         readl(reg);
8576         write_nic_byte(dev, 0x210000, 0x40);
8577         readl(reg);
8578
8579         /* copy microcode from buffer into Symbol */
8580
8581         while (microcode_data_left > 0) {
8582                 write_nic_byte(dev, 0x210010, *microcode_data++);
8583                 write_nic_byte(dev, 0x210010, *microcode_data++);
8584                 microcode_data_left -= 2;
8585         }
8586
8587         /* EN_CS_ACCESS bit to reset the control store pointer */
8588         write_nic_byte(dev, 0x210000, 0x0);
8589         readl(reg);
8590
8591         /* Enable System (Reg 0)
8592          * first enable causes garbage in RX FIFO */
8593         write_nic_byte(dev, 0x210000, 0x0);
8594         readl(reg);
8595         write_nic_byte(dev, 0x210000, 0x80);
8596         readl(reg);
8597
8598         /* Reset External Baseband Reg */
8599         write_nic_word(dev, IPW2100_CONTROL_REG, 0x703);
8600         readl(reg);
8601         write_nic_word(dev, IPW2100_CONTROL_REG, 0x707);
8602         readl(reg);
8603
8604         /* HW Config (Reg 5) */
8605         write_nic_byte(dev, 0x210014, 0x72);    // fifo width =16
8606         readl(reg);
8607         write_nic_byte(dev, 0x210014, 0x72);    // fifo width =16
8608         readl(reg);
8609
8610         /* Enable System (Reg 0)
8611          * second enable should be OK */
8612         write_nic_byte(dev, 0x210000, 0x00);    // clear enable system
8613         readl(reg);
8614         write_nic_byte(dev, 0x210000, 0x80);    // set enable system
8615
8616         /* check Symbol is enabled - upped this from 5 as it wasn't always
8617          * catching the update */
8618         for (i = 0; i < 10; i++) {
8619                 udelay(10);
8620
8621                 /* check Dino is enabled bit */
8622                 read_nic_byte(dev, 0x210000, &data);
8623                 if (data & 0x1)
8624                         break;
8625         }
8626
8627         if (i == 10) {
8628                 printk(KERN_ERR DRV_NAME ": %s: Error initializing Symbol\n",
8629                        dev->name);
8630                 return -EIO;
8631         }
8632
8633         /* Get Symbol alive response */
8634         for (i = 0; i < 30; i++) {
8635                 /* Read alive response structure */
8636                 for (j = 0;
8637                      j < (sizeof(struct symbol_alive_response) >> 1); j++)
8638                         read_nic_word(dev, 0x210004, ((u16 *) & response) + j);
8639
8640                 if ((response.cmd_id == 1) && (response.ucode_valid == 0x1))
8641                         break;
8642                 udelay(10);
8643         }
8644
8645         if (i == 30) {
8646                 printk(KERN_ERR DRV_NAME
8647                        ": %s: No response from Symbol - hw not alive\n",
8648                        dev->name);
8649                 printk_buf(IPW_DL_ERROR, (u8 *) & response, sizeof(response));
8650                 return -EIO;
8651         }
8652
8653         return 0;
8654 }