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