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