drivers/net/wireless/ipw2100.c

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