err.no Git - linux-2.6/blob - drivers/net/wireless/ipw2100.c

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