drivers/net/wireless/ipw2x00/ipw2200.c

   1 /******************************************************************************
   2
   3   Copyright(c) 2003 - 2006 Intel Corporation. All rights reserved.
   4
   5   802.11 status code portion of this file from ethereal-0.10.6:
   6     Copyright 2000, Axis Communications AB
   7     Ethereal - Network traffic analyzer
   8     By Gerald Combs <gerald@ethereal.com>
   9     Copyright 1998 Gerald Combs
  10
  11   This program is free software; you can redistribute it and/or modify it
  12   under the terms of version 2 of the GNU General Public License as
  13   published by the Free Software Foundation.
  14
  15   This program is distributed in the hope that it will be useful, but WITHOUT
  16   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  18   more details.
  19
  20   You should have received a copy of the GNU General Public License along with
  21   this program; if not, write to the Free Software Foundation, Inc., 59
  22   Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23
  24   The full GNU General Public License is included in this distribution in the
  25   file called LICENSE.
  26
  27   Contact Information:
  28   Intel Linux Wireless <ilw@linux.intel.com>
  29   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  30
  31 ******************************************************************************/
  32
  33 #include <linux/sched.h>
  34 #include <linux/slab.h>
  35 #include "ipw2200.h"
  36
  37
  38 #ifndef KBUILD_EXTMOD
  39 #define VK "k"
  40 #else
  41 #define VK
  42 #endif
  43
  44 #ifdef CONFIG_IPW2200_DEBUG
  45 #define VD "d"
  46 #else
  47 #define VD
  48 #endif
  49
  50 #ifdef CONFIG_IPW2200_MONITOR
  51 #define VM "m"
  52 #else
  53 #define VM
  54 #endif
  55
  56 #ifdef CONFIG_IPW2200_PROMISCUOUS
  57 #define VP "p"
  58 #else
  59 #define VP
  60 #endif
  61
  62 #ifdef CONFIG_IPW2200_RADIOTAP
  63 #define VR "r"
  64 #else
  65 #define VR
  66 #endif
  67
  68 #ifdef CONFIG_IPW2200_QOS
  69 #define VQ "q"
  70 #else
  71 #define VQ
  72 #endif
  73
  74 #define IPW2200_VERSION "1.2.2" VK VD VM VP VR VQ
  75 #define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver"
  76 #define DRV_COPYRIGHT   "Copyright(c) 2003-2006 Intel Corporation"
  77 #define DRV_VERSION     IPW2200_VERSION
  78
  79 #define ETH_P_80211_STATS (ETH_P_80211_RAW + 1)
  80
  81 MODULE_DESCRIPTION(DRV_DESCRIPTION);
  82 MODULE_VERSION(DRV_VERSION);
  83 MODULE_AUTHOR(DRV_COPYRIGHT);
  84 MODULE_LICENSE("GPL");
  85 MODULE_FIRMWARE("ipw2200-ibss.fw");
  86 #ifdef CONFIG_IPW2200_MONITOR
  87 MODULE_FIRMWARE("ipw2200-sniffer.fw");
  88 #endif
  89 MODULE_FIRMWARE("ipw2200-bss.fw");
  90
  91 static int cmdlog = 0;
  92 static int debug = 0;
  93 static int default_channel = 0;
  94 static int network_mode = 0;
  95
  96 static u32 ipw_debug_level;
  97 static int associate;
  98 static int auto_create = 1;
  99 static int led_support = 0;
 100 static int disable = 0;
 101 static int bt_coexist = 0;
 102 static int hwcrypto = 0;
 103 static int roaming = 1;
 104 static const char ipw_modes[] = {
 105         'a', 'b', 'g', '?'
 106 };
 107 static int antenna = CFG_SYS_ANTENNA_BOTH;
 108
 109 #ifdef CONFIG_IPW2200_PROMISCUOUS
 110 static int rtap_iface = 0;     /* def: 0 -- do not create rtap interface */
 111 #endif
 112
 113 static struct ieee80211_rate ipw2200_rates[] = {
 114         { .bitrate = 10 },
 115         { .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 116         { .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 117         { .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 118         { .bitrate = 60 },
 119         { .bitrate = 90 },
 120         { .bitrate = 120 },
 121         { .bitrate = 180 },
 122         { .bitrate = 240 },
 123         { .bitrate = 360 },
 124         { .bitrate = 480 },
 125         { .bitrate = 540 }
 126 };
 127
 128 #define ipw2200_a_rates         (ipw2200_rates + 4)
 129 #define ipw2200_num_a_rates     8
 130 #define ipw2200_bg_rates        (ipw2200_rates + 0)
 131 #define ipw2200_num_bg_rates    12
 132
 133 #ifdef CONFIG_IPW2200_QOS
 134 static int qos_enable = 0;
 135 static int qos_burst_enable = 0;
 136 static int qos_no_ack_mask = 0;
 137 static int burst_duration_CCK = 0;
 138 static int burst_duration_OFDM = 0;
 139
 140 static struct libipw_qos_parameters def_qos_parameters_OFDM = {
 141         {QOS_TX0_CW_MIN_OFDM, QOS_TX1_CW_MIN_OFDM, QOS_TX2_CW_MIN_OFDM,
 142          QOS_TX3_CW_MIN_OFDM},
 143         {QOS_TX0_CW_MAX_OFDM, QOS_TX1_CW_MAX_OFDM, QOS_TX2_CW_MAX_OFDM,
 144          QOS_TX3_CW_MAX_OFDM},
 145         {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
 146         {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
 147         {QOS_TX0_TXOP_LIMIT_OFDM, QOS_TX1_TXOP_LIMIT_OFDM,
 148          QOS_TX2_TXOP_LIMIT_OFDM, QOS_TX3_TXOP_LIMIT_OFDM}
 149 };
 150
 151 static struct libipw_qos_parameters def_qos_parameters_CCK = {
 152         {QOS_TX0_CW_MIN_CCK, QOS_TX1_CW_MIN_CCK, QOS_TX2_CW_MIN_CCK,
 153          QOS_TX3_CW_MIN_CCK},
 154         {QOS_TX0_CW_MAX_CCK, QOS_TX1_CW_MAX_CCK, QOS_TX2_CW_MAX_CCK,
 155          QOS_TX3_CW_MAX_CCK},
 156         {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
 157         {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
 158         {QOS_TX0_TXOP_LIMIT_CCK, QOS_TX1_TXOP_LIMIT_CCK, QOS_TX2_TXOP_LIMIT_CCK,
 159          QOS_TX3_TXOP_LIMIT_CCK}
 160 };
 161
 162 static struct libipw_qos_parameters def_parameters_OFDM = {
 163         {DEF_TX0_CW_MIN_OFDM, DEF_TX1_CW_MIN_OFDM, DEF_TX2_CW_MIN_OFDM,
 164          DEF_TX3_CW_MIN_OFDM},
 165         {DEF_TX0_CW_MAX_OFDM, DEF_TX1_CW_MAX_OFDM, DEF_TX2_CW_MAX_OFDM,
 166          DEF_TX3_CW_MAX_OFDM},
 167         {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
 168         {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
 169         {DEF_TX0_TXOP_LIMIT_OFDM, DEF_TX1_TXOP_LIMIT_OFDM,
 170          DEF_TX2_TXOP_LIMIT_OFDM, DEF_TX3_TXOP_LIMIT_OFDM}
 171 };
 172
 173 static struct libipw_qos_parameters def_parameters_CCK = {
 174         {DEF_TX0_CW_MIN_CCK, DEF_TX1_CW_MIN_CCK, DEF_TX2_CW_MIN_CCK,
 175          DEF_TX3_CW_MIN_CCK},
 176         {DEF_TX0_CW_MAX_CCK, DEF_TX1_CW_MAX_CCK, DEF_TX2_CW_MAX_CCK,
 177          DEF_TX3_CW_MAX_CCK},
 178         {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
 179         {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
 180         {DEF_TX0_TXOP_LIMIT_CCK, DEF_TX1_TXOP_LIMIT_CCK, DEF_TX2_TXOP_LIMIT_CCK,
 181          DEF_TX3_TXOP_LIMIT_CCK}
 182 };
 183
 184 static u8 qos_oui[QOS_OUI_LEN] = { 0x00, 0x50, 0xF2 };
 185
 186 static int from_priority_to_tx_queue[] = {
 187         IPW_TX_QUEUE_1, IPW_TX_QUEUE_2, IPW_TX_QUEUE_2, IPW_TX_QUEUE_1,
 188         IPW_TX_QUEUE_3, IPW_TX_QUEUE_3, IPW_TX_QUEUE_4, IPW_TX_QUEUE_4
 189 };
 190
 191 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv);
 192
 193 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct libipw_qos_parameters
 194                                        *qos_param);
 195 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct libipw_qos_information_element
 196                                      *qos_param);
 197 #endif                          /* CONFIG_IPW2200_QOS */
 198
 199 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev);
 200 static void ipw_remove_current_network(struct ipw_priv *priv);
 201 static void ipw_rx(struct ipw_priv *priv);
 202 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
 203                                 struct clx2_tx_queue *txq, int qindex);
 204 static int ipw_queue_reset(struct ipw_priv *priv);
 205
 206 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
 207                              int len, int sync);
 208
 209 static void ipw_tx_queue_free(struct ipw_priv *);
 210
 211 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *);
 212 static void ipw_rx_queue_free(struct ipw_priv *, struct ipw_rx_queue *);
 213 static void ipw_rx_queue_replenish(void *);
 214 static int ipw_up(struct ipw_priv *);
 215 static void ipw_bg_up(struct work_struct *work);
 216 static void ipw_down(struct ipw_priv *);
 217 static void ipw_bg_down(struct work_struct *work);
 218 static int ipw_config(struct ipw_priv *);
 219 static int init_supported_rates(struct ipw_priv *priv,
 220                                 struct ipw_supported_rates *prates);
 221 static void ipw_set_hwcrypto_keys(struct ipw_priv *);
 222 static void ipw_send_wep_keys(struct ipw_priv *, int);
 223
 224 static int snprint_line(char *buf, size_t count,
 225                         const u8 * data, u32 len, u32 ofs)
 226 {
 227         int out, i, j, l;
 228         char c;
 229
 230         out = snprintf(buf, count, "%08X", ofs);
 231
 232         for (l = 0, i = 0; i < 2; i++) {
 233                 out += snprintf(buf + out, count - out, " ");
 234                 for (j = 0; j < 8 && l < len; j++, l++)
 235                         out += snprintf(buf + out, count - out, "%02X ",
 236                                         data[(i * 8 + j)]);
 237                 for (; j < 8; j++)
 238                         out += snprintf(buf + out, count - out, "   ");
 239         }
 240
 241         out += snprintf(buf + out, count - out, " ");
 242         for (l = 0, i = 0; i < 2; i++) {
 243                 out += snprintf(buf + out, count - out, " ");
 244                 for (j = 0; j < 8 && l < len; j++, l++) {
 245                         c = data[(i * 8 + j)];
 246                         if (!isascii(c) || !isprint(c))
 247                                 c = '.';
 248
 249                         out += snprintf(buf + out, count - out, "%c", c);
 250                 }
 251
 252                 for (; j < 8; j++)
 253                         out += snprintf(buf + out, count - out, " ");
 254         }
 255
 256         return out;
 257 }
 258
 259 static void printk_buf(int level, const u8 * data, u32 len)
 260 {
 261         char line[81];
 262         u32 ofs = 0;
 263         if (!(ipw_debug_level & level))
 264                 return;
 265
 266         while (len) {
 267                 snprint_line(line, sizeof(line), &data[ofs],
 268                              min(len, 16U), ofs);
 269                 printk(KERN_DEBUG "%s\n", line);
 270                 ofs += 16;
 271                 len -= min(len, 16U);
 272         }
 273 }
 274
 275 static int snprintk_buf(u8 * output, size_t size, const u8 * data, size_t len)
 276 {
 277         size_t out = size;
 278         u32 ofs = 0;
 279         int total = 0;
 280
 281         while (size && len) {
 282                 out = snprint_line(output, size, &data[ofs],
 283                                    min_t(size_t, len, 16U), ofs);
 284
 285                 ofs += 16;
 286                 output += out;
 287                 size -= out;
 288                 len -= min_t(size_t, len, 16U);
 289                 total += out;
 290         }
 291         return total;
 292 }
 293
 294 /* alias for 32-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
 295 static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg);
 296 #define ipw_read_reg32(a, b) _ipw_read_reg32(a, b)
 297
 298 /* alias for 8-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
 299 static u8 _ipw_read_reg8(struct ipw_priv *ipw, u32 reg);
 300 #define ipw_read_reg8(a, b) _ipw_read_reg8(a, b)
 301
 302 /* 8-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
 303 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value);
 304 static inline void ipw_write_reg8(struct ipw_priv *a, u32 b, u8 c)
 305 {
 306         IPW_DEBUG_IO("%s %d: write_indirect8(0x%08X, 0x%08X)\n", __FILE__,
 307                      __LINE__, (u32) (b), (u32) (c));
 308         _ipw_write_reg8(a, b, c);
 309 }
 310
 311 /* 16-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
 312 static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value);
 313 static inline void ipw_write_reg16(struct ipw_priv *a, u32 b, u16 c)
 314 {
 315         IPW_DEBUG_IO("%s %d: write_indirect16(0x%08X, 0x%08X)\n", __FILE__,
 316                      __LINE__, (u32) (b), (u32) (c));
 317         _ipw_write_reg16(a, b, c);
 318 }
 319
 320 /* 32-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
 321 static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value);
 322 static inline void ipw_write_reg32(struct ipw_priv *a, u32 b, u32 c)
 323 {
 324         IPW_DEBUG_IO("%s %d: write_indirect32(0x%08X, 0x%08X)\n", __FILE__,
 325                      __LINE__, (u32) (b), (u32) (c));
 326         _ipw_write_reg32(a, b, c);
 327 }
 328
 329 /* 8-bit direct write (low 4K) */
 330 static inline void _ipw_write8(struct ipw_priv *ipw, unsigned long ofs,
 331                 u8 val)
 332 {
 333         writeb(val, ipw->hw_base + ofs);
 334 }
 335
 336 /* 8-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
 337 #define ipw_write8(ipw, ofs, val) do { \
 338         IPW_DEBUG_IO("%s %d: write_direct8(0x%08X, 0x%08X)\n", __FILE__, \
 339                         __LINE__, (u32)(ofs), (u32)(val)); \
 340         _ipw_write8(ipw, ofs, val); \
 341 } while (0)
 342
 343 /* 16-bit direct write (low 4K) */
 344 static inline void _ipw_write16(struct ipw_priv *ipw, unsigned long ofs,
 345                 u16 val)
 346 {
 347         writew(val, ipw->hw_base + ofs);
 348 }
 349
 350 /* 16-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
 351 #define ipw_write16(ipw, ofs, val) do { \
 352         IPW_DEBUG_IO("%s %d: write_direct16(0x%08X, 0x%08X)\n", __FILE__, \
 353                         __LINE__, (u32)(ofs), (u32)(val)); \
 354         _ipw_write16(ipw, ofs, val); \
 355 } while (0)
 356
 357 /* 32-bit direct write (low 4K) */
 358 static inline void _ipw_write32(struct ipw_priv *ipw, unsigned long ofs,
 359                 u32 val)
 360 {
 361         writel(val, ipw->hw_base + ofs);
 362 }
 363
 364 /* 32-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
 365 #define ipw_write32(ipw, ofs, val) do { \
 366         IPW_DEBUG_IO("%s %d: write_direct32(0x%08X, 0x%08X)\n", __FILE__, \
 367                         __LINE__, (u32)(ofs), (u32)(val)); \
 368         _ipw_write32(ipw, ofs, val); \
 369 } while (0)
 370
 371 /* 8-bit direct read (low 4K) */
 372 static inline u8 _ipw_read8(struct ipw_priv *ipw, unsigned long ofs)
 373 {
 374         return readb(ipw->hw_base + ofs);
 375 }
 376
 377 /* alias to 8-bit direct read (low 4K of SRAM/regs), with debug wrapper */
 378 #define ipw_read8(ipw, ofs) ({ \
 379         IPW_DEBUG_IO("%s %d: read_direct8(0x%08X)\n", __FILE__, __LINE__, \
 380                         (u32)(ofs)); \
 381         _ipw_read8(ipw, ofs); \
 382 })
 383
 384 /* 16-bit direct read (low 4K) */
 385 static inline u16 _ipw_read16(struct ipw_priv *ipw, unsigned long ofs)
 386 {
 387         return readw(ipw->hw_base + ofs);
 388 }
 389
 390 /* alias to 16-bit direct read (low 4K of SRAM/regs), with debug wrapper */
 391 #define ipw_read16(ipw, ofs) ({ \
 392         IPW_DEBUG_IO("%s %d: read_direct16(0x%08X)\n", __FILE__, __LINE__, \
 393                         (u32)(ofs)); \
 394         _ipw_read16(ipw, ofs); \
 395 })
 396
 397 /* 32-bit direct read (low 4K) */
 398 static inline u32 _ipw_read32(struct ipw_priv *ipw, unsigned long ofs)
 399 {
 400         return readl(ipw->hw_base + ofs);
 401 }
 402
 403 /* alias to 32-bit direct read (low 4K of SRAM/regs), with debug wrapper */
 404 #define ipw_read32(ipw, ofs) ({ \
 405         IPW_DEBUG_IO("%s %d: read_direct32(0x%08X)\n", __FILE__, __LINE__, \
 406                         (u32)(ofs)); \
 407         _ipw_read32(ipw, ofs); \
 408 })
 409
 410 static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
 411 /* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
 412 #define ipw_read_indirect(a, b, c, d) ({ \
 413         IPW_DEBUG_IO("%s %d: read_indirect(0x%08X) %u bytes\n", __FILE__, \
 414                         __LINE__, (u32)(b), (u32)(d)); \
 415         _ipw_read_indirect(a, b, c, d); \
 416 })
 417
 418 /* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
 419 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
 420                                 int num);
 421 #define ipw_write_indirect(a, b, c, d) do { \
 422         IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %u bytes\n", __FILE__, \
 423                         __LINE__, (u32)(b), (u32)(d)); \
 424         _ipw_write_indirect(a, b, c, d); \
 425 } while (0)
 426
 427 /* 32-bit indirect write (above 4K) */
 428 static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value)
 429 {
 430         IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value);
 431         _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
 432         _ipw_write32(priv, IPW_INDIRECT_DATA, value);
 433 }
 434
 435 /* 8-bit indirect write (above 4K) */
 436 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value)
 437 {
 438         u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK;        /* dword align */
 439         u32 dif_len = reg - aligned_addr;
 440
 441         IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
 442         _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
 443         _ipw_write8(priv, IPW_INDIRECT_DATA + dif_len, value);
 444 }
 445
 446 /* 16-bit indirect write (above 4K) */
 447 static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
 448 {
 449         u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK;        /* dword align */
 450         u32 dif_len = (reg - aligned_addr) & (~0x1ul);
 451
 452         IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
 453         _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
 454         _ipw_write16(priv, IPW_INDIRECT_DATA + dif_len, value);
 455 }
 456
 457 /* 8-bit indirect read (above 4K) */
 458 static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg)
 459 {
 460         u32 word;
 461         _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
 462         IPW_DEBUG_IO(" reg = 0x%8X :\n", reg);
 463         word = _ipw_read32(priv, IPW_INDIRECT_DATA);
 464         return (word >> ((reg & 0x3) * 8)) & 0xff;
 465 }
 466
 467 /* 32-bit indirect read (above 4K) */
 468 static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
 469 {
 470         u32 value;
 471
 472         IPW_DEBUG_IO("%p : reg = 0x%08x\n", priv, reg);
 473
 474         _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
 475         value = _ipw_read32(priv, IPW_INDIRECT_DATA);
 476         IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x\n", reg, value);
 477         return value;
 478 }
 479
 480 /* General purpose, no alignment requirement, iterative (multi-byte) read, */
 481 /*    for area above 1st 4K of SRAM/reg space */
 482 static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
 483                                int num)
 484 {
 485         u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;       /* dword align */
 486         u32 dif_len = addr - aligned_addr;
 487         u32 i;
 488
 489         IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
 490
 491         if (num <= 0) {
 492                 return;
 493         }
 494
 495         /* Read the first dword (or portion) byte by byte */
 496         if (unlikely(dif_len)) {
 497                 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
 498                 /* Start reading at aligned_addr + dif_len */
 499                 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
 500                         *buf++ = _ipw_read8(priv, IPW_INDIRECT_DATA + i);
 501                 aligned_addr += 4;
 502         }
 503
 504         /* Read all of the middle dwords as dwords, with auto-increment */
 505         _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
 506         for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
 507                 *(u32 *) buf = _ipw_read32(priv, IPW_AUTOINC_DATA);
 508
 509         /* Read the last dword (or portion) byte by byte */
 510         if (unlikely(num)) {
 511                 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
 512                 for (i = 0; num > 0; i++, num--)
 513                         *buf++ = ipw_read8(priv, IPW_INDIRECT_DATA + i);
 514         }
 515 }
 516
 517 /* General purpose, no alignment requirement, iterative (multi-byte) write, */
 518 /*    for area above 1st 4K of SRAM/reg space */
 519 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
 520                                 int num)
 521 {
 522         u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;       /* dword align */
 523         u32 dif_len = addr - aligned_addr;
 524         u32 i;
 525
 526         IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
 527
 528         if (num <= 0) {
 529                 return;
 530         }
 531
 532         /* Write the first dword (or portion) byte by byte */
 533         if (unlikely(dif_len)) {
 534                 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
 535                 /* Start writing at aligned_addr + dif_len */
 536                 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--, buf++)
 537                         _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
 538                 aligned_addr += 4;
 539         }
 540
 541         /* Write all of the middle dwords as dwords, with auto-increment */
 542         _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
 543         for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
 544                 _ipw_write32(priv, IPW_AUTOINC_DATA, *(u32 *) buf);
 545
 546         /* Write the last dword (or portion) byte by byte */
 547         if (unlikely(num)) {
 548                 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
 549                 for (i = 0; num > 0; i++, num--, buf++)
 550                         _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
 551         }
 552 }
 553
 554 /* General purpose, no alignment requirement, iterative (multi-byte) write, */
 555 /*    for 1st 4K of SRAM/regs space */
 556 static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf,
 557                              int num)
 558 {
 559         memcpy_toio((priv->hw_base + addr), buf, num);
 560 }
 561
 562 /* Set bit(s) in low 4K of SRAM/regs */
 563 static inline void ipw_set_bit(struct ipw_priv *priv, u32 reg, u32 mask)
 564 {
 565         ipw_write32(priv, reg, ipw_read32(priv, reg) | mask);
 566 }
 567
 568 /* Clear bit(s) in low 4K of SRAM/regs */
 569 static inline void ipw_clear_bit(struct ipw_priv *priv, u32 reg, u32 mask)
 570 {
 571         ipw_write32(priv, reg, ipw_read32(priv, reg) & ~mask);
 572 }
 573
 574 static inline void __ipw_enable_interrupts(struct ipw_priv *priv)
 575 {
 576         if (priv->status & STATUS_INT_ENABLED)
 577                 return;
 578         priv->status |= STATUS_INT_ENABLED;
 579         ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL);
 580 }
 581
 582 static inline void __ipw_disable_interrupts(struct ipw_priv *priv)
 583 {
 584         if (!(priv->status & STATUS_INT_ENABLED))
 585                 return;
 586         priv->status &= ~STATUS_INT_ENABLED;
 587         ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
 588 }
 589
 590 static inline void ipw_enable_interrupts(struct ipw_priv *priv)
 591 {
 592         unsigned long flags;
 593
 594         spin_lock_irqsave(&priv->irq_lock, flags);
 595         __ipw_enable_interrupts(priv);
 596         spin_unlock_irqrestore(&priv->irq_lock, flags);
 597 }
 598
 599 static inline void ipw_disable_interrupts(struct ipw_priv *priv)
 600 {
 601         unsigned long flags;
 602
 603         spin_lock_irqsave(&priv->irq_lock, flags);
 604         __ipw_disable_interrupts(priv);
 605         spin_unlock_irqrestore(&priv->irq_lock, flags);
 606 }
 607
 608 static char *ipw_error_desc(u32 val)
 609 {
 610         switch (val) {
 611         case IPW_FW_ERROR_OK:
 612                 return "ERROR_OK";
 613         case IPW_FW_ERROR_FAIL:
 614                 return "ERROR_FAIL";
 615         case IPW_FW_ERROR_MEMORY_UNDERFLOW:
 616                 return "MEMORY_UNDERFLOW";
 617         case IPW_FW_ERROR_MEMORY_OVERFLOW:
 618                 return "MEMORY_OVERFLOW";
 619         case IPW_FW_ERROR_BAD_PARAM:
 620                 return "BAD_PARAM";
 621         case IPW_FW_ERROR_BAD_CHECKSUM:
 622                 return "BAD_CHECKSUM";
 623         case IPW_FW_ERROR_NMI_INTERRUPT:
 624                 return "NMI_INTERRUPT";
 625         case IPW_FW_ERROR_BAD_DATABASE:
 626                 return "BAD_DATABASE";
 627         case IPW_FW_ERROR_ALLOC_FAIL:
 628                 return "ALLOC_FAIL";
 629         case IPW_FW_ERROR_DMA_UNDERRUN:
 630                 return "DMA_UNDERRUN";
 631         case IPW_FW_ERROR_DMA_STATUS:
 632                 return "DMA_STATUS";
 633         case IPW_FW_ERROR_DINO_ERROR:
 634                 return "DINO_ERROR";
 635         case IPW_FW_ERROR_EEPROM_ERROR:
 636                 return "EEPROM_ERROR";
 637         case IPW_FW_ERROR_SYSASSERT:
 638                 return "SYSASSERT";
 639         case IPW_FW_ERROR_FATAL_ERROR:
 640                 return "FATAL_ERROR";
 641         default:
 642                 return "UNKNOWN_ERROR";
 643         }
 644 }
 645
 646 static void ipw_dump_error_log(struct ipw_priv *priv,
 647                                struct ipw_fw_error *error)
 648 {
 649         u32 i;
 650
 651         if (!error) {
 652                 IPW_ERROR("Error allocating and capturing error log.  "
 653                           "Nothing to dump.\n");
 654                 return;
 655         }
 656
 657         IPW_ERROR("Start IPW Error Log Dump:\n");
 658         IPW_ERROR("Status: 0x%08X, Config: %08X\n",
 659                   error->status, error->config);
 660
 661         for (i = 0; i < error->elem_len; i++)
 662                 IPW_ERROR("%s %i 0x%08x  0x%08x  0x%08x  0x%08x  0x%08x\n",
 663                           ipw_error_desc(error->elem[i].desc),
 664                           error->elem[i].time,
 665                           error->elem[i].blink1,
 666                           error->elem[i].blink2,
 667                           error->elem[i].link1,
 668                           error->elem[i].link2, error->elem[i].data);
 669         for (i = 0; i < error->log_len; i++)
 670                 IPW_ERROR("%i\t0x%08x\t%i\n",
 671                           error->log[i].time,
 672                           error->log[i].data, error->log[i].event);
 673 }
 674
 675 static inline int ipw_is_init(struct ipw_priv *priv)
 676 {
 677         return (priv->status & STATUS_INIT) ? 1 : 0;
 678 }
 679
 680 static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len)
 681 {
 682         u32 addr, field_info, field_len, field_count, total_len;
 683
 684         IPW_DEBUG_ORD("ordinal = %i\n", ord);
 685
 686         if (!priv || !val || !len) {
 687                 IPW_DEBUG_ORD("Invalid argument\n");
 688                 return -EINVAL;
 689         }
 690
 691         /* verify device ordinal tables have been initialized */
 692         if (!priv->table0_addr || !priv->table1_addr || !priv->table2_addr) {
 693                 IPW_DEBUG_ORD("Access ordinals before initialization\n");
 694                 return -EINVAL;
 695         }
 696
 697         switch (IPW_ORD_TABLE_ID_MASK & ord) {
 698         case IPW_ORD_TABLE_0_MASK:
 699                 /*
 700                  * TABLE 0: Direct access to a table of 32 bit values
 701                  *
 702                  * This is a very simple table with the data directly
 703                  * read from the table
 704                  */
 705
 706                 /* remove the table id from the ordinal */
 707                 ord &= IPW_ORD_TABLE_VALUE_MASK;
 708
 709                 /* boundary check */
 710                 if (ord > priv->table0_len) {
 711                         IPW_DEBUG_ORD("ordinal value (%i) longer then "
 712                                       "max (%i)\n", ord, priv->table0_len);
 713                         return -EINVAL;
 714                 }
 715
 716                 /* verify we have enough room to store the value */
 717                 if (*len < sizeof(u32)) {
 718                         IPW_DEBUG_ORD("ordinal buffer length too small, "
 719                                       "need %zd\n", sizeof(u32));
 720                         return -EINVAL;
 721                 }
 722
 723                 IPW_DEBUG_ORD("Reading TABLE0[%i] from offset 0x%08x\n",
 724                               ord, priv->table0_addr + (ord << 2));
 725
 726                 *len = sizeof(u32);
 727                 ord <<= 2;
 728                 *((u32 *) val) = ipw_read32(priv, priv->table0_addr + ord);
 729                 break;
 730
 731         case IPW_ORD_TABLE_1_MASK:
 732                 /*
 733                  * TABLE 1: Indirect access to a table of 32 bit values
 734                  *
 735                  * This is a fairly large table of u32 values each
 736                  * representing starting addr for the data (which is
 737                  * also a u32)
 738                  */
 739
 740                 /* remove the table id from the ordinal */
 741                 ord &= IPW_ORD_TABLE_VALUE_MASK;
 742
 743                 /* boundary check */
 744                 if (ord > priv->table1_len) {
 745                         IPW_DEBUG_ORD("ordinal value too long\n");
 746                         return -EINVAL;
 747                 }
 748
 749                 /* verify we have enough room to store the value */
 750                 if (*len < sizeof(u32)) {
 751                         IPW_DEBUG_ORD("ordinal buffer length too small, "
 752                                       "need %zd\n", sizeof(u32));
 753                         return -EINVAL;
 754                 }
 755
 756                 *((u32 *) val) =
 757                     ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
 758                 *len = sizeof(u32);
 759                 break;
 760
 761         case IPW_ORD_TABLE_2_MASK:
 762                 /*
 763                  * TABLE 2: Indirect access to a table of variable sized values
 764                  *
 765                  * This table consist of six values, each containing
 766                  *     - dword containing the starting offset of the data
 767                  *     - dword containing the lengh in the first 16bits
 768                  *       and the count in the second 16bits
 769                  */
 770
 771                 /* remove the table id from the ordinal */
 772                 ord &= IPW_ORD_TABLE_VALUE_MASK;
 773
 774                 /* boundary check */
 775                 if (ord > priv->table2_len) {
 776                         IPW_DEBUG_ORD("ordinal value too long\n");
 777                         return -EINVAL;
 778                 }
 779
 780                 /* get the address of statistic */
 781                 addr = ipw_read_reg32(priv, priv->table2_addr + (ord << 3));
 782
 783                 /* get the second DW of statistics ;
 784                  * two 16-bit words - first is length, second is count */
 785                 field_info =
 786                     ipw_read_reg32(priv,
 787                                    priv->table2_addr + (ord << 3) +
 788                                    sizeof(u32));
 789
 790                 /* get each entry length */
 791                 field_len = *((u16 *) & field_info);
 792
 793                 /* get number of entries */
 794                 field_count = *(((u16 *) & field_info) + 1);
 795
 796                 /* abort if not enough memory */
 797                 total_len = field_len * field_count;
 798                 if (total_len > *len) {
 799                         *len = total_len;
 800                         return -EINVAL;
 801                 }
 802
 803                 *len = total_len;
 804                 if (!total_len)
 805                         return 0;
 806
 807                 IPW_DEBUG_ORD("addr = 0x%08x, total_len = %i, "
 808                               "field_info = 0x%08x\n",
 809                               addr, total_len, field_info);
 810                 ipw_read_indirect(priv, addr, val, total_len);
 811                 break;
 812
 813         default:
 814                 IPW_DEBUG_ORD("Invalid ordinal!\n");
 815                 return -EINVAL;
 816
 817         }
 818
 819         return 0;
 820 }
 821
 822 static void ipw_init_ordinals(struct ipw_priv *priv)
 823 {
 824         priv->table0_addr = IPW_ORDINALS_TABLE_LOWER;
 825         priv->table0_len = ipw_read32(priv, priv->table0_addr);
 826
 827         IPW_DEBUG_ORD("table 0 offset at 0x%08x, len = %i\n",
 828                       priv->table0_addr, priv->table0_len);
 829
 830         priv->table1_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_1);
 831         priv->table1_len = ipw_read_reg32(priv, priv->table1_addr);
 832
 833         IPW_DEBUG_ORD("table 1 offset at 0x%08x, len = %i\n",
 834                       priv->table1_addr, priv->table1_len);
 835
 836         priv->table2_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_2);
 837         priv->table2_len = ipw_read_reg32(priv, priv->table2_addr);
 838         priv->table2_len &= 0x0000ffff; /* use first two bytes */
 839
 840         IPW_DEBUG_ORD("table 2 offset at 0x%08x, len = %i\n",
 841                       priv->table2_addr, priv->table2_len);
 842
 843 }
 844
 845 static u32 ipw_register_toggle(u32 reg)
 846 {
 847         reg &= ~IPW_START_STANDBY;
 848         if (reg & IPW_GATE_ODMA)
 849                 reg &= ~IPW_GATE_ODMA;
 850         if (reg & IPW_GATE_IDMA)
 851                 reg &= ~IPW_GATE_IDMA;
 852         if (reg & IPW_GATE_ADMA)
 853                 reg &= ~IPW_GATE_ADMA;
 854         return reg;
 855 }
 856
 857 /*
 858  * LED behavior:
 859  * - On radio ON, turn on any LEDs that require to be on during start
 860  * - On initialization, start unassociated blink
 861  * - On association, disable unassociated blink
 862  * - On disassociation, start unassociated blink
 863  * - On radio OFF, turn off any LEDs started during radio on
 864  *
 865  */
 866 #define LD_TIME_LINK_ON msecs_to_jiffies(300)
 867 #define LD_TIME_LINK_OFF msecs_to_jiffies(2700)
 868 #define LD_TIME_ACT_ON msecs_to_jiffies(250)
 869
 870 static void ipw_led_link_on(struct ipw_priv *priv)
 871 {
 872         unsigned long flags;
 873         u32 led;
 874
 875         /* If configured to not use LEDs, or nic_type is 1,
 876          * then we don't toggle a LINK led */
 877         if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
 878                 return;
 879
 880         spin_lock_irqsave(&priv->lock, flags);
 881
 882         if (!(priv->status & STATUS_RF_KILL_MASK) &&
 883             !(priv->status & STATUS_LED_LINK_ON)) {
 884                 IPW_DEBUG_LED("Link LED On\n");
 885                 led = ipw_read_reg32(priv, IPW_EVENT_REG);
 886                 led |= priv->led_association_on;
 887
 888                 led = ipw_register_toggle(led);
 889
 890                 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
 891                 ipw_write_reg32(priv, IPW_EVENT_REG, led);
 892
 893                 priv->status |= STATUS_LED_LINK_ON;
 894
 895                 /* If we aren't associated, schedule turning the LED off */
 896                 if (!(priv->status & STATUS_ASSOCIATED))
 897                         queue_delayed_work(priv->workqueue,
 898                                            &priv->led_link_off,
 899                                            LD_TIME_LINK_ON);
 900         }
 901
 902         spin_unlock_irqrestore(&priv->lock, flags);
 903 }
 904
 905 static void ipw_bg_led_link_on(struct work_struct *work)
 906 {
 907         struct ipw_priv *priv =
 908                 container_of(work, struct ipw_priv, led_link_on.work);
 909         mutex_lock(&priv->mutex);
 910         ipw_led_link_on(priv);
 911         mutex_unlock(&priv->mutex);
 912 }
 913
 914 static void ipw_led_link_off(struct ipw_priv *priv)
 915 {
 916         unsigned long flags;
 917         u32 led;
 918
 919         /* If configured not to use LEDs, or nic type is 1,
 920          * then we don't goggle the LINK led. */
 921         if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
 922                 return;
 923
 924         spin_lock_irqsave(&priv->lock, flags);
 925
 926         if (priv->status & STATUS_LED_LINK_ON) {
 927                 led = ipw_read_reg32(priv, IPW_EVENT_REG);
 928                 led &= priv->led_association_off;
 929                 led = ipw_register_toggle(led);
 930
 931                 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
 932                 ipw_write_reg32(priv, IPW_EVENT_REG, led);
 933
 934                 IPW_DEBUG_LED("Link LED Off\n");
 935
 936                 priv->status &= ~STATUS_LED_LINK_ON;
 937
 938                 /* If we aren't associated and the radio is on, schedule
 939                  * turning the LED on (blink while unassociated) */
 940                 if (!(priv->status & STATUS_RF_KILL_MASK) &&
 941                     !(priv->status & STATUS_ASSOCIATED))
 942                         queue_delayed_work(priv->workqueue, &priv->led_link_on,
 943                                            LD_TIME_LINK_OFF);
 944
 945         }
 946
 947         spin_unlock_irqrestore(&priv->lock, flags);
 948 }
 949
 950 static void ipw_bg_led_link_off(struct work_struct *work)
 951 {
 952         struct ipw_priv *priv =
 953                 container_of(work, struct ipw_priv, led_link_off.work);
 954         mutex_lock(&priv->mutex);
 955         ipw_led_link_off(priv);
 956         mutex_unlock(&priv->mutex);
 957 }
 958
 959 static void __ipw_led_activity_on(struct ipw_priv *priv)
 960 {
 961         u32 led;
 962
 963         if (priv->config & CFG_NO_LED)
 964                 return;
 965
 966         if (priv->status & STATUS_RF_KILL_MASK)
 967                 return;
 968
 969         if (!(priv->status & STATUS_LED_ACT_ON)) {
 970                 led = ipw_read_reg32(priv, IPW_EVENT_REG);
 971                 led |= priv->led_activity_on;
 972
 973                 led = ipw_register_toggle(led);
 974
 975                 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
 976                 ipw_write_reg32(priv, IPW_EVENT_REG, led);
 977
 978                 IPW_DEBUG_LED("Activity LED On\n");
 979
 980                 priv->status |= STATUS_LED_ACT_ON;
 981
 982                 cancel_delayed_work(&priv->led_act_off);
 983                 queue_delayed_work(priv->workqueue, &priv->led_act_off,
 984                                    LD_TIME_ACT_ON);
 985         } else {
 986                 /* Reschedule LED off for full time period */
 987                 cancel_delayed_work(&priv->led_act_off);
 988                 queue_delayed_work(priv->workqueue, &priv->led_act_off,
 989                                    LD_TIME_ACT_ON);
 990         }
 991 }
 992
 993 #if 0
 994 void ipw_led_activity_on(struct ipw_priv *priv)
 995 {
 996         unsigned long flags;
 997         spin_lock_irqsave(&priv->lock, flags);
 998         __ipw_led_activity_on(priv);
 999         spin_unlock_irqrestore(&priv->lock, flags);
1000 }
1001 #endif  /*  0  */
1002
1003 static void ipw_led_activity_off(struct ipw_priv *priv)
1004 {
1005         unsigned long flags;
1006         u32 led;
1007
1008         if (priv->config & CFG_NO_LED)
1009                 return;
1010
1011         spin_lock_irqsave(&priv->lock, flags);
1012
1013         if (priv->status & STATUS_LED_ACT_ON) {
1014                 led = ipw_read_reg32(priv, IPW_EVENT_REG);
1015                 led &= priv->led_activity_off;
1016
1017                 led = ipw_register_toggle(led);
1018
1019                 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
1020                 ipw_write_reg32(priv, IPW_EVENT_REG, led);
1021
1022                 IPW_DEBUG_LED("Activity LED Off\n");
1023
1024                 priv->status &= ~STATUS_LED_ACT_ON;
1025         }
1026
1027         spin_unlock_irqrestore(&priv->lock, flags);
1028 }
1029
1030 static void ipw_bg_led_activity_off(struct work_struct *work)
1031 {
1032         struct ipw_priv *priv =
1033                 container_of(work, struct ipw_priv, led_act_off.work);
1034         mutex_lock(&priv->mutex);
1035         ipw_led_activity_off(priv);
1036         mutex_unlock(&priv->mutex);
1037 }
1038
1039 static void ipw_led_band_on(struct ipw_priv *priv)
1040 {
1041         unsigned long flags;
1042         u32 led;
1043
1044         /* Only nic type 1 supports mode LEDs */
1045         if (priv->config & CFG_NO_LED ||
1046             priv->nic_type != EEPROM_NIC_TYPE_1 || !priv->assoc_network)
1047                 return;
1048
1049         spin_lock_irqsave(&priv->lock, flags);
1050
1051         led = ipw_read_reg32(priv, IPW_EVENT_REG);
1052         if (priv->assoc_network->mode == IEEE_A) {
1053                 led |= priv->led_ofdm_on;
1054                 led &= priv->led_association_off;
1055                 IPW_DEBUG_LED("Mode LED On: 802.11a\n");
1056         } else if (priv->assoc_network->mode == IEEE_G) {
1057                 led |= priv->led_ofdm_on;
1058                 led |= priv->led_association_on;
1059                 IPW_DEBUG_LED("Mode LED On: 802.11g\n");
1060         } else {
1061                 led &= priv->led_ofdm_off;
1062                 led |= priv->led_association_on;
1063                 IPW_DEBUG_LED("Mode LED On: 802.11b\n");
1064         }
1065
1066         led = ipw_register_toggle(led);
1067
1068         IPW_DEBUG_LED("Reg: 0x%08X\n", led);
1069         ipw_write_reg32(priv, IPW_EVENT_REG, led);
1070
1071         spin_unlock_irqrestore(&priv->lock, flags);
1072 }
1073
1074 static void ipw_led_band_off(struct ipw_priv *priv)
1075 {
1076         unsigned long flags;
1077         u32 led;
1078
1079         /* Only nic type 1 supports mode LEDs */
1080         if (priv->config & CFG_NO_LED || priv->nic_type != EEPROM_NIC_TYPE_1)
1081                 return;
1082
1083         spin_lock_irqsave(&priv->lock, flags);
1084
1085         led = ipw_read_reg32(priv, IPW_EVENT_REG);
1086         led &= priv->led_ofdm_off;
1087         led &= priv->led_association_off;
1088
1089         led = ipw_register_toggle(led);
1090
1091         IPW_DEBUG_LED("Reg: 0x%08X\n", led);
1092         ipw_write_reg32(priv, IPW_EVENT_REG, led);
1093
1094         spin_unlock_irqrestore(&priv->lock, flags);
1095 }
1096
1097 static void ipw_led_radio_on(struct ipw_priv *priv)
1098 {
1099         ipw_led_link_on(priv);
1100 }
1101
1102 static void ipw_led_radio_off(struct ipw_priv *priv)
1103 {
1104         ipw_led_activity_off(priv);
1105         ipw_led_link_off(priv);
1106 }
1107
1108 static void ipw_led_link_up(struct ipw_priv *priv)
1109 {
1110         /* Set the Link Led on for all nic types */
1111         ipw_led_link_on(priv);
1112 }
1113
1114 static void ipw_led_link_down(struct ipw_priv *priv)
1115 {
1116         ipw_led_activity_off(priv);
1117         ipw_led_link_off(priv);
1118
1119         if (priv->status & STATUS_RF_KILL_MASK)
1120                 ipw_led_radio_off(priv);
1121 }
1122
1123 static void ipw_led_init(struct ipw_priv *priv)
1124 {
1125         priv->nic_type = priv->eeprom[EEPROM_NIC_TYPE];
1126
1127         /* Set the default PINs for the link and activity leds */
1128         priv->led_activity_on = IPW_ACTIVITY_LED;
1129         priv->led_activity_off = ~(IPW_ACTIVITY_LED);
1130
1131         priv->led_association_on = IPW_ASSOCIATED_LED;
1132         priv->led_association_off = ~(IPW_ASSOCIATED_LED);
1133
1134         /* Set the default PINs for the OFDM leds */
1135         priv->led_ofdm_on = IPW_OFDM_LED;
1136         priv->led_ofdm_off = ~(IPW_OFDM_LED);
1137
1138         switch (priv->nic_type) {
1139         case EEPROM_NIC_TYPE_1:
1140                 /* In this NIC type, the LEDs are reversed.... */
1141                 priv->led_activity_on = IPW_ASSOCIATED_LED;
1142                 priv->led_activity_off = ~(IPW_ASSOCIATED_LED);
1143                 priv->led_association_on = IPW_ACTIVITY_LED;
1144                 priv->led_association_off = ~(IPW_ACTIVITY_LED);
1145
1146                 if (!(priv->config & CFG_NO_LED))
1147                         ipw_led_band_on(priv);
1148
1149                 /* And we don't blink link LEDs for this nic, so
1150                  * just return here */
1151                 return;
1152
1153         case EEPROM_NIC_TYPE_3:
1154         case EEPROM_NIC_TYPE_2:
1155         case EEPROM_NIC_TYPE_4:
1156         case EEPROM_NIC_TYPE_0:
1157                 break;
1158
1159         default:
1160                 IPW_DEBUG_INFO("Unknown NIC type from EEPROM: %d\n",
1161                                priv->nic_type);
1162                 priv->nic_type = EEPROM_NIC_TYPE_0;
1163                 break;
1164         }
1165
1166         if (!(priv->config & CFG_NO_LED)) {
1167                 if (priv->status & STATUS_ASSOCIATED)
1168                         ipw_led_link_on(priv);
1169                 else
1170                         ipw_led_link_off(priv);
1171         }
1172 }
1173
1174 static void ipw_led_shutdown(struct ipw_priv *priv)
1175 {
1176         ipw_led_activity_off(priv);
1177         ipw_led_link_off(priv);
1178         ipw_led_band_off(priv);
1179         cancel_delayed_work(&priv->led_link_on);
1180         cancel_delayed_work(&priv->led_link_off);
1181         cancel_delayed_work(&priv->led_act_off);
1182 }
1183
1184 /*
1185  * The following adds a new attribute to the sysfs representation
1186  * of this device driver (i.e. a new file in /sys/bus/pci/drivers/ipw/)
1187  * used for controling the debug level.
1188  *
1189  * See the level definitions in ipw for details.
1190  */
1191 static ssize_t show_debug_level(struct device_driver *d, char *buf)
1192 {
1193         return sprintf(buf, "0x%08X\n", ipw_debug_level);
1194 }
1195
1196 static ssize_t store_debug_level(struct device_driver *d, const char *buf,
1197                                  size_t count)
1198 {
1199         char *p = (char *)buf;
1200         u32 val;
1201
1202         if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1203                 p++;
1204                 if (p[0] == 'x' || p[0] == 'X')
1205                         p++;
1206                 val = simple_strtoul(p, &p, 16);
1207         } else
1208                 val = simple_strtoul(p, &p, 10);
1209         if (p == buf)
1210                 printk(KERN_INFO DRV_NAME
1211                        ": %s is not in hex or decimal form.\n", buf);
1212         else
1213                 ipw_debug_level = val;
1214
1215         return strnlen(buf, count);
1216 }
1217
1218 static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
1219                    show_debug_level, store_debug_level);
1220
1221 static inline u32 ipw_get_event_log_len(struct ipw_priv *priv)
1222 {
1223         /* length = 1st dword in log */
1224         return ipw_read_reg32(priv, ipw_read32(priv, IPW_EVENT_LOG));
1225 }
1226
1227 static void ipw_capture_event_log(struct ipw_priv *priv,
1228                                   u32 log_len, struct ipw_event *log)
1229 {
1230         u32 base;
1231
1232         if (log_len) {
1233                 base = ipw_read32(priv, IPW_EVENT_LOG);
1234                 ipw_read_indirect(priv, base + sizeof(base) + sizeof(u32),
1235                                   (u8 *) log, sizeof(*log) * log_len);
1236         }
1237 }
1238
1239 static struct ipw_fw_error *ipw_alloc_error_log(struct ipw_priv *priv)
1240 {
1241         struct ipw_fw_error *error;
1242         u32 log_len = ipw_get_event_log_len(priv);
1243         u32 base = ipw_read32(priv, IPW_ERROR_LOG);
1244         u32 elem_len = ipw_read_reg32(priv, base);
1245
1246         error = kmalloc(sizeof(*error) +
1247                         sizeof(*error->elem) * elem_len +
1248                         sizeof(*error->log) * log_len, GFP_ATOMIC);
1249         if (!error) {
1250                 IPW_ERROR("Memory allocation for firmware error log "
1251                           "failed.\n");
1252                 return NULL;
1253         }
1254         error->jiffies = jiffies;
1255         error->status = priv->status;
1256         error->config = priv->config;
1257         error->elem_len = elem_len;
1258         error->log_len = log_len;
1259         error->elem = (struct ipw_error_elem *)error->payload;
1260         error->log = (struct ipw_event *)(error->elem + elem_len);
1261
1262         ipw_capture_event_log(priv, log_len, error->log);
1263
1264         if (elem_len)
1265                 ipw_read_indirect(priv, base + sizeof(base), (u8 *) error->elem,
1266                                   sizeof(*error->elem) * elem_len);
1267
1268         return error;
1269 }
1270
1271 static ssize_t show_event_log(struct device *d,
1272                               struct device_attribute *attr, char *buf)
1273 {
1274         struct ipw_priv *priv = dev_get_drvdata(d);
1275         u32 log_len = ipw_get_event_log_len(priv);
1276         u32 log_size;
1277         struct ipw_event *log;
1278         u32 len = 0, i;
1279
1280         /* not using min() because of its strict type checking */
1281         log_size = PAGE_SIZE / sizeof(*log) > log_len ?
1282                         sizeof(*log) * log_len : PAGE_SIZE;
1283         log = kzalloc(log_size, GFP_KERNEL);
1284         if (!log) {
1285                 IPW_ERROR("Unable to allocate memory for log\n");
1286                 return 0;
1287         }
1288         log_len = log_size / sizeof(*log);
1289         ipw_capture_event_log(priv, log_len, log);
1290
1291         len += snprintf(buf + len, PAGE_SIZE - len, "%08X", log_len);
1292         for (i = 0; i < log_len; i++)
1293                 len += snprintf(buf + len, PAGE_SIZE - len,
1294                                 "\n%08X%08X%08X",
1295                                 log[i].time, log[i].event, log[i].data);
1296         len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1297         kfree(log);
1298         return len;
1299 }
1300
1301 static DEVICE_ATTR(event_log, S_IRUGO, show_event_log, NULL);
1302
1303 static ssize_t show_error(struct device *d,
1304                           struct device_attribute *attr, char *buf)
1305 {
1306         struct ipw_priv *priv = dev_get_drvdata(d);
1307         u32 len = 0, i;
1308         if (!priv->error)
1309                 return 0;
1310         len += snprintf(buf + len, PAGE_SIZE - len,
1311                         "%08lX%08X%08X%08X",
1312                         priv->error->jiffies,
1313                         priv->error->status,
1314                         priv->error->config, priv->error->elem_len);
1315         for (i = 0; i < priv->error->elem_len; i++)
1316                 len += snprintf(buf + len, PAGE_SIZE - len,
1317                                 "\n%08X%08X%08X%08X%08X%08X%08X",
1318                                 priv->error->elem[i].time,
1319                                 priv->error->elem[i].desc,
1320                                 priv->error->elem[i].blink1,
1321                                 priv->error->elem[i].blink2,
1322                                 priv->error->elem[i].link1,
1323                                 priv->error->elem[i].link2,
1324                                 priv->error->elem[i].data);
1325
1326         len += snprintf(buf + len, PAGE_SIZE - len,
1327                         "\n%08X", priv->error->log_len);
1328         for (i = 0; i < priv->error->log_len; i++)
1329                 len += snprintf(buf + len, PAGE_SIZE - len,
1330                                 "\n%08X%08X%08X",
1331                                 priv->error->log[i].time,
1332                                 priv->error->log[i].event,
1333                                 priv->error->log[i].data);
1334         len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1335         return len;
1336 }
1337
1338 static ssize_t clear_error(struct device *d,
1339                            struct device_attribute *attr,
1340                            const char *buf, size_t count)
1341 {
1342         struct ipw_priv *priv = dev_get_drvdata(d);
1343
1344         kfree(priv->error);
1345         priv->error = NULL;
1346         return count;
1347 }
1348
1349 static DEVICE_ATTR(error, S_IRUGO | S_IWUSR, show_error, clear_error);
1350
1351 static ssize_t show_cmd_log(struct device *d,
1352                             struct device_attribute *attr, char *buf)
1353 {
1354         struct ipw_priv *priv = dev_get_drvdata(d);
1355         u32 len = 0, i;
1356         if (!priv->cmdlog)
1357                 return 0;
1358         for (i = (priv->cmdlog_pos + 1) % priv->cmdlog_len;
1359              (i != priv->cmdlog_pos) && (PAGE_SIZE - len);
1360              i = (i + 1) % priv->cmdlog_len) {
1361                 len +=
1362                     snprintf(buf + len, PAGE_SIZE - len,
1363                              "\n%08lX%08X%08X%08X\n", priv->cmdlog[i].jiffies,
1364                              priv->cmdlog[i].retcode, priv->cmdlog[i].cmd.cmd,
1365                              priv->cmdlog[i].cmd.len);
1366                 len +=
1367                     snprintk_buf(buf + len, PAGE_SIZE - len,
1368                                  (u8 *) priv->cmdlog[i].cmd.param,
1369                                  priv->cmdlog[i].cmd.len);
1370                 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1371         }
1372         len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1373         return len;
1374 }
1375
1376 static DEVICE_ATTR(cmd_log, S_IRUGO, show_cmd_log, NULL);
1377
1378 #ifdef CONFIG_IPW2200_PROMISCUOUS
1379 static void ipw_prom_free(struct ipw_priv *priv);
1380 static int ipw_prom_alloc(struct ipw_priv *priv);
1381 static ssize_t store_rtap_iface(struct device *d,
1382                          struct device_attribute *attr,
1383                          const char *buf, size_t count)
1384 {
1385         struct ipw_priv *priv = dev_get_drvdata(d);
1386         int rc = 0;
1387
1388         if (count < 1)
1389                 return -EINVAL;
1390
1391         switch (buf[0]) {
1392         case '0':
1393                 if (!rtap_iface)
1394                         return count;
1395
1396                 if (netif_running(priv->prom_net_dev)) {
1397                         IPW_WARNING("Interface is up.  Cannot unregister.\n");
1398                         return count;
1399                 }
1400
1401                 ipw_prom_free(priv);
1402                 rtap_iface = 0;
1403                 break;
1404
1405         case '1':
1406                 if (rtap_iface)
1407                         return count;
1408
1409                 rc = ipw_prom_alloc(priv);
1410                 if (!rc)
1411                         rtap_iface = 1;
1412                 break;
1413
1414         default:
1415                 return -EINVAL;
1416         }
1417
1418         if (rc) {
1419                 IPW_ERROR("Failed to register promiscuous network "
1420                           "device (error %d).\n", rc);
1421         }
1422
1423         return count;
1424 }
1425
1426 static ssize_t show_rtap_iface(struct device *d,
1427                         struct device_attribute *attr,
1428                         char *buf)
1429 {
1430         struct ipw_priv *priv = dev_get_drvdata(d);
1431         if (rtap_iface)
1432                 return sprintf(buf, "%s", priv->prom_net_dev->name);
1433         else {
1434                 buf[0] = '-';
1435                 buf[1] = '1';
1436                 buf[2] = '\0';
1437                 return 3;
1438         }
1439 }
1440
1441 static DEVICE_ATTR(rtap_iface, S_IWUSR | S_IRUSR, show_rtap_iface,
1442                    store_rtap_iface);
1443
1444 static ssize_t store_rtap_filter(struct device *d,
1445                          struct device_attribute *attr,
1446                          const char *buf, size_t count)
1447 {
1448         struct ipw_priv *priv = dev_get_drvdata(d);
1449
1450         if (!priv->prom_priv) {
1451                 IPW_ERROR("Attempting to set filter without "
1452                           "rtap_iface enabled.\n");
1453                 return -EPERM;
1454         }
1455
1456         priv->prom_priv->filter = simple_strtol(buf, NULL, 0);
1457
1458         IPW_DEBUG_INFO("Setting rtap filter to " BIT_FMT16 "\n",
1459                        BIT_ARG16(priv->prom_priv->filter));
1460
1461         return count;
1462 }
1463
1464 static ssize_t show_rtap_filter(struct device *d,
1465                         struct device_attribute *attr,
1466                         char *buf)
1467 {
1468         struct ipw_priv *priv = dev_get_drvdata(d);
1469         return sprintf(buf, "0x%04X",
1470                        priv->prom_priv ? priv->prom_priv->filter : 0);
1471 }
1472
1473 static DEVICE_ATTR(rtap_filter, S_IWUSR | S_IRUSR, show_rtap_filter,
1474                    store_rtap_filter);
1475 #endif
1476
1477 static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
1478                              char *buf)
1479 {
1480         struct ipw_priv *priv = dev_get_drvdata(d);
1481         return sprintf(buf, "%d\n", priv->ieee->scan_age);
1482 }
1483
1484 static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
1485                               const char *buf, size_t count)
1486 {
1487         struct ipw_priv *priv = dev_get_drvdata(d);
1488         struct net_device *dev = priv->net_dev;
1489         char buffer[] = "00000000";
1490         unsigned long len =
1491             (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
1492         unsigned long val;
1493         char *p = buffer;
1494
1495         IPW_DEBUG_INFO("enter\n");
1496
1497         strncpy(buffer, buf, len);
1498         buffer[len] = 0;
1499
1500         if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1501                 p++;
1502                 if (p[0] == 'x' || p[0] == 'X')
1503                         p++;
1504                 val = simple_strtoul(p, &p, 16);
1505         } else
1506                 val = simple_strtoul(p, &p, 10);
1507         if (p == buffer) {
1508                 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
1509         } else {
1510                 priv->ieee->scan_age = val;
1511                 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
1512         }
1513
1514         IPW_DEBUG_INFO("exit\n");
1515         return len;
1516 }
1517
1518 static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
1519
1520 static ssize_t show_led(struct device *d, struct device_attribute *attr,
1521                         char *buf)
1522 {
1523         struct ipw_priv *priv = dev_get_drvdata(d);
1524         return sprintf(buf, "%d\n", (priv->config & CFG_NO_LED) ? 0 : 1);
1525 }
1526
1527 static ssize_t store_led(struct device *d, struct device_attribute *attr,
1528                          const char *buf, size_t count)
1529 {
1530         struct ipw_priv *priv = dev_get_drvdata(d);
1531
1532         IPW_DEBUG_INFO("enter\n");
1533
1534         if (count == 0)
1535                 return 0;
1536
1537         if (*buf == 0) {
1538                 IPW_DEBUG_LED("Disabling LED control.\n");
1539                 priv->config |= CFG_NO_LED;
1540                 ipw_led_shutdown(priv);
1541         } else {
1542                 IPW_DEBUG_LED("Enabling LED control.\n");
1543                 priv->config &= ~CFG_NO_LED;
1544                 ipw_led_init(priv);
1545         }
1546
1547         IPW_DEBUG_INFO("exit\n");
1548         return count;
1549 }
1550
1551 static DEVICE_ATTR(led, S_IWUSR | S_IRUGO, show_led, store_led);
1552
1553 static ssize_t show_status(struct device *d,
1554                            struct device_attribute *attr, char *buf)
1555 {
1556         struct ipw_priv *p = dev_get_drvdata(d);
1557         return sprintf(buf, "0x%08x\n", (int)p->status);
1558 }
1559
1560 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
1561
1562 static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
1563                         char *buf)
1564 {
1565         struct ipw_priv *p = dev_get_drvdata(d);
1566         return sprintf(buf, "0x%08x\n", (int)p->config);
1567 }
1568
1569 static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
1570
1571 static ssize_t show_nic_type(struct device *d,
1572                              struct device_attribute *attr, char *buf)
1573 {
1574         struct ipw_priv *priv = dev_get_drvdata(d);
1575         return sprintf(buf, "TYPE: %d\n", priv->nic_type);
1576 }
1577
1578 static DEVICE_ATTR(nic_type, S_IRUGO, show_nic_type, NULL);
1579
1580 static ssize_t show_ucode_version(struct device *d,
1581                                   struct device_attribute *attr, char *buf)
1582 {
1583         u32 len = sizeof(u32), tmp = 0;
1584         struct ipw_priv *p = dev_get_drvdata(d);
1585
1586         if (ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
1587                 return 0;
1588
1589         return sprintf(buf, "0x%08x\n", tmp);
1590 }
1591
1592 static DEVICE_ATTR(ucode_version, S_IWUSR | S_IRUGO, show_ucode_version, NULL);
1593
1594 static ssize_t show_rtc(struct device *d, struct device_attribute *attr,
1595                         char *buf)
1596 {
1597         u32 len = sizeof(u32), tmp = 0;
1598         struct ipw_priv *p = dev_get_drvdata(d);
1599
1600         if (ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
1601                 return 0;
1602
1603         return sprintf(buf, "0x%08x\n", tmp);
1604 }
1605
1606 static DEVICE_ATTR(rtc, S_IWUSR | S_IRUGO, show_rtc, NULL);
1607
1608 /*
1609  * Add a device attribute to view/control the delay between eeprom
1610  * operations.
1611  */
1612 static ssize_t show_eeprom_delay(struct device *d,
1613                                  struct device_attribute *attr, char *buf)
1614 {
1615         struct ipw_priv *p = dev_get_drvdata(d);
1616         int n = p->eeprom_delay;
1617         return sprintf(buf, "%i\n", n);
1618 }
1619 static ssize_t store_eeprom_delay(struct device *d,
1620                                   struct device_attribute *attr,
1621                                   const char *buf, size_t count)
1622 {
1623         struct ipw_priv *p = dev_get_drvdata(d);
1624         sscanf(buf, "%i", &p->eeprom_delay);
1625         return strnlen(buf, count);
1626 }
1627
1628 static DEVICE_ATTR(eeprom_delay, S_IWUSR | S_IRUGO,
1629                    show_eeprom_delay, store_eeprom_delay);
1630
1631 static ssize_t show_command_event_reg(struct device *d,
1632                                       struct device_attribute *attr, char *buf)
1633 {
1634         u32 reg = 0;
1635         struct ipw_priv *p = dev_get_drvdata(d);
1636
1637         reg = ipw_read_reg32(p, IPW_INTERNAL_CMD_EVENT);
1638         return sprintf(buf, "0x%08x\n", reg);
1639 }
1640 static ssize_t store_command_event_reg(struct device *d,
1641                                        struct device_attribute *attr,
1642                                        const char *buf, size_t count)
1643 {
1644         u32 reg;
1645         struct ipw_priv *p = dev_get_drvdata(d);
1646
1647         sscanf(buf, "%x", &reg);
1648         ipw_write_reg32(p, IPW_INTERNAL_CMD_EVENT, reg);
1649         return strnlen(buf, count);
1650 }
1651
1652 static DEVICE_ATTR(command_event_reg, S_IWUSR | S_IRUGO,
1653                    show_command_event_reg, store_command_event_reg);
1654
1655 static ssize_t show_mem_gpio_reg(struct device *d,
1656                                  struct device_attribute *attr, char *buf)
1657 {
1658         u32 reg = 0;
1659         struct ipw_priv *p = dev_get_drvdata(d);
1660
1661         reg = ipw_read_reg32(p, 0x301100);
1662         return sprintf(buf, "0x%08x\n", reg);
1663 }
1664 static ssize_t store_mem_gpio_reg(struct device *d,
1665                                   struct device_attribute *attr,
1666                                   const char *buf, size_t count)
1667 {
1668         u32 reg;
1669         struct ipw_priv *p = dev_get_drvdata(d);
1670
1671         sscanf(buf, "%x", &reg);
1672         ipw_write_reg32(p, 0x301100, reg);
1673         return strnlen(buf, count);
1674 }
1675
1676 static DEVICE_ATTR(mem_gpio_reg, S_IWUSR | S_IRUGO,
1677                    show_mem_gpio_reg, store_mem_gpio_reg);
1678
1679 static ssize_t show_indirect_dword(struct device *d,
1680                                    struct device_attribute *attr, char *buf)
1681 {
1682         u32 reg = 0;
1683         struct ipw_priv *priv = dev_get_drvdata(d);
1684
1685         if (priv->status & STATUS_INDIRECT_DWORD)
1686                 reg = ipw_read_reg32(priv, priv->indirect_dword);
1687         else
1688                 reg = 0;
1689
1690         return sprintf(buf, "0x%08x\n", reg);
1691 }
1692 static ssize_t store_indirect_dword(struct device *d,
1693                                     struct device_attribute *attr,
1694                                     const char *buf, size_t count)
1695 {
1696         struct ipw_priv *priv = dev_get_drvdata(d);
1697
1698         sscanf(buf, "%x", &priv->indirect_dword);
1699         priv->status |= STATUS_INDIRECT_DWORD;
1700         return strnlen(buf, count);
1701 }
1702
1703 static DEVICE_ATTR(indirect_dword, S_IWUSR | S_IRUGO,
1704                    show_indirect_dword, store_indirect_dword);
1705
1706 static ssize_t show_indirect_byte(struct device *d,
1707                                   struct device_attribute *attr, char *buf)
1708 {
1709         u8 reg = 0;
1710         struct ipw_priv *priv = dev_get_drvdata(d);
1711
1712         if (priv->status & STATUS_INDIRECT_BYTE)
1713                 reg = ipw_read_reg8(priv, priv->indirect_byte);
1714         else
1715                 reg = 0;
1716
1717         return sprintf(buf, "0x%02x\n", reg);
1718 }
1719 static ssize_t store_indirect_byte(struct device *d,
1720                                    struct device_attribute *attr,
1721                                    const char *buf, size_t count)
1722 {
1723         struct ipw_priv *priv = dev_get_drvdata(d);
1724
1725         sscanf(buf, "%x", &priv->indirect_byte);
1726         priv->status |= STATUS_INDIRECT_BYTE;
1727         return strnlen(buf, count);
1728 }
1729
1730 static DEVICE_ATTR(indirect_byte, S_IWUSR | S_IRUGO,
1731                    show_indirect_byte, store_indirect_byte);
1732
1733 static ssize_t show_direct_dword(struct device *d,
1734                                  struct device_attribute *attr, char *buf)
1735 {
1736         u32 reg = 0;
1737         struct ipw_priv *priv = dev_get_drvdata(d);
1738
1739         if (priv->status & STATUS_DIRECT_DWORD)
1740                 reg = ipw_read32(priv, priv->direct_dword);
1741         else
1742                 reg = 0;
1743
1744         return sprintf(buf, "0x%08x\n", reg);
1745 }
1746 static ssize_t store_direct_dword(struct device *d,
1747                                   struct device_attribute *attr,
1748                                   const char *buf, size_t count)
1749 {
1750         struct ipw_priv *priv = dev_get_drvdata(d);
1751
1752         sscanf(buf, "%x", &priv->direct_dword);
1753         priv->status |= STATUS_DIRECT_DWORD;
1754         return strnlen(buf, count);
1755 }
1756
1757 static DEVICE_ATTR(direct_dword, S_IWUSR | S_IRUGO,
1758                    show_direct_dword, store_direct_dword);
1759
1760 static int rf_kill_active(struct ipw_priv *priv)
1761 {
1762         if (0 == (ipw_read32(priv, 0x30) & 0x10000)) {
1763                 priv->status |= STATUS_RF_KILL_HW;
1764                 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
1765         } else {
1766                 priv->status &= ~STATUS_RF_KILL_HW;
1767                 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false);
1768         }
1769
1770         return (priv->status & STATUS_RF_KILL_HW) ? 1 : 0;
1771 }
1772
1773 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
1774                             char *buf)
1775 {
1776         /* 0 - RF kill not enabled
1777            1 - SW based RF kill active (sysfs)
1778            2 - HW based RF kill active
1779            3 - Both HW and SW baed RF kill active */
1780         struct ipw_priv *priv = dev_get_drvdata(d);
1781         int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
1782             (rf_kill_active(priv) ? 0x2 : 0x0);
1783         return sprintf(buf, "%i\n", val);
1784 }
1785
1786 static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
1787 {
1788         if ((disable_radio ? 1 : 0) ==
1789             ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
1790                 return 0;
1791
1792         IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO  %s\n",
1793                           disable_radio ? "OFF" : "ON");
1794
1795         if (disable_radio) {
1796                 priv->status |= STATUS_RF_KILL_SW;
1797
1798                 if (priv->workqueue) {
1799                         cancel_delayed_work(&priv->request_scan);
1800                         cancel_delayed_work(&priv->request_direct_scan);
1801                         cancel_delayed_work(&priv->request_passive_scan);
1802                         cancel_delayed_work(&priv->scan_event);
1803                 }
1804                 queue_work(priv->workqueue, &priv->down);
1805         } else {
1806                 priv->status &= ~STATUS_RF_KILL_SW;
1807                 if (rf_kill_active(priv)) {
1808                         IPW_DEBUG_RF_KILL("Can not turn radio back on - "
1809                                           "disabled by HW switch\n");
1810                         /* Make sure the RF_KILL check timer is running */
1811                         cancel_delayed_work(&priv->rf_kill);
1812                         queue_delayed_work(priv->workqueue, &priv->rf_kill,
1813                                            round_jiffies_relative(2 * HZ));
1814                 } else
1815                         queue_work(priv->workqueue, &priv->up);
1816         }
1817
1818         return 1;
1819 }
1820
1821 static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
1822                              const char *buf, size_t count)
1823 {
1824         struct ipw_priv *priv = dev_get_drvdata(d);
1825
1826         ipw_radio_kill_sw(priv, buf[0] == '1');
1827
1828         return count;
1829 }
1830
1831 static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
1832
1833 static ssize_t show_speed_scan(struct device *d, struct device_attribute *attr,
1834                                char *buf)
1835 {
1836         struct ipw_priv *priv = dev_get_drvdata(d);
1837         int pos = 0, len = 0;
1838         if (priv->config & CFG_SPEED_SCAN) {
1839                 while (priv->speed_scan[pos] != 0)
1840                         len += sprintf(&buf[len], "%d ",
1841                                        priv->speed_scan[pos++]);
1842                 return len + sprintf(&buf[len], "\n");
1843         }
1844
1845         return sprintf(buf, "0\n");
1846 }
1847
1848 static ssize_t store_speed_scan(struct device *d, struct device_attribute *attr,
1849                                 const char *buf, size_t count)
1850 {
1851         struct ipw_priv *priv = dev_get_drvdata(d);
1852         int channel, pos = 0;
1853         const char *p = buf;
1854
1855         /* list of space separated channels to scan, optionally ending with 0 */
1856         while ((channel = simple_strtol(p, NULL, 0))) {
1857                 if (pos == MAX_SPEED_SCAN - 1) {
1858                         priv->speed_scan[pos] = 0;
1859                         break;
1860                 }
1861
1862                 if (libipw_is_valid_channel(priv->ieee, channel))
1863                         priv->speed_scan[pos++] = channel;
1864                 else
1865                         IPW_WARNING("Skipping invalid channel request: %d\n",
1866                                     channel);
1867                 p = strchr(p, ' ');
1868                 if (!p)
1869                         break;
1870                 while (*p == ' ' || *p == '\t')
1871                         p++;
1872         }
1873
1874         if (pos == 0)
1875                 priv->config &= ~CFG_SPEED_SCAN;
1876         else {
1877                 priv->speed_scan_pos = 0;
1878                 priv->config |= CFG_SPEED_SCAN;
1879         }
1880
1881         return count;
1882 }
1883
1884 static DEVICE_ATTR(speed_scan, S_IWUSR | S_IRUGO, show_speed_scan,
1885                    store_speed_scan);
1886
1887 static ssize_t show_net_stats(struct device *d, struct device_attribute *attr,
1888                               char *buf)
1889 {
1890         struct ipw_priv *priv = dev_get_drvdata(d);
1891         return sprintf(buf, "%c\n", (priv->config & CFG_NET_STATS) ? '1' : '0');
1892 }
1893
1894 static ssize_t store_net_stats(struct device *d, struct device_attribute *attr,
1895                                const char *buf, size_t count)
1896 {
1897         struct ipw_priv *priv = dev_get_drvdata(d);
1898         if (buf[0] == '1')
1899                 priv->config |= CFG_NET_STATS;
1900         else
1901                 priv->config &= ~CFG_NET_STATS;
1902
1903         return count;
1904 }
1905
1906 static DEVICE_ATTR(net_stats, S_IWUSR | S_IRUGO,
1907                    show_net_stats, store_net_stats);
1908
1909 static ssize_t show_channels(struct device *d,
1910                              struct device_attribute *attr,
1911                              char *buf)
1912 {
1913         struct ipw_priv *priv = dev_get_drvdata(d);
1914         const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
1915         int len = 0, i;
1916
1917         len = sprintf(&buf[len],
1918                       "Displaying %d channels in 2.4Ghz band "
1919                       "(802.11bg):\n", geo->bg_channels);
1920
1921         for (i = 0; i < geo->bg_channels; i++) {
1922                 len += sprintf(&buf[len], "%d: BSS%s%s, %s, Band %s.\n",
1923                                geo->bg[i].channel,
1924                                geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT ?
1925                                " (radar spectrum)" : "",
1926                                ((geo->bg[i].flags & LIBIPW_CH_NO_IBSS) ||
1927                                 (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT))
1928                                ? "" : ", IBSS",
1929                                geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY ?
1930                                "passive only" : "active/passive",
1931                                geo->bg[i].flags & LIBIPW_CH_B_ONLY ?
1932                                "B" : "B/G");
1933         }
1934
1935         len += sprintf(&buf[len],
1936                        "Displaying %d channels in 5.2Ghz band "
1937                        "(802.11a):\n", geo->a_channels);
1938         for (i = 0; i < geo->a_channels; i++) {
1939                 len += sprintf(&buf[len], "%d: BSS%s%s, %s.\n",
1940                                geo->a[i].channel,
1941                                geo->a[i].flags & LIBIPW_CH_RADAR_DETECT ?
1942                                " (radar spectrum)" : "",
1943                                ((geo->a[i].flags & LIBIPW_CH_NO_IBSS) ||
1944                                 (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT))
1945                                ? "" : ", IBSS",
1946                                geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY ?
1947                                "passive only" : "active/passive");
1948         }
1949
1950         return len;
1951 }
1952
1953 static DEVICE_ATTR(channels, S_IRUSR, show_channels, NULL);
1954
1955 static void notify_wx_assoc_event(struct ipw_priv *priv)
1956 {
1957         union iwreq_data wrqu;
1958         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1959         if (priv->status & STATUS_ASSOCIATED)
1960                 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
1961         else
1962                 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
1963         wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1964 }
1965
1966 static void ipw_irq_tasklet(struct ipw_priv *priv)
1967 {
1968         u32 inta, inta_mask, handled = 0;
1969         unsigned long flags;
1970         int rc = 0;
1971
1972         spin_lock_irqsave(&priv->irq_lock, flags);
1973
1974         inta = ipw_read32(priv, IPW_INTA_RW);
1975         inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
1976         inta &= (IPW_INTA_MASK_ALL & inta_mask);
1977
1978         /* Add any cached INTA values that need to be handled */
1979         inta |= priv->isr_inta;
1980
1981         spin_unlock_irqrestore(&priv->irq_lock, flags);
1982
1983         spin_lock_irqsave(&priv->lock, flags);
1984
1985         /* handle all the justifications for the interrupt */
1986         if (inta & IPW_INTA_BIT_RX_TRANSFER) {
1987                 ipw_rx(priv);
1988                 handled |= IPW_INTA_BIT_RX_TRANSFER;
1989         }
1990
1991         if (inta & IPW_INTA_BIT_TX_CMD_QUEUE) {
1992                 IPW_DEBUG_HC("Command completed.\n");
1993                 rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
1994                 priv->status &= ~STATUS_HCMD_ACTIVE;
1995                 wake_up_interruptible(&priv->wait_command_queue);
1996                 handled |= IPW_INTA_BIT_TX_CMD_QUEUE;
1997         }
1998
1999         if (inta & IPW_INTA_BIT_TX_QUEUE_1) {
2000                 IPW_DEBUG_TX("TX_QUEUE_1\n");
2001                 rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
2002                 handled |= IPW_INTA_BIT_TX_QUEUE_1;
2003         }
2004
2005         if (inta & IPW_INTA_BIT_TX_QUEUE_2) {
2006                 IPW_DEBUG_TX("TX_QUEUE_2\n");
2007                 rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
2008                 handled |= IPW_INTA_BIT_TX_QUEUE_2;
2009         }
2010
2011         if (inta & IPW_INTA_BIT_TX_QUEUE_3) {
2012                 IPW_DEBUG_TX("TX_QUEUE_3\n");
2013                 rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
2014                 handled |= IPW_INTA_BIT_TX_QUEUE_3;
2015         }
2016
2017         if (inta & IPW_INTA_BIT_TX_QUEUE_4) {
2018                 IPW_DEBUG_TX("TX_QUEUE_4\n");
2019                 rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
2020                 handled |= IPW_INTA_BIT_TX_QUEUE_4;
2021         }
2022
2023         if (inta & IPW_INTA_BIT_STATUS_CHANGE) {
2024                 IPW_WARNING("STATUS_CHANGE\n");
2025                 handled |= IPW_INTA_BIT_STATUS_CHANGE;
2026         }
2027
2028         if (inta & IPW_INTA_BIT_BEACON_PERIOD_EXPIRED) {
2029                 IPW_WARNING("TX_PERIOD_EXPIRED\n");
2030                 handled |= IPW_INTA_BIT_BEACON_PERIOD_EXPIRED;
2031         }
2032
2033         if (inta & IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) {
2034                 IPW_WARNING("HOST_CMD_DONE\n");
2035                 handled |= IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE;
2036         }
2037
2038         if (inta & IPW_INTA_BIT_FW_INITIALIZATION_DONE) {
2039                 IPW_WARNING("FW_INITIALIZATION_DONE\n");
2040                 handled |= IPW_INTA_BIT_FW_INITIALIZATION_DONE;
2041         }
2042
2043         if (inta & IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) {
2044                 IPW_WARNING("PHY_OFF_DONE\n");
2045                 handled |= IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE;
2046         }
2047
2048         if (inta & IPW_INTA_BIT_RF_KILL_DONE) {
2049                 IPW_DEBUG_RF_KILL("RF_KILL_DONE\n");
2050                 priv->status |= STATUS_RF_KILL_HW;
2051                 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
2052                 wake_up_interruptible(&priv->wait_command_queue);
2053                 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
2054                 cancel_delayed_work(&priv->request_scan);
2055                 cancel_delayed_work(&priv->request_direct_scan);
2056                 cancel_delayed_work(&priv->request_passive_scan);
2057                 cancel_delayed_work(&priv->scan_event);
2058                 schedule_work(&priv->link_down);
2059                 queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ);
2060                 handled |= IPW_INTA_BIT_RF_KILL_DONE;
2061         }
2062
2063         if (inta & IPW_INTA_BIT_FATAL_ERROR) {
2064                 IPW_WARNING("Firmware error detected.  Restarting.\n");
2065                 if (priv->error) {
2066                         IPW_DEBUG_FW("Sysfs 'error' log already exists.\n");
2067                         if (ipw_debug_level & IPW_DL_FW_ERRORS) {
2068                                 struct ipw_fw_error *error =
2069                                     ipw_alloc_error_log(priv);
2070                                 ipw_dump_error_log(priv, error);
2071                                 kfree(error);
2072                         }
2073                 } else {
2074                         priv->error = ipw_alloc_error_log(priv);
2075                         if (priv->error)
2076                                 IPW_DEBUG_FW("Sysfs 'error' log captured.\n");
2077                         else
2078                                 IPW_DEBUG_FW("Error allocating sysfs 'error' "
2079                                              "log.\n");
2080                         if (ipw_debug_level & IPW_DL_FW_ERRORS)
2081                                 ipw_dump_error_log(priv, priv->error);
2082                 }
2083
2084                 /* XXX: If hardware encryption is for WPA/WPA2,
2085                  * we have to notify the supplicant. */
2086                 if (priv->ieee->sec.encrypt) {
2087                         priv->status &= ~STATUS_ASSOCIATED;
2088                         notify_wx_assoc_event(priv);
2089                 }
2090
2091                 /* Keep the restart process from trying to send host
2092                  * commands by clearing the INIT status bit */
2093                 priv->status &= ~STATUS_INIT;
2094
2095                 /* Cancel currently queued command. */
2096                 priv->status &= ~STATUS_HCMD_ACTIVE;
2097                 wake_up_interruptible(&priv->wait_command_queue);
2098
2099                 queue_work(priv->workqueue, &priv->adapter_restart);
2100                 handled |= IPW_INTA_BIT_FATAL_ERROR;
2101         }
2102
2103         if (inta & IPW_INTA_BIT_PARITY_ERROR) {
2104                 IPW_ERROR("Parity error\n");
2105                 handled |= IPW_INTA_BIT_PARITY_ERROR;
2106         }
2107
2108         if (handled != inta) {
2109                 IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
2110         }
2111
2112         spin_unlock_irqrestore(&priv->lock, flags);
2113
2114         /* enable all interrupts */
2115         ipw_enable_interrupts(priv);
2116 }
2117
2118 #define IPW_CMD(x) case IPW_CMD_ ## x : return #x
2119 static char *get_cmd_string(u8 cmd)
2120 {
2121         switch (cmd) {
2122                 IPW_CMD(HOST_COMPLETE);
2123                 IPW_CMD(POWER_DOWN);
2124                 IPW_CMD(SYSTEM_CONFIG);
2125                 IPW_CMD(MULTICAST_ADDRESS);
2126                 IPW_CMD(SSID);
2127                 IPW_CMD(ADAPTER_ADDRESS);
2128                 IPW_CMD(PORT_TYPE);
2129                 IPW_CMD(RTS_THRESHOLD);
2130                 IPW_CMD(FRAG_THRESHOLD);
2131                 IPW_CMD(POWER_MODE);
2132                 IPW_CMD(WEP_KEY);
2133                 IPW_CMD(TGI_TX_KEY);
2134                 IPW_CMD(SCAN_REQUEST);
2135                 IPW_CMD(SCAN_REQUEST_EXT);
2136                 IPW_CMD(ASSOCIATE);
2137                 IPW_CMD(SUPPORTED_RATES);
2138                 IPW_CMD(SCAN_ABORT);
2139                 IPW_CMD(TX_FLUSH);
2140                 IPW_CMD(QOS_PARAMETERS);
2141                 IPW_CMD(DINO_CONFIG);
2142                 IPW_CMD(RSN_CAPABILITIES);
2143                 IPW_CMD(RX_KEY);
2144                 IPW_CMD(CARD_DISABLE);
2145                 IPW_CMD(SEED_NUMBER);
2146                 IPW_CMD(TX_POWER);
2147                 IPW_CMD(COUNTRY_INFO);
2148                 IPW_CMD(AIRONET_INFO);
2149                 IPW_CMD(AP_TX_POWER);
2150                 IPW_CMD(CCKM_INFO);
2151                 IPW_CMD(CCX_VER_INFO);
2152                 IPW_CMD(SET_CALIBRATION);
2153                 IPW_CMD(SENSITIVITY_CALIB);
2154                 IPW_CMD(RETRY_LIMIT);
2155                 IPW_CMD(IPW_PRE_POWER_DOWN);
2156                 IPW_CMD(VAP_BEACON_TEMPLATE);
2157                 IPW_CMD(VAP_DTIM_PERIOD);
2158                 IPW_CMD(EXT_SUPPORTED_RATES);
2159                 IPW_CMD(VAP_LOCAL_TX_PWR_CONSTRAINT);
2160                 IPW_CMD(VAP_QUIET_INTERVALS);
2161                 IPW_CMD(VAP_CHANNEL_SWITCH);
2162                 IPW_CMD(VAP_MANDATORY_CHANNELS);
2163                 IPW_CMD(VAP_CELL_PWR_LIMIT);
2164                 IPW_CMD(VAP_CF_PARAM_SET);
2165                 IPW_CMD(VAP_SET_BEACONING_STATE);
2166                 IPW_CMD(MEASUREMENT);
2167                 IPW_CMD(POWER_CAPABILITY);
2168                 IPW_CMD(SUPPORTED_CHANNELS);
2169                 IPW_CMD(TPC_REPORT);
2170                 IPW_CMD(WME_INFO);
2171                 IPW_CMD(PRODUCTION_COMMAND);
2172         default:
2173                 return "UNKNOWN";
2174         }
2175 }
2176
2177 #define HOST_COMPLETE_TIMEOUT HZ
2178
2179 static int __ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
2180 {
2181         int rc = 0;
2182         unsigned long flags;
2183
2184         spin_lock_irqsave(&priv->lock, flags);
2185         if (priv->status & STATUS_HCMD_ACTIVE) {
2186                 IPW_ERROR("Failed to send %s: Already sending a command.\n",
2187                           get_cmd_string(cmd->cmd));
2188                 spin_unlock_irqrestore(&priv->lock, flags);
2189                 return -EAGAIN;
2190         }
2191
2192         priv->status |= STATUS_HCMD_ACTIVE;
2193
2194         if (priv->cmdlog) {
2195                 priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
2196                 priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
2197                 priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
2198                 memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
2199                        cmd->len);
2200                 priv->cmdlog[priv->cmdlog_pos].retcode = -1;
2201         }
2202
2203         IPW_DEBUG_HC("%s command (#%d) %d bytes: 0x%08X\n",
2204                      get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
2205                      priv->status);
2206
2207 #ifndef DEBUG_CMD_WEP_KEY
2208         if (cmd->cmd == IPW_CMD_WEP_KEY)
2209                 IPW_DEBUG_HC("WEP_KEY command masked out for secure.\n");
2210         else
2211 #endif
2212                 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
2213
2214         rc = ipw_queue_tx_hcmd(priv, cmd->cmd, cmd->param, cmd->len, 0);
2215         if (rc) {
2216                 priv->status &= ~STATUS_HCMD_ACTIVE;
2217                 IPW_ERROR("Failed to send %s: Reason %d\n",
2218                           get_cmd_string(cmd->cmd), rc);
2219                 spin_unlock_irqrestore(&priv->lock, flags);
2220                 goto exit;
2221         }
2222         spin_unlock_irqrestore(&priv->lock, flags);
2223
2224         rc = wait_event_interruptible_timeout(priv->wait_command_queue,
2225                                               !(priv->
2226                                                 status & STATUS_HCMD_ACTIVE),
2227                                               HOST_COMPLETE_TIMEOUT);
2228         if (rc == 0) {
2229                 spin_lock_irqsave(&priv->lock, flags);
2230                 if (priv->status & STATUS_HCMD_ACTIVE) {
2231                         IPW_ERROR("Failed to send %s: Command timed out.\n",
2232                                   get_cmd_string(cmd->cmd));
2233                         priv->status &= ~STATUS_HCMD_ACTIVE;
2234                         spin_unlock_irqrestore(&priv->lock, flags);
2235                         rc = -EIO;
2236                         goto exit;
2237                 }
2238                 spin_unlock_irqrestore(&priv->lock, flags);
2239         } else
2240                 rc = 0;
2241
2242         if (priv->status & STATUS_RF_KILL_HW) {
2243                 IPW_ERROR("Failed to send %s: Aborted due to RF kill switch.\n",
2244                           get_cmd_string(cmd->cmd));
2245                 rc = -EIO;
2246                 goto exit;
2247         }
2248
2249       exit:
2250         if (priv->cmdlog) {
2251                 priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
2252                 priv->cmdlog_pos %= priv->cmdlog_len;
2253         }
2254         return rc;
2255 }
2256
2257 static int ipw_send_cmd_simple(struct ipw_priv *priv, u8 command)
2258 {
2259         struct host_cmd cmd = {
2260                 .cmd = command,
2261         };
2262
2263         return __ipw_send_cmd(priv, &cmd);
2264 }
2265
2266 static int ipw_send_cmd_pdu(struct ipw_priv *priv, u8 command, u8 len,
2267                             void *data)
2268 {
2269         struct host_cmd cmd = {
2270                 .cmd = command,
2271                 .len = len,
2272                 .param = data,
2273         };
2274
2275         return __ipw_send_cmd(priv, &cmd);
2276 }
2277
2278 static int ipw_send_host_complete(struct ipw_priv *priv)
2279 {
2280         if (!priv) {
2281                 IPW_ERROR("Invalid args\n");
2282                 return -1;
2283         }
2284
2285         return ipw_send_cmd_simple(priv, IPW_CMD_HOST_COMPLETE);
2286 }
2287
2288 static int ipw_send_system_config(struct ipw_priv *priv)
2289 {
2290         return ipw_send_cmd_pdu(priv, IPW_CMD_SYSTEM_CONFIG,
2291                                 sizeof(priv->sys_config),
2292                                 &priv->sys_config);
2293 }
2294
2295 static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
2296 {
2297         if (!priv || !ssid) {
2298                 IPW_ERROR("Invalid args\n");
2299                 return -1;
2300         }
2301
2302         return ipw_send_cmd_pdu(priv, IPW_CMD_SSID, min(len, IW_ESSID_MAX_SIZE),
2303                                 ssid);
2304 }
2305
2306 static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
2307 {
2308         if (!priv || !mac) {
2309                 IPW_ERROR("Invalid args\n");
2310                 return -1;
2311         }
2312
2313         IPW_DEBUG_INFO("%s: Setting MAC to %pM\n",
2314                        priv->net_dev->name, mac);
2315
2316         return ipw_send_cmd_pdu(priv, IPW_CMD_ADAPTER_ADDRESS, ETH_ALEN, mac);
2317 }
2318
2319 /*
2320  * NOTE: This must be executed from our workqueue as it results in udelay
2321  * being called which may corrupt the keyboard if executed on default
2322  * workqueue
2323  */
2324 static void ipw_adapter_restart(void *adapter)
2325 {
2326         struct ipw_priv *priv = adapter;
2327
2328         if (priv->status & STATUS_RF_KILL_MASK)
2329                 return;
2330
2331         ipw_down(priv);
2332
2333         if (priv->assoc_network &&
2334             (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
2335                 ipw_remove_current_network(priv);
2336
2337         if (ipw_up(priv)) {
2338                 IPW_ERROR("Failed to up device\n");
2339                 return;
2340         }
2341 }
2342
2343 static void ipw_bg_adapter_restart(struct work_struct *work)
2344 {
2345         struct ipw_priv *priv =
2346                 container_of(work, struct ipw_priv, adapter_restart);
2347         mutex_lock(&priv->mutex);
2348         ipw_adapter_restart(priv);
2349         mutex_unlock(&priv->mutex);
2350 }
2351
2352 static void ipw_abort_scan(struct ipw_priv *priv);
2353
2354 #define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
2355
2356 static void ipw_scan_check(void *data)
2357 {
2358         struct ipw_priv *priv = data;
2359
2360         if (priv->status & STATUS_SCAN_ABORTING) {
2361                 IPW_DEBUG_SCAN("Scan completion watchdog resetting "
2362                                "adapter after (%dms).\n",
2363                                jiffies_to_msecs(IPW_SCAN_CHECK_WATCHDOG));
2364                 queue_work(priv->workqueue, &priv->adapter_restart);
2365         } else if (priv->status & STATUS_SCANNING) {
2366                 IPW_DEBUG_SCAN("Scan completion watchdog aborting scan "
2367                                "after (%dms).\n",
2368                                jiffies_to_msecs(IPW_SCAN_CHECK_WATCHDOG));
2369                 ipw_abort_scan(priv);
2370                 queue_delayed_work(priv->workqueue, &priv->scan_check, HZ);
2371         }
2372 }
2373
2374 static void ipw_bg_scan_check(struct work_struct *work)
2375 {
2376         struct ipw_priv *priv =
2377                 container_of(work, struct ipw_priv, scan_check.work);
2378         mutex_lock(&priv->mutex);
2379         ipw_scan_check(priv);
2380         mutex_unlock(&priv->mutex);
2381 }
2382
2383 static int ipw_send_scan_request_ext(struct ipw_priv *priv,
2384                                      struct ipw_scan_request_ext *request)
2385 {
2386         return ipw_send_cmd_pdu(priv, IPW_CMD_SCAN_REQUEST_EXT,
2387                                 sizeof(*request), request);
2388 }
2389
2390 static int ipw_send_scan_abort(struct ipw_priv *priv)
2391 {
2392         if (!priv) {
2393                 IPW_ERROR("Invalid args\n");
2394                 return -1;
2395         }
2396
2397         return ipw_send_cmd_simple(priv, IPW_CMD_SCAN_ABORT);
2398 }
2399
2400 static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
2401 {
2402         struct ipw_sensitivity_calib calib = {
2403                 .beacon_rssi_raw = cpu_to_le16(sens),
2404         };
2405
2406         return ipw_send_cmd_pdu(priv, IPW_CMD_SENSITIVITY_CALIB, sizeof(calib),
2407                                 &calib);
2408 }
2409
2410 static int ipw_send_associate(struct ipw_priv *priv,
2411                               struct ipw_associate *associate)
2412 {
2413         if (!priv || !associate) {
2414                 IPW_ERROR("Invalid args\n");
2415                 return -1;
2416         }
2417
2418         return ipw_send_cmd_pdu(priv, IPW_CMD_ASSOCIATE, sizeof(*associate),
2419                                 associate);
2420 }
2421
2422 static int ipw_send_supported_rates(struct ipw_priv *priv,
2423                                     struct ipw_supported_rates *rates)
2424 {
2425         if (!priv || !rates) {
2426                 IPW_ERROR("Invalid args\n");
2427                 return -1;
2428         }
2429
2430         return ipw_send_cmd_pdu(priv, IPW_CMD_SUPPORTED_RATES, sizeof(*rates),
2431                                 rates);
2432 }
2433
2434 static int ipw_set_random_seed(struct ipw_priv *priv)
2435 {
2436         u32 val;
2437
2438         if (!priv) {
2439                 IPW_ERROR("Invalid args\n");
2440                 return -1;
2441         }
2442
2443         get_random_bytes(&val, sizeof(val));
2444
2445         return ipw_send_cmd_pdu(priv, IPW_CMD_SEED_NUMBER, sizeof(val), &val);
2446 }
2447
2448 static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
2449 {
2450         __le32 v = cpu_to_le32(phy_off);
2451         if (!priv) {
2452                 IPW_ERROR("Invalid args\n");
2453                 return -1;
2454         }
2455
2456         return ipw_send_cmd_pdu(priv, IPW_CMD_CARD_DISABLE, sizeof(v), &v);
2457 }
2458
2459 static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
2460 {
2461         if (!priv || !power) {
2462                 IPW_ERROR("Invalid args\n");
2463                 return -1;
2464         }
2465
2466         return ipw_send_cmd_pdu(priv, IPW_CMD_TX_POWER, sizeof(*power), power);
2467 }
2468
2469 static int ipw_set_tx_power(struct ipw_priv *priv)
2470 {
2471         const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
2472         struct ipw_tx_power tx_power;
2473         s8 max_power;
2474         int i;
2475
2476         memset(&tx_power, 0, sizeof(tx_power));
2477
2478         /* configure device for 'G' band */
2479         tx_power.ieee_mode = IPW_G_MODE;
2480         tx_power.num_channels = geo->bg_channels;
2481         for (i = 0; i < geo->bg_channels; i++) {
2482                 max_power = geo->bg[i].max_power;
2483                 tx_power.channels_tx_power[i].channel_number =
2484                     geo->bg[i].channel;
2485                 tx_power.channels_tx_power[i].tx_power = max_power ?
2486                     min(max_power, priv->tx_power) : priv->tx_power;
2487         }
2488         if (ipw_send_tx_power(priv, &tx_power))
2489                 return -EIO;
2490
2491         /* configure device to also handle 'B' band */
2492         tx_power.ieee_mode = IPW_B_MODE;
2493         if (ipw_send_tx_power(priv, &tx_power))
2494                 return -EIO;
2495
2496         /* configure device to also handle 'A' band */
2497         if (priv->ieee->abg_true) {
2498                 tx_power.ieee_mode = IPW_A_MODE;
2499                 tx_power.num_channels = geo->a_channels;
2500                 for (i = 0; i < tx_power.num_channels; i++) {
2501                         max_power = geo->a[i].max_power;
2502                         tx_power.channels_tx_power[i].channel_number =
2503                             geo->a[i].channel;
2504                         tx_power.channels_tx_power[i].tx_power = max_power ?
2505                             min(max_power, priv->tx_power) : priv->tx_power;
2506                 }
2507                 if (ipw_send_tx_power(priv, &tx_power))
2508                         return -EIO;
2509         }
2510         return 0;
2511 }
2512
2513 static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
2514 {
2515         struct ipw_rts_threshold rts_threshold = {
2516                 .rts_threshold = cpu_to_le16(rts),
2517         };
2518
2519         if (!priv) {
2520                 IPW_ERROR("Invalid args\n");
2521                 return -1;
2522         }
2523
2524         return ipw_send_cmd_pdu(priv, IPW_CMD_RTS_THRESHOLD,
2525                                 sizeof(rts_threshold), &rts_threshold);
2526 }
2527
2528 static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
2529 {
2530         struct ipw_frag_threshold frag_threshold = {
2531                 .frag_threshold = cpu_to_le16(frag),
2532         };
2533
2534         if (!priv) {
2535                 IPW_ERROR("Invalid args\n");
2536                 return -1;
2537         }
2538
2539         return ipw_send_cmd_pdu(priv, IPW_CMD_FRAG_THRESHOLD,
2540                                 sizeof(frag_threshold), &frag_threshold);
2541 }
2542
2543 static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
2544 {
2545         __le32 param;
2546
2547         if (!priv) {
2548                 IPW_ERROR("Invalid args\n");
2549                 return -1;
2550         }
2551
2552         /* If on battery, set to 3, if AC set to CAM, else user
2553          * level */
2554         switch (mode) {
2555         case IPW_POWER_BATTERY:
2556                 param = cpu_to_le32(IPW_POWER_INDEX_3);
2557                 break;
2558         case IPW_POWER_AC:
2559                 param = cpu_to_le32(IPW_POWER_MODE_CAM);
2560                 break;
2561         default:
2562                 param = cpu_to_le32(mode);
2563                 break;
2564         }
2565
2566         return ipw_send_cmd_pdu(priv, IPW_CMD_POWER_MODE, sizeof(param),
2567                                 &param);
2568 }
2569
2570 static int ipw_send_retry_limit(struct ipw_priv *priv, u8 slimit, u8 llimit)
2571 {
2572         struct ipw_retry_limit retry_limit = {
2573                 .short_retry_limit = slimit,
2574                 .long_retry_limit = llimit
2575         };
2576
2577         if (!priv) {
2578                 IPW_ERROR("Invalid args\n");
2579                 return -1;
2580         }
2581
2582         return ipw_send_cmd_pdu(priv, IPW_CMD_RETRY_LIMIT, sizeof(retry_limit),
2583                                 &retry_limit);
2584 }
2585
2586 /*
2587  * The IPW device contains a Microwire compatible EEPROM that stores
2588  * various data like the MAC address.  Usually the firmware has exclusive
2589  * access to the eeprom, but during device initialization (before the
2590  * device driver has sent the HostComplete command to the firmware) the
2591  * device driver has read access to the EEPROM by way of indirect addressing
2592  * through a couple of memory mapped registers.
2593  *
2594  * The following is a simplified implementation for pulling data out of the
2595  * the eeprom, along with some helper functions to find information in
2596  * the per device private data's copy of the eeprom.
2597  *
2598  * NOTE: To better understand how these functions work (i.e what is a chip
2599  *       select and why do have to keep driving the eeprom clock?), read
2600  *       just about any data sheet for a Microwire compatible EEPROM.
2601  */
2602
2603 /* write a 32 bit value into the indirect accessor register */
2604 static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2605 {
2606         ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
2607
2608         /* the eeprom requires some time to complete the operation */
2609         udelay(p->eeprom_delay);
2610 }
2611
2612 /* perform a chip select operation */
2613 static void eeprom_cs(struct ipw_priv *priv)
2614 {
2615         eeprom_write_reg(priv, 0);
2616         eeprom_write_reg(priv, EEPROM_BIT_CS);
2617         eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2618         eeprom_write_reg(priv, EEPROM_BIT_CS);
2619 }
2620
2621 /* perform a chip select operation */
2622 static void eeprom_disable_cs(struct ipw_priv *priv)
2623 {
2624         eeprom_write_reg(priv, EEPROM_BIT_CS);
2625         eeprom_write_reg(priv, 0);
2626         eeprom_write_reg(priv, EEPROM_BIT_SK);
2627 }
2628
2629 /* push a single bit down to the eeprom */
2630 static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
2631 {
2632         int d = (bit ? EEPROM_BIT_DI : 0);
2633         eeprom_write_reg(p, EEPROM_BIT_CS | d);
2634         eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
2635 }
2636
2637 /* push an opcode followed by an address down to the eeprom */
2638 static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
2639 {
2640         int i;
2641
2642         eeprom_cs(priv);
2643         eeprom_write_bit(priv, 1);
2644         eeprom_write_bit(priv, op & 2);
2645         eeprom_write_bit(priv, op & 1);
2646         for (i = 7; i >= 0; i--) {
2647                 eeprom_write_bit(priv, addr & (1 << i));
2648         }
2649 }
2650
2651 /* pull 16 bits off the eeprom, one bit at a time */
2652 static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
2653 {
2654         int i;
2655         u16 r = 0;
2656
2657         /* Send READ Opcode */
2658         eeprom_op(priv, EEPROM_CMD_READ, addr);
2659
2660         /* Send dummy bit */
2661         eeprom_write_reg(priv, EEPROM_BIT_CS);
2662
2663         /* Read the byte off the eeprom one bit at a time */
2664         for (i = 0; i < 16; i++) {
2665                 u32 data = 0;
2666                 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2667                 eeprom_write_reg(priv, EEPROM_BIT_CS);
2668                 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2669                 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
2670         }
2671
2672         /* Send another dummy bit */
2673         eeprom_write_reg(priv, 0);
2674         eeprom_disable_cs(priv);
2675
2676         return r;
2677 }
2678
2679 /* helper function for pulling the mac address out of the private */
2680 /* data's copy of the eeprom data                                 */
2681 static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
2682 {
2683         memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], 6);
2684 }
2685
2686 /*
2687  * Either the device driver (i.e. the host) or the firmware can
2688  * load eeprom data into the designated region in SRAM.  If neither
2689  * happens then the FW will shutdown with a fatal error.
2690  *
2691  * In order to signal the FW to load the EEPROM, the EEPROM_LOAD_DISABLE
2692  * bit needs region of shared SRAM needs to be non-zero.
2693  */
2694 static void ipw_eeprom_init_sram(struct ipw_priv *priv)
2695 {
2696         int i;
2697         __le16 *eeprom = (__le16 *) priv->eeprom;
2698
2699         IPW_DEBUG_TRACE(">>\n");
2700
2701         /* read entire contents of eeprom into private buffer */
2702         for (i = 0; i < 128; i++)
2703                 eeprom[i] = cpu_to_le16(eeprom_read_u16(priv, (u8) i));
2704
2705         /*
2706            If the data looks correct, then copy it to our private
2707            copy.  Otherwise let the firmware know to perform the operation
2708            on its own.
2709          */
2710         if (priv->eeprom[EEPROM_VERSION] != 0) {
2711                 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2712
2713                 /* write the eeprom data to sram */
2714                 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
2715                         ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
2716
2717                 /* Do not load eeprom data on fatal error or suspend */
2718                 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
2719         } else {
2720                 IPW_DEBUG_INFO("Enabling FW initializationg of SRAM\n");
2721
2722                 /* Load eeprom data on fatal error or suspend */
2723                 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 1);
2724         }
2725
2726         IPW_DEBUG_TRACE("<<\n");
2727 }
2728
2729 static void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
2730 {
2731         count >>= 2;
2732         if (!count)
2733                 return;
2734         _ipw_write32(priv, IPW_AUTOINC_ADDR, start);
2735         while (count--)
2736                 _ipw_write32(priv, IPW_AUTOINC_DATA, 0);
2737 }
2738
2739 static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
2740 {
2741         ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
2742                         CB_NUMBER_OF_ELEMENTS_SMALL *
2743                         sizeof(struct command_block));
2744 }
2745
2746 static int ipw_fw_dma_enable(struct ipw_priv *priv)
2747 {                               /* start dma engine but no transfers yet */
2748
2749         IPW_DEBUG_FW(">> :\n");
2750
2751         /* Start the dma */
2752         ipw_fw_dma_reset_command_blocks(priv);
2753
2754         /* Write CB base address */
2755         ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
2756
2757         IPW_DEBUG_FW("<< :\n");
2758         return 0;
2759 }
2760
2761 static void ipw_fw_dma_abort(struct ipw_priv *priv)
2762 {
2763         u32 control = 0;
2764
2765         IPW_DEBUG_FW(">> :\n");
2766
2767         /* set the Stop and Abort bit */
2768         control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
2769         ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2770         priv->sram_desc.last_cb_index = 0;
2771
2772         IPW_DEBUG_FW("<<\n");
2773 }
2774
2775 static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
2776                                           struct command_block *cb)
2777 {
2778         u32 address =
2779             IPW_SHARED_SRAM_DMA_CONTROL +
2780             (sizeof(struct command_block) * index);
2781         IPW_DEBUG_FW(">> :\n");
2782
2783         ipw_write_indirect(priv, address, (u8 *) cb,
2784                            (int)sizeof(struct command_block));
2785
2786         IPW_DEBUG_FW("<< :\n");
2787         return 0;
2788
2789 }
2790
2791 static int ipw_fw_dma_kick(struct ipw_priv *priv)
2792 {
2793         u32 control = 0;
2794         u32 index = 0;
2795
2796         IPW_DEBUG_FW(">> :\n");
2797
2798         for (index = 0; index < priv->sram_desc.last_cb_index; index++)
2799                 ipw_fw_dma_write_command_block(priv, index,
2800                                                &priv->sram_desc.cb_list[index]);
2801
2802         /* Enable the DMA in the CSR register */
2803         ipw_clear_bit(priv, IPW_RESET_REG,
2804                       IPW_RESET_REG_MASTER_DISABLED |
2805                       IPW_RESET_REG_STOP_MASTER);
2806
2807         /* Set the Start bit. */
2808         control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
2809         ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2810
2811         IPW_DEBUG_FW("<< :\n");
2812         return 0;
2813 }
2814
2815 static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
2816 {
2817         u32 address;
2818         u32 register_value = 0;
2819         u32 cb_fields_address = 0;
2820
2821         IPW_DEBUG_FW(">> :\n");
2822         address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2823         IPW_DEBUG_FW_INFO("Current CB is 0x%x\n", address);
2824
2825         /* Read the DMA Controlor register */
2826         register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
2827         IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x\n", register_value);
2828
2829         /* Print the CB values */
2830         cb_fields_address = address;
2831         register_value = ipw_read_reg32(priv, cb_fields_address);
2832         IPW_DEBUG_FW_INFO("Current CB Control Field is 0x%x\n", register_value);
2833
2834         cb_fields_address += sizeof(u32);
2835         register_value = ipw_read_reg32(priv, cb_fields_address);
2836         IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x\n", register_value);
2837
2838         cb_fields_address += sizeof(u32);
2839         register_value = ipw_read_reg32(priv, cb_fields_address);
2840         IPW_DEBUG_FW_INFO("Current CB Destination Field is 0x%x\n",
2841                           register_value);
2842
2843         cb_fields_address += sizeof(u32);
2844         register_value = ipw_read_reg32(priv, cb_fields_address);
2845         IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x\n", register_value);
2846
2847         IPW_DEBUG_FW(">> :\n");
2848 }
2849
2850 static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
2851 {
2852         u32 current_cb_address = 0;
2853         u32 current_cb_index = 0;
2854
2855         IPW_DEBUG_FW("<< :\n");
2856         current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2857
2858         current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
2859             sizeof(struct command_block);
2860
2861         IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X\n",
2862                           current_cb_index, current_cb_address);
2863
2864         IPW_DEBUG_FW(">> :\n");
2865         return current_cb_index;
2866
2867 }
2868
2869 static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
2870                                         u32 src_address,
2871                                         u32 dest_address,
2872                                         u32 length,
2873                                         int interrupt_enabled, int is_last)
2874 {
2875
2876         u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
2877             CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
2878             CB_DEST_SIZE_LONG;
2879         struct command_block *cb;
2880         u32 last_cb_element = 0;
2881
2882         IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
2883                           src_address, dest_address, length);
2884
2885         if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
2886                 return -1;
2887
2888         last_cb_element = priv->sram_desc.last_cb_index;
2889         cb = &priv->sram_desc.cb_list[last_cb_element];
2890         priv->sram_desc.last_cb_index++;
2891
2892         /* Calculate the new CB control word */
2893         if (interrupt_enabled)
2894                 control |= CB_INT_ENABLED;
2895
2896         if (is_last)
2897                 control |= CB_LAST_VALID;
2898
2899         control |= length;
2900
2901         /* Calculate the CB Element's checksum value */
2902         cb->status = control ^ src_address ^ dest_address;
2903
2904         /* Copy the Source and Destination addresses */
2905         cb->dest_addr = dest_address;
2906         cb->source_addr = src_address;
2907
2908         /* Copy the Control Word last */
2909         cb->control = control;
2910
2911         return 0;
2912 }
2913
2914 static int ipw_fw_dma_add_buffer(struct ipw_priv *priv, dma_addr_t *src_address,
2915                                  int nr, u32 dest_address, u32 len)
2916 {
2917         int ret, i;
2918         u32 size;
2919
2920         IPW_DEBUG_FW(">>\n");
2921         IPW_DEBUG_FW_INFO("nr=%d dest_address=0x%x len=0x%x\n",
2922                           nr, dest_address, len);
2923
2924         for (i = 0; i < nr; i++) {
2925                 size = min_t(u32, len - i * CB_MAX_LENGTH, CB_MAX_LENGTH);
2926                 ret = ipw_fw_dma_add_command_block(priv, src_address[i],
2927                                                    dest_address +
2928                                                    i * CB_MAX_LENGTH, size,
2929                                                    0, 0);
2930                 if (ret) {
2931                         IPW_DEBUG_FW_INFO(": Failed\n");
2932                         return -1;
2933                 } else
2934                         IPW_DEBUG_FW_INFO(": Added new cb\n");
2935         }
2936
2937         IPW_DEBUG_FW("<<\n");
2938         return 0;
2939 }
2940
2941 static int ipw_fw_dma_wait(struct ipw_priv *priv)
2942 {
2943         u32 current_index = 0, previous_index;
2944         u32 watchdog = 0;
2945
2946         IPW_DEBUG_FW(">> :\n");
2947
2948         current_index = ipw_fw_dma_command_block_index(priv);
2949         IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%08X\n",
2950                           (int)priv->sram_desc.last_cb_index);
2951
2952         while (current_index < priv->sram_desc.last_cb_index) {
2953                 udelay(50);
2954                 previous_index = current_index;
2955                 current_index = ipw_fw_dma_command_block_index(priv);
2956
2957                 if (previous_index < current_index) {
2958                         watchdog = 0;
2959                         continue;
2960                 }
2961                 if (++watchdog > 400) {
2962                         IPW_DEBUG_FW_INFO("Timeout\n");
2963                         ipw_fw_dma_dump_command_block(priv);
2964                         ipw_fw_dma_abort(priv);
2965                         return -1;
2966                 }
2967         }
2968
2969         ipw_fw_dma_abort(priv);
2970
2971         /*Disable the DMA in the CSR register */
2972         ipw_set_bit(priv, IPW_RESET_REG,
2973                     IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
2974
2975         IPW_DEBUG_FW("<< dmaWaitSync\n");
2976         return 0;
2977 }
2978
2979 static void ipw_remove_current_network(struct ipw_priv *priv)
2980 {
2981         struct list_head *element, *safe;
2982         struct libipw_network *network = NULL;
2983         unsigned long flags;
2984
2985         spin_lock_irqsave(&priv->ieee->lock, flags);
2986         list_for_each_safe(element, safe, &priv->ieee->network_list) {
2987                 network = list_entry(element, struct libipw_network, list);
2988                 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
2989                         list_del(element);
2990                         list_add_tail(&network->list,
2991                                       &priv->ieee->network_free_list);
2992                 }
2993         }
2994         spin_unlock_irqrestore(&priv->ieee->lock, flags);
2995 }
2996
2997 /**
2998  * Check that card is still alive.
2999  * Reads debug register from domain0.
3000  * If card is present, pre-defined value should
3001  * be found there.
3002  *
3003  * @param priv
3004  * @return 1 if card is present, 0 otherwise
3005  */
3006 static inline int ipw_alive(struct ipw_priv *priv)
3007 {
3008         return ipw_read32(priv, 0x90) == 0xd55555d5;
3009 }
3010
3011 /* timeout in msec, attempted in 10-msec quanta */
3012 static int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
3013                                int timeout)
3014 {
3015         int i = 0;
3016
3017         do {
3018                 if ((ipw_read32(priv, addr) & mask) == mask)
3019                         return i;
3020                 mdelay(10);
3021                 i += 10;
3022         } while (i < timeout);
3023
3024         return -ETIME;
3025 }
3026
3027 /* These functions load the firmware and micro code for the operation of
3028  * the ipw hardware.  It assumes the buffer has all the bits for the
3029  * image and the caller is handling the memory allocation and clean up.
3030  */
3031
3032 static int ipw_stop_master(struct ipw_priv *priv)
3033 {
3034         int rc;
3035
3036         IPW_DEBUG_TRACE(">>\n");
3037         /* stop master. typical delay - 0 */
3038         ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
3039
3040         /* timeout is in msec, polled in 10-msec quanta */
3041         rc = ipw_poll_bit(priv, IPW_RESET_REG,
3042                           IPW_RESET_REG_MASTER_DISABLED, 100);
3043         if (rc < 0) {
3044                 IPW_ERROR("wait for stop master failed after 100ms\n");
3045                 return -1;
3046         }
3047
3048         IPW_DEBUG_INFO("stop master %dms\n", rc);
3049
3050         return rc;
3051 }
3052
3053 static void ipw_arc_release(struct ipw_priv *priv)
3054 {
3055         IPW_DEBUG_TRACE(">>\n");
3056         mdelay(5);
3057
3058         ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
3059
3060         /* no one knows timing, for safety add some delay */
3061         mdelay(5);
3062 }
3063
3064 struct fw_chunk {
3065         __le32 address;
3066         __le32 length;
3067 };
3068
3069 static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
3070 {
3071         int rc = 0, i, addr;
3072         u8 cr = 0;
3073         __le16 *image;
3074
3075         image = (__le16 *) data;
3076
3077         IPW_DEBUG_TRACE(">>\n");
3078
3079         rc = ipw_stop_master(priv);
3080
3081         if (rc < 0)
3082                 return rc;
3083
3084         for (addr = IPW_SHARED_LOWER_BOUND;
3085              addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
3086                 ipw_write32(priv, addr, 0);
3087         }
3088
3089         /* no ucode (yet) */
3090         memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
3091         /* destroy DMA queues */
3092         /* reset sequence */
3093
3094         ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
3095         ipw_arc_release(priv);
3096         ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
3097         mdelay(1);
3098
3099         /* reset PHY */
3100         ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
3101         mdelay(1);
3102
3103         ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
3104         mdelay(1);
3105
3106         /* enable ucode store */
3107         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0x0);
3108         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_CS);
3109         mdelay(1);
3110
3111         /* write ucode */
3112         /**
3113          * @bug
3114          * Do NOT set indirect address register once and then
3115          * store data to indirect data register in the loop.
3116          * It seems very reasonable, but in this case DINO do not
3117          * accept ucode. It is essential to set address each time.
3118          */
3119         /* load new ipw uCode */
3120         for (i = 0; i < len / 2; i++)
3121                 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
3122                                 le16_to_cpu(image[i]));
3123
3124         /* enable DINO */
3125         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
3126         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
3127
3128         /* this is where the igx / win driver deveates from the VAP driver. */
3129
3130         /* wait for alive response */
3131         for (i = 0; i < 100; i++) {
3132                 /* poll for incoming data */
3133                 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
3134                 if (cr & DINO_RXFIFO_DATA)
3135                         break;
3136                 mdelay(1);
3137         }
3138
3139         if (cr & DINO_RXFIFO_DATA) {
3140                 /* alive_command_responce size is NOT multiple of 4 */
3141                 __le32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
3142
3143                 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
3144                         response_buffer[i] =
3145                             cpu_to_le32(ipw_read_reg32(priv,
3146                                                        IPW_BASEBAND_RX_FIFO_READ));
3147                 memcpy(&priv->dino_alive, response_buffer,
3148                        sizeof(priv->dino_alive));
3149                 if (priv->dino_alive.alive_command == 1
3150                     && priv->dino_alive.ucode_valid == 1) {
3151                         rc = 0;
3152                         IPW_DEBUG_INFO
3153                             ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
3154                              "of %02d/%02d/%02d %02d:%02d\n",
3155                              priv->dino_alive.software_revision,
3156                              priv->dino_alive.software_revision,
3157                              priv->dino_alive.device_identifier,
3158                              priv->dino_alive.device_identifier,
3159                              priv->dino_alive.time_stamp[0],
3160                              priv->dino_alive.time_stamp[1],
3161                              priv->dino_alive.time_stamp[2],
3162                              priv->dino_alive.time_stamp[3],
3163                              priv->dino_alive.time_stamp[4]);
3164                 } else {
3165                         IPW_DEBUG_INFO("Microcode is not alive\n");
3166                         rc = -EINVAL;
3167                 }
3168         } else {
3169                 IPW_DEBUG_INFO("No alive response from DINO\n");
3170                 rc = -ETIME;
3171         }
3172
3173         /* disable DINO, otherwise for some reason
3174            firmware have problem getting alive resp. */
3175         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
3176
3177         return rc;
3178 }
3179
3180 static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
3181 {
3182         int ret = -1;
3183         int offset = 0;
3184         struct fw_chunk *chunk;
3185         int total_nr = 0;
3186         int i;
3187         struct pci_pool *pool;
3188         void **virts;
3189         dma_addr_t *phys;
3190
3191         IPW_DEBUG_TRACE("<< :\n");
3192
3193         virts = kmalloc(sizeof(void *) * CB_NUMBER_OF_ELEMENTS_SMALL,
3194                         GFP_KERNEL);
3195         if (!virts)
3196                 return -ENOMEM;
3197
3198         phys = kmalloc(sizeof(dma_addr_t) * CB_NUMBER_OF_ELEMENTS_SMALL,
3199                         GFP_KERNEL);
3200         if (!phys) {
3201                 kfree(virts);
3202                 return -ENOMEM;
3203         }
3204         pool = pci_pool_create("ipw2200", priv->pci_dev, CB_MAX_LENGTH, 0, 0);
3205         if (!pool) {
3206                 IPW_ERROR("pci_pool_create failed\n");
3207                 kfree(phys);
3208                 kfree(virts);
3209                 return -ENOMEM;
3210         }
3211
3212         /* Start the Dma */
3213         ret = ipw_fw_dma_enable(priv);
3214
3215         /* the DMA is already ready this would be a bug. */
3216         BUG_ON(priv->sram_desc.last_cb_index > 0);
3217
3218         do {
3219                 u32 chunk_len;
3220                 u8 *start;
3221                 int size;
3222                 int nr = 0;
3223
3224                 chunk = (struct fw_chunk *)(data + offset);
3225                 offset += sizeof(struct fw_chunk);
3226                 chunk_len = le32_to_cpu(chunk->length);
3227                 start = data + offset;
3228
3229                 nr = (chunk_len + CB_MAX_LENGTH - 1) / CB_MAX_LENGTH;
3230                 for (i = 0; i < nr; i++) {
3231                         virts[total_nr] = pci_pool_alloc(pool, GFP_KERNEL,
3232                                                          &phys[total_nr]);
3233                         if (!virts[total_nr]) {
3234                                 ret = -ENOMEM;
3235                                 goto out;
3236                         }
3237                         size = min_t(u32, chunk_len - i * CB_MAX_LENGTH,
3238                                      CB_MAX_LENGTH);
3239                         memcpy(virts[total_nr], start, size);
3240                         start += size;
3241                         total_nr++;
3242                         /* We don't support fw chunk larger than 64*8K */
3243                         BUG_ON(total_nr > CB_NUMBER_OF_ELEMENTS_SMALL);
3244                 }
3245
3246                 /* build DMA packet and queue up for sending */
3247                 /* dma to chunk->address, the chunk->length bytes from data +
3248                  * offeset*/
3249                 /* Dma loading */
3250                 ret = ipw_fw_dma_add_buffer(priv, &phys[total_nr - nr],
3251                                             nr, le32_to_cpu(chunk->address),
3252                                             chunk_len);
3253                 if (ret) {
3254                         IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3255                         goto out;
3256                 }
3257
3258                 offset += chunk_len;
3259         } while (offset < len);
3260
3261         /* Run the DMA and wait for the answer */
3262         ret = ipw_fw_dma_kick(priv);
3263         if (ret) {
3264                 IPW_ERROR("dmaKick Failed\n");
3265                 goto out;
3266         }
3267
3268         ret = ipw_fw_dma_wait(priv);
3269         if (ret) {
3270                 IPW_ERROR("dmaWaitSync Failed\n");
3271                 goto out;
3272         }
3273  out:
3274         for (i = 0; i < total_nr; i++)
3275                 pci_pool_free(pool, virts[i], phys[i]);
3276
3277         pci_pool_destroy(pool);
3278         kfree(phys);
3279         kfree(virts);
3280
3281         return ret;
3282 }
3283
3284 /* stop nic */
3285 static int ipw_stop_nic(struct ipw_priv *priv)
3286 {
3287         int rc = 0;
3288
3289         /* stop */
3290         ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
3291
3292         rc = ipw_poll_bit(priv, IPW_RESET_REG,
3293                           IPW_RESET_REG_MASTER_DISABLED, 500);
3294         if (rc < 0) {
3295                 IPW_ERROR("wait for reg master disabled failed after 500ms\n");
3296                 return rc;
3297         }
3298
3299         ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
3300
3301         return rc;
3302 }
3303
3304 static void ipw_start_nic(struct ipw_priv *priv)
3305 {
3306         IPW_DEBUG_TRACE(">>\n");
3307
3308         /* prvHwStartNic  release ARC */
3309         ipw_clear_bit(priv, IPW_RESET_REG,
3310                       IPW_RESET_REG_MASTER_DISABLED |
3311                       IPW_RESET_REG_STOP_MASTER |
3312                       CBD_RESET_REG_PRINCETON_RESET);
3313
3314         /* enable power management */
3315         ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3316                     IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
3317
3318         IPW_DEBUG_TRACE("<<\n");
3319 }
3320
3321 static int ipw_init_nic(struct ipw_priv *priv)
3322 {
3323         int rc;
3324
3325         IPW_DEBUG_TRACE(">>\n");
3326         /* reset */
3327         /*prvHwInitNic */
3328         /* set "initialization complete" bit to move adapter to D0 state */
3329         ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3330
3331         /* low-level PLL activation */
3332         ipw_write32(priv, IPW_READ_INT_REGISTER,
3333                     IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
3334
3335         /* wait for clock stabilization */
3336         rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3337                           IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
3338         if (rc < 0)
3339                 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3340
3341         /* assert SW reset */
3342         ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
3343
3344         udelay(10);
3345
3346         /* set "initialization complete" bit to move adapter to D0 state */
3347         ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3348
3349         IPW_DEBUG_TRACE(">>\n");
3350         return 0;
3351 }
3352
3353 /* Call this function from process context, it will sleep in request_firmware.
3354  * Probe is an ok place to call this from.
3355  */
3356 static int ipw_reset_nic(struct ipw_priv *priv)
3357 {
3358         int rc = 0;
3359         unsigned long flags;
3360
3361         IPW_DEBUG_TRACE(">>\n");
3362
3363         rc = ipw_init_nic(priv);
3364
3365         spin_lock_irqsave(&priv->lock, flags);
3366         /* Clear the 'host command active' bit... */
3367         priv->status &= ~STATUS_HCMD_ACTIVE;
3368         wake_up_interruptible(&priv->wait_command_queue);
3369         priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3370         wake_up_interruptible(&priv->wait_state);
3371         spin_unlock_irqrestore(&priv->lock, flags);
3372
3373         IPW_DEBUG_TRACE("<<\n");
3374         return rc;
3375 }
3376
3377
3378 struct ipw_fw {
3379         __le32 ver;
3380         __le32 boot_size;
3381         __le32 ucode_size;
3382         __le32 fw_size;
3383         u8 data[0];
3384 };
3385
3386 static int ipw_get_fw(struct ipw_priv *priv,
3387                       const struct firmware **raw, const char *name)
3388 {
3389         struct ipw_fw *fw;
3390         int rc;
3391
3392         /* ask firmware_class module to get the boot firmware off disk */
3393         rc = request_firmware(raw, name, &priv->pci_dev->dev);
3394         if (rc < 0) {
3395                 IPW_ERROR("%s request_firmware failed: Reason %d\n", name, rc);
3396                 return rc;
3397         }
3398
3399         if ((*raw)->size < sizeof(*fw)) {
3400                 IPW_ERROR("%s is too small (%zd)\n", name, (*raw)->size);
3401                 return -EINVAL;
3402         }
3403
3404         fw = (void *)(*raw)->data;
3405
3406         if ((*raw)->size < sizeof(*fw) + le32_to_cpu(fw->boot_size) +
3407             le32_to_cpu(fw->ucode_size) + le32_to_cpu(fw->fw_size)) {
3408                 IPW_ERROR("%s is too small or corrupt (%zd)\n",
3409                           name, (*raw)->size);
3410                 return -EINVAL;
3411         }
3412
3413         IPW_DEBUG_INFO("Read firmware '%s' image v%d.%d (%zd bytes)\n",
3414                        name,
3415                        le32_to_cpu(fw->ver) >> 16,
3416                        le32_to_cpu(fw->ver) & 0xff,
3417                        (*raw)->size - sizeof(*fw));
3418         return 0;
3419 }
3420
3421 #define IPW_RX_BUF_SIZE (3000)
3422
3423 static void ipw_rx_queue_reset(struct ipw_priv *priv,
3424                                       struct ipw_rx_queue *rxq)
3425 {
3426         unsigned long flags;
3427         int i;
3428
3429         spin_lock_irqsave(&rxq->lock, flags);
3430
3431         INIT_LIST_HEAD(&rxq->rx_free);
3432         INIT_LIST_HEAD(&rxq->rx_used);
3433
3434         /* Fill the rx_used queue with _all_ of the Rx buffers */
3435         for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3436                 /* In the reset function, these buffers may have been allocated
3437                  * to an SKB, so we need to unmap and free potential storage */
3438                 if (rxq->pool[i].skb != NULL) {
3439                         pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
3440                                          IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
3441                         dev_kfree_skb(rxq->pool[i].skb);
3442                         rxq->pool[i].skb = NULL;
3443                 }
3444                 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3445         }
3446
3447         /* Set us so that we have processed and used all buffers, but have
3448          * not restocked the Rx queue with fresh buffers */
3449         rxq->read = rxq->write = 0;
3450         rxq->free_count = 0;
3451         spin_unlock_irqrestore(&rxq->lock, flags);
3452 }
3453
3454 #ifdef CONFIG_PM
3455 static int fw_loaded = 0;
3456 static const struct firmware *raw = NULL;
3457
3458 static void free_firmware(void)
3459 {
3460         if (fw_loaded) {
3461                 release_firmware(raw);
3462                 raw = NULL;
3463                 fw_loaded = 0;
3464         }
3465 }
3466 #else
3467 #define free_firmware() do {} while (0)
3468 #endif
3469
3470 static int ipw_load(struct ipw_priv *priv)
3471 {
3472 #ifndef CONFIG_PM
3473         const struct firmware *raw = NULL;
3474 #endif
3475         struct ipw_fw *fw;
3476         u8 *boot_img, *ucode_img, *fw_img;
3477         u8 *name = NULL;
3478         int rc = 0, retries = 3;
3479
3480         switch (priv->ieee->iw_mode) {
3481         case IW_MODE_ADHOC:
3482                 name = "ipw2200-ibss.fw";
3483                 break;
3484 #ifdef CONFIG_IPW2200_MONITOR
3485         case IW_MODE_MONITOR:
3486                 name = "ipw2200-sniffer.fw";
3487                 break;
3488 #endif
3489         case IW_MODE_INFRA:
3490                 name = "ipw2200-bss.fw";
3491                 break;
3492         }
3493
3494         if (!name) {
3495                 rc = -EINVAL;
3496                 goto error;
3497         }
3498
3499 #ifdef CONFIG_PM
3500         if (!fw_loaded) {
3501 #endif
3502                 rc = ipw_get_fw(priv, &raw, name);
3503                 if (rc < 0)
3504                         goto error;
3505 #ifdef CONFIG_PM
3506         }
3507 #endif
3508
3509         fw = (void *)raw->data;
3510         boot_img = &fw->data[0];
3511         ucode_img = &fw->data[le32_to_cpu(fw->boot_size)];
3512         fw_img = &fw->data[le32_to_cpu(fw->boot_size) +
3513                            le32_to_cpu(fw->ucode_size)];
3514
3515         if (rc < 0)
3516                 goto error;
3517
3518         if (!priv->rxq)
3519                 priv->rxq = ipw_rx_queue_alloc(priv);
3520         else
3521                 ipw_rx_queue_reset(priv, priv->rxq);
3522         if (!priv->rxq) {
3523                 IPW_ERROR("Unable to initialize Rx queue\n");
3524                 goto error;
3525         }
3526
3527       retry:
3528         /* Ensure interrupts are disabled */
3529         ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3530         priv->status &= ~STATUS_INT_ENABLED;
3531
3532         /* ack pending interrupts */
3533         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3534
3535         ipw_stop_nic(priv);
3536
3537         rc = ipw_reset_nic(priv);
3538         if (rc < 0) {
3539                 IPW_ERROR("Unable to reset NIC\n");
3540                 goto error;
3541         }
3542
3543         ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3544                         IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
3545
3546         /* DMA the initial boot firmware into the device */
3547         rc = ipw_load_firmware(priv, boot_img, le32_to_cpu(fw->boot_size));
3548         if (rc < 0) {
3549                 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
3550                 goto error;
3551         }
3552
3553         /* kick start the device */
3554         ipw_start_nic(priv);
3555
3556         /* wait for the device to finish its initial startup sequence */
3557         rc = ipw_poll_bit(priv, IPW_INTA_RW,
3558                           IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3559         if (rc < 0) {
3560                 IPW_ERROR("device failed to boot initial fw image\n");
3561                 goto error;
3562         }
3563         IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3564
3565         /* ack fw init done interrupt */
3566         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3567
3568         /* DMA the ucode into the device */
3569         rc = ipw_load_ucode(priv, ucode_img, le32_to_cpu(fw->ucode_size));
3570         if (rc < 0) {
3571                 IPW_ERROR("Unable to load ucode: %d\n", rc);
3572                 goto error;
3573         }
3574
3575         /* stop nic */
3576         ipw_stop_nic(priv);
3577
3578         /* DMA bss firmware into the device */
3579         rc = ipw_load_firmware(priv, fw_img, le32_to_cpu(fw->fw_size));
3580         if (rc < 0) {
3581                 IPW_ERROR("Unable to load firmware: %d\n", rc);
3582                 goto error;
3583         }
3584 #ifdef CONFIG_PM
3585         fw_loaded = 1;
3586 #endif
3587
3588         ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3589
3590         rc = ipw_queue_reset(priv);
3591         if (rc < 0) {
3592                 IPW_ERROR("Unable to initialize queues\n");
3593                 goto error;
3594         }
3595
3596         /* Ensure interrupts are disabled */
3597         ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3598         /* ack pending interrupts */
3599         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3600
3601         /* kick start the device */
3602         ipw_start_nic(priv);
3603
3604         if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
3605                 if (retries > 0) {
3606                         IPW_WARNING("Parity error.  Retrying init.\n");
3607                         retries--;
3608                         goto retry;
3609                 }
3610
3611                 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3612                 rc = -EIO;
3613                 goto error;
3614         }
3615
3616         /* wait for the device */
3617         rc = ipw_poll_bit(priv, IPW_INTA_RW,
3618                           IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3619         if (rc < 0) {
3620                 IPW_ERROR("device failed to start within 500ms\n");
3621                 goto error;
3622         }
3623         IPW_DEBUG_INFO("device response after %dms\n", rc);
3624
3625         /* ack fw init done interrupt */
3626         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3627
3628         /* read eeprom data and initialize the eeprom region of sram */
3629         priv->eeprom_delay = 1;
3630         ipw_eeprom_init_sram(priv);
3631
3632         /* enable interrupts */
3633         ipw_enable_interrupts(priv);
3634
3635         /* Ensure our queue has valid packets */
3636         ipw_rx_queue_replenish(priv);
3637
3638         ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
3639
3640         /* ack pending interrupts */
3641         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3642
3643 #ifndef CONFIG_PM
3644         release_firmware(raw);
3645 #endif
3646         return 0;
3647
3648       error:
3649         if (priv->rxq) {
3650                 ipw_rx_queue_free(priv, priv->rxq);
3651                 priv->rxq = NULL;
3652         }
3653         ipw_tx_queue_free(priv);
3654         if (raw)
3655                 release_firmware(raw);
3656 #ifdef CONFIG_PM
3657         fw_loaded = 0;
3658         raw = NULL;
3659 #endif
3660
3661         return rc;
3662 }
3663
3664 /**
3665  * DMA services
3666  *
3667  * Theory of operation
3668  *
3669  * A queue is a circular buffers with 'Read' and 'Write' pointers.
3670  * 2 empty entries always kept in the buffer to protect from overflow.
3671  *
3672  * For Tx queue, there are low mark and high mark limits. If, after queuing
3673  * the packet for Tx, free space become < low mark, Tx queue stopped. When
3674  * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
3675  * Tx queue resumed.
3676  *
3677  * The IPW operates with six queues, one receive queue in the device's
3678  * sram, one transmit queue for sending commands to the device firmware,
3679  * and four transmit queues for data.
3680  *
3681  * The four transmit queues allow for performing quality of service (qos)
3682  * transmissions as per the 802.11 protocol.  Currently Linux does not
3683  * provide a mechanism to the user for utilizing prioritized queues, so
3684  * we only utilize the first data transmit queue (queue1).
3685  */
3686
3687 /**
3688  * Driver allocates buffers of this size for Rx
3689  */
3690
3691 /**
3692  * ipw_rx_queue_space - Return number of free slots available in queue.
3693  */
3694 static int ipw_rx_queue_space(const struct ipw_rx_queue *q)
3695 {
3696         int s = q->read - q->write;
3697         if (s <= 0)
3698                 s += RX_QUEUE_SIZE;
3699         /* keep some buffer to not confuse full and empty queue */
3700         s -= 2;
3701         if (s < 0)
3702                 s = 0;
3703         return s;
3704 }
3705
3706 static inline int ipw_tx_queue_space(const struct clx2_queue *q)
3707 {
3708         int s = q->last_used - q->first_empty;
3709         if (s <= 0)
3710                 s += q->n_bd;
3711         s -= 2;                 /* keep some reserve to not confuse empty and full situations */
3712         if (s < 0)
3713                 s = 0;
3714         return s;
3715 }
3716
3717 static inline int ipw_queue_inc_wrap(int index, int n_bd)
3718 {
3719         return (++index == n_bd) ? 0 : index;
3720 }
3721
3722 /**
3723  * Initialize common DMA queue structure
3724  *
3725  * @param q                queue to init
3726  * @param count            Number of BD's to allocate. Should be power of 2
3727  * @param read_register    Address for 'read' register
3728  *                         (not offset within BAR, full address)
3729  * @param write_register   Address for 'write' register
3730  *                         (not offset within BAR, full address)
3731  * @param base_register    Address for 'base' register
3732  *                         (not offset within BAR, full address)
3733  * @param size             Address for 'size' register
3734  *                         (not offset within BAR, full address)
3735  */
3736 static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
3737                            int count, u32 read, u32 write, u32 base, u32 size)
3738 {
3739         q->n_bd = count;
3740
3741         q->low_mark = q->n_bd / 4;
3742         if (q->low_mark < 4)
3743                 q->low_mark = 4;
3744
3745         q->high_mark = q->n_bd / 8;
3746         if (q->high_mark < 2)
3747                 q->high_mark = 2;
3748
3749         q->first_empty = q->last_used = 0;
3750         q->reg_r = read;
3751         q->reg_w = write;
3752
3753         ipw_write32(priv, base, q->dma_addr);
3754         ipw_write32(priv, size, count);
3755         ipw_write32(priv, read, 0);
3756         ipw_write32(priv, write, 0);
3757
3758         _ipw_read32(priv, 0x90);
3759 }
3760
3761 static int ipw_queue_tx_init(struct ipw_priv *priv,
3762                              struct clx2_tx_queue *q,
3763                              int count, u32 read, u32 write, u32 base, u32 size)
3764 {
3765         struct pci_dev *dev = priv->pci_dev;
3766
3767         q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL);
3768         if (!q->txb) {
3769                 IPW_ERROR("vmalloc for auxilary BD structures failed\n");
3770                 return -ENOMEM;
3771         }
3772
3773         q->bd =
3774             pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
3775         if (!q->bd) {
3776                 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
3777                           sizeof(q->bd[0]) * count);
3778                 kfree(q->txb);
3779                 q->txb = NULL;
3780                 return -ENOMEM;
3781         }
3782
3783         ipw_queue_init(priv, &q->q, count, read, write, base, size);
3784         return 0;
3785 }
3786
3787 /**
3788  * Free one TFD, those at index [txq->q.last_used].
3789  * Do NOT advance any indexes
3790  *
3791  * @param dev
3792  * @param txq
3793  */
3794 static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3795                                   struct clx2_tx_queue *txq)
3796 {
3797         struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3798         struct pci_dev *dev = priv->pci_dev;
3799         int i;
3800
3801         /* classify bd */
3802         if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3803                 /* nothing to cleanup after for host commands */
3804                 return;
3805
3806         /* sanity check */
3807         if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3808                 IPW_ERROR("Too many chunks: %i\n",
3809                           le32_to_cpu(bd->u.data.num_chunks));
3810                 /** @todo issue fatal error, it is quite serious situation */
3811                 return;
3812         }
3813
3814         /* unmap chunks if any */
3815         for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3816                 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
3817                                  le16_to_cpu(bd->u.data.chunk_len[i]),
3818                                  PCI_DMA_TODEVICE);
3819                 if (txq->txb[txq->q.last_used]) {
3820                         libipw_txb_free(txq->txb[txq->q.last_used]);
3821                         txq->txb[txq->q.last_used] = NULL;
3822                 }
3823         }
3824 }
3825
3826 /**
3827  * Deallocate DMA queue.
3828  *
3829  * Empty queue by removing and destroying all BD's.
3830  * Free all buffers.
3831  *
3832  * @param dev
3833  * @param q
3834  */
3835 static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
3836 {
3837         struct clx2_queue *q = &txq->q;
3838         struct pci_dev *dev = priv->pci_dev;
3839
3840         if (q->n_bd == 0)
3841                 return;
3842
3843         /* first, empty all BD's */
3844         for (; q->first_empty != q->last_used;
3845              q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3846                 ipw_queue_tx_free_tfd(priv, txq);
3847         }
3848
3849         /* free buffers belonging to queue itself */
3850         pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
3851                             q->dma_addr);
3852         kfree(txq->txb);
3853
3854         /* 0 fill whole structure */
3855         memset(txq, 0, sizeof(*txq));
3856 }
3857
3858 /**
3859  * Destroy all DMA queues and structures
3860  *
3861  * @param priv
3862  */
3863 static void ipw_tx_queue_free(struct ipw_priv *priv)
3864 {
3865         /* Tx CMD queue */
3866         ipw_queue_tx_free(priv, &priv->txq_cmd);
3867
3868         /* Tx queues */
3869         ipw_queue_tx_free(priv, &priv->txq[0]);
3870         ipw_queue_tx_free(priv, &priv->txq[1]);
3871         ipw_queue_tx_free(priv, &priv->txq[2]);
3872         ipw_queue_tx_free(priv, &priv->txq[3]);
3873 }
3874
3875 static void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
3876 {
3877         /* First 3 bytes are manufacturer */
3878         bssid[0] = priv->mac_addr[0];
3879         bssid[1] = priv->mac_addr[1];
3880         bssid[2] = priv->mac_addr[2];
3881
3882         /* Last bytes are random */
3883         get_random_bytes(&bssid[3], ETH_ALEN - 3);
3884
3885         bssid[0] &= 0xfe;       /* clear multicast bit */
3886         bssid[0] |= 0x02;       /* set local assignment bit (IEEE802) */
3887 }
3888
3889 static u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
3890 {
3891         struct ipw_station_entry entry;
3892         int i;
3893
3894         for (i = 0; i < priv->num_stations; i++) {
3895                 if (!memcmp(priv->stations[i], bssid, ETH_ALEN)) {
3896                         /* Another node is active in network */
3897                         priv->missed_adhoc_beacons = 0;
3898                         if (!(priv->config & CFG_STATIC_CHANNEL))
3899                                 /* when other nodes drop out, we drop out */
3900                                 priv->config &= ~CFG_ADHOC_PERSIST;
3901
3902                         return i;
3903                 }
3904         }
3905
3906         if (i == MAX_STATIONS)
3907                 return IPW_INVALID_STATION;
3908
3909         IPW_DEBUG_SCAN("Adding AdHoc station: %pM\n", bssid);
3910
3911         entry.reserved = 0;
3912         entry.support_mode = 0;
3913         memcpy(entry.mac_addr, bssid, ETH_ALEN);
3914         memcpy(priv->stations[i], bssid, ETH_ALEN);
3915         ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
3916                          &entry, sizeof(entry));
3917         priv->num_stations++;
3918
3919         return i;
3920 }
3921
3922 static u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
3923 {
3924         int i;
3925
3926         for (i = 0; i < priv->num_stations; i++)
3927                 if (!memcmp(priv->stations[i], bssid, ETH_ALEN))
3928                         return i;
3929
3930         return IPW_INVALID_STATION;
3931 }
3932
3933 static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3934 {
3935         int err;
3936
3937         if (priv->status & STATUS_ASSOCIATING) {
3938                 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
3939                 queue_work(priv->workqueue, &priv->disassociate);
3940                 return;
3941         }
3942
3943         if (!(priv->status & STATUS_ASSOCIATED)) {
3944                 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3945                 return;
3946         }
3947
3948         IPW_DEBUG_ASSOC("Disassocation attempt from %pM "
3949                         "on channel %d.\n",
3950                         priv->assoc_request.bssid,
3951                         priv->assoc_request.channel);
3952
3953         priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3954         priv->status |= STATUS_DISASSOCIATING;
3955
3956         if (quiet)
3957                 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3958         else
3959                 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
3960
3961         err = ipw_send_associate(priv, &priv->assoc_request);
3962         if (err) {
3963                 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3964                              "failed.\n");
3965                 return;
3966         }
3967
3968 }
3969
3970 static int ipw_disassociate(void *data)
3971 {
3972         struct ipw_priv *priv = data;
3973         if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3974                 return 0;
3975         ipw_send_disassociate(data, 0);
3976         netif_carrier_off(priv->net_dev);
3977         return 1;
3978 }
3979
3980 static void ipw_bg_disassociate(struct work_struct *work)
3981 {
3982         struct ipw_priv *priv =
3983                 container_of(work, struct ipw_priv, disassociate);
3984         mutex_lock(&priv->mutex);
3985         ipw_disassociate(priv);
3986         mutex_unlock(&priv->mutex);
3987 }
3988
3989 static void ipw_system_config(struct work_struct *work)
3990 {
3991         struct ipw_priv *priv =
3992                 container_of(work, struct ipw_priv, system_config);
3993
3994 #ifdef CONFIG_IPW2200_PROMISCUOUS
3995         if (priv->prom_net_dev && netif_running(priv->prom_net_dev)) {
3996                 priv->sys_config.accept_all_data_frames = 1;
3997                 priv->sys_config.accept_non_directed_frames = 1;
3998                 priv->sys_config.accept_all_mgmt_bcpr = 1;
3999                 priv->sys_config.accept_all_mgmt_frames = 1;
4000         }
4001 #endif
4002
4003         ipw_send_system_config(priv);
4004 }
4005
4006 struct ipw_status_code {
4007         u16 status;
4008         const char *reason;
4009 };
4010
4011 static const struct ipw_status_code ipw_status_codes[] = {
4012         {0x00, "Successful"},
4013         {0x01, "Unspecified failure"},
4014         {0x0A, "Cannot support all requested capabilities in the "
4015          "Capability information field"},
4016         {0x0B, "Reassociation denied due to inability to confirm that "
4017          "association exists"},
4018         {0x0C, "Association denied due to reason outside the scope of this "
4019          "standard"},
4020         {0x0D,
4021          "Responding station does not support the specified authentication "
4022          "algorithm"},
4023         {0x0E,
4024          "Received an Authentication frame with authentication sequence "
4025          "transaction sequence number out of expected sequence"},
4026         {0x0F, "Authentication rejected because of challenge failure"},
4027         {0x10, "Authentication rejected due to timeout waiting for next "
4028          "frame in sequence"},
4029         {0x11, "Association denied because AP is unable to handle additional "
4030          "associated stations"},
4031         {0x12,
4032          "Association denied due to requesting station not supporting all "
4033          "of the datarates in the BSSBasicServiceSet Parameter"},
4034         {0x13,
4035          "Association denied due to requesting station not supporting "
4036          "short preamble operation"},
4037         {0x14,
4038          "Association denied due to requesting station not supporting "
4039          "PBCC encoding"},
4040         {0x15,
4041          "Association denied due to requesting station not supporting "
4042          "channel agility"},
4043         {0x19,
4044          "Association denied due to requesting station not supporting "
4045          "short slot operation"},
4046         {0x1A,
4047          "Association denied due to requesting station not supporting "
4048          "DSSS-OFDM operation"},
4049         {0x28, "Invalid Information Element"},
4050         {0x29, "Group Cipher is not valid"},
4051         {0x2A, "Pairwise Cipher is not valid"},
4052         {0x2B, "AKMP is not valid"},
4053         {0x2C, "Unsupported RSN IE version"},
4054         {0x2D, "Invalid RSN IE Capabilities"},
4055         {0x2E, "Cipher suite is rejected per security policy"},
4056 };
4057
4058 static const char *ipw_get_status_code(u16 status)
4059 {
4060         int i;
4061         for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
4062                 if (ipw_status_codes[i].status == (status & 0xff))
4063                         return ipw_status_codes[i].reason;
4064         return "Unknown status value.";
4065 }
4066
4067 static void inline average_init(struct average *avg)
4068 {
4069         memset(avg, 0, sizeof(*avg));
4070 }
4071
4072 #define DEPTH_RSSI 8
4073 #define DEPTH_NOISE 16
4074 static s16 exponential_average(s16 prev_avg, s16 val, u8 depth)
4075 {
4076         return ((depth-1)*prev_avg +  val)/depth;
4077 }
4078
4079 static void average_add(struct average *avg, s16 val)
4080 {
4081         avg->sum -= avg->entries[avg->pos];
4082         avg->sum += val;
4083         avg->entries[avg->pos++] = val;
4084         if (unlikely(avg->pos == AVG_ENTRIES)) {
4085                 avg->init = 1;
4086                 avg->pos = 0;
4087         }
4088 }
4089
4090 static s16 average_value(struct average *avg)
4091 {
4092         if (!unlikely(avg->init)) {
4093                 if (avg->pos)
4094                         return avg->sum / avg->pos;
4095                 return 0;
4096         }
4097
4098         return avg->sum / AVG_ENTRIES;
4099 }
4100
4101 static void ipw_reset_stats(struct ipw_priv *priv)
4102 {
4103         u32 len = sizeof(u32);
4104
4105         priv->quality = 0;
4106
4107         average_init(&priv->average_missed_beacons);
4108         priv->exp_avg_rssi = -60;
4109         priv->exp_avg_noise = -85 + 0x100;
4110
4111         priv->last_rate = 0;
4112         priv->last_missed_beacons = 0;
4113         priv->last_rx_packets = 0;
4114         priv->last_tx_packets = 0;
4115         priv->last_tx_failures = 0;
4116
4117         /* Firmware managed, reset only when NIC is restarted, so we have to
4118          * normalize on the current value */
4119         ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
4120                         &priv->last_rx_err, &len);
4121         ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
4122                         &priv->last_tx_failures, &len);
4123
4124         /* Driver managed, reset with each association */
4125         priv->missed_adhoc_beacons = 0;
4126         priv->missed_beacons = 0;
4127         priv->tx_packets = 0;
4128         priv->rx_packets = 0;
4129
4130 }
4131
4132 static u32 ipw_get_max_rate(struct ipw_priv *priv)
4133 {
4134         u32 i = 0x80000000;
4135         u32 mask = priv->rates_mask;
4136         /* If currently associated in B mode, restrict the maximum
4137          * rate match to B rates */
4138         if (priv->assoc_request.ieee_mode == IPW_B_MODE)
4139                 mask &= LIBIPW_CCK_RATES_MASK;
4140
4141         /* TODO: Verify that the rate is supported by the current rates
4142          * list. */
4143
4144         while (i && !(mask & i))
4145                 i >>= 1;
4146         switch (i) {
4147         case LIBIPW_CCK_RATE_1MB_MASK:
4148                 return 1000000;
4149         case LIBIPW_CCK_RATE_2MB_MASK:
4150                 return 2000000;
4151         case LIBIPW_CCK_RATE_5MB_MASK:
4152                 return 5500000;
4153         case LIBIPW_OFDM_RATE_6MB_MASK:
4154                 return 6000000;
4155         case LIBIPW_OFDM_RATE_9MB_MASK:
4156                 return 9000000;
4157         case LIBIPW_CCK_RATE_11MB_MASK:
4158                 return 11000000;
4159         case LIBIPW_OFDM_RATE_12MB_MASK:
4160                 return 12000000;
4161         case LIBIPW_OFDM_RATE_18MB_MASK:
4162                 return 18000000;
4163         case LIBIPW_OFDM_RATE_24MB_MASK:
4164                 return 24000000;
4165         case LIBIPW_OFDM_RATE_36MB_MASK:
4166                 return 36000000;
4167         case LIBIPW_OFDM_RATE_48MB_MASK:
4168                 return 48000000;
4169         case LIBIPW_OFDM_RATE_54MB_MASK:
4170                 return 54000000;
4171         }
4172
4173         if (priv->ieee->mode == IEEE_B)
4174                 return 11000000;
4175         else
4176                 return 54000000;
4177 }
4178
4179 static u32 ipw_get_current_rate(struct ipw_priv *priv)
4180 {
4181         u32 rate, len = sizeof(rate);
4182         int err;
4183
4184         if (!(priv->status & STATUS_ASSOCIATED))
4185                 return 0;
4186
4187         if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
4188                 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
4189                                       &len);
4190                 if (err) {
4191                         IPW_DEBUG_INFO("failed querying ordinals.\n");
4192                         return 0;
4193                 }
4194         } else
4195                 return ipw_get_max_rate(priv);
4196
4197         switch (rate) {
4198         case IPW_TX_RATE_1MB:
4199                 return 1000000;
4200         case IPW_TX_RATE_2MB:
4201                 return 2000000;
4202         case IPW_TX_RATE_5MB:
4203                 return 5500000;
4204         case IPW_TX_RATE_6MB:
4205                 return 6000000;
4206         case IPW_TX_RATE_9MB:
4207                 return 9000000;
4208         case IPW_TX_RATE_11MB:
4209                 return 11000000;
4210         case IPW_TX_RATE_12MB:
4211                 return 12000000;
4212         case IPW_TX_RATE_18MB:
4213                 return 18000000;
4214         case IPW_TX_RATE_24MB:
4215                 return 24000000;
4216         case IPW_TX_RATE_36MB:
4217                 return 36000000;
4218         case IPW_TX_RATE_48MB:
4219                 return 48000000;
4220         case IPW_TX_RATE_54MB:
4221                 return 54000000;
4222         }
4223
4224         return 0;
4225 }
4226
4227 #define IPW_STATS_INTERVAL (2 * HZ)
4228 static void ipw_gather_stats(struct ipw_priv *priv)
4229 {
4230         u32 rx_err, rx_err_delta, rx_packets_delta;
4231         u32 tx_failures, tx_failures_delta, tx_packets_delta;
4232         u32 missed_beacons_percent, missed_beacons_delta;
4233         u32 quality = 0;
4234         u32 len = sizeof(u32);
4235         s16 rssi;
4236         u32 beacon_quality, signal_quality, tx_quality, rx_quality,
4237             rate_quality;
4238         u32 max_rate;
4239
4240         if (!(priv->status & STATUS_ASSOCIATED)) {
4241                 priv->quality = 0;
4242                 return;
4243         }
4244
4245         /* Update the statistics */
4246         ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
4247                         &priv->missed_beacons, &len);
4248         missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
4249         priv->last_missed_beacons = priv->missed_beacons;
4250         if (priv->assoc_request.beacon_interval) {
4251                 missed_beacons_percent = missed_beacons_delta *
4252                     (HZ * le16_to_cpu(priv->assoc_request.beacon_interval)) /
4253                     (IPW_STATS_INTERVAL * 10);
4254         } else {
4255                 missed_beacons_percent = 0;
4256         }
4257         average_add(&priv->average_missed_beacons, missed_beacons_percent);
4258
4259         ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
4260         rx_err_delta = rx_err - priv->last_rx_err;
4261         priv->last_rx_err = rx_err;
4262
4263         ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
4264         tx_failures_delta = tx_failures - priv->last_tx_failures;
4265         priv->last_tx_failures = tx_failures;
4266
4267         rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
4268         priv->last_rx_packets = priv->rx_packets;
4269
4270         tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
4271         priv->last_tx_packets = priv->tx_packets;
4272
4273         /* Calculate quality based on the following:
4274          *
4275          * Missed beacon: 100% = 0, 0% = 70% missed
4276          * Rate: 60% = 1Mbs, 100% = Max
4277          * Rx and Tx errors represent a straight % of total Rx/Tx
4278          * RSSI: 100% = > -50,  0% = < -80
4279          * Rx errors: 100% = 0, 0% = 50% missed
4280          *
4281          * The lowest computed quality is used.
4282          *
4283          */
4284 #define BEACON_THRESHOLD 5
4285         beacon_quality = 100 - missed_beacons_percent;
4286         if (beacon_quality < BEACON_THRESHOLD)
4287                 beacon_quality = 0;
4288         else
4289                 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
4290                     (100 - BEACON_THRESHOLD);
4291         IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
4292                         beacon_quality, missed_beacons_percent);
4293
4294         priv->last_rate = ipw_get_current_rate(priv);
4295         max_rate = ipw_get_max_rate(priv);
4296         rate_quality = priv->last_rate * 40 / max_rate + 60;
4297         IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4298                         rate_quality, priv->last_rate / 1000000);
4299
4300         if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
4301                 rx_quality = 100 - (rx_err_delta * 100) /
4302                     (rx_packets_delta + rx_err_delta);
4303         else
4304                 rx_quality = 100;
4305         IPW_DEBUG_STATS("Rx quality   : %3d%% (%u errors, %u packets)\n",
4306                         rx_quality, rx_err_delta, rx_packets_delta);
4307
4308         if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
4309                 tx_quality = 100 - (tx_failures_delta * 100) /
4310                     (tx_packets_delta + tx_failures_delta);
4311         else
4312                 tx_quality = 100;
4313         IPW_DEBUG_STATS("Tx quality   : %3d%% (%u errors, %u packets)\n",
4314                         tx_quality, tx_failures_delta, tx_packets_delta);
4315
4316         rssi = priv->exp_avg_rssi;
4317         signal_quality =
4318             (100 *
4319              (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4320              (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4321              (priv->ieee->perfect_rssi - rssi) *
4322              (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4323               62 * (priv->ieee->perfect_rssi - rssi))) /
4324             ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4325              (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4326         if (signal_quality > 100)
4327                 signal_quality = 100;
4328         else if (signal_quality < 1)
4329                 signal_quality = 0;
4330
4331         IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
4332                         signal_quality, rssi);
4333
4334         quality = min(rx_quality, signal_quality);
4335         quality = min(tx_quality, quality);
4336         quality = min(rate_quality, quality);
4337         quality = min(beacon_quality, quality);
4338         if (quality == beacon_quality)
4339                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4340                                 quality);
4341         if (quality == rate_quality)
4342                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4343                                 quality);
4344         if (quality == tx_quality)
4345                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4346                                 quality);
4347         if (quality == rx_quality)
4348                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4349                                 quality);
4350         if (quality == signal_quality)
4351                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4352                                 quality);
4353
4354         priv->quality = quality;
4355
4356         queue_delayed_work(priv->workqueue, &priv->gather_stats,
4357                            IPW_STATS_INTERVAL);
4358 }
4359
4360 static void ipw_bg_gather_stats(struct work_struct *work)
4361 {
4362         struct ipw_priv *priv =
4363                 container_of(work, struct ipw_priv, gather_stats.work);
4364         mutex_lock(&priv->mutex);
4365         ipw_gather_stats(priv);
4366         mutex_unlock(&priv->mutex);
4367 }
4368
4369 /* Missed beacon behavior:
4370  * 1st missed -> roaming_threshold, just wait, don't do any scan/roam.
4371  * roaming_threshold -> disassociate_threshold, scan and roam for better signal.
4372  * Above disassociate threshold, give up and stop scanning.
4373  * Roaming is disabled if disassociate_threshold <= roaming_threshold  */
4374 static void ipw_handle_missed_beacon(struct ipw_priv *priv,
4375                                             int missed_count)
4376 {
4377         priv->notif_missed_beacons = missed_count;
4378
4379         if (missed_count > priv->disassociate_threshold &&
4380             priv->status & STATUS_ASSOCIATED) {
4381                 /* If associated and we've hit the missed
4382                  * beacon threshold, disassociate, turn
4383                  * off roaming, and abort any active scans */
4384                 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4385                           IPW_DL_STATE | IPW_DL_ASSOC,
4386                           "Missed beacon: %d - disassociate\n", missed_count);
4387                 priv->status &= ~STATUS_ROAMING;
4388                 if (priv->status & STATUS_SCANNING) {
4389                         IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4390                                   IPW_DL_STATE,
4391                                   "Aborting scan with missed beacon.\n");
4392                         queue_work(priv->workqueue, &priv->abort_scan);
4393                 }
4394
4395                 queue_work(priv->workqueue, &priv->disassociate);
4396                 return;
4397         }
4398
4399         if (priv->status & STATUS_ROAMING) {
4400                 /* If we are currently roaming, then just
4401                  * print a debug statement... */
4402                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4403                           "Missed beacon: %d - roam in progress\n",
4404                           missed_count);
4405                 return;
4406         }
4407
4408         if (roaming &&
4409             (missed_count > priv->roaming_threshold &&
4410              missed_count <= priv->disassociate_threshold)) {
4411                 /* If we are not already roaming, set the ROAM
4412                  * bit in the status and kick off a scan.
4413                  * This can happen several times before we reach
4414                  * disassociate_threshold. */
4415                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4416                           "Missed beacon: %d - initiate "
4417                           "roaming\n", missed_count);
4418                 if (!(priv->status & STATUS_ROAMING)) {
4419                         priv->status |= STATUS_ROAMING;
4420                         if (!(priv->status & STATUS_SCANNING))
4421                                 queue_delayed_work(priv->workqueue,
4422                                                    &priv->request_scan, 0);
4423                 }
4424                 return;
4425         }
4426
4427         if (priv->status & STATUS_SCANNING &&
4428             missed_count > IPW_MB_SCAN_CANCEL_THRESHOLD) {
4429                 /* Stop scan to keep fw from getting
4430                  * stuck (only if we aren't roaming --
4431                  * otherwise we'll never scan more than 2 or 3
4432                  * channels..) */
4433                 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4434                           "Aborting scan with missed beacon.\n");
4435                 queue_work(priv->workqueue, &priv->abort_scan);
4436         }
4437
4438         IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
4439 }
4440
4441 static void ipw_scan_event(struct work_struct *work)
4442 {
4443         union iwreq_data wrqu;
4444
4445         struct ipw_priv *priv =
4446                 container_of(work, struct ipw_priv, scan_event.work);
4447
4448         wrqu.data.length = 0;
4449         wrqu.data.flags = 0;
4450         wireless_send_event(priv->net_dev, SIOCGIWSCAN, &wrqu, NULL);
4451 }
4452
4453 static void handle_scan_event(struct ipw_priv *priv)
4454 {
4455         /* Only userspace-requested scan completion events go out immediately */
4456         if (!priv->user_requested_scan) {
4457                 if (!delayed_work_pending(&priv->scan_event))
4458                         queue_delayed_work(priv->workqueue, &priv->scan_event,
4459                                          round_jiffies_relative(msecs_to_jiffies(4000)));
4460         } else {
4461                 union iwreq_data wrqu;
4462
4463                 priv->user_requested_scan = 0;
4464                 cancel_delayed_work(&priv->scan_event);
4465
4466                 wrqu.data.length = 0;
4467                 wrqu.data.flags = 0;
4468                 wireless_send_event(priv->net_dev, SIOCGIWSCAN, &wrqu, NULL);
4469         }
4470 }
4471
4472 /**
4473  * Handle host notification packet.
4474  * Called from interrupt routine
4475  */
4476 static void ipw_rx_notification(struct ipw_priv *priv,
4477                                        struct ipw_rx_notification *notif)
4478 {
4479         DECLARE_SSID_BUF(ssid);
4480         u16 size = le16_to_cpu(notif->size);
4481
4482         IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, size);
4483
4484         switch (notif->subtype) {
4485         case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4486                         struct notif_association *assoc = &notif->u.assoc;
4487
4488                         switch (assoc->state) {
4489                         case CMAS_ASSOCIATED:{
4490                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4491                                                   IPW_DL_ASSOC,
4492                                                   "associated: '%s' %pM\n",
4493                                                   print_ssid(ssid, priv->essid,
4494                                                              priv->essid_len),
4495                                                   priv->bssid);
4496
4497                                         switch (priv->ieee->iw_mode) {
4498                                         case IW_MODE_INFRA:
4499                                                 memcpy(priv->ieee->bssid,
4500                                                        priv->bssid, ETH_ALEN);
4501                                                 break;
4502
4503                                         case IW_MODE_ADHOC:
4504                                                 memcpy(priv->ieee->bssid,
4505                                                        priv->bssid, ETH_ALEN);
4506
4507                                                 /* clear out the station table */
4508                                                 priv->num_stations = 0;
4509
4510                                                 IPW_DEBUG_ASSOC
4511                                                     ("queueing adhoc check\n");
4512                                                 queue_delayed_work(priv->
4513                                                                    workqueue,
4514                                                                    &priv->
4515                                                                    adhoc_check,
4516                                                                    le16_to_cpu(priv->
4517                                                                    assoc_request.
4518                                                                    beacon_interval));
4519                                                 break;
4520                                         }
4521
4522                                         priv->status &= ~STATUS_ASSOCIATING;
4523                                         priv->status |= STATUS_ASSOCIATED;
4524                                         queue_work(priv->workqueue,
4525                                                    &priv->system_config);
4526
4527 #ifdef CONFIG_IPW2200_QOS
4528 #define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
4529                          le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_control))
4530                                         if ((priv->status & STATUS_AUTH) &&
4531                                             (IPW_GET_PACKET_STYPE(&notif->u.raw)
4532                                              == IEEE80211_STYPE_ASSOC_RESP)) {
4533                                                 if ((sizeof
4534                                                      (struct
4535                                                       libipw_assoc_response)
4536                                                      <= size)
4537                                                     && (size <= 2314)) {
4538                                                         struct
4539                                                         libipw_rx_stats
4540                                                             stats = {
4541                                                                 .len = size - 1,
4542                                                         };
4543
4544                                                         IPW_DEBUG_QOS
4545                                                             ("QoS Associate "
4546                                                              "size %d\n", size);
4547                                                         libipw_rx_mgt(priv->
4548                                                                          ieee,
4549                                                                          (struct
4550                                                                           libipw_hdr_4addr
4551                                                                           *)
4552                                                                          &notif->u.raw, &stats);
4553                                                 }
4554                                         }
4555 #endif
4556
4557                                         schedule_work(&priv->link_up);
4558
4559                                         break;
4560                                 }
4561
4562                         case CMAS_AUTHENTICATED:{
4563                                         if (priv->
4564                                             status & (STATUS_ASSOCIATED |
4565                                                       STATUS_AUTH)) {
4566                                                 struct notif_authenticate *auth
4567                                                     = &notif->u.auth;
4568                                                 IPW_DEBUG(IPW_DL_NOTIF |
4569                                                           IPW_DL_STATE |
4570                                                           IPW_DL_ASSOC,
4571                                                           "deauthenticated: '%s' "
4572                                                           "%pM"
4573                                                           ": (0x%04X) - %s\n",
4574                                                           print_ssid(ssid,
4575                                                                      priv->
4576                                                                      essid,
4577                                                                      priv->
4578                                                                      essid_len),
4579                                                           priv->bssid,
4580                                                           le16_to_cpu(auth->status),
4581                                                           ipw_get_status_code
4582                                                           (le16_to_cpu
4583                                                            (auth->status)));
4584
4585                                                 priv->status &=
4586                                                     ~(STATUS_ASSOCIATING |
4587                                                       STATUS_AUTH |
4588                                                       STATUS_ASSOCIATED);
4589
4590                                                 schedule_work(&priv->link_down);
4591                                                 break;
4592                                         }
4593
4594                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4595                                                   IPW_DL_ASSOC,
4596                                                   "authenticated: '%s' %pM\n",
4597                                                   print_ssid(ssid, priv->essid,
4598                                                              priv->essid_len),
4599                                                   priv->bssid);
4600                                         break;
4601                                 }
4602
4603                         case CMAS_INIT:{
4604                                         if (priv->status & STATUS_AUTH) {
4605                                                 struct
4606                                                     libipw_assoc_response
4607                                                 *resp;
4608                                                 resp =
4609                                                     (struct
4610                                                      libipw_assoc_response
4611                                                      *)&notif->u.raw;
4612                                                 IPW_DEBUG(IPW_DL_NOTIF |
4613                                                           IPW_DL_STATE |
4614                                                           IPW_DL_ASSOC,
4615                                                           "association failed (0x%04X): %s\n",
4616                                                           le16_to_cpu(resp->status),
4617                                                           ipw_get_status_code
4618                                                           (le16_to_cpu
4619                                                            (resp->status)));
4620                                         }
4621
4622                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4623                                                   IPW_DL_ASSOC,
4624                                                   "disassociated: '%s' %pM\n",
4625                                                   print_ssid(ssid, priv->essid,
4626                                                              priv->essid_len),
4627                                                   priv->bssid);
4628
4629                                         priv->status &=
4630                                             ~(STATUS_DISASSOCIATING |
4631                                               STATUS_ASSOCIATING |
4632                                               STATUS_ASSOCIATED | STATUS_AUTH);
4633                                         if (priv->assoc_network
4634                                             && (priv->assoc_network->
4635                                                 capability &
4636                                                 WLAN_CAPABILITY_IBSS))
4637                                                 ipw_remove_current_network
4638                                                     (priv);
4639
4640                                         schedule_work(&priv->link_down);
4641
4642                                         break;
4643                                 }
4644
4645                         case CMAS_RX_ASSOC_RESP:
4646                                 break;
4647
4648                         default:
4649                                 IPW_ERROR("assoc: unknown (%d)\n",
4650                                           assoc->state);
4651                                 break;
4652                         }
4653
4654                         break;
4655                 }
4656
4657         case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4658                         struct notif_authenticate *auth = &notif->u.auth;
4659                         switch (auth->state) {
4660                         case CMAS_AUTHENTICATED:
4661                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4662                                           "authenticated: '%s' %pM\n",
4663                                           print_ssid(ssid, priv->essid,
4664                                                      priv->essid_len),
4665                                           priv->bssid);
4666                                 priv->status |= STATUS_AUTH;
4667                                 break;
4668
4669                         case CMAS_INIT:
4670                                 if (priv->status & STATUS_AUTH) {
4671                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4672                                                   IPW_DL_ASSOC,
4673                                                   "authentication failed (0x%04X): %s\n",
4674                                                   le16_to_cpu(auth->status),
4675                                                   ipw_get_status_code(le16_to_cpu
4676                                                                       (auth->
4677                                                                        status)));
4678                                 }
4679                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4680                                           IPW_DL_ASSOC,
4681                                           "deauthenticated: '%s' %pM\n",
4682                                           print_ssid(ssid, priv->essid,
4683                                                      priv->essid_len),
4684                                           priv->bssid);
4685
4686                                 priv->status &= ~(STATUS_ASSOCIATING |
4687                                                   STATUS_AUTH |
4688                                                   STATUS_ASSOCIATED);
4689
4690                                 schedule_work(&priv->link_down);
4691                                 break;
4692
4693                         case CMAS_TX_AUTH_SEQ_1:
4694                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4695                                           IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4696                                 break;
4697                         case CMAS_RX_AUTH_SEQ_2:
4698                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4699                                           IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4700                                 break;
4701                         case CMAS_AUTH_SEQ_1_PASS:
4702                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4703                                           IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4704                                 break;
4705                         case CMAS_AUTH_SEQ_1_FAIL:
4706                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4707                                           IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4708                                 break;
4709                         case CMAS_TX_AUTH_SEQ_3:
4710                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4711                                           IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4712                                 break;
4713                         case CMAS_RX_AUTH_SEQ_4:
4714                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4715                                           IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4716                                 break;
4717                         case CMAS_AUTH_SEQ_2_PASS:
4718                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4719                                           IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4720                                 break;
4721                         case CMAS_AUTH_SEQ_2_FAIL:
4722                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4723                                           IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4724                                 break;
4725                         case CMAS_TX_ASSOC:
4726                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4727                                           IPW_DL_ASSOC, "TX_ASSOC\n");
4728                                 break;
4729                         case CMAS_RX_ASSOC_RESP:
4730                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4731                                           IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
4732
4733                                 break;
4734                         case CMAS_ASSOCIATED:
4735                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4736                                           IPW_DL_ASSOC, "ASSOCIATED\n");
4737                                 break;
4738                         default:
4739                                 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4740                                                 auth->state);
4741                                 break;
4742                         }
4743                         break;
4744                 }
4745
4746         case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4747                         struct notif_channel_result *x =
4748                             &notif->u.channel_result;
4749
4750                         if (size == sizeof(*x)) {
4751                                 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4752                                                x->channel_num);
4753                         } else {
4754                                 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4755                                                "(should be %zd)\n",
4756                                                size, sizeof(*x));
4757                         }
4758                         break;
4759                 }
4760
4761         case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4762                         struct notif_scan_complete *x = &notif->u.scan_complete;
4763                         if (size == sizeof(*x)) {
4764                                 IPW_DEBUG_SCAN
4765                                     ("Scan completed: type %d, %d channels, "
4766                                      "%d status\n", x->scan_type,
4767                                      x->num_channels, x->status);
4768                         } else {
4769                                 IPW_ERROR("Scan completed of wrong size %d "
4770                                           "(should be %zd)\n",
4771                                           size, sizeof(*x));
4772                         }
4773
4774                         priv->status &=
4775                             ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4776
4777                         wake_up_interruptible(&priv->wait_state);
4778                         cancel_delayed_work(&priv->scan_check);
4779
4780                         if (priv->status & STATUS_EXIT_PENDING)
4781                                 break;
4782
4783                         priv->ieee->scans++;
4784
4785 #ifdef CONFIG_IPW2200_MONITOR
4786                         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
4787                                 priv->status |= STATUS_SCAN_FORCED;
4788                                 queue_delayed_work(priv->workqueue,
4789                                                    &priv->request_scan, 0);
4790                                 break;
4791                         }
4792                         priv->status &= ~STATUS_SCAN_FORCED;
4793 #endif                          /* CONFIG_IPW2200_MONITOR */
4794
4795                         /* Do queued direct scans first */
4796                         if (priv->status & STATUS_DIRECT_SCAN_PENDING) {
4797                                 queue_delayed_work(priv->workqueue,
4798                                                    &priv->request_direct_scan, 0);
4799                         }
4800
4801                         if (!(priv->status & (STATUS_ASSOCIATED |
4802                                               STATUS_ASSOCIATING |
4803                                               STATUS_ROAMING |
4804                                               STATUS_DISASSOCIATING)))
4805                                 queue_work(priv->workqueue, &priv->associate);
4806                         else if (priv->status & STATUS_ROAMING) {
4807                                 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4808                                         /* If a scan completed and we are in roam mode, then
4809                                          * the scan that completed was the one requested as a
4810                                          * result of entering roam... so, schedule the
4811                                          * roam work */
4812                                         queue_work(priv->workqueue,
4813                                                    &priv->roam);
4814                                 else
4815                                         /* Don't schedule if we aborted the scan */
4816                                         priv->status &= ~STATUS_ROAMING;
4817                         } else if (priv->status & STATUS_SCAN_PENDING)
4818                                 queue_delayed_work(priv->workqueue,
4819                                                    &priv->request_scan, 0);
4820                         else if (priv->config & CFG_BACKGROUND_SCAN
4821                                  && priv->status & STATUS_ASSOCIATED)
4822                                 queue_delayed_work(priv->workqueue,
4823                                                    &priv->request_scan,
4824                                                    round_jiffies_relative(HZ));
4825
4826                         /* Send an empty event to user space.
4827                          * We don't send the received data on the event because
4828                          * it would require us to do complex transcoding, and
4829                          * we want to minimise the work done in the irq handler
4830                          * Use a request to extract the data.
4831                          * Also, we generate this even for any scan, regardless
4832                          * on how the scan was initiated. User space can just
4833                          * sync on periodic scan to get fresh data...
4834                          * Jean II */
4835                         if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4836                                 handle_scan_event(priv);
4837                         break;
4838                 }
4839
4840         case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4841                         struct notif_frag_length *x = &notif->u.frag_len;
4842
4843                         if (size == sizeof(*x))
4844                                 IPW_ERROR("Frag length: %d\n",
4845                                           le16_to_cpu(x->frag_length));
4846                         else
4847                                 IPW_ERROR("Frag length of wrong size %d "
4848                                           "(should be %zd)\n",
4849                                           size, sizeof(*x));
4850                         break;
4851                 }
4852
4853         case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4854                         struct notif_link_deterioration *x =
4855                             &notif->u.link_deterioration;
4856
4857                         if (size == sizeof(*x)) {
4858                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4859                                         "link deterioration: type %d, cnt %d\n",
4860                                         x->silence_notification_type,
4861                                         x->silence_count);
4862                                 memcpy(&priv->last_link_deterioration, x,
4863                                        sizeof(*x));
4864                         } else {
4865                                 IPW_ERROR("Link Deterioration of wrong size %d "
4866                                           "(should be %zd)\n",
4867                                           size, sizeof(*x));
4868                         }
4869                         break;
4870                 }
4871
4872         case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4873                         IPW_ERROR("Dino config\n");
4874                         if (priv->hcmd
4875                             && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
4876                                 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
4877
4878                         break;
4879                 }
4880
4881         case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4882                         struct notif_beacon_state *x = &notif->u.beacon_state;
4883                         if (size != sizeof(*x)) {
4884                                 IPW_ERROR
4885                                     ("Beacon state of wrong size %d (should "
4886                                      "be %zd)\n", size, sizeof(*x));
4887                                 break;
4888                         }
4889
4890                         if (le32_to_cpu(x->state) ==
4891                             HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4892                                 ipw_handle_missed_beacon(priv,
4893                                                          le32_to_cpu(x->
4894                                                                      number));
4895
4896                         break;
4897                 }
4898
4899         case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4900                         struct notif_tgi_tx_key *x = &notif->u.tgi_tx_key;
4901                         if (size == sizeof(*x)) {
4902                                 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4903                                           "0x%02x station %d\n",
4904                                           x->key_state, x->security_type,
4905                                           x->station_index);
4906                                 break;
4907                         }
4908
4909                         IPW_ERROR
4910                             ("TGi Tx Key of wrong size %d (should be %zd)\n",
4911                              size, sizeof(*x));
4912                         break;
4913                 }
4914
4915         case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4916                         struct notif_calibration *x = &notif->u.calibration;
4917
4918                         if (size == sizeof(*x)) {
4919                                 memcpy(&priv->calib, x, sizeof(*x));
4920                                 IPW_DEBUG_INFO("TODO: Calibration\n");
4921                                 break;
4922                         }
4923
4924                         IPW_ERROR
4925                             ("Calibration of wrong size %d (should be %zd)\n",
4926                              size, sizeof(*x));
4927                         break;
4928                 }
4929
4930         case HOST_NOTIFICATION_NOISE_STATS:{
4931                         if (size == sizeof(u32)) {
4932                                 priv->exp_avg_noise =
4933                                     exponential_average(priv->exp_avg_noise,
4934                                     (u8) (le32_to_cpu(notif->u.noise.value) & 0xff),
4935                                     DEPTH_NOISE);
4936                                 break;
4937                         }
4938
4939                         IPW_ERROR
4940                             ("Noise stat is wrong size %d (should be %zd)\n",
4941                              size, sizeof(u32));
4942                         break;
4943                 }
4944
4945         default:
4946                 IPW_DEBUG_NOTIF("Unknown notification: "
4947                                 "subtype=%d,flags=0x%2x,size=%d\n",
4948                                 notif->subtype, notif->flags, size);
4949         }
4950 }
4951
4952 /**
4953  * Destroys all DMA structures and initialise them again
4954  *
4955  * @param priv
4956  * @return error code
4957  */
4958 static int ipw_queue_reset(struct ipw_priv *priv)
4959 {
4960         int rc = 0;
4961         /** @todo customize queue sizes */
4962         int nTx = 64, nTxCmd = 8;
4963         ipw_tx_queue_free(priv);
4964         /* Tx CMD queue */
4965         rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
4966                                IPW_TX_CMD_QUEUE_READ_INDEX,
4967                                IPW_TX_CMD_QUEUE_WRITE_INDEX,
4968                                IPW_TX_CMD_QUEUE_BD_BASE,
4969                                IPW_TX_CMD_QUEUE_BD_SIZE);
4970         if (rc) {
4971                 IPW_ERROR("Tx Cmd queue init failed\n");
4972                 goto error;
4973         }
4974         /* Tx queue(s) */
4975         rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
4976                                IPW_TX_QUEUE_0_READ_INDEX,
4977                                IPW_TX_QUEUE_0_WRITE_INDEX,
4978                                IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
4979         if (rc) {
4980                 IPW_ERROR("Tx 0 queue init failed\n");
4981                 goto error;
4982         }
4983         rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
4984                                IPW_TX_QUEUE_1_READ_INDEX,
4985                                IPW_TX_QUEUE_1_WRITE_INDEX,
4986                                IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
4987         if (rc) {
4988                 IPW_ERROR("Tx 1 queue init failed\n");
4989                 goto error;
4990         }
4991         rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
4992                                IPW_TX_QUEUE_2_READ_INDEX,
4993                                IPW_TX_QUEUE_2_WRITE_INDEX,
4994                                IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
4995         if (rc) {
4996                 IPW_ERROR("Tx 2 queue init failed\n");
4997                 goto error;
4998         }
4999         rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
5000                                IPW_TX_QUEUE_3_READ_INDEX,
5001                                IPW_TX_QUEUE_3_WRITE_INDEX,
5002                                IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
5003         if (rc) {
5004                 IPW_ERROR("Tx 3 queue init failed\n");
5005                 goto error;
5006         }
5007         /* statistics */
5008         priv->rx_bufs_min = 0;
5009         priv->rx_pend_max = 0;
5010         return rc;
5011
5012       error:
5013         ipw_tx_queue_free(priv);
5014         return rc;
5015 }
5016
5017 /**
5018  * Reclaim Tx queue entries no more used by NIC.
5019  *
5020  * When FW advances 'R' index, all entries between old and
5021  * new 'R' index need to be reclaimed. As result, some free space
5022  * forms. If there is enough free space (> low mark), wake Tx queue.
5023  *
5024  * @note Need to protect against garbage in 'R' index
5025  * @param priv
5026  * @param txq
5027  * @param qindex
5028  * @return Number of used entries remains in the queue
5029  */
5030 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
5031                                 struct clx2_tx_queue *txq, int qindex)
5032 {
5033         u32 hw_tail;
5034         int used;
5035         struct clx2_queue *q = &txq->q;
5036
5037         hw_tail = ipw_read32(priv, q->reg_r);
5038         if (hw_tail >= q->n_bd) {
5039                 IPW_ERROR
5040                     ("Read index for DMA queue (%d) is out of range [0-%d)\n",
5041                      hw_tail, q->n_bd);
5042                 goto done;
5043         }
5044         for (; q->last_used != hw_tail;
5045              q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
5046                 ipw_queue_tx_free_tfd(priv, txq);
5047                 priv->tx_packets++;
5048         }
5049       done:
5050         if ((ipw_tx_queue_space(q) > q->low_mark) &&
5051             (qindex >= 0))
5052                 netif_wake_queue(priv->net_dev);
5053         used = q->first_empty - q->last_used;
5054         if (used < 0)
5055                 used += q->n_bd;
5056
5057         return used;
5058 }
5059
5060 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
5061                              int len, int sync)
5062 {
5063         struct clx2_tx_queue *txq = &priv->txq_cmd;
5064         struct clx2_queue *q = &txq->q;
5065         struct tfd_frame *tfd;
5066
5067         if (ipw_tx_queue_space(q) < (sync ? 1 : 2)) {
5068                 IPW_ERROR("No space for Tx\n");
5069                 return -EBUSY;
5070         }
5071
5072         tfd = &txq->bd[q->first_empty];
5073         txq->txb[q->first_empty] = NULL;
5074
5075         memset(tfd, 0, sizeof(*tfd));
5076         tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
5077         tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
5078         priv->hcmd_seq++;
5079         tfd->u.cmd.index = hcmd;
5080         tfd->u.cmd.length = len;
5081         memcpy(tfd->u.cmd.payload, buf, len);
5082         q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
5083         ipw_write32(priv, q->reg_w, q->first_empty);
5084         _ipw_read32(priv, 0x90);
5085
5086         return 0;
5087 }
5088
5089 /*
5090  * Rx theory of operation
5091  *
5092  * The host allocates 32 DMA target addresses and passes the host address
5093  * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
5094  * 0 to 31
5095  *
5096  * Rx Queue Indexes
5097  * The host/firmware share two index registers for managing the Rx buffers.
5098  *
5099  * The READ index maps to the first position that the firmware may be writing
5100  * to -- the driver can read up to (but not including) this position and get
5101  * good data.
5102  * The READ index is managed by the firmware once the card is enabled.
5103  *
5104  * The WRITE index maps to the last position the driver has read from -- the
5105  * position preceding WRITE is the last slot the firmware can place a packet.
5106  *
5107  * The queue is empty (no good data) if WRITE = READ - 1, and is full if
5108  * WRITE = READ.
5109  *
5110  * During initialization the host sets up the READ queue position to the first
5111  * INDEX position, and WRITE to the last (READ - 1 wrapped)
5112  *
5113  * When the firmware places a packet in a buffer it will advance the READ index
5114  * and fire the RX interrupt.  The driver can then query the READ index and
5115  * process as many packets as possible, moving the WRITE index forward as it
5116  * resets the Rx queue buffers with new memory.
5117  *
5118  * The management in the driver is as follows:
5119  * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free.  When
5120  *   ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
5121  *   to replensish the ipw->rxq->rx_free.
5122  * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
5123  *   ipw->rxq is replenished and the READ INDEX is updated (updating the
5124  *   'processed' and 'read' driver indexes as well)
5125  * + A received packet is processed and handed to the kernel network stack,
5126  *   detached from the ipw->rxq.  The driver 'processed' index is updated.
5127  * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
5128  *   list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
5129  *   INDEX is not incremented and ipw->status(RX_STALLED) is set.  If there
5130  *   were enough free buffers and RX_STALLED is set it is cleared.
5131  *
5132  *
5133  * Driver sequence:
5134  *
5135  * ipw_rx_queue_alloc()       Allocates rx_free
5136  * ipw_rx_queue_replenish()   Replenishes rx_free list from rx_used, and calls
5137  *                            ipw_rx_queue_restock
5138  * ipw_rx_queue_restock()     Moves available buffers from rx_free into Rx
5139  *                            queue, updates firmware pointers, and updates
5140  *                            the WRITE index.  If insufficient rx_free buffers
5141  *                            are available, schedules ipw_rx_queue_replenish
5142  *
5143  * -- enable interrupts --
5144  * ISR - ipw_rx()             Detach ipw_rx_mem_buffers from pool up to the
5145  *                            READ INDEX, detaching the SKB from the pool.
5146  *                            Moves the packet buffer from queue to rx_used.
5147  *                            Calls ipw_rx_queue_restock to refill any empty
5148  *                            slots.
5149  * ...
5150  *
5151  */
5152
5153 /*
5154  * If there are slots in the RX queue that  need to be restocked,
5155  * and we have free pre-allocated buffers, fill the ranks as much
5156  * as we can pulling from rx_free.
5157  *
5158  * This moves the 'write' index forward to catch up with 'processed', and
5159  * also updates the memory address in the firmware to reference the new
5160  * target buffer.
5161  */
5162 static void ipw_rx_queue_restock(struct ipw_priv *priv)
5163 {
5164         struct ipw_rx_queue *rxq = priv->rxq;
5165         struct list_head *element;
5166         struct ipw_rx_mem_buffer *rxb;
5167         unsigned long flags;
5168         int write;
5169
5170         spin_lock_irqsave(&rxq->lock, flags);
5171         write = rxq->write;
5172         while ((ipw_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
5173                 element = rxq->rx_free.next;
5174                 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
5175                 list_del(element);
5176
5177                 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
5178                             rxb->dma_addr);
5179                 rxq->queue[rxq->write] = rxb;
5180                 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
5181                 rxq->free_count--;
5182         }
5183         spin_unlock_irqrestore(&rxq->lock, flags);
5184
5185         /* If the pre-allocated buffer pool is dropping low, schedule to
5186          * refill it */
5187         if (rxq->free_count <= RX_LOW_WATERMARK)
5188                 queue_work(priv->workqueue, &priv->rx_replenish);
5189
5190         /* If we've added more space for the firmware to place data, tell it */
5191         if (write != rxq->write)
5192                 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
5193 }
5194
5195 /*
5196  * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
5197  * Also restock the Rx queue via ipw_rx_queue_restock.
5198  *
5199  * This is called as a scheduled work item (except for during intialization)
5200  */
5201 static void ipw_rx_queue_replenish(void *data)
5202 {
5203         struct ipw_priv *priv = data;
5204         struct ipw_rx_queue *rxq = priv->rxq;
5205         struct list_head *element;
5206         struct ipw_rx_mem_buffer *rxb;
5207         unsigned long flags;
5208
5209         spin_lock_irqsave(&rxq->lock, flags);
5210         while (!list_empty(&rxq->rx_used)) {
5211                 element = rxq->rx_used.next;
5212                 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
5213                 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
5214                 if (!rxb->skb) {
5215                         printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
5216                                priv->net_dev->name);
5217                         /* We don't reschedule replenish work here -- we will
5218                          * call the restock method and if it still needs
5219                          * more buffers it will schedule replenish */
5220                         break;
5221                 }
5222                 list_del(element);
5223
5224                 rxb->dma_addr =
5225                     pci_map_single(priv->pci_dev, rxb->skb->data,
5226                                    IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
5227
5228                 list_add_tail(&rxb->list, &rxq->rx_free);
5229                 rxq->free_count++;
5230         }
5231         spin_unlock_irqrestore(&rxq->lock, flags);
5232
5233         ipw_rx_queue_restock(priv);
5234 }
5235
5236 static void ipw_bg_rx_queue_replenish(struct work_struct *work)
5237 {
5238         struct ipw_priv *priv =
5239                 container_of(work, struct ipw_priv, rx_replenish);
5240         mutex_lock(&priv->mutex);
5241         ipw_rx_queue_replenish(priv);
5242         mutex_unlock(&priv->mutex);
5243 }
5244
5245 /* Assumes that the skb field of the buffers in 'pool' is kept accurate.
5246  * If an SKB has been detached, the POOL needs to have its SKB set to NULL
5247  * This free routine walks the list of POOL entries and if SKB is set to
5248  * non NULL it is unmapped and freed
5249  */
5250 static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
5251 {
5252         int i;
5253
5254         if (!rxq)
5255                 return;
5256
5257         for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
5258                 if (rxq->pool[i].skb != NULL) {
5259                         pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
5260                                          IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
5261                         dev_kfree_skb(rxq->pool[i].skb);
5262                 }
5263         }
5264
5265         kfree(rxq);
5266 }
5267
5268 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
5269 {
5270         struct ipw_rx_queue *rxq;
5271         int i;
5272
5273         rxq = kzalloc(sizeof(*rxq), GFP_KERNEL);
5274         if (unlikely(!rxq)) {
5275                 IPW_ERROR("memory allocation failed\n");
5276                 return NULL;
5277         }
5278         spin_lock_init(&rxq->lock);
5279         INIT_LIST_HEAD(&rxq->rx_free);
5280         INIT_LIST_HEAD(&rxq->rx_used);
5281
5282         /* Fill the rx_used queue with _all_ of the Rx buffers */
5283         for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
5284                 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
5285
5286         /* Set us so that we have processed and used all buffers, but have
5287          * not restocked the Rx queue with fresh buffers */
5288         rxq->read = rxq->write = 0;
5289         rxq->free_count = 0;
5290
5291         return rxq;
5292 }
5293
5294 static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
5295 {
5296         rate &= ~LIBIPW_BASIC_RATE_MASK;
5297         if (ieee_mode == IEEE_A) {
5298                 switch (rate) {
5299                 case LIBIPW_OFDM_RATE_6MB:
5300                         return priv->rates_mask & LIBIPW_OFDM_RATE_6MB_MASK ?
5301                             1 : 0;
5302                 case LIBIPW_OFDM_RATE_9MB:
5303                         return priv->rates_mask & LIBIPW_OFDM_RATE_9MB_MASK ?
5304                             1 : 0;
5305                 case LIBIPW_OFDM_RATE_12MB:
5306                         return priv->
5307                             rates_mask & LIBIPW_OFDM_RATE_12MB_MASK ? 1 : 0;
5308                 case LIBIPW_OFDM_RATE_18MB:
5309                         return priv->
5310                             rates_mask & LIBIPW_OFDM_RATE_18MB_MASK ? 1 : 0;
5311                 case LIBIPW_OFDM_RATE_24MB:
5312                         return priv->
5313                             rates_mask & LIBIPW_OFDM_RATE_24MB_MASK ? 1 : 0;
5314                 case LIBIPW_OFDM_RATE_36MB:
5315                         return priv->
5316                             rates_mask & LIBIPW_OFDM_RATE_36MB_MASK ? 1 : 0;
5317                 case LIBIPW_OFDM_RATE_48MB:
5318                         return priv->
5319                             rates_mask & LIBIPW_OFDM_RATE_48MB_MASK ? 1 : 0;
5320                 case LIBIPW_OFDM_RATE_54MB:
5321                         return priv->
5322                             rates_mask & LIBIPW_OFDM_RATE_54MB_MASK ? 1 : 0;
5323                 default:
5324                         return 0;
5325                 }
5326         }
5327
5328         /* B and G mixed */
5329         switch (rate) {
5330         case LIBIPW_CCK_RATE_1MB:
5331                 return priv->rates_mask & LIBIPW_CCK_RATE_1MB_MASK ? 1 : 0;
5332         case LIBIPW_CCK_RATE_2MB:
5333                 return priv->rates_mask & LIBIPW_CCK_RATE_2MB_MASK ? 1 : 0;
5334         case LIBIPW_CCK_RATE_5MB:
5335                 return priv->rates_mask & LIBIPW_CCK_RATE_5MB_MASK ? 1 : 0;
5336         case LIBIPW_CCK_RATE_11MB:
5337                 return priv->rates_mask & LIBIPW_CCK_RATE_11MB_MASK ? 1 : 0;
5338         }
5339
5340         /* If we are limited to B modulations, bail at this point */
5341         if (ieee_mode == IEEE_B)
5342                 return 0;
5343
5344         /* G */
5345         switch (rate) {
5346         case LIBIPW_OFDM_RATE_6MB:
5347                 return priv->rates_mask & LIBIPW_OFDM_RATE_6MB_MASK ? 1 : 0;
5348         case LIBIPW_OFDM_RATE_9MB:
5349                 return priv->rates_mask & LIBIPW_OFDM_RATE_9MB_MASK ? 1 : 0;
5350         case LIBIPW_OFDM_RATE_12MB:
5351                 return priv->rates_mask & LIBIPW_OFDM_RATE_12MB_MASK ? 1 : 0;
5352         case LIBIPW_OFDM_RATE_18MB:
5353                 return priv->rates_mask & LIBIPW_OFDM_RATE_18MB_MASK ? 1 : 0;
5354         case LIBIPW_OFDM_RATE_24MB:
5355                 return priv->rates_mask & LIBIPW_OFDM_RATE_24MB_MASK ? 1 : 0;
5356         case LIBIPW_OFDM_RATE_36MB:
5357                 return priv->rates_mask & LIBIPW_OFDM_RATE_36MB_MASK ? 1 : 0;
5358         case LIBIPW_OFDM_RATE_48MB:
5359                 return priv->rates_mask & LIBIPW_OFDM_RATE_48MB_MASK ? 1 : 0;
5360         case LIBIPW_OFDM_RATE_54MB:
5361                 return priv->rates_mask & LIBIPW_OFDM_RATE_54MB_MASK ? 1 : 0;
5362         }
5363
5364         return 0;
5365 }
5366
5367 static int ipw_compatible_rates(struct ipw_priv *priv,
5368                                 const struct libipw_network *network,
5369                                 struct ipw_supported_rates *rates)
5370 {
5371         int num_rates, i;
5372
5373         memset(rates, 0, sizeof(*rates));
5374         num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
5375         rates->num_rates = 0;
5376         for (i = 0; i < num_rates; i++) {
5377                 if (!ipw_is_rate_in_mask(priv, network->mode,
5378                                          network->rates[i])) {
5379
5380                         if (network->rates[i] & LIBIPW_BASIC_RATE_MASK) {
5381                                 IPW_DEBUG_SCAN("Adding masked mandatory "
5382                                                "rate %02X\n",
5383                                                network->rates[i]);
5384                                 rates->supported_rates[rates->num_rates++] =
5385                                     network->rates[i];
5386                                 continue;
5387                         }
5388
5389                         IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5390                                        network->rates[i], priv->rates_mask);
5391                         continue;
5392                 }
5393
5394                 rates->supported_rates[rates->num_rates++] = network->rates[i];
5395         }
5396
5397         num_rates = min(network->rates_ex_len,
5398                         (u8) (IPW_MAX_RATES - num_rates));
5399         for (i = 0; i < num_rates; i++) {
5400                 if (!ipw_is_rate_in_mask(priv, network->mode,
5401                                          network->rates_ex[i])) {
5402                         if (network->rates_ex[i] & LIBIPW_BASIC_RATE_MASK) {
5403                                 IPW_DEBUG_SCAN("Adding masked mandatory "
5404                                                "rate %02X\n",
5405                                                network->rates_ex[i]);
5406                                 rates->supported_rates[rates->num_rates++] =
5407                                     network->rates[i];
5408                                 continue;
5409                         }
5410
5411                         IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5412                                        network->rates_ex[i], priv->rates_mask);
5413                         continue;
5414                 }
5415
5416                 rates->supported_rates[rates->num_rates++] =
5417                     network->rates_ex[i];
5418         }
5419
5420         return 1;
5421 }
5422
5423 static void ipw_copy_rates(struct ipw_supported_rates *dest,
5424                                   const struct ipw_supported_rates *src)
5425 {
5426         u8 i;
5427         for (i = 0; i < src->num_rates; i++)
5428                 dest->supported_rates[i] = src->supported_rates[i];
5429         dest->num_rates = src->num_rates;
5430 }
5431
5432 /* TODO: Look at sniffed packets in the air to determine if the basic rate
5433  * mask should ever be used -- right now all callers to add the scan rates are
5434  * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5435 static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
5436                                    u8 modulation, u32 rate_mask)
5437 {
5438         u8 basic_mask = (LIBIPW_OFDM_MODULATION == modulation) ?
5439             LIBIPW_BASIC_RATE_MASK : 0;
5440
5441         if (rate_mask & LIBIPW_CCK_RATE_1MB_MASK)
5442                 rates->supported_rates[rates->num_rates++] =
5443                     LIBIPW_BASIC_RATE_MASK | LIBIPW_CCK_RATE_1MB;
5444
5445         if (rate_mask & LIBIPW_CCK_RATE_2MB_MASK)
5446                 rates->supported_rates[rates->num_rates++] =
5447                     LIBIPW_BASIC_RATE_MASK | LIBIPW_CCK_RATE_2MB;
5448
5449         if (rate_mask & LIBIPW_CCK_RATE_5MB_MASK)
5450                 rates->supported_rates[rates->num_rates++] = basic_mask |
5451                     LIBIPW_CCK_RATE_5MB;
5452
5453         if (rate_mask & LIBIPW_CCK_RATE_11MB_MASK)
5454                 rates->supported_rates[rates->num_rates++] = basic_mask |
5455                     LIBIPW_CCK_RATE_11MB;
5456 }
5457
5458 static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
5459                                     u8 modulation, u32 rate_mask)
5460 {
5461         u8 basic_mask = (LIBIPW_OFDM_MODULATION == modulation) ?
5462             LIBIPW_BASIC_RATE_MASK : 0;
5463
5464         if (rate_mask & LIBIPW_OFDM_RATE_6MB_MASK)
5465                 rates->supported_rates[rates->num_rates++] = basic_mask |
5466                     LIBIPW_OFDM_RATE_6MB;
5467
5468         if (rate_mask & LIBIPW_OFDM_RATE_9MB_MASK)
5469                 rates->supported_rates[rates->num_rates++] =
5470                     LIBIPW_OFDM_RATE_9MB;
5471
5472         if (rate_mask & LIBIPW_OFDM_RATE_12MB_MASK)
5473                 rates->supported_rates[rates->num_rates++] = basic_mask |
5474                     LIBIPW_OFDM_RATE_12MB;
5475
5476         if (rate_mask & LIBIPW_OFDM_RATE_18MB_MASK)
5477                 rates->supported_rates[rates->num_rates++] =
5478                     LIBIPW_OFDM_RATE_18MB;
5479
5480         if (rate_mask & LIBIPW_OFDM_RATE_24MB_MASK)
5481                 rates->supported_rates[rates->num_rates++] = basic_mask |
5482                     LIBIPW_OFDM_RATE_24MB;
5483
5484         if (rate_mask & LIBIPW_OFDM_RATE_36MB_MASK)
5485                 rates->supported_rates[rates->num_rates++] =
5486                     LIBIPW_OFDM_RATE_36MB;
5487
5488         if (rate_mask & LIBIPW_OFDM_RATE_48MB_MASK)
5489                 rates->supported_rates[rates->num_rates++] =
5490                     LIBIPW_OFDM_RATE_48MB;
5491
5492         if (rate_mask & LIBIPW_OFDM_RATE_54MB_MASK)
5493                 rates->supported_rates[rates->num_rates++] =
5494                     LIBIPW_OFDM_RATE_54MB;
5495 }
5496
5497 struct ipw_network_match {
5498         struct libipw_network *network;
5499         struct ipw_supported_rates rates;
5500 };
5501
5502 static int ipw_find_adhoc_network(struct ipw_priv *priv,
5503                                   struct ipw_network_match *match,
5504                                   struct libipw_network *network,
5505                                   int roaming)
5506 {
5507         struct ipw_supported_rates rates;
5508         DECLARE_SSID_BUF(ssid);
5509
5510         /* Verify that this network's capability is compatible with the
5511          * current mode (AdHoc or Infrastructure) */
5512         if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
5513              !(network->capability & WLAN_CAPABILITY_IBSS))) {
5514                 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded due to "
5515                                 "capability mismatch.\n",
5516                                 print_ssid(ssid, network->ssid,
5517                                            network->ssid_len),
5518                                 network->bssid);
5519                 return 0;
5520         }
5521
5522         if (unlikely(roaming)) {
5523                 /* If we are roaming, then ensure check if this is a valid
5524                  * network to try and roam to */
5525                 if ((network->ssid_len != match->network->ssid_len) ||
5526                     memcmp(network->ssid, match->network->ssid,
5527                            network->ssid_len)) {
5528                         IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
5529                                         "because of non-network ESSID.\n",
5530                                         print_ssid(ssid, network->ssid,
5531                                                    network->ssid_len),
5532                                         network->bssid);
5533                         return 0;
5534                 }
5535         } else {
5536                 /* If an ESSID has been configured then compare the broadcast
5537                  * ESSID to ours */
5538                 if ((priv->config & CFG_STATIC_ESSID) &&
5539                     ((network->ssid_len != priv->essid_len) ||
5540                      memcmp(network->ssid, priv->essid,
5541                             min(network->ssid_len, priv->essid_len)))) {
5542                         char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5543
5544                         strncpy(escaped,
5545                                 print_ssid(ssid, network->ssid,
5546                                            network->ssid_len),
5547                                 sizeof(escaped));
5548                         IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
5549                                         "because of ESSID mismatch: '%s'.\n",
5550                                         escaped, network->bssid,
5551                                         print_ssid(ssid, priv->essid,
5552                                                    priv->essid_len));
5553                         return 0;
5554                 }
5555         }
5556
5557         /* If the old network rate is better than this one, don't bother
5558          * testing everything else. */
5559
5560         if (network->time_stamp[0] < match->network->time_stamp[0]) {
5561                 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5562                                 "current network.\n",
5563                                 print_ssid(ssid, match->network->ssid,
5564                                            match->network->ssid_len));
5565                 return 0;
5566         } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
5567                 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5568                                 "current network.\n",
5569                                 print_ssid(ssid, match->network->ssid,
5570                                            match->network->ssid_len));
5571                 return 0;
5572         }
5573
5574         /* Now go through and see if the requested network is valid... */
5575         if (priv->ieee->scan_age != 0 &&
5576             time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5577                 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
5578                                 "because of age: %ums.\n",
5579                                 print_ssid(ssid, network->ssid,
5580                                            network->ssid_len),
5581                                 network->bssid,
5582                                 jiffies_to_msecs(jiffies -
5583                                                  network->last_scanned));
5584                 return 0;
5585         }
5586
5587         if ((priv->config & CFG_STATIC_CHANNEL) &&
5588             (network->channel != priv->channel)) {
5589                 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
5590                                 "because of channel mismatch: %d != %d.\n",
5591                                 print_ssid(ssid, network->ssid,
5592                                            network->ssid_len),
5593                                 network->bssid,
5594                                 network->channel, priv->channel);
5595                 return 0;
5596         }
5597
5598         /* Verify privacy compatability */
5599         if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5600             ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5601                 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
5602                                 "because of privacy mismatch: %s != %s.\n",
5603                                 print_ssid(ssid, network->ssid,
5604                                            network->ssid_len),
5605                                 network->bssid,
5606                                 priv->
5607                                 capability & CAP_PRIVACY_ON ? "on" : "off",
5608                                 network->
5609                                 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5610                                 "off");
5611                 return 0;
5612         }
5613
5614         if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5615                 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
5616                                 "because of the same BSSID match: %pM"
5617                                 ".\n", print_ssid(ssid, network->ssid,
5618                                                   network->ssid_len),
5619                                 network->bssid,
5620                                 priv->bssid);
5621                 return 0;
5622         }
5623
5624         /* Filter out any incompatible freq / mode combinations */
5625         if (!libipw_is_valid_mode(priv->ieee, network->mode)) {
5626                 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
5627                                 "because of invalid frequency/mode "
5628                                 "combination.\n",
5629                                 print_ssid(ssid, network->ssid,
5630                                            network->ssid_len),
5631                                 network->bssid);
5632                 return 0;
5633         }
5634
5635         /* Ensure that the rates supported by the driver are compatible with
5636          * this AP, including verification of basic rates (mandatory) */
5637         if (!ipw_compatible_rates(priv, network, &rates)) {
5638                 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
5639                                 "because configured rate mask excludes "
5640                                 "AP mandatory rate.\n",
5641                                 print_ssid(ssid, network->ssid,
5642                                            network->ssid_len),
5643                                 network->bssid);
5644                 return 0;
5645         }
5646
5647         if (rates.num_rates == 0) {
5648                 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
5649                                 "because of no compatible rates.\n",
5650                                 print_ssid(ssid, network->ssid,
5651                                            network->ssid_len),
5652                                 network->bssid);
5653                 return 0;
5654         }
5655
5656         /* TODO: Perform any further minimal comparititive tests.  We do not
5657          * want to put too much policy logic here; intelligent scan selection
5658          * should occur within a generic IEEE 802.11 user space tool.  */
5659
5660         /* Set up 'new' AP to this network */
5661         ipw_copy_rates(&match->rates, &rates);
5662         match->network = network;
5663         IPW_DEBUG_MERGE("Network '%s (%pM)' is a viable match.\n",
5664                         print_ssid(ssid, network->ssid, network->ssid_len),
5665                         network->bssid);
5666
5667         return 1;
5668 }
5669
5670 static void ipw_merge_adhoc_network(struct work_struct *work)
5671 {
5672         DECLARE_SSID_BUF(ssid);
5673         struct ipw_priv *priv =
5674                 container_of(work, struct ipw_priv, merge_networks);
5675         struct libipw_network *network = NULL;
5676         struct ipw_network_match match = {
5677                 .network = priv->assoc_network
5678         };
5679
5680         if ((priv->status & STATUS_ASSOCIATED) &&
5681             (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5682                 /* First pass through ROAM process -- look for a better
5683                  * network */
5684                 unsigned long flags;
5685
5686                 spin_lock_irqsave(&priv->ieee->lock, flags);
5687                 list_for_each_entry(network, &priv->ieee->network_list, list) {
5688                         if (network != priv->assoc_network)
5689                                 ipw_find_adhoc_network(priv, &match, network,
5690                                                        1);
5691                 }
5692                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5693
5694                 if (match.network == priv->assoc_network) {
5695                         IPW_DEBUG_MERGE("No better ADHOC in this network to "
5696                                         "merge to.\n");
5697                         return;
5698                 }
5699
5700                 mutex_lock(&priv->mutex);
5701                 if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5702                         IPW_DEBUG_MERGE("remove network %s\n",
5703                                         print_ssid(ssid, priv->essid,
5704                                                    priv->essid_len));
5705                         ipw_remove_current_network(priv);
5706                 }
5707
5708                 ipw_disassociate(priv);
5709                 priv->assoc_network = match.network;
5710                 mutex_unlock(&priv->mutex);
5711                 return;
5712         }
5713 }
5714
5715 static int ipw_best_network(struct ipw_priv *priv,
5716                             struct ipw_network_match *match,
5717                             struct libipw_network *network, int roaming)
5718 {
5719         struct ipw_supported_rates rates;
5720         DECLARE_SSID_BUF(ssid);
5721
5722         /* Verify that this network's capability is compatible with the
5723          * current mode (AdHoc or Infrastructure) */
5724         if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
5725              !(network->capability & WLAN_CAPABILITY_ESS)) ||
5726             (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5727              !(network->capability & WLAN_CAPABILITY_IBSS))) {
5728                 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded due to "
5729                                 "capability mismatch.\n",
5730                                 print_ssid(ssid, network->ssid,
5731                                            network->ssid_len),
5732                                 network->bssid);
5733                 return 0;
5734         }
5735
5736         if (unlikely(roaming)) {
5737                 /* If we are roaming, then ensure check if this is a valid
5738                  * network to try and roam to */
5739                 if ((network->ssid_len != match->network->ssid_len) ||
5740                     memcmp(network->ssid, match->network->ssid,
5741                            network->ssid_len)) {
5742                         IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
5743                                         "because of non-network ESSID.\n",
5744                                         print_ssid(ssid, network->ssid,
5745                                                    network->ssid_len),
5746                                         network->bssid);
5747                         return 0;
5748                 }
5749         } else {
5750                 /* If an ESSID has been configured then compare the broadcast
5751                  * ESSID to ours */
5752                 if ((priv->config & CFG_STATIC_ESSID) &&
5753                     ((network->ssid_len != priv->essid_len) ||
5754                      memcmp(network->ssid, priv->essid,
5755                             min(network->ssid_len, priv->essid_len)))) {
5756                         char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5757                         strncpy(escaped,
5758                                 print_ssid(ssid, network->ssid,
5759                                            network->ssid_len),
5760                                 sizeof(escaped));
5761                         IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
5762                                         "because of ESSID mismatch: '%s'.\n",
5763                                         escaped, network->bssid,
5764                                         print_ssid(ssid, priv->essid,
5765                                                    priv->essid_len));
5766                         return 0;
5767                 }
5768         }
5769
5770         /* If the old network rate is better than this one, don't bother
5771          * testing everything else. */
5772         if (match->network && match->network->stats.rssi > network->stats.rssi) {
5773                 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5774                 strncpy(escaped,
5775                         print_ssid(ssid, network->ssid, network->ssid_len),
5776                         sizeof(escaped));
5777                 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded because "
5778                                 "'%s (%pM)' has a stronger signal.\n",
5779                                 escaped, network->bssid,
5780                                 print_ssid(ssid, match->network->ssid,
5781                                            match->network->ssid_len),
5782                                 match->network->bssid);
5783                 return 0;
5784         }
5785
5786         /* If this network has already had an association attempt within the
5787          * last 3 seconds, do not try and associate again... */
5788         if (network->last_associate &&
5789             time_after(network->last_associate + (HZ * 3UL), jiffies)) {
5790                 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
5791                                 "because of storming (%ums since last "
5792                                 "assoc attempt).\n",
5793                                 print_ssid(ssid, network->ssid,
5794                                            network->ssid_len),
5795                                 network->bssid,
5796                                 jiffies_to_msecs(jiffies -
5797                                                  network->last_associate));
5798                 return 0;
5799         }
5800
5801         /* Now go through and see if the requested network is valid... */
5802         if (priv->ieee->scan_age != 0 &&
5803             time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5804                 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
5805                                 "because of age: %ums.\n",
5806                                 print_ssid(ssid, network->ssid,
5807                                            network->ssid_len),
5808                                 network->bssid,
5809                                 jiffies_to_msecs(jiffies -
5810                                                  network->last_scanned));
5811                 return 0;
5812         }
5813
5814         if ((priv->config & CFG_STATIC_CHANNEL) &&
5815             (network->channel != priv->channel)) {
5816                 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
5817                                 "because of channel mismatch: %d != %d.\n",
5818                                 print_ssid(ssid, network->ssid,
5819                                            network->ssid_len),
5820                                 network->bssid,
5821                                 network->channel, priv->channel);
5822                 return 0;
5823         }
5824
5825         /* Verify privacy compatability */
5826         if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5827             ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5828                 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
5829                                 "because of privacy mismatch: %s != %s.\n",
5830                                 print_ssid(ssid, network->ssid,
5831                                            network->ssid_len),
5832                                 network->bssid,
5833                                 priv->capability & CAP_PRIVACY_ON ? "on" :
5834                                 "off",
5835                                 network->capability &
5836                                 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
5837                 return 0;
5838         }
5839
5840         if ((priv->config & CFG_STATIC_BSSID) &&
5841             memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5842                 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
5843                                 "because of BSSID mismatch: %pM.\n",
5844                                 print_ssid(ssid, network->ssid,
5845                                            network->ssid_len),
5846                                 network->bssid, priv->bssid);
5847                 return 0;
5848         }
5849
5850         /* Filter out any incompatible freq / mode combinations */
5851         if (!libipw_is_valid_mode(priv->ieee, network->mode)) {
5852                 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
5853                                 "because of invalid frequency/mode "
5854                                 "combination.\n",
5855                                 print_ssid(ssid, network->ssid,
5856                                            network->ssid_len),
5857                                 network->bssid);
5858                 return 0;
5859         }
5860
5861         /* Filter out invalid channel in current GEO */
5862         if (!libipw_is_valid_channel(priv->ieee, network->channel)) {
5863                 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
5864                                 "because of invalid channel in current GEO\n",
5865                                 print_ssid(ssid, network->ssid,
5866                                            network->ssid_len),
5867                                 network->bssid);
5868                 return 0;
5869         }
5870
5871         /* Ensure that the rates supported by the driver are compatible with
5872          * this AP, including verification of basic rates (mandatory) */
5873         if (!ipw_compatible_rates(priv, network, &rates)) {
5874                 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
5875                                 "because configured rate mask excludes "
5876                                 "AP mandatory rate.\n",
5877                                 print_ssid(ssid, network->ssid,
5878                                            network->ssid_len),
5879                                 network->bssid);
5880                 return 0;
5881         }
5882
5883         if (rates.num_rates == 0) {
5884                 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
5885                                 "because of no compatible rates.\n",
5886                                 print_ssid(ssid, network->ssid,
5887                                            network->ssid_len),
5888                                 network->bssid);
5889                 return 0;
5890         }
5891
5892         /* TODO: Perform any further minimal comparititive tests.  We do not
5893          * want to put too much policy logic here; intelligent scan selection
5894          * should occur within a generic IEEE 802.11 user space tool.  */
5895
5896         /* Set up 'new' AP to this network */
5897         ipw_copy_rates(&match->rates, &rates);
5898         match->network = network;
5899
5900         IPW_DEBUG_ASSOC("Network '%s (%pM)' is a viable match.\n",
5901                         print_ssid(ssid, network->ssid, network->ssid_len),
5902                         network->bssid);
5903
5904         return 1;
5905 }
5906
5907 static void ipw_adhoc_create(struct ipw_priv *priv,
5908                              struct libipw_network *network)
5909 {
5910         const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
5911         int i;
5912
5913         /*
5914          * For the purposes of scanning, we can set our wireless mode
5915          * to trigger scans across combinations of bands, but when it
5916          * comes to creating a new ad-hoc network, we have tell the FW
5917          * exactly which band to use.
5918          *
5919          * We also have the possibility of an invalid channel for the
5920          * chossen band.  Attempting to create a new ad-hoc network
5921          * with an invalid channel for wireless mode will trigger a
5922          * FW fatal error.
5923          *
5924          */
5925         switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
5926         case LIBIPW_52GHZ_BAND:
5927                 network->mode = IEEE_A;
5928                 i = libipw_channel_to_index(priv->ieee, priv->channel);
5929                 BUG_ON(i == -1);
5930                 if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY) {
5931                         IPW_WARNING("Overriding invalid channel\n");
5932                         priv->channel = geo->a[0].channel;
5933                 }
5934                 break;
5935
5936         case LIBIPW_24GHZ_BAND:
5937                 if (priv->ieee->mode & IEEE_G)
5938                         network->mode = IEEE_G;
5939                 else
5940                         network->mode = IEEE_B;
5941                 i = libipw_channel_to_index(priv->ieee, priv->channel);
5942                 BUG_ON(i == -1);
5943                 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY) {
5944                         IPW_WARNING("Overriding invalid channel\n");
5945                         priv->channel = geo->bg[0].channel;
5946                 }
5947                 break;
5948
5949         default:
5950                 IPW_WARNING("Overriding invalid channel\n");
5951                 if (priv->ieee->mode & IEEE_A) {
5952                         network->mode = IEEE_A;
5953                         priv->channel = geo->a[0].channel;
5954                 } else if (priv->ieee->mode & IEEE_G) {
5955                         network->mode = IEEE_G;
5956                         priv->channel = geo->bg[0].channel;
5957                 } else {
5958                         network->mode = IEEE_B;
5959                         priv->channel = geo->bg[0].channel;
5960                 }
5961                 break;
5962         }
5963
5964         network->channel = priv->channel;
5965         priv->config |= CFG_ADHOC_PERSIST;
5966         ipw_create_bssid(priv, network->bssid);
5967         network->ssid_len = priv->essid_len;
5968         memcpy(network->ssid, priv->essid, priv->essid_len);
5969         memset(&network->stats, 0, sizeof(network->stats));
5970         network->capability = WLAN_CAPABILITY_IBSS;
5971         if (!(priv->config & CFG_PREAMBLE_LONG))
5972                 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
5973         if (priv->capability & CAP_PRIVACY_ON)
5974                 network->capability |= WLAN_CAPABILITY_PRIVACY;
5975         network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
5976         memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
5977         network->rates_ex_len = priv->rates.num_rates - network->rates_len;
5978         memcpy(network->rates_ex,
5979                &priv->rates.supported_rates[network->rates_len],
5980                network->rates_ex_len);
5981         network->last_scanned = 0;
5982         network->flags = 0;
5983         network->last_associate = 0;
5984         network->time_stamp[0] = 0;
5985         network->time_stamp[1] = 0;
5986         network->beacon_interval = 100; /* Default */
5987         network->listen_interval = 10;  /* Default */
5988         network->atim_window = 0;       /* Default */
5989         network->wpa_ie_len = 0;
5990         network->rsn_ie_len = 0;
5991 }
5992
5993 static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5994 {
5995         struct ipw_tgi_tx_key key;
5996
5997         if (!(priv->ieee->sec.flags & (1 << index)))
5998                 return;
5999
6000         key.key_id = index;
6001         memcpy(key.key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
6002         key.security_type = type;
6003         key.station_index = 0;  /* always 0 for BSS */
6004         key.flags = 0;
6005         /* 0 for new key; previous value of counter (after fatal error) */
6006         key.tx_counter[0] = cpu_to_le32(0);
6007         key.tx_counter[1] = cpu_to_le32(0);
6008
6009         ipw_send_cmd_pdu(priv, IPW_CMD_TGI_TX_KEY, sizeof(key), &key);
6010 }
6011
6012 static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
6013 {
6014         struct ipw_wep_key key;
6015         int i;
6016
6017         key.cmd_id = DINO_CMD_WEP_KEY;
6018         key.seq_num = 0;
6019
6020         /* Note: AES keys cannot be set for multiple times.
6021          * Only set it at the first time. */
6022         for (i = 0; i < 4; i++) {
6023                 key.key_index = i | type;
6024                 if (!(priv->ieee->sec.flags & (1 << i))) {
6025                         key.key_size = 0;
6026                         continue;
6027                 }
6028
6029                 key.key_size = priv->ieee->sec.key_sizes[i];
6030                 memcpy(key.key, priv->ieee->sec.keys[i], key.key_size);
6031
6032                 ipw_send_cmd_pdu(priv, IPW_CMD_WEP_KEY, sizeof(key), &key);
6033         }
6034 }
6035
6036 static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
6037 {
6038         if (priv->ieee->host_encrypt)
6039                 return;
6040
6041         switch (level) {
6042         case SEC_LEVEL_3:
6043                 priv->sys_config.disable_unicast_decryption = 0;
6044                 priv->ieee->host_decrypt = 0;
6045                 break;
6046         case SEC_LEVEL_2:
6047                 priv->sys_config.disable_unicast_decryption = 1;
6048                 priv->ieee->host_decrypt = 1;
6049                 break;
6050         case SEC_LEVEL_1:
6051                 priv->sys_config.disable_unicast_decryption = 0;
6052                 priv->ieee->host_decrypt = 0;
6053                 break;
6054         case SEC_LEVEL_0:
6055                 priv->sys_config.disable_unicast_decryption = 1;
6056                 break;
6057         default:
6058                 break;
6059         }
6060 }
6061
6062 static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
6063 {
6064         if (priv->ieee->host_encrypt)
6065                 return;
6066
6067         switch (level) {
6068         case SEC_LEVEL_3:
6069                 priv->sys_config.disable_multicast_decryption = 0;
6070                 break;
6071         case SEC_LEVEL_2:
6072                 priv->sys_config.disable_multicast_decryption = 1;
6073                 break;
6074         case SEC_LEVEL_1:
6075                 priv->sys_config.disable_multicast_decryption = 0;
6076                 break;
6077         case SEC_LEVEL_0:
6078                 priv->sys_config.disable_multicast_decryption = 1;
6079                 break;
6080         default:
6081                 break;
6082         }
6083 }
6084
6085 static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
6086 {
6087         switch (priv->ieee->sec.level) {
6088         case SEC_LEVEL_3:
6089                 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
6090                         ipw_send_tgi_tx_key(priv,
6091                                             DCT_FLAG_EXT_SECURITY_CCM,
6092                                             priv->ieee->sec.active_key);
6093
6094                 if (!priv->ieee->host_mc_decrypt)
6095                         ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
6096                 break;
6097         case SEC_LEVEL_2:
6098                 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
6099                         ipw_send_tgi_tx_key(priv,
6100                                             DCT_FLAG_EXT_SECURITY_TKIP,
6101                                             priv->ieee->sec.active_key);
6102                 break;
6103         case SEC_LEVEL_1:
6104                 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
6105                 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
6106                 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
6107                 break;
6108         case SEC_LEVEL_0:
6109         default:
6110                 break;
6111         }
6112 }
6113
6114 static void ipw_adhoc_check(void *data)
6115 {
6116         struct ipw_priv *priv = data;
6117
6118         if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
6119             !(priv->config & CFG_ADHOC_PERSIST)) {
6120                 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
6121                           IPW_DL_STATE | IPW_DL_ASSOC,
6122                           "Missed beacon: %d - disassociate\n",
6123                           priv->missed_adhoc_beacons);
6124                 ipw_remove_current_network(priv);
6125                 ipw_disassociate(priv);
6126                 return;
6127         }
6128
6129         queue_delayed_work(priv->workqueue, &priv->adhoc_check,
6130                            le16_to_cpu(priv->assoc_request.beacon_interval));
6131 }
6132
6133 static void ipw_bg_adhoc_check(struct work_struct *work)
6134 {
6135         struct ipw_priv *priv =
6136                 container_of(work, struct ipw_priv, adhoc_check.work);
6137         mutex_lock(&priv->mutex);
6138         ipw_adhoc_check(priv);
6139         mutex_unlock(&priv->mutex);
6140 }
6141
6142 static void ipw_debug_config(struct ipw_priv *priv)
6143 {
6144         DECLARE_SSID_BUF(ssid);
6145         IPW_DEBUG_INFO("Scan completed, no valid APs matched "
6146                        "[CFG 0x%08X]\n", priv->config);
6147         if (priv->config & CFG_STATIC_CHANNEL)
6148                 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
6149         else
6150                 IPW_DEBUG_INFO("Channel unlocked.\n");
6151         if (priv->config & CFG_STATIC_ESSID)
6152                 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
6153                                print_ssid(ssid, priv->essid, priv->essid_len));
6154         else
6155                 IPW_DEBUG_INFO("ESSID unlocked.\n");
6156         if (priv->config & CFG_STATIC_BSSID)
6157                 IPW_DEBUG_INFO("BSSID locked to %pM\n", priv->bssid);
6158         else
6159                 IPW_DEBUG_INFO("BSSID unlocked.\n");
6160         if (priv->capability & CAP_PRIVACY_ON)
6161                 IPW_DEBUG_INFO("PRIVACY on\n");
6162         else
6163                 IPW_DEBUG_INFO("PRIVACY off\n");
6164         IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
6165 }
6166
6167 static void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
6168 {
6169         /* TODO: Verify that this works... */
6170         struct ipw_fixed_rate fr;
6171         u32 reg;
6172         u16 mask = 0;
6173         u16 new_tx_rates = priv->rates_mask;
6174
6175         /* Identify 'current FW band' and match it with the fixed
6176          * Tx rates */
6177
6178         switch (priv->ieee->freq_band) {
6179         case LIBIPW_52GHZ_BAND: /* A only */
6180                 /* IEEE_A */
6181                 if (priv->rates_mask & ~LIBIPW_OFDM_RATES_MASK) {
6182                         /* Invalid fixed rate mask */
6183                         IPW_DEBUG_WX
6184                             ("invalid fixed rate mask in ipw_set_fixed_rate\n");
6185                         new_tx_rates = 0;
6186                         break;
6187                 }
6188
6189                 new_tx_rates >>= LIBIPW_OFDM_SHIFT_MASK_A;
6190                 break;
6191
6192         default:                /* 2.4Ghz or Mixed */
6193                 /* IEEE_B */
6194                 if (mode == IEEE_B) {
6195                         if (new_tx_rates & ~LIBIPW_CCK_RATES_MASK) {
6196                                 /* Invalid fixed rate mask */
6197                                 IPW_DEBUG_WX
6198                                     ("invalid fixed rate mask in ipw_set_fixed_rate\n");
6199                                 new_tx_rates = 0;
6200                         }
6201                         break;
6202                 }
6203
6204                 /* IEEE_G */
6205                 if (new_tx_rates & ~(LIBIPW_CCK_RATES_MASK |
6206                                     LIBIPW_OFDM_RATES_MASK)) {
6207                         /* Invalid fixed rate mask */
6208                         IPW_DEBUG_WX
6209                             ("invalid fixed rate mask in ipw_set_fixed_rate\n");
6210                         new_tx_rates = 0;
6211                         break;
6212                 }
6213
6214                 if (LIBIPW_OFDM_RATE_6MB_MASK & new_tx_rates) {
6215                         mask |= (LIBIPW_OFDM_RATE_6MB_MASK >> 1);
6216                         new_tx_rates &= ~LIBIPW_OFDM_RATE_6MB_MASK;
6217                 }
6218
6219                 if (LIBIPW_OFDM_RATE_9MB_MASK & new_tx_rates) {
6220                         mask |= (LIBIPW_OFDM_RATE_9MB_MASK >> 1);
6221                         new_tx_rates &= ~LIBIPW_OFDM_RATE_9MB_MASK;
6222                 }
6223
6224                 if (LIBIPW_OFDM_RATE_12MB_MASK & new_tx_rates) {
6225                         mask |= (LIBIPW_OFDM_RATE_12MB_MASK >> 1);
6226                         new_tx_rates &= ~LIBIPW_OFDM_RATE_12MB_MASK;
6227                 }
6228
6229                 new_tx_rates |= mask;
6230                 break;
6231         }
6232
6233         fr.tx_rates = cpu_to_le16(new_tx_rates);
6234
6235         reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
6236         ipw_write_reg32(priv, reg, *(u32 *) & fr);
6237 }
6238
6239 static void ipw_abort_scan(struct ipw_priv *priv)
6240 {
6241         int err;
6242
6243         if (priv->status & STATUS_SCAN_ABORTING) {
6244                 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
6245                 return;
6246         }
6247         priv->status |= STATUS_SCAN_ABORTING;
6248
6249         err = ipw_send_scan_abort(priv);
6250         if (err)
6251                 IPW_DEBUG_HC("Request to abort scan failed.\n");
6252 }
6253
6254 static void ipw_add_scan_channels(struct ipw_priv *priv,
6255                                   struct ipw_scan_request_ext *scan,
6256                                   int scan_type)
6257 {
6258         int channel_index = 0;
6259         const struct libipw_geo *geo;
6260         int i;
6261
6262         geo = libipw_get_geo(priv->ieee);
6263
6264         if (priv->ieee->freq_band & LIBIPW_52GHZ_BAND) {
6265                 int start = channel_index;
6266                 for (i = 0; i < geo->a_channels; i++) {
6267                         if ((priv->status & STATUS_ASSOCIATED) &&
6268                             geo->a[i].channel == priv->channel)
6269                                 continue;
6270                         channel_index++;
6271                         scan->channels_list[channel_index] = geo->a[i].channel;
6272                         ipw_set_scan_type(scan, channel_index,
6273                                           geo->a[i].
6274                                           flags & LIBIPW_CH_PASSIVE_ONLY ?
6275                                           IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
6276                                           scan_type);
6277                 }
6278
6279                 if (start != channel_index) {
6280                         scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
6281                             (channel_index - start);
6282                         channel_index++;
6283                 }
6284         }
6285
6286         if (priv->ieee->freq_band & LIBIPW_24GHZ_BAND) {
6287                 int start = channel_index;
6288                 if (priv->config & CFG_SPEED_SCAN) {
6289                         int index;
6290                         u8 channels[LIBIPW_24GHZ_CHANNELS] = {
6291                                 /* nop out the list */
6292                                 [0] = 0
6293                         };
6294
6295                         u8 channel;
6296                         while (channel_index < IPW_SCAN_CHANNELS - 1) {
6297                                 channel =
6298                                     priv->speed_scan[priv->speed_scan_pos];
6299                                 if (channel == 0) {
6300                                         priv->speed_scan_pos = 0;
6301                                         channel = priv->speed_scan[0];
6302                                 }
6303                                 if ((priv->status & STATUS_ASSOCIATED) &&
6304                                     channel == priv->channel) {
6305                                         priv->speed_scan_pos++;
6306                                         continue;
6307                                 }
6308
6309                                 /* If this channel has already been
6310                                  * added in scan, break from loop
6311                                  * and this will be the first channel
6312                                  * in the next scan.
6313                                  */
6314                                 if (channels[channel - 1] != 0)
6315                                         break;
6316
6317                                 channels[channel - 1] = 1;
6318                                 priv->speed_scan_pos++;
6319                                 channel_index++;
6320                                 scan->channels_list[channel_index] = channel;
6321                                 index =
6322                                     libipw_channel_to_index(priv->ieee, channel);
6323                                 ipw_set_scan_type(scan, channel_index,
6324                                                   geo->bg[index].
6325                                                   flags &
6326                                                   LIBIPW_CH_PASSIVE_ONLY ?
6327                                                   IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6328                                                   : scan_type);
6329                         }
6330                 } else {
6331                         for (i = 0; i < geo->bg_channels; i++) {
6332                                 if ((priv->status & STATUS_ASSOCIATED) &&
6333                                     geo->bg[i].channel == priv->channel)
6334                                         continue;
6335                                 channel_index++;
6336                                 scan->channels_list[channel_index] =
6337                                     geo->bg[i].channel;
6338                                 ipw_set_scan_type(scan, channel_index,
6339                                                   geo->bg[i].
6340                                                   flags &
6341                                                   LIBIPW_CH_PASSIVE_ONLY ?
6342                                                   IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6343                                                   : scan_type);
6344                         }
6345                 }
6346
6347                 if (start != channel_index) {
6348                         scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6349                             (channel_index - start);
6350                 }
6351         }
6352 }
6353
6354 static int ipw_passive_dwell_time(struct ipw_priv *priv)
6355 {
6356         /* staying on passive channels longer than the DTIM interval during a
6357          * scan, while associated, causes the firmware to cancel the scan
6358          * without notification. Hence, don't stay on passive channels longer
6359          * than the beacon interval.
6360          */
6361         if (priv->status & STATUS_ASSOCIATED
6362             && priv->assoc_network->beacon_interval > 10)
6363                 return priv->assoc_network->beacon_interval - 10;
6364         else
6365                 return 120;
6366 }
6367
6368 static int ipw_request_scan_helper(struct ipw_priv *priv, int type, int direct)
6369 {
6370         struct ipw_scan_request_ext scan;
6371         int err = 0, scan_type;
6372
6373         if (!(priv->status & STATUS_INIT) ||
6374             (priv->status & STATUS_EXIT_PENDING))
6375                 return 0;
6376
6377         mutex_lock(&priv->mutex);
6378
6379         if (direct && (priv->direct_scan_ssid_len == 0)) {
6380                 IPW_DEBUG_HC("Direct scan requested but no SSID to scan for\n");
6381                 priv->status &= ~STATUS_DIRECT_SCAN_PENDING;
6382                 goto done;
6383         }
6384
6385         if (priv->status & STATUS_SCANNING) {
6386                 IPW_DEBUG_HC("Concurrent scan requested.  Queuing.\n");
6387                 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6388                                         STATUS_SCAN_PENDING;
6389                 goto done;
6390         }
6391
6392         if (!(priv->status & STATUS_SCAN_FORCED) &&
6393             priv->status & STATUS_SCAN_ABORTING) {
6394                 IPW_DEBUG_HC("Scan request while abort pending.  Queuing.\n");
6395                 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6396                                         STATUS_SCAN_PENDING;
6397                 goto done;
6398         }
6399
6400         if (priv->status & STATUS_RF_KILL_MASK) {
6401                 IPW_DEBUG_HC("Queuing scan due to RF Kill activation\n");
6402                 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6403                                         STATUS_SCAN_PENDING;
6404                 goto done;
6405         }
6406
6407         memset(&scan, 0, sizeof(scan));
6408         scan.full_scan_index = cpu_to_le32(libipw_get_scans(priv->ieee));
6409
6410         if (type == IW_SCAN_TYPE_PASSIVE) {
6411                 IPW_DEBUG_WX("use passive scanning\n");
6412                 scan_type = IPW_SCAN_PASSIVE_FULL_DWELL_SCAN;
6413                 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6414                         cpu_to_le16(ipw_passive_dwell_time(priv));
6415                 ipw_add_scan_channels(priv, &scan, scan_type);
6416                 goto send_request;
6417         }
6418
6419         /* Use active scan by default. */
6420         if (priv->config & CFG_SPEED_SCAN)
6421                 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6422                         cpu_to_le16(30);
6423         else
6424                 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6425                         cpu_to_le16(20);
6426
6427         scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
6428                 cpu_to_le16(20);
6429
6430         scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6431                 cpu_to_le16(ipw_passive_dwell_time(priv));
6432         scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
6433
6434 #ifdef CONFIG_IPW2200_MONITOR
6435         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
6436                 u8 channel;
6437                 u8 band = 0;
6438
6439                 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
6440                 case LIBIPW_52GHZ_BAND:
6441                         band = (u8) (IPW_A_MODE << 6) | 1;
6442                         channel = priv->channel;
6443                         break;
6444
6445                 case LIBIPW_24GHZ_BAND:
6446                         band = (u8) (IPW_B_MODE << 6) | 1;
6447                         channel = priv->channel;
6448                         break;
6449
6450                 default:
6451                         band = (u8) (IPW_B_MODE << 6) | 1;
6452                         channel = 9;
6453                         break;
6454                 }
6455
6456                 scan.channels_list[0] = band;
6457                 scan.channels_list[1] = channel;
6458                 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
6459
6460                 /* NOTE:  The card will sit on this channel for this time
6461                  * period.  Scan aborts are timing sensitive and frequently
6462                  * result in firmware restarts.  As such, it is best to
6463                  * set a small dwell_time here and just keep re-issuing
6464                  * scans.  Otherwise fast channel hopping will not actually
6465                  * hop channels.
6466                  *
6467                  * TODO: Move SPEED SCAN support to all modes and bands */
6468                 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6469                         cpu_to_le16(2000);
6470         } else {
6471 #endif                          /* CONFIG_IPW2200_MONITOR */
6472                 /* Honor direct scans first, otherwise if we are roaming make
6473                  * this a direct scan for the current network.  Finally,
6474                  * ensure that every other scan is a fast channel hop scan */
6475                 if (direct) {
6476                         err = ipw_send_ssid(priv, priv->direct_scan_ssid,
6477                                             priv->direct_scan_ssid_len);
6478                         if (err) {
6479                                 IPW_DEBUG_HC("Attempt to send SSID command  "
6480                                              "failed\n");
6481                                 goto done;
6482                         }
6483
6484                         scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6485                 } else if ((priv->status & STATUS_ROAMING)
6486                            || (!(priv->status & STATUS_ASSOCIATED)
6487                                && (priv->config & CFG_STATIC_ESSID)
6488                                && (le32_to_cpu(scan.full_scan_index) % 2))) {
6489                         err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6490                         if (err) {
6491                                 IPW_DEBUG_HC("Attempt to send SSID command "
6492                                              "failed.\n");
6493                                 goto done;
6494                         }
6495
6496                         scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6497                 } else
6498                         scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
6499
6500                 ipw_add_scan_channels(priv, &scan, scan_type);
6501 #ifdef CONFIG_IPW2200_MONITOR
6502         }
6503 #endif
6504
6505 send_request:
6506         err = ipw_send_scan_request_ext(priv, &scan);
6507         if (err) {
6508                 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
6509                 goto done;
6510         }
6511
6512         priv->status |= STATUS_SCANNING;
6513         if (direct) {
6514                 priv->status &= ~STATUS_DIRECT_SCAN_PENDING;
6515                 priv->direct_scan_ssid_len = 0;
6516         } else
6517                 priv->status &= ~STATUS_SCAN_PENDING;
6518
6519         queue_delayed_work(priv->workqueue, &priv->scan_check,
6520                            IPW_SCAN_CHECK_WATCHDOG);
6521 done:
6522         mutex_unlock(&priv->mutex);
6523         return err;
6524 }
6525
6526 static void ipw_request_passive_scan(struct work_struct *work)
6527 {
6528         struct ipw_priv *priv =
6529                 container_of(work, struct ipw_priv, request_passive_scan.work);
6530         ipw_request_scan_helper(priv, IW_SCAN_TYPE_PASSIVE, 0);
6531 }
6532
6533 static void ipw_request_scan(struct work_struct *work)
6534 {
6535         struct ipw_priv *priv =
6536                 container_of(work, struct ipw_priv, request_scan.work);
6537         ipw_request_scan_helper(priv, IW_SCAN_TYPE_ACTIVE, 0);
6538 }
6539
6540 static void ipw_request_direct_scan(struct work_struct *work)
6541 {
6542         struct ipw_priv *priv =
6543                 container_of(work, struct ipw_priv, request_direct_scan.work);
6544         ipw_request_scan_helper(priv, IW_SCAN_TYPE_ACTIVE, 1);
6545 }
6546
6547 static void ipw_bg_abort_scan(struct work_struct *work)
6548 {
6549         struct ipw_priv *priv =
6550                 container_of(work, struct ipw_priv, abort_scan);
6551         mutex_lock(&priv->mutex);
6552         ipw_abort_scan(priv);
6553         mutex_unlock(&priv->mutex);
6554 }
6555
6556 static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6557 {
6558         /* This is called when wpa_supplicant loads and closes the driver
6559          * interface. */
6560         priv->ieee->wpa_enabled = value;
6561         return 0;
6562 }
6563
6564 static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6565 {
6566         struct libipw_device *ieee = priv->ieee;
6567         struct libipw_security sec = {
6568                 .flags = SEC_AUTH_MODE,
6569         };
6570         int ret = 0;
6571
6572         if (value & IW_AUTH_ALG_SHARED_KEY) {
6573                 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6574                 ieee->open_wep = 0;
6575         } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
6576                 sec.auth_mode = WLAN_AUTH_OPEN;
6577                 ieee->open_wep = 1;
6578         } else if (value & IW_AUTH_ALG_LEAP) {
6579                 sec.auth_mode = WLAN_AUTH_LEAP;
6580                 ieee->open_wep = 1;
6581         } else
6582                 return -EINVAL;
6583
6584         if (ieee->set_security)
6585                 ieee->set_security(ieee->dev, &sec);
6586         else
6587                 ret = -EOPNOTSUPP;
6588
6589         return ret;
6590 }
6591
6592 static void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie,
6593                                 int wpa_ie_len)
6594 {
6595         /* make sure WPA is enabled */
6596         ipw_wpa_enable(priv, 1);
6597 }
6598
6599 static int ipw_set_rsn_capa(struct ipw_priv *priv,
6600                             char *capabilities, int length)
6601 {
6602         IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6603
6604         return ipw_send_cmd_pdu(priv, IPW_CMD_RSN_CAPABILITIES, length,
6605                                 capabilities);
6606 }
6607
6608 /*
6609  * WE-18 support
6610  */
6611
6612 /* SIOCSIWGENIE */
6613 static int ipw_wx_set_genie(struct net_device *dev,
6614                             struct iw_request_info *info,
6615                             union iwreq_data *wrqu, char *extra)
6616 {
6617         struct ipw_priv *priv = libipw_priv(dev);
6618         struct libipw_device *ieee = priv->ieee;
6619         u8 *buf;
6620         int err = 0;
6621
6622         if (wrqu->data.length > MAX_WPA_IE_LEN ||
6623             (wrqu->data.length && extra == NULL))
6624                 return -EINVAL;
6625
6626         if (wrqu->data.length) {
6627                 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
6628                 if (buf == NULL) {
6629                         err = -ENOMEM;
6630                         goto out;
6631                 }
6632
6633                 memcpy(buf, extra, wrqu->data.length);
6634                 kfree(ieee->wpa_ie);
6635                 ieee->wpa_ie = buf;
6636                 ieee->wpa_ie_len = wrqu->data.length;
6637         } else {
6638                 kfree(ieee->wpa_ie);
6639                 ieee->wpa_ie = NULL;
6640                 ieee->wpa_ie_len = 0;
6641         }
6642
6643         ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6644       out:
6645         return err;
6646 }
6647
6648 /* SIOCGIWGENIE */
6649 static int ipw_wx_get_genie(struct net_device *dev,
6650                             struct iw_request_info *info,
6651                             union iwreq_data *wrqu, char *extra)
6652 {
6653         struct ipw_priv *priv = libipw_priv(dev);
6654         struct libipw_device *ieee = priv->ieee;
6655         int err = 0;
6656
6657         if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6658                 wrqu->data.length = 0;
6659                 goto out;
6660         }
6661
6662         if (wrqu->data.length < ieee->wpa_ie_len) {
6663                 err = -E2BIG;
6664                 goto out;
6665         }
6666
6667         wrqu->data.length = ieee->wpa_ie_len;
6668         memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6669
6670       out:
6671         return err;
6672 }
6673
6674 static int wext_cipher2level(int cipher)
6675 {
6676         switch (cipher) {
6677         case IW_AUTH_CIPHER_NONE:
6678                 return SEC_LEVEL_0;
6679         case IW_AUTH_CIPHER_WEP40:
6680         case IW_AUTH_CIPHER_WEP104:
6681                 return SEC_LEVEL_1;
6682         case IW_AUTH_CIPHER_TKIP:
6683                 return SEC_LEVEL_2;
6684         case IW_AUTH_CIPHER_CCMP:
6685                 return SEC_LEVEL_3;
6686         default:
6687                 return -1;
6688         }
6689 }
6690
6691 /* SIOCSIWAUTH */
6692 static int ipw_wx_set_auth(struct net_device *dev,
6693                            struct iw_request_info *info,
6694                            union iwreq_data *wrqu, char *extra)
6695 {
6696         struct ipw_priv *priv = libipw_priv(dev);
6697         struct libipw_device *ieee = priv->ieee;
6698         struct iw_param *param = &wrqu->param;
6699         struct lib80211_crypt_data *crypt;
6700         unsigned long flags;
6701         int ret = 0;
6702
6703         switch (param->flags & IW_AUTH_INDEX) {
6704         case IW_AUTH_WPA_VERSION:
6705                 break;
6706         case IW_AUTH_CIPHER_PAIRWISE:
6707                 ipw_set_hw_decrypt_unicast(priv,
6708                                            wext_cipher2level(param->value));
6709                 break;
6710         case IW_AUTH_CIPHER_GROUP:
6711                 ipw_set_hw_decrypt_multicast(priv,
6712                                              wext_cipher2level(param->value));
6713                 break;
6714         case IW_AUTH_KEY_MGMT:
6715                 /*
6716                  * ipw2200 does not use these parameters
6717                  */
6718                 break;
6719
6720         case IW_AUTH_TKIP_COUNTERMEASURES:
6721                 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
6722                 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
6723                         break;
6724
6725                 flags = crypt->ops->get_flags(crypt->priv);
6726
6727                 if (param->value)
6728                         flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6729                 else
6730                         flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6731
6732                 crypt->ops->set_flags(flags, crypt->priv);
6733
6734                 break;
6735
6736         case IW_AUTH_DROP_UNENCRYPTED:{
6737                         /* HACK:
6738                          *
6739                          * wpa_supplicant calls set_wpa_enabled when the driver
6740                          * is loaded and unloaded, regardless of if WPA is being
6741                          * used.  No other calls are made which can be used to
6742                          * determine if encryption will be used or not prior to
6743                          * association being expected.  If encryption is not being
6744                          * used, drop_unencrypted is set to false, else true -- we
6745                          * can use this to determine if the CAP_PRIVACY_ON bit should
6746                          * be set.
6747                          */
6748                         struct libipw_security sec = {
6749                                 .flags = SEC_ENABLED,
6750                                 .enabled = param->value,
6751                         };
6752                         priv->ieee->drop_unencrypted = param->value;
6753                         /* We only change SEC_LEVEL for open mode. Others
6754                          * are set by ipw_wpa_set_encryption.
6755                          */
6756                         if (!param->value) {
6757                                 sec.flags |= SEC_LEVEL;
6758                                 sec.level = SEC_LEVEL_0;
6759                         } else {
6760                                 sec.flags |= SEC_LEVEL;
6761                                 sec.level = SEC_LEVEL_1;
6762                         }
6763                         if (priv->ieee->set_security)
6764                                 priv->ieee->set_security(priv->ieee->dev, &sec);
6765                         break;
6766                 }
6767
6768         case IW_AUTH_80211_AUTH_ALG:
6769                 ret = ipw_wpa_set_auth_algs(priv, param->value);
6770                 break;
6771
6772         case IW_AUTH_WPA_ENABLED:
6773                 ret = ipw_wpa_enable(priv, param->value);
6774                 ipw_disassociate(priv);
6775                 break;
6776
6777         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6778                 ieee->ieee802_1x = param->value;
6779                 break;
6780
6781         case IW_AUTH_PRIVACY_INVOKED:
6782                 ieee->privacy_invoked = param->value;
6783                 break;
6784
6785         default:
6786                 return -EOPNOTSUPP;
6787         }
6788         return ret;
6789 }
6790
6791 /* SIOCGIWAUTH */
6792 static int ipw_wx_get_auth(struct net_device *dev,
6793                            struct iw_request_info *info,
6794                            union iwreq_data *wrqu, char *extra)
6795 {
6796         struct ipw_priv *priv = libipw_priv(dev);
6797         struct libipw_device *ieee = priv->ieee;
6798         struct lib80211_crypt_data *crypt;
6799         struct iw_param *param = &wrqu->param;
6800         int ret = 0;
6801
6802         switch (param->flags & IW_AUTH_INDEX) {
6803         case IW_AUTH_WPA_VERSION:
6804         case IW_AUTH_CIPHER_PAIRWISE:
6805         case IW_AUTH_CIPHER_GROUP:
6806         case IW_AUTH_KEY_MGMT:
6807                 /*
6808                  * wpa_supplicant will control these internally
6809                  */
6810                 ret = -EOPNOTSUPP;
6811                 break;
6812
6813         case IW_AUTH_TKIP_COUNTERMEASURES:
6814                 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
6815                 if (!crypt || !crypt->ops->get_flags)
6816                         break;
6817
6818                 param->value = (crypt->ops->get_flags(crypt->priv) &
6819                                 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6820
6821                 break;
6822
6823         case IW_AUTH_DROP_UNENCRYPTED:
6824                 param->value = ieee->drop_unencrypted;
6825                 break;
6826
6827         case IW_AUTH_80211_AUTH_ALG:
6828                 param->value = ieee->sec.auth_mode;
6829                 break;
6830
6831         case IW_AUTH_WPA_ENABLED:
6832                 param->value = ieee->wpa_enabled;
6833                 break;
6834
6835         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6836                 param->value = ieee->ieee802_1x;
6837                 break;
6838
6839         case IW_AUTH_ROAMING_CONTROL:
6840         case IW_AUTH_PRIVACY_INVOKED:
6841                 param->value = ieee->privacy_invoked;
6842                 break;
6843
6844         default:
6845                 return -EOPNOTSUPP;
6846         }
6847         return 0;
6848 }
6849
6850 /* SIOCSIWENCODEEXT */
6851 static int ipw_wx_set_encodeext(struct net_device *dev,
6852                                 struct iw_request_info *info,
6853                                 union iwreq_data *wrqu, char *extra)
6854 {
6855         struct ipw_priv *priv = libipw_priv(dev);
6856         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6857
6858         if (hwcrypto) {
6859                 if (ext->alg == IW_ENCODE_ALG_TKIP) {
6860                         /* IPW HW can't build TKIP MIC,
6861                            host decryption still needed */
6862                         if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6863                                 priv->ieee->host_mc_decrypt = 1;
6864                         else {
6865                                 priv->ieee->host_encrypt = 0;
6866                                 priv->ieee->host_encrypt_msdu = 1;
6867                                 priv->ieee->host_decrypt = 1;
6868                         }
6869                 } else {
6870                         priv->ieee->host_encrypt = 0;
6871                         priv->ieee->host_encrypt_msdu = 0;
6872                         priv->ieee->host_decrypt = 0;
6873                         priv->ieee->host_mc_decrypt = 0;
6874                 }
6875         }
6876
6877         return libipw_wx_set_encodeext(priv->ieee, info, wrqu, extra);
6878 }
6879
6880 /* SIOCGIWENCODEEXT */
6881 static int ipw_wx_get_encodeext(struct net_device *dev,
6882                                 struct iw_request_info *info,
6883                                 union iwreq_data *wrqu, char *extra)
6884 {
6885         struct ipw_priv *priv = libipw_priv(dev);
6886         return libipw_wx_get_encodeext(priv->ieee, info, wrqu, extra);
6887 }
6888
6889 /* SIOCSIWMLME */
6890 static int ipw_wx_set_mlme(struct net_device *dev,
6891                            struct iw_request_info *info,
6892                            union iwreq_data *wrqu, char *extra)
6893 {
6894         struct ipw_priv *priv = libipw_priv(dev);
6895         struct iw_mlme *mlme = (struct iw_mlme *)extra;
6896         __le16 reason;
6897
6898         reason = cpu_to_le16(mlme->reason_code);
6899
6900         switch (mlme->cmd) {
6901         case IW_MLME_DEAUTH:
6902                 /* silently ignore */
6903                 break;
6904
6905         case IW_MLME_DISASSOC:
6906                 ipw_disassociate(priv);
6907                 break;
6908
6909         default:
6910                 return -EOPNOTSUPP;
6911         }
6912         return 0;
6913 }
6914
6915 #ifdef CONFIG_IPW2200_QOS
6916
6917 /* QoS */
6918 /*
6919 * get the modulation type of the current network or
6920 * the card current mode
6921 */
6922 static u8 ipw_qos_current_mode(struct ipw_priv * priv)
6923 {
6924         u8 mode = 0;
6925
6926         if (priv->status & STATUS_ASSOCIATED) {
6927                 unsigned long flags;
6928
6929                 spin_lock_irqsave(&priv->ieee->lock, flags);
6930                 mode = priv->assoc_network->mode;
6931                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6932         } else {
6933                 mode = priv->ieee->mode;
6934         }
6935         IPW_DEBUG_QOS("QoS network/card mode %d\n", mode);
6936         return mode;
6937 }
6938
6939 /*
6940 * Handle management frame beacon and probe response
6941 */
6942 static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6943                                          int active_network,
6944                                          struct libipw_network *network)
6945 {
6946         u32 size = sizeof(struct libipw_qos_parameters);
6947
6948         if (network->capability & WLAN_CAPABILITY_IBSS)
6949                 network->qos_data.active = network->qos_data.supported;
6950
6951         if (network->flags & NETWORK_HAS_QOS_MASK) {
6952                 if (active_network &&
6953                     (network->flags & NETWORK_HAS_QOS_PARAMETERS))
6954                         network->qos_data.active = network->qos_data.supported;
6955
6956                 if ((network->qos_data.active == 1) && (active_network == 1) &&
6957                     (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6958                     (network->qos_data.old_param_count !=
6959                      network->qos_data.param_count)) {
6960                         network->qos_data.old_param_count =
6961                             network->qos_data.param_count;
6962                         schedule_work(&priv->qos_activate);
6963                         IPW_DEBUG_QOS("QoS parameters change call "
6964                                       "qos_activate\n");
6965                 }
6966         } else {
6967                 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6968                         memcpy(&network->qos_data.parameters,
6969                                &def_parameters_CCK, size);
6970                 else
6971                         memcpy(&network->qos_data.parameters,
6972                                &def_parameters_OFDM, size);
6973
6974                 if ((network->qos_data.active == 1) && (active_network == 1)) {
6975                         IPW_DEBUG_QOS("QoS was disabled call qos_activate\n");
6976                         schedule_work(&priv->qos_activate);
6977                 }
6978
6979                 network->qos_data.active = 0;
6980                 network->qos_data.supported = 0;
6981         }
6982         if ((priv->status & STATUS_ASSOCIATED) &&
6983             (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6984                 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
6985                         if (network->capability & WLAN_CAPABILITY_IBSS)
6986                                 if ((network->ssid_len ==
6987                                      priv->assoc_network->ssid_len) &&
6988                                     !memcmp(network->ssid,
6989                                             priv->assoc_network->ssid,
6990                                             network->ssid_len)) {
6991                                         queue_work(priv->workqueue,
6992                                                    &priv->merge_networks);
6993                                 }
6994         }
6995
6996         return 0;
6997 }
6998
6999 /*
7000 * This function set up the firmware to support QoS. It sends
7001 * IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
7002 */
7003 static int ipw_qos_activate(struct ipw_priv *priv,
7004                             struct libipw_qos_data *qos_network_data)
7005 {
7006         int err;
7007         struct libipw_qos_parameters qos_parameters[QOS_QOS_SETS];
7008         struct libipw_qos_parameters *active_one = NULL;
7009         u32 size = sizeof(struct libipw_qos_parameters);
7010         u32 burst_duration;
7011         int i;
7012         u8 type;
7013
7014         type = ipw_qos_current_mode(priv);
7015
7016         active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
7017         memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
7018         active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
7019         memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
7020
7021         if (qos_network_data == NULL) {
7022                 if (type == IEEE_B) {
7023                         IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
7024                         active_one = &def_parameters_CCK;
7025                 } else
7026                         active_one = &def_parameters_OFDM;
7027
7028                 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
7029                 burst_duration = ipw_qos_get_burst_duration(priv);
7030                 for (i = 0; i < QOS_QUEUE_NUM; i++)
7031                         qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
7032                             cpu_to_le16(burst_duration);
7033         } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7034                 if (type == IEEE_B) {
7035                         IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
7036                                       type);
7037                         if (priv->qos_data.qos_enable == 0)
7038                                 active_one = &def_parameters_CCK;
7039                         else
7040                                 active_one = priv->qos_data.def_qos_parm_CCK;
7041                 } else {
7042                         if (priv->qos_data.qos_enable == 0)
7043                                 active_one = &def_parameters_OFDM;
7044                         else
7045                                 active_one = priv->qos_data.def_qos_parm_OFDM;
7046                 }
7047                 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
7048         } else {
7049                 unsigned long flags;
7050                 int active;
7051
7052                 spin_lock_irqsave(&priv->ieee->lock, flags);
7053                 active_one = &(qos_network_data->parameters);
7054                 qos_network_data->old_param_count =
7055                     qos_network_data->param_count;
7056                 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
7057                 active = qos_network_data->supported;
7058                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7059
7060                 if (active == 0) {
7061                         burst_duration = ipw_qos_get_burst_duration(priv);
7062                         for (i = 0; i < QOS_QUEUE_NUM; i++)
7063                                 qos_parameters[QOS_PARAM_SET_ACTIVE].
7064                                     tx_op_limit[i] = cpu_to_le16(burst_duration);
7065                 }
7066         }
7067
7068         IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
7069         err = ipw_send_qos_params_command(priv,
7070                                           (struct libipw_qos_parameters *)
7071                                           &(qos_parameters[0]));
7072         if (err)
7073                 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
7074
7075         return err;
7076 }
7077
7078 /*
7079 * send IPW_CMD_WME_INFO to the firmware
7080 */
7081 static int ipw_qos_set_info_element(struct ipw_priv *priv)
7082 {
7083         int ret = 0;
7084         struct libipw_qos_information_element qos_info;
7085
7086         if (priv == NULL)
7087                 return -1;
7088
7089         qos_info.elementID = QOS_ELEMENT_ID;
7090         qos_info.length = sizeof(struct libipw_qos_information_element) - 2;
7091
7092         qos_info.version = QOS_VERSION_1;
7093         qos_info.ac_info = 0;
7094
7095         memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
7096         qos_info.qui_type = QOS_OUI_TYPE;
7097         qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
7098
7099         ret = ipw_send_qos_info_command(priv, &qos_info);
7100         if (ret != 0) {
7101                 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
7102         }
7103         return ret;
7104 }
7105
7106 /*
7107 * Set the QoS parameter with the association request structure
7108 */
7109 static int ipw_qos_association(struct ipw_priv *priv,
7110                                struct libipw_network *network)
7111 {
7112         int err = 0;
7113         struct libipw_qos_data *qos_data = NULL;
7114         struct libipw_qos_data ibss_data = {
7115                 .supported = 1,
7116                 .active = 1,
7117         };
7118
7119         switch (priv->ieee->iw_mode) {
7120         case IW_MODE_ADHOC:
7121                 BUG_ON(!(network->capability & WLAN_CAPABILITY_IBSS));
7122
7123                 qos_data = &ibss_data;
7124                 break;
7125
7126         case IW_MODE_INFRA:
7127                 qos_data = &network->qos_data;
7128                 break;
7129
7130         default:
7131                 BUG();
7132                 break;
7133         }
7134
7135         err = ipw_qos_activate(priv, qos_data);
7136         if (err) {
7137                 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
7138                 return err;
7139         }
7140
7141         if (priv->qos_data.qos_enable && qos_data->supported) {
7142                 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
7143                 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
7144                 return ipw_qos_set_info_element(priv);
7145         }
7146
7147         return 0;
7148 }
7149
7150 /*
7151 * handling the beaconing responses. if we get different QoS setting
7152 * off the network from the associated setting, adjust the QoS
7153 * setting
7154 */
7155 static int ipw_qos_association_resp(struct ipw_priv *priv,
7156                                     struct libipw_network *network)
7157 {
7158         int ret = 0;
7159         unsigned long flags;
7160         u32 size = sizeof(struct libipw_qos_parameters);
7161         int set_qos_param = 0;
7162
7163         if ((priv == NULL) || (network == NULL) ||
7164             (priv->assoc_network == NULL))
7165                 return ret;
7166
7167         if (!(priv->status & STATUS_ASSOCIATED))
7168                 return ret;
7169
7170         if ((priv->ieee->iw_mode != IW_MODE_INFRA))
7171                 return ret;
7172
7173         spin_lock_irqsave(&priv->ieee->lock, flags);
7174         if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
7175                 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
7176                        sizeof(struct libipw_qos_data));
7177                 priv->assoc_network->qos_data.active = 1;
7178                 if ((network->qos_data.old_param_count !=
7179                      network->qos_data.param_count)) {
7180                         set_qos_param = 1;
7181                         network->qos_data.old_param_count =
7182                             network->qos_data.param_count;
7183                 }
7184
7185         } else {
7186                 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
7187                         memcpy(&priv->assoc_network->qos_data.parameters,
7188                                &def_parameters_CCK, size);
7189                 else
7190                         memcpy(&priv->assoc_network->qos_data.parameters,
7191                                &def_parameters_OFDM, size);
7192                 priv->assoc_network->qos_data.active = 0;
7193                 priv->assoc_network->qos_data.supported = 0;
7194                 set_qos_param = 1;
7195         }
7196
7197         spin_unlock_irqrestore(&priv->ieee->lock, flags);
7198
7199         if (set_qos_param == 1)
7200                 schedule_work(&priv->qos_activate);
7201
7202         return ret;
7203 }
7204
7205 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
7206 {
7207         u32 ret = 0;
7208
7209         if ((priv == NULL))
7210                 return 0;
7211
7212         if (!(priv->ieee->modulation & LIBIPW_OFDM_MODULATION))
7213                 ret = priv->qos_data.burst_duration_CCK;
7214         else
7215                 ret = priv->qos_data.burst_duration_OFDM;
7216
7217         return ret;
7218 }
7219
7220 /*
7221 * Initialize the setting of QoS global
7222 */
7223 static void ipw_qos_init(struct ipw_priv *priv, int enable,
7224                          int burst_enable, u32 burst_duration_CCK,
7225                          u32 burst_duration_OFDM)
7226 {
7227         priv->qos_data.qos_enable = enable;
7228
7229         if (priv->qos_data.qos_enable) {
7230                 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
7231                 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
7232                 IPW_DEBUG_QOS("QoS is enabled\n");
7233         } else {
7234                 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
7235                 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
7236                 IPW_DEBUG_QOS("QoS is not enabled\n");
7237         }
7238
7239         priv->qos_data.burst_enable = burst_enable;
7240
7241         if (burst_enable) {
7242                 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
7243                 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
7244         } else {
7245                 priv->qos_data.burst_duration_CCK = 0;
7246                 priv->qos_data.burst_duration_OFDM = 0;
7247         }
7248 }
7249
7250 /*
7251 * map the packet priority to the right TX Queue
7252 */
7253 static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
7254 {
7255         if (priority > 7 || !priv->qos_data.qos_enable)
7256                 priority = 0;
7257
7258         return from_priority_to_tx_queue[priority] - 1;
7259 }
7260
7261 static int ipw_is_qos_active(struct net_device *dev,
7262                              struct sk_buff *skb)
7263 {
7264         struct ipw_priv *priv = libipw_priv(dev);
7265         struct libipw_qos_data *qos_data = NULL;
7266         int active, supported;
7267         u8 *daddr = skb->data + ETH_ALEN;
7268         int unicast = !is_multicast_ether_addr(daddr);
7269
7270         if (!(priv->status & STATUS_ASSOCIATED))
7271                 return 0;
7272
7273         qos_data = &priv->assoc_network->qos_data;
7274
7275         if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7276                 if (unicast == 0)
7277                         qos_data->active = 0;
7278                 else
7279                         qos_data->active = qos_data->supported;
7280         }
7281         active = qos_data->active;
7282         supported = qos_data->supported;
7283         IPW_DEBUG_QOS("QoS  %d network is QoS active %d  supported %d  "
7284                       "unicast %d\n",
7285                       priv->qos_data.qos_enable, active, supported, unicast);
7286         if (active && priv->qos_data.qos_enable)
7287                 return 1;
7288
7289         return 0;
7290
7291 }
7292 /*
7293 * add QoS parameter to the TX command
7294 */
7295 static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
7296                                         u16 priority,
7297                                         struct tfd_data *tfd)
7298 {
7299         int tx_queue_id = 0;
7300
7301
7302         tx_queue_id = from_priority_to_tx_queue[priority] - 1;
7303         tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
7304
7305         if (priv->qos_data.qos_no_ack_mask & (1UL << tx_queue_id)) {
7306                 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
7307                 tfd->tfd.tfd_26.mchdr.qos_ctrl |= cpu_to_le16(CTRL_QOS_NO_ACK);
7308         }
7309         return 0;
7310 }
7311
7312 /*
7313 * background support to run QoS activate functionality
7314 */
7315 static void ipw_bg_qos_activate(struct work_struct *work)
7316 {
7317         struct ipw_priv *priv =
7318                 container_of(work, struct ipw_priv, qos_activate);
7319
7320         mutex_lock(&priv->mutex);
7321
7322         if (priv->status & STATUS_ASSOCIATED)
7323                 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
7324
7325         mutex_unlock(&priv->mutex);
7326 }
7327
7328 static int ipw_handle_probe_response(struct net_device *dev,
7329                                      struct libipw_probe_response *resp,
7330                                      struct libipw_network *network)
7331 {
7332         struct ipw_priv *priv = libipw_priv(dev);
7333         int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7334                               (network == priv->assoc_network));
7335
7336         ipw_qos_handle_probe_response(priv, active_network, network);
7337
7338         return 0;
7339 }
7340
7341 static int ipw_handle_beacon(struct net_device *dev,
7342                              struct libipw_beacon *resp,
7343                              struct libipw_network *network)
7344 {
7345         struct ipw_priv *priv = libipw_priv(dev);
7346         int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7347                               (network == priv->assoc_network));
7348
7349         ipw_qos_handle_probe_response(priv, active_network, network);
7350
7351         return 0;
7352 }
7353
7354 static int ipw_handle_assoc_response(struct net_device *dev,
7355                                      struct libipw_assoc_response *resp,
7356                                      struct libipw_network *network)
7357 {
7358         struct ipw_priv *priv = libipw_priv(dev);
7359         ipw_qos_association_resp(priv, network);
7360         return 0;
7361 }
7362
7363 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct libipw_qos_parameters
7364                                        *qos_param)
7365 {
7366         return ipw_send_cmd_pdu(priv, IPW_CMD_QOS_PARAMETERS,
7367                                 sizeof(*qos_param) * 3, qos_param);
7368 }
7369
7370 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct libipw_qos_information_element
7371                                      *qos_param)
7372 {
7373         return ipw_send_cmd_pdu(priv, IPW_CMD_WME_INFO, sizeof(*qos_param),
7374                                 qos_param);
7375 }
7376
7377 #endif                          /* CONFIG_IPW2200_QOS */
7378
7379 static int ipw_associate_network(struct ipw_priv *priv,
7380                                  struct libipw_network *network,
7381                                  struct ipw_supported_rates *rates, int roaming)
7382 {
7383         int err;
7384         DECLARE_SSID_BUF(ssid);
7385
7386         if (priv->config & CFG_FIXED_RATE)
7387                 ipw_set_fixed_rate(priv, network->mode);
7388
7389         if (!(priv->config & CFG_STATIC_ESSID)) {
7390                 priv->essid_len = min(network->ssid_len,
7391                                       (u8) IW_ESSID_MAX_SIZE);
7392                 memcpy(priv->essid, network->ssid, priv->essid_len);
7393         }
7394
7395         network->last_associate = jiffies;
7396
7397         memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7398         priv->assoc_request.channel = network->channel;
7399         priv->assoc_request.auth_key = 0;
7400
7401         if ((priv->capability & CAP_PRIVACY_ON) &&
7402             (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)) {
7403                 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
7404                 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7405
7406                 if (priv->ieee->sec.level == SEC_LEVEL_1)
7407                         ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
7408
7409         } else if ((priv->capability & CAP_PRIVACY_ON) &&
7410                    (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP))
7411                 priv->assoc_request.auth_type = AUTH_LEAP;
7412         else
7413                 priv->assoc_request.auth_type = AUTH_OPEN;
7414
7415         if (priv->ieee->wpa_ie_len) {
7416                 priv->assoc_request.policy_support = cpu_to_le16(0x02); /* RSN active */
7417                 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7418                                  priv->ieee->wpa_ie_len);
7419         }
7420
7421         /*
7422          * It is valid for our ieee device to support multiple modes, but
7423          * when it comes to associating to a given network we have to choose
7424          * just one mode.
7425          */
7426         if (network->mode & priv->ieee->mode & IEEE_A)
7427                 priv->assoc_request.ieee_mode = IPW_A_MODE;
7428         else if (network->mode & priv->ieee->mode & IEEE_G)
7429                 priv->assoc_request.ieee_mode = IPW_G_MODE;
7430         else if (network->mode & priv->ieee->mode & IEEE_B)
7431                 priv->assoc_request.ieee_mode = IPW_B_MODE;
7432
7433         priv->assoc_request.capability = cpu_to_le16(network->capability);
7434         if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7435             && !(priv->config & CFG_PREAMBLE_LONG)) {
7436                 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7437         } else {
7438                 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7439
7440                 /* Clear the short preamble if we won't be supporting it */
7441                 priv->assoc_request.capability &=
7442                     ~cpu_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE);
7443         }
7444
7445         /* Clear capability bits that aren't used in Ad Hoc */
7446         if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7447                 priv->assoc_request.capability &=
7448                     ~cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT_TIME);
7449
7450         IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
7451                         "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
7452                         roaming ? "Rea" : "A",
7453                         print_ssid(ssid, priv->essid, priv->essid_len),
7454                         network->channel,
7455                         ipw_modes[priv->assoc_request.ieee_mode],
7456                         rates->num_rates,
7457                         (priv->assoc_request.preamble_length ==
7458                          DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7459                         network->capability &
7460                         WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
7461                         priv->capability & CAP_PRIVACY_ON ? "on " : "off",
7462                         priv->capability & CAP_PRIVACY_ON ?
7463                         (priv->capability & CAP_SHARED_KEY ? "(shared)" :
7464                          "(open)") : "",
7465                         priv->capability & CAP_PRIVACY_ON ? " key=" : "",
7466                         priv->capability & CAP_PRIVACY_ON ?
7467                         '1' + priv->ieee->sec.active_key : '.',
7468                         priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
7469
7470         priv->assoc_request.beacon_interval = cpu_to_le16(network->beacon_interval);
7471         if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
7472             (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
7473                 priv->assoc_request.assoc_type = HC_IBSS_START;
7474                 priv->assoc_request.assoc_tsf_msw = 0;
7475                 priv->assoc_request.assoc_tsf_lsw = 0;
7476         } else {
7477                 if (unlikely(roaming))
7478                         priv->assoc_request.assoc_type = HC_REASSOCIATE;
7479                 else
7480                         priv->assoc_request.assoc_type = HC_ASSOCIATE;
7481                 priv->assoc_request.assoc_tsf_msw = cpu_to_le32(network->time_stamp[1]);
7482                 priv->assoc_request.assoc_tsf_lsw = cpu_to_le32(network->time_stamp[0]);
7483         }
7484
7485         memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
7486
7487         if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7488                 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
7489                 priv->assoc_request.atim_window = cpu_to_le16(network->atim_window);
7490         } else {
7491                 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
7492                 priv->assoc_request.atim_window = 0;
7493         }
7494
7495         priv->assoc_request.listen_interval = cpu_to_le16(network->listen_interval);
7496
7497         err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7498         if (err) {
7499                 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7500                 return err;
7501         }
7502
7503         rates->ieee_mode = priv->assoc_request.ieee_mode;
7504         rates->purpose = IPW_RATE_CONNECT;
7505         ipw_send_supported_rates(priv, rates);
7506
7507         if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7508                 priv->sys_config.dot11g_auto_detection = 1;
7509         else
7510                 priv->sys_config.dot11g_auto_detection = 0;
7511
7512         if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7513                 priv->sys_config.answer_broadcast_ssid_probe = 1;
7514         else
7515                 priv->sys_config.answer_broadcast_ssid_probe = 0;
7516
7517         err = ipw_send_system_config(priv);
7518         if (err) {
7519                 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7520                 return err;
7521         }
7522
7523         IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
7524         err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
7525         if (err) {
7526                 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7527                 return err;
7528         }
7529
7530         /*
7531          * If preemption is enabled, it is possible for the association
7532          * to complete before we return from ipw_send_associate.  Therefore
7533          * we have to be sure and update our priviate data first.
7534          */
7535         priv->channel = network->channel;
7536         memcpy(priv->bssid, network->bssid, ETH_ALEN);
7537         priv->status |= STATUS_ASSOCIATING;
7538         priv->status &= ~STATUS_SECURITY_UPDATED;
7539
7540         priv->assoc_network = network;
7541
7542 #ifdef CONFIG_IPW2200_QOS
7543         ipw_qos_association(priv, network);
7544 #endif
7545
7546         err = ipw_send_associate(priv, &priv->assoc_request);
7547         if (err) {
7548                 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7549                 return err;
7550         }
7551
7552         IPW_DEBUG(IPW_DL_STATE, "associating: '%s' %pM\n",
7553                   print_ssid(ssid, priv->essid, priv->essid_len),
7554                   priv->bssid);
7555
7556         return 0;
7557 }
7558
7559 static void ipw_roam(void *data)
7560 {
7561         struct ipw_priv *priv = data;
7562         struct libipw_network *network = NULL;
7563         struct ipw_network_match match = {
7564                 .network = priv->assoc_network
7565         };
7566
7567         /* The roaming process is as follows:
7568          *
7569          * 1.  Missed beacon threshold triggers the roaming process by
7570          *     setting the status ROAM bit and requesting a scan.
7571          * 2.  When the scan completes, it schedules the ROAM work
7572          * 3.  The ROAM work looks at all of the known networks for one that
7573          *     is a better network than the currently associated.  If none
7574          *     found, the ROAM process is over (ROAM bit cleared)
7575          * 4.  If a better network is found, a disassociation request is
7576          *     sent.
7577          * 5.  When the disassociation completes, the roam work is again
7578          *     scheduled.  The second time through, the driver is no longer
7579          *     associated, and the newly selected network is sent an
7580          *     association request.
7581          * 6.  At this point ,the roaming process is complete and the ROAM
7582          *     status bit is cleared.
7583          */
7584
7585         /* If we are no longer associated, and the roaming bit is no longer
7586          * set, then we are not actively roaming, so just return */
7587         if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7588                 return;
7589
7590         if (priv->status & STATUS_ASSOCIATED) {
7591                 /* First pass through ROAM process -- look for a better
7592                  * network */
7593                 unsigned long flags;
7594                 u8 rssi = priv->assoc_network->stats.rssi;
7595                 priv->assoc_network->stats.rssi = -128;
7596                 spin_lock_irqsave(&priv->ieee->lock, flags);
7597                 list_for_each_entry(network, &priv->ieee->network_list, list) {
7598                         if (network != priv->assoc_network)
7599                                 ipw_best_network(priv, &match, network, 1);
7600                 }
7601                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7602                 priv->assoc_network->stats.rssi = rssi;
7603
7604                 if (match.network == priv->assoc_network) {
7605                         IPW_DEBUG_ASSOC("No better APs in this network to "
7606                                         "roam to.\n");
7607                         priv->status &= ~STATUS_ROAMING;
7608                         ipw_debug_config(priv);
7609                         return;
7610                 }
7611
7612                 ipw_send_disassociate(priv, 1);
7613                 priv->assoc_network = match.network;
7614
7615                 return;
7616         }
7617
7618         /* Second pass through ROAM process -- request association */
7619         ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7620         ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7621         priv->status &= ~STATUS_ROAMING;
7622 }
7623
7624 static void ipw_bg_roam(struct work_struct *work)
7625 {
7626         struct ipw_priv *priv =
7627                 container_of(work, struct ipw_priv, roam);
7628         mutex_lock(&priv->mutex);
7629         ipw_roam(priv);
7630         mutex_unlock(&priv->mutex);
7631 }
7632
7633 static int ipw_associate(void *data)
7634 {
7635         struct ipw_priv *priv = data;
7636
7637         struct libipw_network *network = NULL;
7638         struct ipw_network_match match = {
7639                 .network = NULL
7640         };
7641         struct ipw_supported_rates *rates;
7642         struct list_head *element;
7643         unsigned long flags;
7644         DECLARE_SSID_BUF(ssid);
7645
7646         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7647                 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7648                 return 0;
7649         }
7650
7651         if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
7652                 IPW_DEBUG_ASSOC("Not attempting association (already in "
7653                                 "progress)\n");
7654                 return 0;
7655         }
7656
7657         if (priv->status & STATUS_DISASSOCIATING) {
7658                 IPW_DEBUG_ASSOC("Not attempting association (in "
7659                                 "disassociating)\n ");
7660                 queue_work(priv->workqueue, &priv->associate);
7661                 return 0;
7662         }
7663
7664         if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
7665                 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7666                                 "initialized)\n");
7667                 return 0;
7668         }
7669
7670         if (!(priv->config & CFG_ASSOCIATE) &&
7671             !(priv->config & (CFG_STATIC_ESSID | CFG_STATIC_BSSID))) {
7672                 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
7673                 return 0;
7674         }
7675
7676         /* Protect our use of the network_list */
7677         spin_lock_irqsave(&priv->ieee->lock, flags);
7678         list_for_each_entry(network, &priv->ieee->network_list, list)
7679             ipw_best_network(priv, &match, network, 0);
7680
7681         network = match.network;
7682         rates = &match.rates;
7683
7684         if (network == NULL &&
7685             priv->ieee->iw_mode == IW_MODE_ADHOC &&
7686             priv->config & CFG_ADHOC_CREATE &&
7687             priv->config & CFG_STATIC_ESSID &&
7688             priv->config & CFG_STATIC_CHANNEL) {
7689                 /* Use oldest network if the free list is empty */
7690                 if (list_empty(&priv->ieee->network_free_list)) {
7691                         struct libipw_network *oldest = NULL;
7692                         struct libipw_network *target;
7693
7694                         list_for_each_entry(target, &priv->ieee->network_list, list) {
7695                                 if ((oldest == NULL) ||
7696                                     (target->last_scanned < oldest->last_scanned))
7697                                         oldest = target;
7698                         }
7699
7700                         /* If there are no more slots, expire the oldest */
7701                         list_del(&oldest->list);
7702                         target = oldest;
7703                         IPW_DEBUG_ASSOC("Expired '%s' (%pM) from "
7704                                         "network list.\n",
7705                                         print_ssid(ssid, target->ssid,
7706                                                    target->ssid_len),
7707                                         target->bssid);
7708                         list_add_tail(&target->list,
7709                                       &priv->ieee->network_free_list);
7710                 }
7711
7712                 element = priv->ieee->network_free_list.next;
7713                 network = list_entry(element, struct libipw_network, list);
7714                 ipw_adhoc_create(priv, network);
7715                 rates = &priv->rates;
7716                 list_del(element);
7717                 list_add_tail(&network->list, &priv->ieee->network_list);
7718         }
7719         spin_unlock_irqrestore(&priv->ieee->lock, flags);
7720
7721         /* If we reached the end of the list, then we don't have any valid
7722          * matching APs */
7723         if (!network) {
7724                 ipw_debug_config(priv);
7725
7726                 if (!(priv->status & STATUS_SCANNING)) {
7727                         if (!(priv->config & CFG_SPEED_SCAN))
7728                                 queue_delayed_work(priv->workqueue,
7729                                                    &priv->request_scan,
7730                                                    SCAN_INTERVAL);
7731                         else
7732                                 queue_delayed_work(priv->workqueue,
7733                                                    &priv->request_scan, 0);
7734                 }
7735
7736                 return 0;
7737         }
7738
7739         ipw_associate_network(priv, network, rates, 0);
7740
7741         return 1;
7742 }
7743
7744 static void ipw_bg_associate(struct work_struct *work)
7745 {
7746         struct ipw_priv *priv =
7747                 container_of(work, struct ipw_priv, associate);
7748         mutex_lock(&priv->mutex);
7749         ipw_associate(priv);
7750         mutex_unlock(&priv->mutex);
7751 }
7752
7753 static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7754                                       struct sk_buff *skb)
7755 {
7756         struct ieee80211_hdr *hdr;
7757         u16 fc;
7758
7759         hdr = (struct ieee80211_hdr *)skb->data;
7760         fc = le16_to_cpu(hdr->frame_control);
7761         if (!(fc & IEEE80211_FCTL_PROTECTED))
7762                 return;
7763
7764         fc &= ~IEEE80211_FCTL_PROTECTED;
7765         hdr->frame_control = cpu_to_le16(fc);
7766         switch (priv->ieee->sec.level) {
7767         case SEC_LEVEL_3:
7768                 /* Remove CCMP HDR */
7769                 memmove(skb->data + LIBIPW_3ADDR_LEN,
7770                         skb->data + LIBIPW_3ADDR_LEN + 8,
7771                         skb->len - LIBIPW_3ADDR_LEN - 8);
7772                 skb_trim(skb, skb->len - 16);   /* CCMP_HDR_LEN + CCMP_MIC_LEN */
7773                 break;
7774         case SEC_LEVEL_2:
7775                 break;
7776         case SEC_LEVEL_1:
7777                 /* Remove IV */
7778                 memmove(skb->data + LIBIPW_3ADDR_LEN,
7779                         skb->data + LIBIPW_3ADDR_LEN + 4,
7780                         skb->len - LIBIPW_3ADDR_LEN - 4);
7781                 skb_trim(skb, skb->len - 8);    /* IV + ICV */
7782                 break;
7783         case SEC_LEVEL_0:
7784                 break;
7785         default:
7786                 printk(KERN_ERR "Unknown security level %d\n",
7787                        priv->ieee->sec.level);
7788                 break;
7789         }
7790 }
7791
7792 static void ipw_handle_data_packet(struct ipw_priv *priv,
7793                                    struct ipw_rx_mem_buffer *rxb,
7794                                    struct libipw_rx_stats *stats)
7795 {
7796         struct net_device *dev = priv->net_dev;
7797         struct libipw_hdr_4addr *hdr;
7798         struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7799
7800         /* We received data from the HW, so stop the watchdog */
7801         dev->trans_start = jiffies;
7802
7803         /* We only process data packets if the
7804          * interface is open */
7805         if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7806                      skb_tailroom(rxb->skb))) {
7807                 dev->stats.rx_errors++;
7808                 priv->wstats.discard.misc++;
7809                 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7810                 return;
7811         } else if (unlikely(!netif_running(priv->net_dev))) {
7812                 dev->stats.rx_dropped++;
7813                 priv->wstats.discard.misc++;
7814                 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7815                 return;
7816         }
7817
7818         /* Advance skb->data to the start of the actual payload */
7819         skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7820
7821         /* Set the size of the skb to the size of the frame */
7822         skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
7823
7824         IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7825
7826         /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
7827         hdr = (struct libipw_hdr_4addr *)rxb->skb->data;
7828         if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
7829             (is_multicast_ether_addr(hdr->addr1) ?
7830              !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
7831                 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7832
7833         if (!libipw_rx(priv->ieee, rxb->skb, stats))
7834                 dev->stats.rx_errors++;
7835         else {                  /* libipw_rx succeeded, so it now owns the SKB */
7836                 rxb->skb = NULL;
7837                 __ipw_led_activity_on(priv);
7838         }
7839 }
7840
7841 #ifdef CONFIG_IPW2200_RADIOTAP
7842 static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7843                                            struct ipw_rx_mem_buffer *rxb,
7844                                            struct libipw_rx_stats *stats)
7845 {
7846         struct net_device *dev = priv->net_dev;
7847         struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7848         struct ipw_rx_frame *frame = &pkt->u.frame;
7849
7850         /* initial pull of some data */
7851         u16 received_channel = frame->received_channel;
7852         u8 antennaAndPhy = frame->antennaAndPhy;
7853         s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM;       /* call it signed anyhow */
7854         u16 pktrate = frame->rate;
7855
7856         /* Magic struct that slots into the radiotap header -- no reason
7857          * to build this manually element by element, we can write it much
7858          * more efficiently than we can parse it. ORDER MATTERS HERE */
7859         struct ipw_rt_hdr *ipw_rt;
7860
7861         short len = le16_to_cpu(pkt->u.frame.length);
7862
7863         /* We received data from the HW, so stop the watchdog */
7864         dev->trans_start = jiffies;
7865
7866         /* We only process data packets if the
7867          * interface is open */
7868         if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7869                      skb_tailroom(rxb->skb))) {
7870                 dev->stats.rx_errors++;
7871                 priv->wstats.discard.misc++;
7872                 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7873                 return;
7874         } else if (unlikely(!netif_running(priv->net_dev))) {
7875                 dev->stats.rx_dropped++;
7876                 priv->wstats.discard.misc++;
7877                 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7878                 return;
7879         }
7880
7881         /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7882          * that now */
7883         if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7884                 /* FIXME: Should alloc bigger skb instead */
7885                 dev->stats.rx_dropped++;
7886                 priv->wstats.discard.misc++;
7887                 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7888                 return;
7889         }
7890
7891         /* copy the frame itself */
7892         memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7893                 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7894
7895         ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7896
7897         ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7898         ipw_rt->rt_hdr.it_pad = 0;      /* always good to zero */
7899         ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct ipw_rt_hdr)); /* total header+data */
7900
7901         /* Big bitfield of all the fields we provide in radiotap */
7902         ipw_rt->rt_hdr.it_present = cpu_to_le32(
7903              (1 << IEEE80211_RADIOTAP_TSFT) |
7904              (1 << IEEE80211_RADIOTAP_FLAGS) |
7905              (1 << IEEE80211_RADIOTAP_RATE) |
7906              (1 << IEEE80211_RADIOTAP_CHANNEL) |
7907              (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
7908              (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
7909              (1 << IEEE80211_RADIOTAP_ANTENNA));
7910
7911         /* Zero the flags, we'll add to them as we go */
7912         ipw_rt->rt_flags = 0;
7913         ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
7914                                frame->parent_tsf[2] << 16 |
7915                                frame->parent_tsf[1] << 8  |
7916                                frame->parent_tsf[0]);
7917
7918         /* Convert signal to DBM */
7919         ipw_rt->rt_dbmsignal = antsignal;
7920         ipw_rt->rt_dbmnoise = (s8) le16_to_cpu(frame->noise);
7921
7922         /* Convert the channel data and set the flags */
7923         ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7924         if (received_channel > 14) {    /* 802.11a */
7925                 ipw_rt->rt_chbitmask =
7926                     cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7927         } else if (antennaAndPhy & 32) {        /* 802.11b */
7928                 ipw_rt->rt_chbitmask =
7929                     cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7930         } else {                /* 802.11g */
7931                 ipw_rt->rt_chbitmask =
7932                     cpu_to_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
7933         }
7934
7935         /* set the rate in multiples of 500k/s */
7936         switch (pktrate) {
7937         case IPW_TX_RATE_1MB:
7938                 ipw_rt->rt_rate = 2;
7939                 break;
7940         case IPW_TX_RATE_2MB:
7941                 ipw_rt->rt_rate = 4;
7942                 break;
7943         case IPW_TX_RATE_5MB:
7944                 ipw_rt->rt_rate = 10;
7945                 break;
7946         case IPW_TX_RATE_6MB:
7947                 ipw_rt->rt_rate = 12;
7948                 break;
7949         case IPW_TX_RATE_9MB:
7950                 ipw_rt->rt_rate = 18;
7951                 break;
7952         case IPW_TX_RATE_11MB:
7953                 ipw_rt->rt_rate = 22;
7954                 break;
7955         case IPW_TX_RATE_12MB:
7956                 ipw_rt->rt_rate = 24;
7957                 break;
7958         case IPW_TX_RATE_18MB:
7959                 ipw_rt->rt_rate = 36;
7960                 break;
7961         case IPW_TX_RATE_24MB:
7962                 ipw_rt->rt_rate = 48;
7963                 break;
7964         case IPW_TX_RATE_36MB:
7965                 ipw_rt->rt_rate = 72;
7966                 break;
7967         case IPW_TX_RATE_48MB:
7968                 ipw_rt->rt_rate = 96;
7969                 break;
7970         case IPW_TX_RATE_54MB:
7971                 ipw_rt->rt_rate = 108;
7972                 break;
7973         default:
7974                 ipw_rt->rt_rate = 0;
7975                 break;
7976         }
7977
7978         /* antenna number */
7979         ipw_rt->rt_antenna = (antennaAndPhy & 3);       /* Is this right? */
7980
7981         /* set the preamble flag if we have it */
7982         if ((antennaAndPhy & 64))
7983                 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7984
7985         /* Set the size of the skb to the size of the frame */
7986         skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
7987
7988         IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7989
7990         if (!libipw_rx(priv->ieee, rxb->skb, stats))
7991                 dev->stats.rx_errors++;
7992         else {                  /* libipw_rx succeeded, so it now owns the SKB */
7993                 rxb->skb = NULL;
7994                 /* no LED during capture */
7995         }
7996 }
7997 #endif
7998
7999 #ifdef CONFIG_IPW2200_PROMISCUOUS
8000 #define libipw_is_probe_response(fc) \
8001    ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT && \
8002     (fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_PROBE_RESP )
8003
8004 #define libipw_is_management(fc) \
8005    ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT)
8006
8007 #define libipw_is_control(fc) \
8008    ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_CTL)
8009
8010 #define libipw_is_data(fc) \
8011    ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA)
8012
8013 #define libipw_is_assoc_request(fc) \
8014    ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_ASSOC_REQ)
8015
8016 #define libipw_is_reassoc_request(fc) \
8017    ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_REASSOC_REQ)
8018
8019 static void ipw_handle_promiscuous_rx(struct ipw_priv *priv,
8020                                       struct ipw_rx_mem_buffer *rxb,
8021                                       struct libipw_rx_stats *stats)
8022 {
8023         struct net_device *dev = priv->prom_net_dev;
8024         struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
8025         struct ipw_rx_frame *frame = &pkt->u.frame;
8026         struct ipw_rt_hdr *ipw_rt;
8027
8028         /* First cache any information we need before we overwrite
8029          * the information provided in the skb from the hardware */
8030         struct ieee80211_hdr *hdr;
8031         u16 channel = frame->received_channel;
8032         u8 phy_flags = frame->antennaAndPhy;
8033         s8 signal = frame->rssi_dbm - IPW_RSSI_TO_DBM;
8034         s8 noise = (s8) le16_to_cpu(frame->noise);
8035         u8 rate = frame->rate;
8036         short len = le16_to_cpu(pkt->u.frame.length);
8037         struct sk_buff *skb;
8038         int hdr_only = 0;
8039         u16 filter = priv->prom_priv->filter;
8040
8041         /* If the filter is set to not include Rx frames then return */
8042         if (filter & IPW_PROM_NO_RX)
8043                 return;
8044
8045         /* We received data from the HW, so stop the watchdog */
8046         dev->trans_start = jiffies;
8047
8048         if (unlikely((len + IPW_RX_FRAME_SIZE) > skb_tailroom(rxb->skb))) {
8049                 dev->stats.rx_errors++;
8050                 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
8051                 return;
8052         }
8053
8054         /* We only process data packets if the interface is open */
8055         if (unlikely(!netif_running(dev))) {
8056                 dev->stats.rx_dropped++;
8057                 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
8058                 return;
8059         }
8060
8061         /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
8062          * that now */
8063         if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
8064                 /* FIXME: Should alloc bigger skb instead */
8065                 dev->stats.rx_dropped++;
8066                 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
8067                 return;
8068         }
8069
8070         hdr = (void *)rxb->skb->data + IPW_RX_FRAME_SIZE;
8071         if (libipw_is_management(le16_to_cpu(hdr->frame_control))) {
8072                 if (filter & IPW_PROM_NO_MGMT)
8073                         return;
8074                 if (filter & IPW_PROM_MGMT_HEADER_ONLY)
8075                         hdr_only = 1;
8076         } else if (libipw_is_control(le16_to_cpu(hdr->frame_control))) {
8077                 if (filter & IPW_PROM_NO_CTL)
8078                         return;
8079                 if (filter & IPW_PROM_CTL_HEADER_ONLY)
8080                         hdr_only = 1;
8081         } else if (libipw_is_data(le16_to_cpu(hdr->frame_control))) {
8082                 if (filter & IPW_PROM_NO_DATA)
8083                         return;
8084                 if (filter & IPW_PROM_DATA_HEADER_ONLY)
8085                         hdr_only = 1;
8086         }
8087
8088         /* Copy the SKB since this is for the promiscuous side */
8089         skb = skb_copy(rxb->skb, GFP_ATOMIC);
8090         if (skb == NULL) {
8091                 IPW_ERROR("skb_clone failed for promiscuous copy.\n");
8092                 return;
8093         }
8094
8095         /* copy the frame data to write after where the radiotap header goes */
8096         ipw_rt = (void *)skb->data;
8097
8098         if (hdr_only)
8099                 len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_control));
8100
8101         memcpy(ipw_rt->payload, hdr, len);
8102
8103         ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
8104         ipw_rt->rt_hdr.it_pad = 0;      /* always good to zero */
8105         ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(*ipw_rt));   /* total header+data */
8106
8107         /* Set the size of the skb to the size of the frame */
8108         skb_put(skb, sizeof(*ipw_rt) + len);
8109
8110         /* Big bitfield of all the fields we provide in radiotap */
8111         ipw_rt->rt_hdr.it_present = cpu_to_le32(
8112              (1 << IEEE80211_RADIOTAP_TSFT) |
8113              (1 << IEEE80211_RADIOTAP_FLAGS) |
8114              (1 << IEEE80211_RADIOTAP_RATE) |
8115              (1 << IEEE80211_RADIOTAP_CHANNEL) |
8116              (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
8117              (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
8118              (1 << IEEE80211_RADIOTAP_ANTENNA));
8119
8120         /* Zero the flags, we'll add to them as we go */
8121         ipw_rt->rt_flags = 0;
8122         ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
8123                                frame->parent_tsf[2] << 16 |
8124                                frame->parent_tsf[1] << 8  |
8125                                frame->parent_tsf[0]);
8126
8127         /* Convert to DBM */
8128         ipw_rt->rt_dbmsignal = signal;
8129         ipw_rt->rt_dbmnoise = noise;
8130
8131         /* Convert the channel data and set the flags */
8132         ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(channel));
8133         if (channel > 14) {     /* 802.11a */
8134                 ipw_rt->rt_chbitmask =
8135                     cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
8136         } else if (phy_flags & (1 << 5)) {      /* 802.11b */
8137                 ipw_rt->rt_chbitmask =
8138                     cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
8139         } else {                /* 802.11g */
8140                 ipw_rt->rt_chbitmask =
8141                     cpu_to_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
8142         }
8143
8144         /* set the rate in multiples of 500k/s */
8145         switch (rate) {
8146         case IPW_TX_RATE_1MB:
8147                 ipw_rt->rt_rate = 2;
8148                 break;
8149         case IPW_TX_RATE_2MB:
8150                 ipw_rt->rt_rate = 4;
8151                 break;
8152         case IPW_TX_RATE_5MB:
8153                 ipw_rt->rt_rate = 10;
8154                 break;
8155         case IPW_TX_RATE_6MB:
8156                 ipw_rt->rt_rate = 12;
8157                 break;
8158         case IPW_TX_RATE_9MB:
8159                 ipw_rt->rt_rate = 18;
8160                 break;
8161         case IPW_TX_RATE_11MB:
8162                 ipw_rt->rt_rate = 22;
8163                 break;
8164         case IPW_TX_RATE_12MB:
8165                 ipw_rt->rt_rate = 24;
8166                 break;
8167         case IPW_TX_RATE_18MB:
8168                 ipw_rt->rt_rate = 36;
8169                 break;
8170         case IPW_TX_RATE_24MB:
8171                 ipw_rt->rt_rate = 48;
8172                 break;
8173         case IPW_TX_RATE_36MB:
8174                 ipw_rt->rt_rate = 72;
8175                 break;
8176         case IPW_TX_RATE_48MB:
8177                 ipw_rt->rt_rate = 96;
8178                 break;
8179         case IPW_TX_RATE_54MB:
8180                 ipw_rt->rt_rate = 108;
8181                 break;
8182         default:
8183                 ipw_rt->rt_rate = 0;
8184                 break;
8185         }
8186
8187         /* antenna number */
8188         ipw_rt->rt_antenna = (phy_flags & 3);
8189
8190         /* set the preamble flag if we have it */
8191         if (phy_flags & (1 << 6))
8192                 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
8193
8194         IPW_DEBUG_RX("Rx packet of %d bytes.\n", skb->len);
8195
8196         if (!libipw_rx(priv->prom_priv->ieee, skb, stats)) {
8197                 dev->stats.rx_errors++;
8198                 dev_kfree_skb_any(skb);
8199         }
8200 }
8201 #endif
8202
8203 static int is_network_packet(struct ipw_priv *priv,
8204                                     struct libipw_hdr_4addr *header)
8205 {
8206         /* Filter incoming packets to determine if they are targetted toward
8207          * this network, discarding packets coming from ourselves */
8208         switch (priv->ieee->iw_mode) {
8209         case IW_MODE_ADHOC:     /* Header: Dest. | Source    | BSSID */
8210                 /* packets from our adapter are dropped (echo) */
8211                 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
8212                         return 0;
8213
8214                 /* {broad,multi}cast packets to our BSSID go through */
8215                 if (is_multicast_ether_addr(header->addr1))
8216                         return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
8217
8218                 /* packets to our adapter go through */
8219                 return !memcmp(header->addr1, priv->net_dev->dev_addr,
8220                                ETH_ALEN);
8221
8222         case IW_MODE_INFRA:     /* Header: Dest. | BSSID | Source */
8223                 /* packets from our adapter are dropped (echo) */
8224                 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
8225                         return 0;
8226
8227                 /* {broad,multi}cast packets to our BSS go through */
8228                 if (is_multicast_ether_addr(header->addr1))
8229                         return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
8230
8231                 /* packets to our adapter go through */
8232                 return !memcmp(header->addr1, priv->net_dev->dev_addr,
8233                                ETH_ALEN);
8234         }
8235
8236         return 1;
8237 }
8238
8239 #define IPW_PACKET_RETRY_TIME HZ
8240
8241 static  int is_duplicate_packet(struct ipw_priv *priv,
8242                                       struct libipw_hdr_4addr *header)
8243 {
8244         u16 sc = le16_to_cpu(header->seq_ctl);
8245         u16 seq = WLAN_GET_SEQ_SEQ(sc);
8246         u16 frag = WLAN_GET_SEQ_FRAG(sc);
8247         u16 *last_seq, *last_frag;
8248         unsigned long *last_time;
8249
8250         switch (priv->ieee->iw_mode) {
8251         case IW_MODE_ADHOC:
8252                 {
8253                         struct list_head *p;
8254                         struct ipw_ibss_seq *entry = NULL;
8255                         u8 *mac = header->addr2;
8256                         int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
8257
8258                         __list_for_each(p, &priv->ibss_mac_hash[index]) {
8259                                 entry =
8260                                     list_entry(p, struct ipw_ibss_seq, list);
8261                                 if (!memcmp(entry->mac, mac, ETH_ALEN))
8262                                         break;
8263                         }
8264                         if (p == &priv->ibss_mac_hash[index]) {
8265                                 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
8266                                 if (!entry) {
8267                                         IPW_ERROR
8268                                             ("Cannot malloc new mac entry\n");
8269                                         return 0;
8270                                 }
8271                                 memcpy(entry->mac, mac, ETH_ALEN);
8272                                 entry->seq_num = seq;
8273                                 entry->frag_num = frag;
8274                                 entry->packet_time = jiffies;
8275                                 list_add(&entry->list,
8276                                          &priv->ibss_mac_hash[index]);
8277                                 return 0;
8278                         }
8279                         last_seq = &entry->seq_num;
8280                         last_frag = &entry->frag_num;
8281                         last_time = &entry->packet_time;
8282                         break;
8283                 }
8284         case IW_MODE_INFRA:
8285                 last_seq = &priv->last_seq_num;
8286                 last_frag = &priv->last_frag_num;
8287                 last_time = &priv->last_packet_time;
8288                 break;
8289         default:
8290                 return 0;
8291         }
8292         if ((*last_seq == seq) &&
8293             time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
8294                 if (*last_frag == frag)
8295                         goto drop;
8296                 if (*last_frag + 1 != frag)
8297                         /* out-of-order fragment */
8298                         goto drop;
8299         } else
8300                 *last_seq = seq;
8301
8302         *last_frag = frag;
8303         *last_time = jiffies;
8304         return 0;
8305
8306       drop:
8307         /* Comment this line now since we observed the card receives
8308          * duplicate packets but the FCTL_RETRY bit is not set in the
8309          * IBSS mode with fragmentation enabled.
8310          BUG_ON(!(le16_to_cpu(header->frame_control) & IEEE80211_FCTL_RETRY)); */
8311         return 1;
8312 }
8313
8314 static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
8315                                    struct ipw_rx_mem_buffer *rxb,
8316                                    struct libipw_rx_stats *stats)
8317 {
8318         struct sk_buff *skb = rxb->skb;
8319         struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
8320         struct libipw_hdr_4addr *header = (struct libipw_hdr_4addr *)
8321             (skb->data + IPW_RX_FRAME_SIZE);
8322
8323         libipw_rx_mgt(priv->ieee, header, stats);
8324
8325         if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
8326             ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8327               IEEE80211_STYPE_PROBE_RESP) ||
8328              (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8329               IEEE80211_STYPE_BEACON))) {
8330                 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
8331                         ipw_add_station(priv, header->addr2);
8332         }
8333
8334         if (priv->config & CFG_NET_STATS) {
8335                 IPW_DEBUG_HC("sending stat packet\n");
8336
8337                 /* Set the size of the skb to the size of the full
8338                  * ipw header and 802.11 frame */
8339                 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
8340                         IPW_RX_FRAME_SIZE);
8341
8342                 /* Advance past the ipw packet header to the 802.11 frame */
8343                 skb_pull(skb, IPW_RX_FRAME_SIZE);
8344
8345                 /* Push the libipw_rx_stats before the 802.11 frame */
8346                 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
8347
8348                 skb->dev = priv->ieee->dev;
8349
8350                 /* Point raw at the libipw_stats */
8351                 skb_reset_mac_header(skb);
8352
8353                 skb->pkt_type = PACKET_OTHERHOST;
8354                 skb->protocol = cpu_to_be16(ETH_P_80211_STATS);
8355                 memset(skb->cb, 0, sizeof(rxb->skb->cb));
8356                 netif_rx(skb);
8357                 rxb->skb = NULL;
8358         }
8359 }
8360
8361 /*
8362  * Main entry function for recieving a packet with 80211 headers.  This
8363  * should be called when ever the FW has notified us that there is a new
8364  * skb in the recieve queue.
8365  */
8366 static void ipw_rx(struct ipw_priv *priv)
8367 {
8368         struct ipw_rx_mem_buffer *rxb;
8369         struct ipw_rx_packet *pkt;
8370         struct libipw_hdr_4addr *header;
8371         u32 r, w, i;
8372         u8 network_packet;
8373         u8 fill_rx = 0;
8374
8375         r = ipw_read32(priv, IPW_RX_READ_INDEX);
8376         w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
8377         i = priv->rxq->read;
8378
8379         if (ipw_rx_queue_space (priv->rxq) > (RX_QUEUE_SIZE / 2))
8380                 fill_rx = 1;
8381
8382         while (i != r) {
8383                 rxb = priv->rxq->queue[i];
8384                 if (unlikely(rxb == NULL)) {
8385                         printk(KERN_CRIT "Queue not allocated!\n");
8386                         break;
8387                 }
8388                 priv->rxq->queue[i] = NULL;
8389
8390                 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
8391                                             IPW_RX_BUF_SIZE,
8392                                             PCI_DMA_FROMDEVICE);
8393
8394                 pkt = (struct ipw_rx_packet *)rxb->skb->data;
8395                 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
8396                              pkt->header.message_type,
8397                              pkt->header.rx_seq_num, pkt->header.control_bits);
8398
8399                 switch (pkt->header.message_type) {
8400                 case RX_FRAME_TYPE:     /* 802.11 frame */  {
8401                                 struct libipw_rx_stats stats = {
8402                                         .rssi = pkt->u.frame.rssi_dbm -
8403                                             IPW_RSSI_TO_DBM,
8404                                         .signal =
8405                                             pkt->u.frame.rssi_dbm -
8406                                             IPW_RSSI_TO_DBM + 0x100,
8407                                         .noise =
8408                                             le16_to_cpu(pkt->u.frame.noise),
8409                                         .rate = pkt->u.frame.rate,
8410                                         .mac_time = jiffies,
8411                                         .received_channel =
8412                                             pkt->u.frame.received_channel,
8413                                         .freq =
8414                                             (pkt->u.frame.
8415                                              control & (1 << 0)) ?
8416                                             LIBIPW_24GHZ_BAND :
8417                                             LIBIPW_52GHZ_BAND,
8418                                         .len = le16_to_cpu(pkt->u.frame.length),
8419                                 };
8420
8421                                 if (stats.rssi != 0)
8422                                         stats.mask |= LIBIPW_STATMASK_RSSI;
8423                                 if (stats.signal != 0)
8424                                         stats.mask |= LIBIPW_STATMASK_SIGNAL;
8425                                 if (stats.noise != 0)
8426                                         stats.mask |= LIBIPW_STATMASK_NOISE;
8427                                 if (stats.rate != 0)
8428                                         stats.mask |= LIBIPW_STATMASK_RATE;
8429
8430                                 priv->rx_packets++;
8431
8432 #ifdef CONFIG_IPW2200_PROMISCUOUS
8433         if (priv->prom_net_dev && netif_running(priv->prom_net_dev))
8434                 ipw_handle_promiscuous_rx(priv, rxb, &stats);
8435 #endif
8436
8437 #ifdef CONFIG_IPW2200_MONITOR
8438                                 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8439 #ifdef CONFIG_IPW2200_RADIOTAP
8440
8441                 ipw_handle_data_packet_monitor(priv,
8442                                                rxb,
8443                                                &stats);
8444 #else
8445                 ipw_handle_data_packet(priv, rxb,
8446                                        &stats);
8447 #endif
8448                                         break;
8449                                 }
8450 #endif
8451
8452                                 header =
8453                                     (struct libipw_hdr_4addr *)(rxb->skb->
8454                                                                    data +
8455                                                                    IPW_RX_FRAME_SIZE);
8456                                 /* TODO: Check Ad-Hoc dest/source and make sure
8457                                  * that we are actually parsing these packets
8458                                  * correctly -- we should probably use the
8459                                  * frame control of the packet and disregard
8460                                  * the current iw_mode */
8461
8462                                 network_packet =
8463                                     is_network_packet(priv, header);
8464                                 if (network_packet && priv->assoc_network) {
8465                                         priv->assoc_network->stats.rssi =
8466                                             stats.rssi;
8467                                         priv->exp_avg_rssi =
8468                                             exponential_average(priv->exp_avg_rssi,
8469                                             stats.rssi, DEPTH_RSSI);
8470                                 }
8471
8472                                 IPW_DEBUG_RX("Frame: len=%u\n",
8473                                              le16_to_cpu(pkt->u.frame.length));
8474
8475                                 if (le16_to_cpu(pkt->u.frame.length) <
8476                                     libipw_get_hdrlen(le16_to_cpu(
8477                                                     header->frame_ctl))) {
8478                                         IPW_DEBUG_DROP
8479                                             ("Received packet is too small. "
8480                                              "Dropping.\n");
8481                                         priv->net_dev->stats.rx_errors++;
8482                                         priv->wstats.discard.misc++;
8483                                         break;
8484                                 }
8485
8486                                 switch (WLAN_FC_GET_TYPE
8487                                         (le16_to_cpu(header->frame_ctl))) {
8488
8489                                 case IEEE80211_FTYPE_MGMT:
8490                                         ipw_handle_mgmt_packet(priv, rxb,
8491                                                                &stats);
8492                                         break;
8493
8494                                 case IEEE80211_FTYPE_CTL:
8495                                         break;
8496
8497                                 case IEEE80211_FTYPE_DATA:
8498                                         if (unlikely(!network_packet ||
8499                                                      is_duplicate_packet(priv,
8500                                                                          header)))
8501                                         {
8502                                                 IPW_DEBUG_DROP("Dropping: "
8503                                                                "%pM, "
8504                                                                "%pM, "
8505                                                                "%pM\n",
8506                                                                header->addr1,
8507                                                                header->addr2,
8508                                                                header->addr3);
8509                                                 break;
8510                                         }
8511
8512                                         ipw_handle_data_packet(priv, rxb,
8513                                                                &stats);
8514
8515                                         break;
8516                                 }
8517                                 break;
8518                         }
8519
8520                 case RX_HOST_NOTIFICATION_TYPE:{
8521                                 IPW_DEBUG_RX
8522                                     ("Notification: subtype=%02X flags=%02X size=%d\n",
8523                                      pkt->u.notification.subtype,
8524                                      pkt->u.notification.flags,
8525                                      le16_to_cpu(pkt->u.notification.size));
8526                                 ipw_rx_notification(priv, &pkt->u.notification);
8527                                 break;
8528                         }
8529
8530                 default:
8531                         IPW_DEBUG_RX("Bad Rx packet of type %d\n",
8532                                      pkt->header.message_type);
8533                         break;
8534                 }
8535
8536                 /* For now we just don't re-use anything.  We can tweak this
8537                  * later to try and re-use notification packets and SKBs that
8538                  * fail to Rx correctly */
8539                 if (rxb->skb != NULL) {
8540                         dev_kfree_skb_any(rxb->skb);
8541                         rxb->skb = NULL;
8542                 }
8543
8544                 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
8545                                  IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
8546                 list_add_tail(&rxb->list, &priv->rxq->rx_used);
8547
8548                 i = (i + 1) % RX_QUEUE_SIZE;
8549
8550                 /* If there are a lot of unsued frames, restock the Rx queue
8551                  * so the ucode won't assert */
8552                 if (fill_rx) {
8553                         priv->rxq->read = i;
8554                         ipw_rx_queue_replenish(priv);
8555                 }
8556         }
8557
8558         /* Backtrack one entry */
8559         priv->rxq->read = i;
8560         ipw_rx_queue_restock(priv);
8561 }
8562
8563 #define DEFAULT_RTS_THRESHOLD     2304U
8564 #define MIN_RTS_THRESHOLD         1U
8565 #define MAX_RTS_THRESHOLD         2304U
8566 #define DEFAULT_BEACON_INTERVAL   100U
8567 #define DEFAULT_SHORT_RETRY_LIMIT 7U
8568 #define DEFAULT_LONG_RETRY_LIMIT  4U
8569
8570 /**
8571  * ipw_sw_reset
8572  * @option: options to control different reset behaviour
8573  *          0 = reset everything except the 'disable' module_param
8574  *          1 = reset everything and print out driver info (for probe only)
8575  *          2 = reset everything
8576  */
8577 static int ipw_sw_reset(struct ipw_priv *priv, int option)
8578 {
8579         int band, modulation;
8580         int old_mode = priv->ieee->iw_mode;
8581
8582         /* Initialize module parameter values here */
8583         priv->config = 0;
8584
8585         /* We default to disabling the LED code as right now it causes
8586          * too many systems to lock up... */
8587         if (!led_support)
8588                 priv->config |= CFG_NO_LED;
8589
8590         if (associate)
8591                 priv->config |= CFG_ASSOCIATE;
8592         else
8593                 IPW_DEBUG_INFO("Auto associate disabled.\n");
8594
8595         if (auto_create)
8596                 priv->config |= CFG_ADHOC_CREATE;
8597         else
8598                 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
8599
8600         priv->config &= ~CFG_STATIC_ESSID;
8601         priv->essid_len = 0;
8602         memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
8603
8604         if (disable && option) {
8605                 priv->status |= STATUS_RF_KILL_SW;
8606                 IPW_DEBUG_INFO("Radio disabled.\n");
8607         }
8608
8609         if (default_channel != 0) {
8610                 priv->config |= CFG_STATIC_CHANNEL;
8611                 priv->channel = default_channel;
8612                 IPW_DEBUG_INFO("Bind to static channel %d\n", default_channel);
8613                 /* TODO: Validate that provided channel is in range */
8614         }
8615 #ifdef CONFIG_IPW2200_QOS
8616         ipw_qos_init(priv, qos_enable, qos_burst_enable,
8617                      burst_duration_CCK, burst_duration_OFDM);
8618 #endif                          /* CONFIG_IPW2200_QOS */
8619
8620         switch (network_mode) {
8621         case 1:
8622                 priv->ieee->iw_mode = IW_MODE_ADHOC;
8623                 priv->net_dev->type = ARPHRD_ETHER;
8624
8625                 break;
8626 #ifdef CONFIG_IPW2200_MONITOR
8627         case 2:
8628                 priv->ieee->iw_mode = IW_MODE_MONITOR;
8629 #ifdef CONFIG_IPW2200_RADIOTAP
8630                 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8631 #else
8632                 priv->net_dev->type = ARPHRD_IEEE80211;
8633 #endif
8634                 break;
8635 #endif
8636         default:
8637         case 0:
8638                 priv->net_dev->type = ARPHRD_ETHER;
8639                 priv->ieee->iw_mode = IW_MODE_INFRA;
8640                 break;
8641         }
8642
8643         if (hwcrypto) {
8644                 priv->ieee->host_encrypt = 0;
8645                 priv->ieee->host_encrypt_msdu = 0;
8646                 priv->ieee->host_decrypt = 0;
8647                 priv->ieee->host_mc_decrypt = 0;
8648         }
8649         IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
8650
8651         /* IPW2200/2915 is abled to do hardware fragmentation. */
8652         priv->ieee->host_open_frag = 0;
8653
8654         if ((priv->pci_dev->device == 0x4223) ||
8655             (priv->pci_dev->device == 0x4224)) {
8656                 if (option == 1)
8657                         printk(KERN_INFO DRV_NAME
8658                                ": Detected Intel PRO/Wireless 2915ABG Network "
8659                                "Connection\n");
8660                 priv->ieee->abg_true = 1;
8661                 band = LIBIPW_52GHZ_BAND | LIBIPW_24GHZ_BAND;
8662                 modulation = LIBIPW_OFDM_MODULATION |
8663                     LIBIPW_CCK_MODULATION;
8664                 priv->adapter = IPW_2915ABG;
8665                 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
8666         } else {
8667                 if (option == 1)
8668                         printk(KERN_INFO DRV_NAME
8669                                ": Detected Intel PRO/Wireless 2200BG Network "
8670                                "Connection\n");
8671
8672                 priv->ieee->abg_true = 0;
8673                 band = LIBIPW_24GHZ_BAND;
8674                 modulation = LIBIPW_OFDM_MODULATION |
8675                     LIBIPW_CCK_MODULATION;
8676                 priv->adapter = IPW_2200BG;
8677                 priv->ieee->mode = IEEE_G | IEEE_B;
8678         }
8679
8680         priv->ieee->freq_band = band;
8681         priv->ieee->modulation = modulation;
8682
8683         priv->rates_mask = LIBIPW_DEFAULT_RATES_MASK;
8684
8685         priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8686         priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
8687
8688         priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8689         priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8690         priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
8691
8692         /* If power management is turned on, default to AC mode */
8693         priv->power_mode = IPW_POWER_AC;
8694         priv->tx_power = IPW_TX_POWER_DEFAULT;
8695
8696         return old_mode == priv->ieee->iw_mode;
8697 }
8698
8699 /*
8700  * This file defines the Wireless Extension handlers.  It does not
8701  * define any methods of hardware manipulation and relies on the
8702  * functions defined in ipw_main to provide the HW interaction.
8703  *
8704  * The exception to this is the use of the ipw_get_ordinal()
8705  * function used to poll the hardware vs. making unecessary calls.
8706  *
8707  */
8708
8709 static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8710 {
8711         if (channel == 0) {
8712                 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8713                 priv->config &= ~CFG_STATIC_CHANNEL;
8714                 IPW_DEBUG_ASSOC("Attempting to associate with new "
8715                                 "parameters.\n");
8716                 ipw_associate(priv);
8717                 return 0;
8718         }
8719
8720         priv->config |= CFG_STATIC_CHANNEL;
8721
8722         if (priv->channel == channel) {
8723                 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8724                                channel);
8725                 return 0;
8726         }
8727
8728         IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8729         priv->channel = channel;
8730
8731 #ifdef CONFIG_IPW2200_MONITOR
8732         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8733                 int i;
8734                 if (priv->status & STATUS_SCANNING) {
8735                         IPW_DEBUG_SCAN("Scan abort triggered due to "
8736                                        "channel change.\n");
8737                         ipw_abort_scan(priv);
8738                 }
8739
8740                 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8741                         udelay(10);
8742
8743                 if (priv->status & STATUS_SCANNING)
8744                         IPW_DEBUG_SCAN("Still scanning...\n");
8745                 else
8746                         IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8747                                        1000 - i);
8748
8749                 return 0;
8750         }
8751 #endif                          /* CONFIG_IPW2200_MONITOR */
8752
8753         /* Network configuration changed -- force [re]association */
8754         IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8755         if (!ipw_disassociate(priv))
8756                 ipw_associate(priv);
8757
8758         return 0;
8759 }
8760
8761 static int ipw_wx_set_freq(struct net_device *dev,
8762                            struct iw_request_info *info,
8763                            union iwreq_data *wrqu, char *extra)
8764 {
8765         struct ipw_priv *priv = libipw_priv(dev);
8766         const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
8767         struct iw_freq *fwrq = &wrqu->freq;
8768         int ret = 0, i;
8769         u8 channel, flags;
8770         int band;
8771
8772         if (fwrq->m == 0) {
8773                 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
8774                 mutex_lock(&priv->mutex);
8775                 ret = ipw_set_channel(priv, 0);
8776                 mutex_unlock(&priv->mutex);
8777                 return ret;
8778         }
8779         /* if setting by freq convert to channel */
8780         if (fwrq->e == 1) {
8781                 channel = libipw_freq_to_channel(priv->ieee, fwrq->m);
8782                 if (channel == 0)
8783                         return -EINVAL;
8784         } else
8785                 channel = fwrq->m;
8786
8787         if (!(band = libipw_is_valid_channel(priv->ieee, channel)))
8788                 return -EINVAL;
8789
8790         if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
8791                 i = libipw_channel_to_index(priv->ieee, channel);
8792                 if (i == -1)
8793                         return -EINVAL;
8794
8795                 flags = (band == LIBIPW_24GHZ_BAND) ?
8796                     geo->bg[i].flags : geo->a[i].flags;
8797                 if (flags & LIBIPW_CH_PASSIVE_ONLY) {
8798                         IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8799                         return -EINVAL;
8800                 }
8801         }
8802
8803         IPW_DEBUG_WX("SET Freq/Channel -> %d\n", fwrq->m);
8804         mutex_lock(&priv->mutex);
8805         ret = ipw_set_channel(priv, channel);
8806         mutex_unlock(&priv->mutex);
8807         return ret;
8808 }
8809
8810 static int ipw_wx_get_freq(struct net_device *dev,
8811                            struct iw_request_info *info,
8812                            union iwreq_data *wrqu, char *extra)
8813 {
8814         struct ipw_priv *priv = libipw_priv(dev);
8815
8816         wrqu->freq.e = 0;
8817
8818         /* If we are associated, trying to associate, or have a statically
8819          * configured CHANNEL then return that; otherwise return ANY */
8820         mutex_lock(&priv->mutex);
8821         if (priv->config & CFG_STATIC_CHANNEL ||
8822             priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) {
8823                 int i;
8824
8825                 i = libipw_channel_to_index(priv->ieee, priv->channel);
8826                 BUG_ON(i == -1);
8827                 wrqu->freq.e = 1;
8828
8829                 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
8830                 case LIBIPW_52GHZ_BAND:
8831                         wrqu->freq.m = priv->ieee->geo.a[i].freq * 100000;
8832                         break;
8833
8834                 case LIBIPW_24GHZ_BAND:
8835                         wrqu->freq.m = priv->ieee->geo.bg[i].freq * 100000;
8836                         break;
8837
8838                 default:
8839                         BUG();
8840                 }
8841         } else
8842                 wrqu->freq.m = 0;
8843
8844         mutex_unlock(&priv->mutex);
8845         IPW_DEBUG_WX("GET Freq/Channel -> %d\n", priv->channel);
8846         return 0;
8847 }
8848
8849 static int ipw_wx_set_mode(struct net_device *dev,
8850                            struct iw_request_info *info,
8851                            union iwreq_data *wrqu, char *extra)
8852 {
8853         struct ipw_priv *priv = libipw_priv(dev);
8854         int err = 0;
8855
8856         IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8857
8858         switch (wrqu->mode) {
8859 #ifdef CONFIG_IPW2200_MONITOR
8860         case IW_MODE_MONITOR:
8861 #endif
8862         case IW_MODE_ADHOC:
8863         case IW_MODE_INFRA:
8864                 break;
8865         case IW_MODE_AUTO:
8866                 wrqu->mode = IW_MODE_INFRA;
8867                 break;
8868         default:
8869                 return -EINVAL;
8870         }
8871         if (wrqu->mode == priv->ieee->iw_mode)
8872                 return 0;
8873
8874         mutex_lock(&priv->mutex);
8875
8876         ipw_sw_reset(priv, 0);
8877
8878 #ifdef CONFIG_IPW2200_MONITOR
8879         if (priv->ieee->iw_mode == IW_MODE_MONITOR)
8880                 priv->net_dev->type = ARPHRD_ETHER;
8881
8882         if (wrqu->mode == IW_MODE_MONITOR)
8883 #ifdef CONFIG_IPW2200_RADIOTAP
8884                 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8885 #else
8886                 priv->net_dev->type = ARPHRD_IEEE80211;
8887 #endif
8888 #endif                          /* CONFIG_IPW2200_MONITOR */
8889
8890         /* Free the existing firmware and reset the fw_loaded
8891          * flag so ipw_load() will bring in the new firmware */
8892         free_firmware();
8893
8894         priv->ieee->iw_mode = wrqu->mode;
8895
8896         queue_work(priv->workqueue, &priv->adapter_restart);
8897         mutex_unlock(&priv->mutex);
8898         return err;
8899 }
8900
8901 static int ipw_wx_get_mode(struct net_device *dev,
8902                            struct iw_request_info *info,
8903                            union iwreq_data *wrqu, char *extra)
8904 {
8905         struct ipw_priv *priv = libipw_priv(dev);
8906         mutex_lock(&priv->mutex);
8907         wrqu->mode = priv->ieee->iw_mode;
8908         IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
8909         mutex_unlock(&priv->mutex);
8910         return 0;
8911 }
8912
8913 /* Values are in microsecond */
8914 static const s32 timeout_duration[] = {
8915         350000,
8916         250000,
8917         75000,
8918         37000,
8919         25000,
8920 };
8921
8922 static const s32 period_duration[] = {
8923         400000,
8924         700000,
8925         1000000,
8926         1000000,
8927         1000000
8928 };
8929
8930 static int ipw_wx_get_range(struct net_device *dev,
8931                             struct iw_request_info *info,
8932                             union iwreq_data *wrqu, char *extra)
8933 {
8934         struct ipw_priv *priv = libipw_priv(dev);
8935         struct iw_range *range = (struct iw_range *)extra;
8936         const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
8937         int i = 0, j;
8938
8939         wrqu->data.length = sizeof(*range);
8940         memset(range, 0, sizeof(*range));
8941
8942         /* 54Mbs == ~27 Mb/s real (802.11g) */
8943         range->throughput = 27 * 1000 * 1000;
8944
8945         range->max_qual.qual = 100;
8946         /* TODO: Find real max RSSI and stick here */
8947         range->max_qual.level = 0;
8948         range->max_qual.noise = 0;
8949         range->max_qual.updated = 7;    /* Updated all three */
8950
8951         range->avg_qual.qual = 70;
8952         /* TODO: Find real 'good' to 'bad' threshold value for RSSI */
8953         range->avg_qual.level = 0;      /* FIXME to real average level */
8954         range->avg_qual.noise = 0;
8955         range->avg_qual.updated = 7;    /* Updated all three */
8956         mutex_lock(&priv->mutex);
8957         range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
8958
8959         for (i = 0; i < range->num_bitrates; i++)
8960                 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
8961                     500000;
8962
8963         range->max_rts = DEFAULT_RTS_THRESHOLD;
8964         range->min_frag = MIN_FRAG_THRESHOLD;
8965         range->max_frag = MAX_FRAG_THRESHOLD;
8966
8967         range->encoding_size[0] = 5;
8968         range->encoding_size[1] = 13;
8969         range->num_encoding_sizes = 2;
8970         range->max_encoding_tokens = WEP_KEYS;
8971
8972         /* Set the Wireless Extension versions */
8973         range->we_version_compiled = WIRELESS_EXT;
8974         range->we_version_source = 18;
8975
8976         i = 0;
8977         if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8978                 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES; j++) {
8979                         if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
8980                             (geo->bg[j].flags & LIBIPW_CH_PASSIVE_ONLY))
8981                                 continue;
8982
8983                         range->freq[i].i = geo->bg[j].channel;
8984                         range->freq[i].m = geo->bg[j].freq * 100000;
8985                         range->freq[i].e = 1;
8986                         i++;
8987                 }
8988         }
8989
8990         if (priv->ieee->mode & IEEE_A) {
8991                 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES; j++) {
8992                         if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
8993                             (geo->a[j].flags & LIBIPW_CH_PASSIVE_ONLY))
8994                                 continue;
8995
8996                         range->freq[i].i = geo->a[j].channel;
8997                         range->freq[i].m = geo->a[j].freq * 100000;
8998                         range->freq[i].e = 1;
8999                         i++;
9000                 }
9001         }
9002
9003         range->num_channels = i;
9004         range->num_frequency = i;
9005
9006         mutex_unlock(&priv->mutex);
9007
9008         /* Event capability (kernel + driver) */
9009         range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
9010                                 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
9011                                 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
9012                                 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
9013         range->event_capa[1] = IW_EVENT_CAPA_K_1;
9014
9015         range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
9016                 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
9017
9018         range->scan_capa = IW_SCAN_CAPA_ESSID | IW_SCAN_CAPA_TYPE;
9019
9020         IPW_DEBUG_WX("GET Range\n");
9021         return 0;
9022 }
9023
9024 static int ipw_wx_set_wap(struct net_device *dev,
9025                           struct iw_request_info *info,
9026                           union iwreq_data *wrqu, char *extra)
9027 {
9028         struct ipw_priv *priv = libipw_priv(dev);
9029
9030         static const unsigned char any[] = {
9031                 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
9032         };
9033         static const unsigned char off[] = {
9034                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
9035         };
9036
9037         if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
9038                 return -EINVAL;
9039         mutex_lock(&priv->mutex);
9040         if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
9041             !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
9042                 /* we disable mandatory BSSID association */
9043                 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
9044                 priv->config &= ~CFG_STATIC_BSSID;
9045                 IPW_DEBUG_ASSOC("Attempting to associate with new "
9046                                 "parameters.\n");
9047                 ipw_associate(priv);
9048                 mutex_unlock(&priv->mutex);
9049                 return 0;
9050         }
9051
9052         priv->config |= CFG_STATIC_BSSID;
9053         if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
9054                 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
9055                 mutex_unlock(&priv->mutex);
9056                 return 0;
9057         }
9058
9059         IPW_DEBUG_WX("Setting mandatory BSSID to %pM\n",
9060                      wrqu->ap_addr.sa_data);
9061
9062         memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
9063
9064         /* Network configuration changed -- force [re]association */
9065         IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
9066         if (!ipw_disassociate(priv))
9067                 ipw_associate(priv);
9068
9069         mutex_unlock(&priv->mutex);
9070         return 0;
9071 }
9072
9073 static int ipw_wx_get_wap(struct net_device *dev,
9074                           struct iw_request_info *info,
9075                           union iwreq_data *wrqu, char *extra)
9076 {
9077         struct ipw_priv *priv = libipw_priv(dev);
9078
9079         /* If we are associated, trying to associate, or have a statically
9080          * configured BSSID then return that; otherwise return ANY */
9081         mutex_lock(&priv->mutex);
9082         if (priv->config & CFG_STATIC_BSSID ||
9083             priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
9084                 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
9085                 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
9086         } else
9087                 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
9088
9089         IPW_DEBUG_WX("Getting WAP BSSID: %pM\n",
9090                      wrqu->ap_addr.sa_data);
9091         mutex_unlock(&priv->mutex);
9092         return 0;
9093 }
9094
9095 static int ipw_wx_set_essid(struct net_device *dev,
9096                             struct iw_request_info *info,
9097                             union iwreq_data *wrqu, char *extra)
9098 {
9099         struct ipw_priv *priv = libipw_priv(dev);
9100         int length;
9101         DECLARE_SSID_BUF(ssid);
9102
9103         mutex_lock(&priv->mutex);
9104
9105         if (!wrqu->essid.flags)
9106         {
9107                 IPW_DEBUG_WX("Setting ESSID to ANY\n");
9108                 ipw_disassociate(priv);
9109                 priv->config &= ~CFG_STATIC_ESSID;
9110                 ipw_associate(priv);
9111                 mutex_unlock(&priv->mutex);
9112                 return 0;
9113         }
9114
9115         length = min((int)wrqu->essid.length, IW_ESSID_MAX_SIZE);
9116
9117         priv->config |= CFG_STATIC_ESSID;
9118
9119         if (priv->essid_len == length && !memcmp(priv->essid, extra, length)
9120             && (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING))) {
9121                 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
9122                 mutex_unlock(&priv->mutex);
9123                 return 0;
9124         }
9125
9126         IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n",
9127                      print_ssid(ssid, extra, length), length);
9128
9129         priv->essid_len = length;
9130         memcpy(priv->essid, extra, priv->essid_len);
9131
9132         /* Network configuration changed -- force [re]association */
9133         IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
9134         if (!ipw_disassociate(priv))
9135                 ipw_associate(priv);
9136
9137         mutex_unlock(&priv->mutex);
9138         return 0;
9139 }
9140
9141 static int ipw_wx_get_essid(struct net_device *dev,
9142                             struct iw_request_info *info,
9143                             union iwreq_data *wrqu, char *extra)
9144 {
9145         struct ipw_priv *priv = libipw_priv(dev);
9146         DECLARE_SSID_BUF(ssid);
9147
9148         /* If we are associated, trying to associate, or have a statically
9149          * configured ESSID then return that; otherwise return ANY */
9150         mutex_lock(&priv->mutex);
9151         if (priv->config & CFG_STATIC_ESSID ||
9152             priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
9153                 IPW_DEBUG_WX("Getting essid: '%s'\n",
9154                              print_ssid(ssid, priv->essid, priv->essid_len));
9155                 memcpy(extra, priv->essid, priv->essid_len);
9156                 wrqu->essid.length = priv->essid_len;
9157                 wrqu->essid.flags = 1;  /* active */
9158         } else {
9159                 IPW_DEBUG_WX("Getting essid: ANY\n");
9160                 wrqu->essid.length = 0;
9161                 wrqu->essid.flags = 0;  /* active */
9162         }
9163         mutex_unlock(&priv->mutex);
9164         return 0;
9165 }
9166
9167 static int ipw_wx_set_nick(struct net_device *dev,
9168                            struct iw_request_info *info,
9169                            union iwreq_data *wrqu, char *extra)
9170 {
9171         struct ipw_priv *priv = libipw_priv(dev);
9172
9173         IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
9174         if (wrqu->data.length > IW_ESSID_MAX_SIZE)
9175                 return -E2BIG;
9176         mutex_lock(&priv->mutex);
9177         wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
9178         memset(priv->nick, 0, sizeof(priv->nick));
9179         memcpy(priv->nick, extra, wrqu->data.length);
9180         IPW_DEBUG_TRACE("<<\n");
9181         mutex_unlock(&priv->mutex);
9182         return 0;
9183
9184 }
9185
9186 static int ipw_wx_get_nick(struct net_device *dev,
9187                            struct iw_request_info *info,
9188                            union iwreq_data *wrqu, char *extra)
9189 {
9190         struct ipw_priv *priv = libipw_priv(dev);
9191         IPW_DEBUG_WX("Getting nick\n");
9192         mutex_lock(&priv->mutex);
9193         wrqu->data.length = strlen(priv->nick);
9194         memcpy(extra, priv->nick, wrqu->data.length);
9195         wrqu->data.flags = 1;   /* active */
9196         mutex_unlock(&priv->mutex);
9197         return 0;
9198 }
9199
9200 static int ipw_wx_set_sens(struct net_device *dev,
9201                             struct iw_request_info *info,
9202                             union iwreq_data *wrqu, char *extra)
9203 {
9204         struct ipw_priv *priv = libipw_priv(dev);
9205         int err = 0;
9206
9207         IPW_DEBUG_WX("Setting roaming threshold to %d\n", wrqu->sens.value);
9208         IPW_DEBUG_WX("Setting disassociate threshold to %d\n", 3*wrqu->sens.value);
9209         mutex_lock(&priv->mutex);
9210
9211         if (wrqu->sens.fixed == 0)
9212         {
9213                 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
9214                 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
9215                 goto out;
9216         }
9217         if ((wrqu->sens.value > IPW_MB_ROAMING_THRESHOLD_MAX) ||
9218             (wrqu->sens.value < IPW_MB_ROAMING_THRESHOLD_MIN)) {
9219                 err = -EINVAL;
9220                 goto out;
9221         }
9222
9223         priv->roaming_threshold = wrqu->sens.value;
9224         priv->disassociate_threshold = 3*wrqu->sens.value;
9225       out:
9226         mutex_unlock(&priv->mutex);
9227         return err;
9228 }
9229
9230 static int ipw_wx_get_sens(struct net_device *dev,
9231                             struct iw_request_info *info,
9232                             union iwreq_data *wrqu, char *extra)
9233 {
9234         struct ipw_priv *priv = libipw_priv(dev);
9235         mutex_lock(&priv->mutex);
9236         wrqu->sens.fixed = 1;
9237         wrqu->sens.value = priv->roaming_threshold;
9238         mutex_unlock(&priv->mutex);
9239
9240         IPW_DEBUG_WX("GET roaming threshold -> %s %d\n",
9241                      wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
9242
9243         return 0;
9244 }
9245
9246 static int ipw_wx_set_rate(struct net_device *dev,
9247                            struct iw_request_info *info,
9248                            union iwreq_data *wrqu, char *extra)
9249 {
9250         /* TODO: We should use semaphores or locks for access to priv */
9251         struct ipw_priv *priv = libipw_priv(dev);
9252         u32 target_rate = wrqu->bitrate.value;
9253         u32 fixed, mask;
9254
9255         /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
9256         /* value = X, fixed = 1 means only rate X */
9257         /* value = X, fixed = 0 means all rates lower equal X */
9258
9259         if (target_rate == -1) {
9260                 fixed = 0;
9261                 mask = LIBIPW_DEFAULT_RATES_MASK;
9262                 /* Now we should reassociate */
9263                 goto apply;
9264         }
9265
9266         mask = 0;
9267         fixed = wrqu->bitrate.fixed;
9268
9269         if (target_rate == 1000000 || !fixed)
9270                 mask |= LIBIPW_CCK_RATE_1MB_MASK;
9271         if (target_rate == 1000000)
9272                 goto apply;
9273
9274         if (target_rate == 2000000 || !fixed)
9275                 mask |= LIBIPW_CCK_RATE_2MB_MASK;
9276         if (target_rate == 2000000)
9277                 goto apply;
9278
9279         if (target_rate == 5500000 || !fixed)
9280                 mask |= LIBIPW_CCK_RATE_5MB_MASK;
9281         if (target_rate == 5500000)
9282                 goto apply;
9283
9284         if (target_rate == 6000000 || !fixed)
9285                 mask |= LIBIPW_OFDM_RATE_6MB_MASK;
9286         if (target_rate == 6000000)
9287                 goto apply;
9288
9289         if (target_rate == 9000000 || !fixed)
9290                 mask |= LIBIPW_OFDM_RATE_9MB_MASK;
9291         if (target_rate == 9000000)
9292                 goto apply;
9293
9294         if (target_rate == 11000000 || !fixed)
9295                 mask |= LIBIPW_CCK_RATE_11MB_MASK;
9296         if (target_rate == 11000000)
9297                 goto apply;
9298
9299         if (target_rate == 12000000 || !fixed)
9300                 mask |= LIBIPW_OFDM_RATE_12MB_MASK;
9301         if (target_rate == 12000000)
9302                 goto apply;
9303
9304         if (target_rate == 18000000 || !fixed)
9305                 mask |= LIBIPW_OFDM_RATE_18MB_MASK;
9306         if (target_rate == 18000000)
9307                 goto apply;
9308
9309         if (target_rate == 24000000 || !fixed)
9310                 mask |= LIBIPW_OFDM_RATE_24MB_MASK;
9311         if (target_rate == 24000000)
9312                 goto apply;
9313
9314         if (target_rate == 36000000 || !fixed)
9315                 mask |= LIBIPW_OFDM_RATE_36MB_MASK;
9316         if (target_rate == 36000000)
9317                 goto apply;
9318
9319         if (target_rate == 48000000 || !fixed)
9320                 mask |= LIBIPW_OFDM_RATE_48MB_MASK;
9321         if (target_rate == 48000000)
9322                 goto apply;
9323
9324         if (target_rate == 54000000 || !fixed)
9325                 mask |= LIBIPW_OFDM_RATE_54MB_MASK;
9326         if (target_rate == 54000000)
9327                 goto apply;
9328
9329         IPW_DEBUG_WX("invalid rate specified, returning error\n");
9330         return -EINVAL;
9331
9332       apply:
9333         IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
9334                      mask, fixed ? "fixed" : "sub-rates");
9335         mutex_lock(&priv->mutex);
9336         if (mask == LIBIPW_DEFAULT_RATES_MASK) {
9337                 priv->config &= ~CFG_FIXED_RATE;
9338                 ipw_set_fixed_rate(priv, priv->ieee->mode);
9339         } else
9340                 priv->config |= CFG_FIXED_RATE;
9341
9342         if (priv->rates_mask == mask) {
9343                 IPW_DEBUG_WX("Mask set to current mask.\n");
9344                 mutex_unlock(&priv->mutex);
9345                 return 0;
9346         }
9347
9348         priv->rates_mask = mask;
9349
9350         /* Network configuration changed -- force [re]association */
9351         IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
9352         if (!ipw_disassociate(priv))
9353                 ipw_associate(priv);
9354
9355         mutex_unlock(&priv->mutex);
9356         return 0;
9357 }
9358
9359 static int ipw_wx_get_rate(struct net_device *dev,
9360                            struct iw_request_info *info,
9361                            union iwreq_data *wrqu, char *extra)
9362 {
9363         struct ipw_priv *priv = libipw_priv(dev);
9364         mutex_lock(&priv->mutex);
9365         wrqu->bitrate.value = priv->last_rate;
9366         wrqu->bitrate.fixed = (priv->config & CFG_FIXED_RATE) ? 1 : 0;
9367         mutex_unlock(&priv->mutex);
9368         IPW_DEBUG_WX("GET Rate -> %d\n", wrqu->bitrate.value);
9369         return 0;
9370 }
9371
9372 static int ipw_wx_set_rts(struct net_device *dev,
9373                           struct iw_request_info *info,
9374                           union iwreq_data *wrqu, char *extra)
9375 {
9376         struct ipw_priv *priv = libipw_priv(dev);
9377         mutex_lock(&priv->mutex);
9378         if (wrqu->rts.disabled || !wrqu->rts.fixed)
9379                 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
9380         else {
9381                 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
9382                     wrqu->rts.value > MAX_RTS_THRESHOLD) {
9383                         mutex_unlock(&priv->mutex);
9384                         return -EINVAL;
9385                 }
9386                 priv->rts_threshold = wrqu->rts.value;
9387         }
9388
9389         ipw_send_rts_threshold(priv, priv->rts_threshold);
9390         mutex_unlock(&priv->mutex);
9391         IPW_DEBUG_WX("SET RTS Threshold -> %d\n", priv->rts_threshold);
9392         return 0;
9393 }
9394
9395 static int ipw_wx_get_rts(struct net_device *dev,
9396                           struct iw_request_info *info,
9397                           union iwreq_data *wrqu, char *extra)
9398 {
9399         struct ipw_priv *priv = libipw_priv(dev);
9400         mutex_lock(&priv->mutex);
9401         wrqu->rts.value = priv->rts_threshold;
9402         wrqu->rts.fixed = 0;    /* no auto select */
9403         wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
9404         mutex_unlock(&priv->mutex);
9405         IPW_DEBUG_WX("GET RTS Threshold -> %d\n", wrqu->rts.value);
9406         return 0;
9407 }
9408
9409 static int ipw_wx_set_txpow(struct net_device *dev,
9410                             struct iw_request_info *info,
9411                             union iwreq_data *wrqu, char *extra)
9412 {
9413         struct ipw_priv *priv = libipw_priv(dev);
9414         int err = 0;
9415
9416         mutex_lock(&priv->mutex);
9417         if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
9418                 err = -EINPROGRESS;
9419                 goto out;
9420         }
9421
9422         if (!wrqu->power.fixed)
9423                 wrqu->power.value = IPW_TX_POWER_DEFAULT;
9424
9425         if (wrqu->power.flags != IW_TXPOW_DBM) {
9426                 err = -EINVAL;
9427                 goto out;
9428         }
9429
9430         if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
9431             (wrqu->power.value < IPW_TX_POWER_MIN)) {
9432                 err = -EINVAL;
9433                 goto out;
9434         }
9435
9436         priv->tx_power = wrqu->power.value;
9437         err = ipw_set_tx_power(priv);
9438       out:
9439         mutex_unlock(&priv->mutex);
9440         return err;
9441 }
9442
9443 static int ipw_wx_get_txpow(struct net_device *dev,
9444                             struct iw_request_info *info,
9445                             union iwreq_data *wrqu, char *extra)
9446 {
9447         struct ipw_priv *priv = libipw_priv(dev);
9448         mutex_lock(&priv->mutex);
9449         wrqu->power.value = priv->tx_power;
9450         wrqu->power.fixed = 1;
9451         wrqu->power.flags = IW_TXPOW_DBM;
9452         wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
9453         mutex_unlock(&priv->mutex);
9454
9455         IPW_DEBUG_WX("GET TX Power -> %s %d\n",
9456                      wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
9457
9458         return 0;
9459 }
9460
9461 static int ipw_wx_set_frag(struct net_device *dev,
9462                            struct iw_request_info *info,
9463                            union iwreq_data *wrqu, char *extra)
9464 {
9465         struct ipw_priv *priv = libipw_priv(dev);
9466         mutex_lock(&priv->mutex);
9467         if (wrqu->frag.disabled || !wrqu->frag.fixed)
9468                 priv->ieee->fts = DEFAULT_FTS;
9469         else {
9470                 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
9471                     wrqu->frag.value > MAX_FRAG_THRESHOLD) {
9472                         mutex_unlock(&priv->mutex);
9473                         return -EINVAL;
9474                 }
9475
9476                 priv->ieee->fts = wrqu->frag.value & ~0x1;
9477         }
9478
9479         ipw_send_frag_threshold(priv, wrqu->frag.value);
9480         mutex_unlock(&priv->mutex);
9481         IPW_DEBUG_WX("SET Frag Threshold -> %d\n", wrqu->frag.value);
9482         return 0;
9483 }
9484
9485 static int ipw_wx_get_frag(struct net_device *dev,
9486                            struct iw_request_info *info,
9487                            union iwreq_data *wrqu, char *extra)
9488 {
9489         struct ipw_priv *priv = libipw_priv(dev);
9490         mutex_lock(&priv->mutex);
9491         wrqu->frag.value = priv->ieee->fts;
9492         wrqu->frag.fixed = 0;   /* no auto select */
9493         wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
9494         mutex_unlock(&priv->mutex);
9495         IPW_DEBUG_WX("GET Frag Threshold -> %d\n", wrqu->frag.value);
9496
9497         return 0;
9498 }
9499
9500 static int ipw_wx_set_retry(struct net_device *dev,
9501                             struct iw_request_info *info,
9502                             union iwreq_data *wrqu, char *extra)
9503 {
9504         struct ipw_priv *priv = libipw_priv(dev);
9505
9506         if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
9507                 return -EINVAL;
9508
9509         if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
9510                 return 0;
9511
9512         if (wrqu->retry.value < 0 || wrqu->retry.value >= 255)
9513                 return -EINVAL;
9514
9515         mutex_lock(&priv->mutex);
9516         if (wrqu->retry.flags & IW_RETRY_SHORT)
9517                 priv->short_retry_limit = (u8) wrqu->retry.value;
9518         else if (wrqu->retry.flags & IW_RETRY_LONG)
9519                 priv->long_retry_limit = (u8) wrqu->retry.value;
9520         else {
9521                 priv->short_retry_limit = (u8) wrqu->retry.value;
9522                 priv->long_retry_limit = (u8) wrqu->retry.value;
9523         }
9524
9525         ipw_send_retry_limit(priv, priv->short_retry_limit,
9526                              priv->long_retry_limit);
9527         mutex_unlock(&priv->mutex);
9528         IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
9529                      priv->short_retry_limit, priv->long_retry_limit);
9530         return 0;
9531 }
9532
9533 static int ipw_wx_get_retry(struct net_device *dev,
9534                             struct iw_request_info *info,
9535                             union iwreq_data *wrqu, char *extra)
9536 {
9537         struct ipw_priv *priv = libipw_priv(dev);
9538
9539         mutex_lock(&priv->mutex);
9540         wrqu->retry.disabled = 0;
9541
9542         if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
9543                 mutex_unlock(&priv->mutex);
9544                 return -EINVAL;
9545         }
9546
9547         if (wrqu->retry.flags & IW_RETRY_LONG) {
9548                 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
9549                 wrqu->retry.value = priv->long_retry_limit;
9550         } else if (wrqu->retry.flags & IW_RETRY_SHORT) {
9551                 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_SHORT;
9552                 wrqu->retry.value = priv->short_retry_limit;
9553         } else {
9554                 wrqu->retry.flags = IW_RETRY_LIMIT;
9555                 wrqu->retry.value = priv->short_retry_limit;
9556         }
9557         mutex_unlock(&priv->mutex);
9558
9559         IPW_DEBUG_WX("GET retry -> %d\n", wrqu->retry.value);
9560
9561         return 0;
9562 }
9563
9564 static int ipw_wx_set_scan(struct net_device *dev,
9565                            struct iw_request_info *info,
9566                            union iwreq_data *wrqu, char *extra)
9567 {
9568         struct ipw_priv *priv = libipw_priv(dev);
9569         struct iw_scan_req *req = (struct iw_scan_req *)extra;
9570         struct delayed_work *work = NULL;
9571
9572         mutex_lock(&priv->mutex);
9573
9574         priv->user_requested_scan = 1;
9575
9576         if (wrqu->data.length == sizeof(struct iw_scan_req)) {
9577                 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
9578                         int len = min((int)req->essid_len,
9579                                       (int)sizeof(priv->direct_scan_ssid));
9580                         memcpy(priv->direct_scan_ssid, req->essid, len);
9581                         priv->direct_scan_ssid_len = len;
9582                         work = &priv->request_direct_scan;
9583                 } else if (req->scan_type == IW_SCAN_TYPE_PASSIVE) {
9584                         work = &priv->request_passive_scan;
9585                 }
9586         } else {
9587                 /* Normal active broadcast scan */
9588                 work = &priv->request_scan;
9589         }
9590
9591         mutex_unlock(&priv->mutex);
9592
9593         IPW_DEBUG_WX("Start scan\n");
9594
9595         queue_delayed_work(priv->workqueue, work, 0);
9596
9597         return 0;
9598 }
9599
9600 static int ipw_wx_get_scan(struct net_device *dev,
9601                            struct iw_request_info *info,
9602                            union iwreq_data *wrqu, char *extra)
9603 {
9604         struct ipw_priv *priv = libipw_priv(dev);
9605         return libipw_wx_get_scan(priv->ieee, info, wrqu, extra);
9606 }
9607
9608 static int ipw_wx_set_encode(struct net_device *dev,
9609                              struct iw_request_info *info,
9610                              union iwreq_data *wrqu, char *key)
9611 {
9612         struct ipw_priv *priv = libipw_priv(dev);
9613         int ret;
9614         u32 cap = priv->capability;
9615
9616         mutex_lock(&priv->mutex);
9617         ret = libipw_wx_set_encode(priv->ieee, info, wrqu, key);
9618
9619         /* In IBSS mode, we need to notify the firmware to update
9620          * the beacon info after we changed the capability. */
9621         if (cap != priv->capability &&
9622             priv->ieee->iw_mode == IW_MODE_ADHOC &&
9623             priv->status & STATUS_ASSOCIATED)
9624                 ipw_disassociate(priv);
9625
9626         mutex_unlock(&priv->mutex);
9627         return ret;
9628 }
9629
9630 static int ipw_wx_get_encode(struct net_device *dev,
9631                              struct iw_request_info *info,
9632                              union iwreq_data *wrqu, char *key)
9633 {
9634         struct ipw_priv *priv = libipw_priv(dev);
9635         return libipw_wx_get_encode(priv->ieee, info, wrqu, key);
9636 }
9637
9638 static int ipw_wx_set_power(struct net_device *dev,
9639                             struct iw_request_info *info,
9640                             union iwreq_data *wrqu, char *extra)
9641 {
9642         struct ipw_priv *priv = libipw_priv(dev);
9643         int err;
9644         mutex_lock(&priv->mutex);
9645         if (wrqu->power.disabled) {
9646                 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9647                 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9648                 if (err) {
9649                         IPW_DEBUG_WX("failed setting power mode.\n");
9650                         mutex_unlock(&priv->mutex);
9651                         return err;
9652                 }
9653                 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9654                 mutex_unlock(&priv->mutex);
9655                 return 0;
9656         }
9657
9658         switch (wrqu->power.flags & IW_POWER_MODE) {
9659         case IW_POWER_ON:       /* If not specified */
9660         case IW_POWER_MODE:     /* If set all mask */
9661         case IW_POWER_ALL_R:    /* If explicitly state all */
9662                 break;
9663         default:                /* Otherwise we don't support it */
9664                 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9665                              wrqu->power.flags);
9666                 mutex_unlock(&priv->mutex);
9667                 return -EOPNOTSUPP;
9668         }
9669
9670         /* If the user hasn't specified a power management mode yet, default
9671          * to BATTERY */
9672         if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
9673                 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9674         else
9675                 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9676
9677         err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9678         if (err) {
9679                 IPW_DEBUG_WX("failed setting power mode.\n");
9680                 mutex_unlock(&priv->mutex);
9681                 return err;
9682         }
9683
9684         IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9685         mutex_unlock(&priv->mutex);
9686         return 0;
9687 }
9688
9689 static int ipw_wx_get_power(struct net_device *dev,
9690                             struct iw_request_info *info,
9691                             union iwreq_data *wrqu, char *extra)
9692 {
9693         struct ipw_priv *priv = libipw_priv(dev);
9694         mutex_lock(&priv->mutex);
9695         if (!(priv->power_mode & IPW_POWER_ENABLED))
9696                 wrqu->power.disabled = 1;
9697         else
9698                 wrqu->power.disabled = 0;
9699
9700         mutex_unlock(&priv->mutex);
9701         IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9702
9703         return 0;
9704 }
9705
9706 static int ipw_wx_set_powermode(struct net_device *dev,
9707                                 struct iw_request_info *info,
9708                                 union iwreq_data *wrqu, char *extra)
9709 {
9710         struct ipw_priv *priv = libipw_priv(dev);
9711         int mode = *(int *)extra;
9712         int err;
9713
9714         mutex_lock(&priv->mutex);
9715         if ((mode < 1) || (mode > IPW_POWER_LIMIT))
9716                 mode = IPW_POWER_AC;
9717
9718         if (IPW_POWER_LEVEL(priv->power_mode) != mode) {
9719                 err = ipw_send_power_mode(priv, mode);
9720                 if (err) {
9721                         IPW_DEBUG_WX("failed setting power mode.\n");
9722                         mutex_unlock(&priv->mutex);
9723                         return err;
9724                 }
9725                 priv->power_mode = IPW_POWER_ENABLED | mode;
9726         }
9727         mutex_unlock(&priv->mutex);
9728         return 0;
9729 }
9730
9731 #define MAX_WX_STRING 80
9732 static int ipw_wx_get_powermode(struct net_device *dev,
9733                                 struct iw_request_info *info,
9734                                 union iwreq_data *wrqu, char *extra)
9735 {
9736         struct ipw_priv *priv = libipw_priv(dev);
9737         int level = IPW_POWER_LEVEL(priv->power_mode);
9738         char *p = extra;
9739
9740         p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9741
9742         switch (level) {
9743         case IPW_POWER_AC:
9744                 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9745                 break;
9746         case IPW_POWER_BATTERY:
9747                 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9748                 break;
9749         default:
9750                 p += snprintf(p, MAX_WX_STRING - (p - extra),
9751                               "(Timeout %dms, Period %dms)",
9752                               timeout_duration[level - 1] / 1000,
9753                               period_duration[level - 1] / 1000);
9754         }
9755
9756         if (!(priv->power_mode & IPW_POWER_ENABLED))
9757                 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
9758
9759         wrqu->data.length = p - extra + 1;
9760
9761         return 0;
9762 }
9763
9764 static int ipw_wx_set_wireless_mode(struct net_device *dev,
9765                                     struct iw_request_info *info,
9766                                     union iwreq_data *wrqu, char *extra)
9767 {
9768         struct ipw_priv *priv = libipw_priv(dev);
9769         int mode = *(int *)extra;
9770         u8 band = 0, modulation = 0;
9771
9772         if (mode == 0 || mode & ~IEEE_MODE_MASK) {
9773                 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
9774                 return -EINVAL;
9775         }
9776         mutex_lock(&priv->mutex);
9777         if (priv->adapter == IPW_2915ABG) {
9778                 priv->ieee->abg_true = 1;
9779                 if (mode & IEEE_A) {
9780                         band |= LIBIPW_52GHZ_BAND;
9781                         modulation |= LIBIPW_OFDM_MODULATION;
9782                 } else
9783                         priv->ieee->abg_true = 0;
9784         } else {
9785                 if (mode & IEEE_A) {
9786                         IPW_WARNING("Attempt to set 2200BG into "
9787                                     "802.11a mode\n");
9788                         mutex_unlock(&priv->mutex);
9789                         return -EINVAL;
9790                 }
9791
9792                 priv->ieee->abg_true = 0;
9793         }
9794
9795         if (mode & IEEE_B) {
9796                 band |= LIBIPW_24GHZ_BAND;
9797                 modulation |= LIBIPW_CCK_MODULATION;
9798         } else
9799                 priv->ieee->abg_true = 0;
9800
9801         if (mode & IEEE_G) {
9802                 band |= LIBIPW_24GHZ_BAND;
9803                 modulation |= LIBIPW_OFDM_MODULATION;
9804         } else
9805                 priv->ieee->abg_true = 0;
9806
9807         priv->ieee->mode = mode;
9808         priv->ieee->freq_band = band;
9809         priv->ieee->modulation = modulation;
9810         init_supported_rates(priv, &priv->rates);
9811
9812         /* Network configuration changed -- force [re]association */
9813         IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9814         if (!ipw_disassociate(priv)) {
9815                 ipw_send_supported_rates(priv, &priv->rates);
9816                 ipw_associate(priv);
9817         }
9818
9819         /* Update the band LEDs */
9820         ipw_led_band_on(priv);
9821
9822         IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
9823                      mode & IEEE_A ? 'a' : '.',
9824                      mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9825         mutex_unlock(&priv->mutex);
9826         return 0;
9827 }
9828
9829 static int ipw_wx_get_wireless_mode(struct net_device *dev,
9830                                     struct iw_request_info *info,
9831                                     union iwreq_data *wrqu, char *extra)
9832 {
9833         struct ipw_priv *priv = libipw_priv(dev);
9834         mutex_lock(&priv->mutex);
9835         switch (priv->ieee->mode) {
9836         case IEEE_A:
9837                 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9838                 break;
9839         case IEEE_B:
9840                 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9841                 break;
9842         case IEEE_A | IEEE_B:
9843                 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9844                 break;
9845         case IEEE_G:
9846                 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9847                 break;
9848         case IEEE_A | IEEE_G:
9849                 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9850                 break;
9851         case IEEE_B | IEEE_G:
9852                 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9853                 break;
9854         case IEEE_A | IEEE_B | IEEE_G:
9855                 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9856                 break;
9857         default:
9858                 strncpy(extra, "unknown", MAX_WX_STRING);
9859                 break;
9860         }
9861
9862         IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9863
9864         wrqu->data.length = strlen(extra) + 1;
9865         mutex_unlock(&priv->mutex);
9866
9867         return 0;
9868 }
9869
9870 static int ipw_wx_set_preamble(struct net_device *dev,
9871                                struct iw_request_info *info,
9872                                union iwreq_data *wrqu, char *extra)
9873 {
9874         struct ipw_priv *priv = libipw_priv(dev);
9875         int mode = *(int *)extra;
9876         mutex_lock(&priv->mutex);
9877         /* Switching from SHORT -> LONG requires a disassociation */
9878         if (mode == 1) {
9879                 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9880                         priv->config |= CFG_PREAMBLE_LONG;
9881
9882                         /* Network configuration changed -- force [re]association */
9883                         IPW_DEBUG_ASSOC
9884                             ("[re]association triggered due to preamble change.\n");
9885                         if (!ipw_disassociate(priv))
9886                                 ipw_associate(priv);
9887                 }
9888                 goto done;
9889         }
9890
9891         if (mode == 0) {
9892                 priv->config &= ~CFG_PREAMBLE_LONG;
9893                 goto done;
9894         }
9895         mutex_unlock(&priv->mutex);
9896         return -EINVAL;
9897
9898       done:
9899         mutex_unlock(&priv->mutex);
9900         return 0;
9901 }
9902
9903 static int ipw_wx_get_preamble(struct net_device *dev,
9904                                struct iw_request_info *info,
9905                                union iwreq_data *wrqu, char *extra)
9906 {
9907         struct ipw_priv *priv = libipw_priv(dev);
9908         mutex_lock(&priv->mutex);
9909         if (priv->config & CFG_PREAMBLE_LONG)
9910                 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9911         else
9912                 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9913         mutex_unlock(&priv->mutex);
9914         return 0;
9915 }
9916
9917 #ifdef CONFIG_IPW2200_MONITOR
9918 static int ipw_wx_set_monitor(struct net_device *dev,
9919                               struct iw_request_info *info,
9920                               union iwreq_data *wrqu, char *extra)
9921 {
9922         struct ipw_priv *priv = libipw_priv(dev);
9923         int *parms = (int *)extra;
9924         int enable = (parms[0] > 0);
9925         mutex_lock(&priv->mutex);
9926         IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
9927         if (enable) {
9928                 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9929 #ifdef CONFIG_IPW2200_RADIOTAP
9930                         priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9931 #else
9932                         priv->net_dev->type = ARPHRD_IEEE80211;
9933 #endif
9934                         queue_work(priv->workqueue, &priv->adapter_restart);
9935                 }
9936
9937                 ipw_set_channel(priv, parms[1]);
9938         } else {
9939                 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9940                         mutex_unlock(&priv->mutex);
9941                         return 0;
9942                 }
9943                 priv->net_dev->type = ARPHRD_ETHER;
9944                 queue_work(priv->workqueue, &priv->adapter_restart);
9945         }
9946         mutex_unlock(&priv->mutex);
9947         return 0;
9948 }
9949
9950 #endif                          /* CONFIG_IPW2200_MONITOR */
9951
9952 static int ipw_wx_reset(struct net_device *dev,
9953                         struct iw_request_info *info,
9954                         union iwreq_data *wrqu, char *extra)
9955 {
9956         struct ipw_priv *priv = libipw_priv(dev);
9957         IPW_DEBUG_WX("RESET\n");
9958         queue_work(priv->workqueue, &priv->adapter_restart);
9959         return 0;
9960 }
9961
9962 static int ipw_wx_sw_reset(struct net_device *dev,
9963                            struct iw_request_info *info,
9964                            union iwreq_data *wrqu, char *extra)
9965 {
9966         struct ipw_priv *priv = libipw_priv(dev);
9967         union iwreq_data wrqu_sec = {
9968                 .encoding = {
9969                              .flags = IW_ENCODE_DISABLED,
9970                              },
9971         };
9972         int ret;
9973
9974         IPW_DEBUG_WX("SW_RESET\n");
9975
9976         mutex_lock(&priv->mutex);
9977
9978         ret = ipw_sw_reset(priv, 2);
9979         if (!ret) {
9980                 free_firmware();
9981                 ipw_adapter_restart(priv);
9982         }
9983
9984         /* The SW reset bit might have been toggled on by the 'disable'
9985          * module parameter, so take appropriate action */
9986         ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9987
9988         mutex_unlock(&priv->mutex);
9989         libipw_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9990         mutex_lock(&priv->mutex);
9991
9992         if (!(priv->status & STATUS_RF_KILL_MASK)) {
9993                 /* Configuration likely changed -- force [re]association */
9994                 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9995                                 "reset.\n");
9996                 if (!ipw_disassociate(priv))
9997                         ipw_associate(priv);
9998         }
9999
10000         mutex_unlock(&priv->mutex);
10001
10002         return 0;
10003 }
10004
10005 /* Rebase the WE IOCTLs to zero for the handler array */
10006 static iw_handler ipw_wx_handlers[] = {
10007         IW_HANDLER(SIOCGIWNAME, (iw_handler)cfg80211_wext_giwname),
10008         IW_HANDLER(SIOCSIWFREQ, ipw_wx_set_freq),
10009         IW_HANDLER(SIOCGIWFREQ, ipw_wx_get_freq),
10010         IW_HANDLER(SIOCSIWMODE, ipw_wx_set_mode),
10011         IW_HANDLER(SIOCGIWMODE, ipw_wx_get_mode),
10012         IW_HANDLER(SIOCSIWSENS, ipw_wx_set_sens),
10013         IW_HANDLER(SIOCGIWSENS, ipw_wx_get_sens),
10014         IW_HANDLER(SIOCGIWRANGE, ipw_wx_get_range),
10015         IW_HANDLER(SIOCSIWAP, ipw_wx_set_wap),
10016         IW_HANDLER(SIOCGIWAP, ipw_wx_get_wap),
10017         IW_HANDLER(SIOCSIWSCAN, ipw_wx_set_scan),
10018         IW_HANDLER(SIOCGIWSCAN, ipw_wx_get_scan),
10019         IW_HANDLER(SIOCSIWESSID, ipw_wx_set_essid),
10020         IW_HANDLER(SIOCGIWESSID, ipw_wx_get_essid),
10021         IW_HANDLER(SIOCSIWNICKN, ipw_wx_set_nick),
10022         IW_HANDLER(SIOCGIWNICKN, ipw_wx_get_nick),
10023         IW_HANDLER(SIOCSIWRATE, ipw_wx_set_rate),
10024         IW_HANDLER(SIOCGIWRATE, ipw_wx_get_rate),
10025         IW_HANDLER(SIOCSIWRTS, ipw_wx_set_rts),
10026         IW_HANDLER(SIOCGIWRTS, ipw_wx_get_rts),
10027         IW_HANDLER(SIOCSIWFRAG, ipw_wx_set_frag),
10028         IW_HANDLER(SIOCGIWFRAG, ipw_wx_get_frag),
10029         IW_HANDLER(SIOCSIWTXPOW, ipw_wx_set_txpow),
10030         IW_HANDLER(SIOCGIWTXPOW, ipw_wx_get_txpow),
10031         IW_HANDLER(SIOCSIWRETRY, ipw_wx_set_retry),
10032         IW_HANDLER(SIOCGIWRETRY, ipw_wx_get_retry),
10033         IW_HANDLER(SIOCSIWENCODE, ipw_wx_set_encode),
10034         IW_HANDLER(SIOCGIWENCODE, ipw_wx_get_encode),
10035         IW_HANDLER(SIOCSIWPOWER, ipw_wx_set_power),
10036         IW_HANDLER(SIOCGIWPOWER, ipw_wx_get_power),
10037         IW_HANDLER(SIOCSIWSPY, iw_handler_set_spy),
10038         IW_HANDLER(SIOCGIWSPY, iw_handler_get_spy),
10039         IW_HANDLER(SIOCSIWTHRSPY, iw_handler_set_thrspy),
10040         IW_HANDLER(SIOCGIWTHRSPY, iw_handler_get_thrspy),
10041         IW_HANDLER(SIOCSIWGENIE, ipw_wx_set_genie),
10042         IW_HANDLER(SIOCGIWGENIE, ipw_wx_get_genie),
10043         IW_HANDLER(SIOCSIWMLME, ipw_wx_set_mlme),
10044         IW_HANDLER(SIOCSIWAUTH, ipw_wx_set_auth),
10045         IW_HANDLER(SIOCGIWAUTH, ipw_wx_get_auth),
10046         IW_HANDLER(SIOCSIWENCODEEXT, ipw_wx_set_encodeext),
10047         IW_HANDLER(SIOCGIWENCODEEXT, ipw_wx_get_encodeext),
10048 };
10049
10050 enum {
10051         IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
10052         IPW_PRIV_GET_POWER,
10053         IPW_PRIV_SET_MODE,
10054         IPW_PRIV_GET_MODE,
10055         IPW_PRIV_SET_PREAMBLE,
10056         IPW_PRIV_GET_PREAMBLE,
10057         IPW_PRIV_RESET,
10058         IPW_PRIV_SW_RESET,
10059 #ifdef CONFIG_IPW2200_MONITOR
10060         IPW_PRIV_SET_MONITOR,
10061 #endif
10062 };
10063
10064 static struct iw_priv_args ipw_priv_args[] = {
10065         {
10066          .cmd = IPW_PRIV_SET_POWER,
10067          .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
10068          .name = "set_power"},
10069         {
10070          .cmd = IPW_PRIV_GET_POWER,
10071          .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
10072          .name = "get_power"},
10073         {
10074          .cmd = IPW_PRIV_SET_MODE,
10075          .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
10076          .name = "set_mode"},
10077         {
10078          .cmd = IPW_PRIV_GET_MODE,
10079          .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
10080          .name = "get_mode"},
10081         {
10082          .cmd = IPW_PRIV_SET_PREAMBLE,
10083          .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
10084          .name = "set_preamble"},
10085         {
10086          .cmd = IPW_PRIV_GET_PREAMBLE,
10087          .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
10088          .name = "get_preamble"},
10089         {
10090          IPW_PRIV_RESET,
10091          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
10092         {
10093          IPW_PRIV_SW_RESET,
10094          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
10095 #ifdef CONFIG_IPW2200_MONITOR
10096         {
10097          IPW_PRIV_SET_MONITOR,
10098          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
10099 #endif                          /* CONFIG_IPW2200_MONITOR */
10100 };
10101
10102 static iw_handler ipw_priv_handler[] = {
10103         ipw_wx_set_powermode,
10104         ipw_wx_get_powermode,
10105         ipw_wx_set_wireless_mode,
10106         ipw_wx_get_wireless_mode,
10107         ipw_wx_set_preamble,
10108         ipw_wx_get_preamble,
10109         ipw_wx_reset,
10110         ipw_wx_sw_reset,
10111 #ifdef CONFIG_IPW2200_MONITOR
10112         ipw_wx_set_monitor,
10113 #endif
10114 };
10115
10116 static struct iw_handler_def ipw_wx_handler_def = {
10117         .standard = ipw_wx_handlers,
10118         .num_standard = ARRAY_SIZE(ipw_wx_handlers),
10119         .num_private = ARRAY_SIZE(ipw_priv_handler),
10120         .num_private_args = ARRAY_SIZE(ipw_priv_args),
10121         .private = ipw_priv_handler,
10122         .private_args = ipw_priv_args,
10123         .get_wireless_stats = ipw_get_wireless_stats,
10124 };
10125
10126 /*
10127  * Get wireless statistics.
10128  * Called by /proc/net/wireless
10129  * Also called by SIOCGIWSTATS
10130  */
10131 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
10132 {
10133         struct ipw_priv *priv = libipw_priv(dev);
10134         struct iw_statistics *wstats;
10135
10136         wstats = &priv->wstats;
10137
10138         /* if hw is disabled, then ipw_get_ordinal() can't be called.
10139          * netdev->get_wireless_stats seems to be called before fw is
10140          * initialized.  STATUS_ASSOCIATED will only be set if the hw is up
10141          * and associated; if not associcated, the values are all meaningless
10142          * anyway, so set them all to NULL and INVALID */
10143         if (!(priv->status & STATUS_ASSOCIATED)) {
10144                 wstats->miss.beacon = 0;
10145                 wstats->discard.retries = 0;
10146                 wstats->qual.qual = 0;
10147                 wstats->qual.level = 0;
10148                 wstats->qual.noise = 0;
10149                 wstats->qual.updated = 7;
10150                 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
10151                     IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
10152                 return wstats;
10153         }
10154
10155         wstats->qual.qual = priv->quality;
10156         wstats->qual.level = priv->exp_avg_rssi;
10157         wstats->qual.noise = priv->exp_avg_noise;
10158         wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
10159             IW_QUAL_NOISE_UPDATED | IW_QUAL_DBM;
10160
10161         wstats->miss.beacon = average_value(&priv->average_missed_beacons);
10162         wstats->discard.retries = priv->last_tx_failures;
10163         wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
10164
10165 /*      if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
10166         goto fail_get_ordinal;
10167         wstats->discard.retries += tx_retry; */
10168
10169         return wstats;
10170 }
10171
10172 /* net device stuff */
10173
10174 static  void init_sys_config(struct ipw_sys_config *sys_config)
10175 {
10176         memset(sys_config, 0, sizeof(struct ipw_sys_config));
10177         sys_config->bt_coexistence = 0;
10178         sys_config->answer_broadcast_ssid_probe = 0;
10179         sys_config->accept_all_data_frames = 0;
10180         sys_config->accept_non_directed_frames = 1;
10181         sys_config->exclude_unicast_unencrypted = 0;
10182         sys_config->disable_unicast_decryption = 1;
10183         sys_config->exclude_multicast_unencrypted = 0;
10184         sys_config->disable_multicast_decryption = 1;
10185         if (antenna < CFG_SYS_ANTENNA_BOTH || antenna > CFG_SYS_ANTENNA_B)
10186                 antenna = CFG_SYS_ANTENNA_BOTH;
10187         sys_config->antenna_diversity = antenna;
10188         sys_config->pass_crc_to_host = 0;       /* TODO: See if 1 gives us FCS */
10189         sys_config->dot11g_auto_detection = 0;
10190         sys_config->enable_cts_to_self = 0;
10191         sys_config->bt_coexist_collision_thr = 0;
10192         sys_config->pass_noise_stats_to_host = 1;       /* 1 -- fix for 256 */
10193         sys_config->silence_threshold = 0x1e;
10194 }
10195
10196 static int ipw_net_open(struct net_device *dev)
10197 {
10198         IPW_DEBUG_INFO("dev->open\n");
10199         netif_start_queue(dev);
10200         return 0;
10201 }
10202
10203 static int ipw_net_stop(struct net_device *dev)
10204 {
10205         IPW_DEBUG_INFO("dev->close\n");
10206         netif_stop_queue(dev);
10207         return 0;
10208 }
10209
10210 /*
10211 todo:
10212
10213 modify to send one tfd per fragment instead of using chunking.  otherwise
10214 we need to heavily modify the libipw_skb_to_txb.
10215 */
10216
10217 static int ipw_tx_skb(struct ipw_priv *priv, struct libipw_txb *txb,
10218                              int pri)
10219 {
10220         struct libipw_hdr_3addrqos *hdr = (struct libipw_hdr_3addrqos *)
10221             txb->fragments[0]->data;
10222         int i = 0;
10223         struct tfd_frame *tfd;
10224 #ifdef CONFIG_IPW2200_QOS
10225         int tx_id = ipw_get_tx_queue_number(priv, pri);
10226         struct clx2_tx_queue *txq = &priv->txq[tx_id];
10227 #else
10228         struct clx2_tx_queue *txq = &priv->txq[0];
10229 #endif
10230         struct clx2_queue *q = &txq->q;
10231         u8 id, hdr_len, unicast;
10232         int fc;
10233
10234         if (!(priv->status & STATUS_ASSOCIATED))
10235                 goto drop;
10236
10237         hdr_len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_ctl));
10238         switch (priv->ieee->iw_mode) {
10239         case IW_MODE_ADHOC:
10240                 unicast = !is_multicast_ether_addr(hdr->addr1);
10241                 id = ipw_find_station(priv, hdr->addr1);
10242                 if (id == IPW_INVALID_STATION) {
10243                         id = ipw_add_station(priv, hdr->addr1);
10244                         if (id == IPW_INVALID_STATION) {
10245                                 IPW_WARNING("Attempt to send data to "
10246                                             "invalid cell: %pM\n",
10247                                             hdr->addr1);
10248                                 goto drop;
10249                         }
10250                 }
10251                 break;
10252
10253         case IW_MODE_INFRA:
10254         default:
10255                 unicast = !is_multicast_ether_addr(hdr->addr3);
10256                 id = 0;
10257                 break;
10258         }
10259
10260         tfd = &txq->bd[q->first_empty];
10261         txq->txb[q->first_empty] = txb;
10262         memset(tfd, 0, sizeof(*tfd));
10263         tfd->u.data.station_number = id;
10264
10265         tfd->control_flags.message_type = TX_FRAME_TYPE;
10266         tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
10267
10268         tfd->u.data.cmd_id = DINO_CMD_TX;
10269         tfd->u.data.len = cpu_to_le16(txb->payload_size);
10270
10271         if (priv->assoc_request.ieee_mode == IPW_B_MODE)
10272                 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
10273         else
10274                 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
10275
10276         if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
10277                 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
10278
10279         fc = le16_to_cpu(hdr->frame_ctl);
10280         hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
10281
10282         memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
10283
10284         if (likely(unicast))
10285                 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10286
10287         if (txb->encrypted && !priv->ieee->host_encrypt) {
10288                 switch (priv->ieee->sec.level) {
10289                 case SEC_LEVEL_3:
10290                         tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10291                             cpu_to_le16(IEEE80211_FCTL_PROTECTED);
10292                         /* XXX: ACK flag must be set for CCMP even if it
10293                          * is a multicast/broadcast packet, because CCMP
10294                          * group communication encrypted by GTK is
10295                          * actually done by the AP. */
10296                         if (!unicast)
10297                                 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10298
10299                         tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10300                         tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
10301                         tfd->u.data.key_index = 0;
10302                         tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
10303                         break;
10304                 case SEC_LEVEL_2:
10305                         tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10306                             cpu_to_le16(IEEE80211_FCTL_PROTECTED);
10307                         tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10308                         tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
10309                         tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
10310                         break;
10311                 case SEC_LEVEL_1:
10312                         tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10313                             cpu_to_le16(IEEE80211_FCTL_PROTECTED);
10314                         tfd->u.data.key_index = priv->ieee->crypt_info.tx_keyidx;
10315                         if (priv->ieee->sec.key_sizes[priv->ieee->crypt_info.tx_keyidx] <=
10316                             40)
10317                                 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
10318                         else
10319                                 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
10320                         break;
10321                 case SEC_LEVEL_0:
10322                         break;
10323                 default:
10324                         printk(KERN_ERR "Unknown security level %d\n",
10325                                priv->ieee->sec.level);
10326                         break;
10327                 }
10328         } else
10329                 /* No hardware encryption */
10330                 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
10331
10332 #ifdef CONFIG_IPW2200_QOS
10333         if (fc & IEEE80211_STYPE_QOS_DATA)
10334                 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data));
10335 #endif                          /* CONFIG_IPW2200_QOS */
10336
10337         /* payload */
10338         tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
10339                                                  txb->nr_frags));
10340         IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
10341                        txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
10342         for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
10343                 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
10344                                i, le32_to_cpu(tfd->u.data.num_chunks),
10345                                txb->fragments[i]->len - hdr_len);
10346                 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
10347                              i, tfd->u.data.num_chunks,
10348                              txb->fragments[i]->len - hdr_len);
10349                 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
10350                            txb->fragments[i]->len - hdr_len);
10351
10352                 tfd->u.data.chunk_ptr[i] =
10353                     cpu_to_le32(pci_map_single
10354                                 (priv->pci_dev,
10355                                  txb->fragments[i]->data + hdr_len,
10356                                  txb->fragments[i]->len - hdr_len,
10357                                  PCI_DMA_TODEVICE));
10358                 tfd->u.data.chunk_len[i] =
10359                     cpu_to_le16(txb->fragments[i]->len - hdr_len);
10360         }
10361
10362         if (i != txb->nr_frags) {
10363                 struct sk_buff *skb;
10364                 u16 remaining_bytes = 0;
10365                 int j;
10366
10367                 for (j = i; j < txb->nr_frags; j++)
10368                         remaining_bytes += txb->fragments[j]->len - hdr_len;
10369
10370                 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
10371                        remaining_bytes);
10372                 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
10373                 if (skb != NULL) {
10374                         tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
10375                         for (j = i; j < txb->nr_frags; j++) {
10376                                 int size = txb->fragments[j]->len - hdr_len;
10377
10378                                 printk(KERN_INFO "Adding frag %d %d...\n",
10379                                        j, size);
10380                                 memcpy(skb_put(skb, size),
10381                                        txb->fragments[j]->data + hdr_len, size);
10382                         }
10383                         dev_kfree_skb_any(txb->fragments[i]);
10384                         txb->fragments[i] = skb;
10385                         tfd->u.data.chunk_ptr[i] =
10386                             cpu_to_le32(pci_map_single
10387                                         (priv->pci_dev, skb->data,
10388                                          remaining_bytes,
10389                                          PCI_DMA_TODEVICE));
10390
10391                         le32_add_cpu(&tfd->u.data.num_chunks, 1);
10392                 }
10393         }
10394
10395         /* kick DMA */
10396         q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
10397         ipw_write32(priv, q->reg_w, q->first_empty);
10398
10399         if (ipw_tx_queue_space(q) < q->high_mark)
10400                 netif_stop_queue(priv->net_dev);
10401
10402         return NETDEV_TX_OK;
10403
10404       drop:
10405         IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
10406         libipw_txb_free(txb);
10407         return NETDEV_TX_OK;
10408 }
10409
10410 static int ipw_net_is_queue_full(struct net_device *dev, int pri)
10411 {
10412         struct ipw_priv *priv = libipw_priv(dev);
10413 #ifdef CONFIG_IPW2200_QOS
10414         int tx_id = ipw_get_tx_queue_number(priv, pri);
10415         struct clx2_tx_queue *txq = &priv->txq[tx_id];
10416 #else
10417         struct clx2_tx_queue *txq = &priv->txq[0];
10418 #endif                          /* CONFIG_IPW2200_QOS */
10419
10420         if (ipw_tx_queue_space(&txq->q) < txq->q.high_mark)
10421                 return 1;
10422
10423         return 0;
10424 }
10425
10426 #ifdef CONFIG_IPW2200_PROMISCUOUS
10427 static void ipw_handle_promiscuous_tx(struct ipw_priv *priv,
10428                                       struct libipw_txb *txb)
10429 {
10430         struct libipw_rx_stats dummystats;
10431         struct ieee80211_hdr *hdr;
10432         u8 n;
10433         u16 filter = priv->prom_priv->filter;
10434         int hdr_only = 0;
10435
10436         if (filter & IPW_PROM_NO_TX)
10437                 return;
10438
10439         memset(&dummystats, 0, sizeof(dummystats));
10440
10441         /* Filtering of fragment chains is done agains the first fragment */
10442         hdr = (void *)txb->fragments[0]->data;
10443         if (libipw_is_management(le16_to_cpu(hdr->frame_control))) {
10444                 if (filter & IPW_PROM_NO_MGMT)
10445                         return;
10446                 if (filter & IPW_PROM_MGMT_HEADER_ONLY)
10447                         hdr_only = 1;
10448         } else if (libipw_is_control(le16_to_cpu(hdr->frame_control))) {
10449                 if (filter & IPW_PROM_NO_CTL)
10450                         return;
10451                 if (filter & IPW_PROM_CTL_HEADER_ONLY)
10452                         hdr_only = 1;
10453         } else if (libipw_is_data(le16_to_cpu(hdr->frame_control))) {
10454                 if (filter & IPW_PROM_NO_DATA)
10455                         return;
10456                 if (filter & IPW_PROM_DATA_HEADER_ONLY)
10457                         hdr_only = 1;
10458         }
10459
10460         for(n=0; n<txb->nr_frags; ++n) {
10461                 struct sk_buff *src = txb->fragments[n];
10462                 struct sk_buff *dst;
10463                 struct ieee80211_radiotap_header *rt_hdr;
10464                 int len;
10465
10466                 if (hdr_only) {
10467                         hdr = (void *)src->data;
10468                         len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_control));
10469                 } else
10470                         len = src->len;
10471
10472                 dst = alloc_skb(len + sizeof(*rt_hdr), GFP_ATOMIC);
10473                 if (!dst)
10474                         continue;
10475
10476                 rt_hdr = (void *)skb_put(dst, sizeof(*rt_hdr));
10477
10478                 rt_hdr->it_version = PKTHDR_RADIOTAP_VERSION;
10479                 rt_hdr->it_pad = 0;
10480                 rt_hdr->it_present = 0; /* after all, it's just an idea */
10481                 rt_hdr->it_present |=  cpu_to_le32(1 << IEEE80211_RADIOTAP_CHANNEL);
10482
10483                 *(__le16*)skb_put(dst, sizeof(u16)) = cpu_to_le16(
10484                         ieee80211chan2mhz(priv->channel));
10485                 if (priv->channel > 14)         /* 802.11a */
10486                         *(__le16*)skb_put(dst, sizeof(u16)) =
10487                                 cpu_to_le16(IEEE80211_CHAN_OFDM |
10488                                              IEEE80211_CHAN_5GHZ);
10489                 else if (priv->ieee->mode == IEEE_B) /* 802.11b */
10490                         *(__le16*)skb_put(dst, sizeof(u16)) =
10491                                 cpu_to_le16(IEEE80211_CHAN_CCK |
10492                                              IEEE80211_CHAN_2GHZ);
10493                 else            /* 802.11g */
10494                         *(__le16*)skb_put(dst, sizeof(u16)) =
10495                                 cpu_to_le16(IEEE80211_CHAN_OFDM |
10496                                  IEEE80211_CHAN_2GHZ);
10497
10498                 rt_hdr->it_len = cpu_to_le16(dst->len);
10499
10500                 skb_copy_from_linear_data(src, skb_put(dst, len), len);
10501
10502                 if (!libipw_rx(priv->prom_priv->ieee, dst, &dummystats))
10503                         dev_kfree_skb_any(dst);
10504         }
10505 }
10506 #endif
10507
10508 static netdev_tx_t ipw_net_hard_start_xmit(struct libipw_txb *txb,
10509                                            struct net_device *dev, int pri)
10510 {
10511         struct ipw_priv *priv = libipw_priv(dev);
10512         unsigned long flags;
10513         netdev_tx_t ret;
10514
10515         IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
10516         spin_lock_irqsave(&priv->lock, flags);
10517
10518 #ifdef CONFIG_IPW2200_PROMISCUOUS
10519         if (rtap_iface && netif_running(priv->prom_net_dev))
10520                 ipw_handle_promiscuous_tx(priv, txb);
10521 #endif
10522
10523         ret = ipw_tx_skb(priv, txb, pri);
10524         if (ret == NETDEV_TX_OK)
10525                 __ipw_led_activity_on(priv);
10526         spin_unlock_irqrestore(&priv->lock, flags);
10527
10528         return ret;
10529 }
10530
10531 static void ipw_net_set_multicast_list(struct net_device *dev)
10532 {
10533
10534 }
10535
10536 static int ipw_net_set_mac_address(struct net_device *dev, void *p)
10537 {
10538         struct ipw_priv *priv = libipw_priv(dev);
10539         struct sockaddr *addr = p;
10540
10541         if (!is_valid_ether_addr(addr->sa_data))
10542                 return -EADDRNOTAVAIL;
10543         mutex_lock(&priv->mutex);
10544         priv->config |= CFG_CUSTOM_MAC;
10545         memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
10546         printk(KERN_INFO "%s: Setting MAC to %pM\n",
10547                priv->net_dev->name, priv->mac_addr);
10548         queue_work(priv->workqueue, &priv->adapter_restart);
10549         mutex_unlock(&priv->mutex);
10550         return 0;
10551 }
10552
10553 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
10554                                     struct ethtool_drvinfo *info)
10555 {
10556         struct ipw_priv *p = libipw_priv(dev);
10557         char vers[64];
10558         char date[32];
10559         u32 len;
10560
10561         strcpy(info->driver, DRV_NAME);
10562         strcpy(info->version, DRV_VERSION);
10563
10564         len = sizeof(vers);
10565         ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
10566         len = sizeof(date);
10567         ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
10568
10569         snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
10570                  vers, date);
10571         strcpy(info->bus_info, pci_name(p->pci_dev));
10572         info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
10573 }
10574
10575 static u32 ipw_ethtool_get_link(struct net_device *dev)
10576 {
10577         struct ipw_priv *priv = libipw_priv(dev);
10578         return (priv->status & STATUS_ASSOCIATED) != 0;
10579 }
10580
10581 static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
10582 {
10583         return IPW_EEPROM_IMAGE_SIZE;
10584 }
10585
10586 static int ipw_ethtool_get_eeprom(struct net_device *dev,
10587                                   struct ethtool_eeprom *eeprom, u8 * bytes)
10588 {
10589         struct ipw_priv *p = libipw_priv(dev);
10590
10591         if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
10592                 return -EINVAL;
10593         mutex_lock(&p->mutex);
10594         memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
10595         mutex_unlock(&p->mutex);
10596         return 0;
10597 }
10598
10599 static int ipw_ethtool_set_eeprom(struct net_device *dev,
10600                                   struct ethtool_eeprom *eeprom, u8 * bytes)
10601 {
10602         struct ipw_priv *p = libipw_priv(dev);
10603         int i;
10604
10605         if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
10606                 return -EINVAL;
10607         mutex_lock(&p->mutex);
10608         memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
10609         for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
10610                 ipw_write8(p, i + IPW_EEPROM_DATA, p->eeprom[i]);
10611         mutex_unlock(&p->mutex);
10612         return 0;
10613 }
10614
10615 static const struct ethtool_ops ipw_ethtool_ops = {
10616         .get_link = ipw_ethtool_get_link,
10617         .get_drvinfo = ipw_ethtool_get_drvinfo,
10618         .get_eeprom_len = ipw_ethtool_get_eeprom_len,
10619         .get_eeprom = ipw_ethtool_get_eeprom,
10620         .set_eeprom = ipw_ethtool_set_eeprom,
10621 };
10622
10623 static irqreturn_t ipw_isr(int irq, void *data)
10624 {
10625         struct ipw_priv *priv = data;
10626         u32 inta, inta_mask;
10627
10628         if (!priv)
10629                 return IRQ_NONE;
10630
10631         spin_lock(&priv->irq_lock);
10632
10633         if (!(priv->status & STATUS_INT_ENABLED)) {
10634                 /* IRQ is disabled */
10635                 goto none;
10636         }
10637
10638         inta = ipw_read32(priv, IPW_INTA_RW);
10639         inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
10640
10641         if (inta == 0xFFFFFFFF) {
10642                 /* Hardware disappeared */
10643                 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10644                 goto none;
10645         }
10646
10647         if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
10648                 /* Shared interrupt */
10649                 goto none;
10650         }
10651
10652         /* tell the device to stop sending interrupts */
10653         __ipw_disable_interrupts(priv);
10654
10655         /* ack current interrupts */
10656         inta &= (IPW_INTA_MASK_ALL & inta_mask);
10657         ipw_write32(priv, IPW_INTA_RW, inta);
10658
10659         /* Cache INTA value for our tasklet */
10660         priv->isr_inta = inta;
10661
10662         tasklet_schedule(&priv->irq_tasklet);
10663
10664         spin_unlock(&priv->irq_lock);
10665
10666         return IRQ_HANDLED;
10667       none:
10668         spin_unlock(&priv->irq_lock);
10669         return IRQ_NONE;
10670 }
10671
10672 static void ipw_rf_kill(void *adapter)
10673 {
10674         struct ipw_priv *priv = adapter;
10675         unsigned long flags;
10676
10677         spin_lock_irqsave(&priv->lock, flags);
10678
10679         if (rf_kill_active(priv)) {
10680                 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10681                 if (priv->workqueue)
10682                         queue_delayed_work(priv->workqueue,
10683                                            &priv->rf_kill, 2 * HZ);
10684                 goto exit_unlock;
10685         }
10686
10687         /* RF Kill is now disabled, so bring the device back up */
10688
10689         if (!(priv->status & STATUS_RF_KILL_MASK)) {
10690                 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10691                                   "device\n");
10692
10693                 /* we can not do an adapter restart while inside an irq lock */
10694                 queue_work(priv->workqueue, &priv->adapter_restart);
10695         } else
10696                 IPW_DEBUG_RF_KILL("HW RF Kill deactivated.  SW RF Kill still "
10697                                   "enabled\n");
10698
10699       exit_unlock:
10700         spin_unlock_irqrestore(&priv->lock, flags);
10701 }
10702
10703 static void ipw_bg_rf_kill(struct work_struct *work)
10704 {
10705         struct ipw_priv *priv =
10706                 container_of(work, struct ipw_priv, rf_kill.work);
10707         mutex_lock(&priv->mutex);
10708         ipw_rf_kill(priv);
10709         mutex_unlock(&priv->mutex);
10710 }
10711
10712 static void ipw_link_up(struct ipw_priv *priv)
10713 {
10714         priv->last_seq_num = -1;
10715         priv->last_frag_num = -1;
10716         priv->last_packet_time = 0;
10717
10718         netif_carrier_on(priv->net_dev);
10719
10720         cancel_delayed_work(&priv->request_scan);
10721         cancel_delayed_work(&priv->request_direct_scan);
10722         cancel_delayed_work(&priv->request_passive_scan);
10723         cancel_delayed_work(&priv->scan_event);
10724         ipw_reset_stats(priv);
10725         /* Ensure the rate is updated immediately */
10726         priv->last_rate = ipw_get_current_rate(priv);
10727         ipw_gather_stats(priv);
10728         ipw_led_link_up(priv);
10729         notify_wx_assoc_event(priv);
10730
10731         if (priv->config & CFG_BACKGROUND_SCAN)
10732                 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10733 }
10734
10735 static void ipw_bg_link_up(struct work_struct *work)
10736 {
10737         struct ipw_priv *priv =
10738                 container_of(work, struct ipw_priv, link_up);
10739         mutex_lock(&priv->mutex);
10740         ipw_link_up(priv);
10741         mutex_unlock(&priv->mutex);
10742 }
10743
10744 static void ipw_link_down(struct ipw_priv *priv)
10745 {
10746         ipw_led_link_down(priv);
10747         netif_carrier_off(priv->net_dev);
10748         notify_wx_assoc_event(priv);
10749
10750         /* Cancel any queued work ... */
10751         cancel_delayed_work(&priv->request_scan);
10752         cancel_delayed_work(&priv->request_direct_scan);
10753         cancel_delayed_work(&priv->request_passive_scan);
10754         cancel_delayed_work(&priv->adhoc_check);
10755         cancel_delayed_work(&priv->gather_stats);
10756
10757         ipw_reset_stats(priv);
10758
10759         if (!(priv->status & STATUS_EXIT_PENDING)) {
10760                 /* Queue up another scan... */
10761                 queue_delayed_work(priv->workqueue, &priv->request_scan, 0);
10762         } else
10763                 cancel_delayed_work(&priv->scan_event);
10764 }
10765
10766 static void ipw_bg_link_down(struct work_struct *work)
10767 {
10768         struct ipw_priv *priv =
10769                 container_of(work, struct ipw_priv, link_down);
10770         mutex_lock(&priv->mutex);
10771         ipw_link_down(priv);
10772         mutex_unlock(&priv->mutex);
10773 }
10774
10775 static int __devinit ipw_setup_deferred_work(struct ipw_priv *priv)
10776 {
10777         int ret = 0;
10778
10779         priv->workqueue = create_workqueue(DRV_NAME);
10780         init_waitqueue_head(&priv->wait_command_queue);
10781         init_waitqueue_head(&priv->wait_state);
10782
10783         INIT_DELAYED_WORK(&priv->adhoc_check, ipw_bg_adhoc_check);
10784         INIT_WORK(&priv->associate, ipw_bg_associate);
10785         INIT_WORK(&priv->disassociate, ipw_bg_disassociate);
10786         INIT_WORK(&priv->system_config, ipw_system_config);
10787         INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish);
10788         INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart);
10789         INIT_DELAYED_WORK(&priv->rf_kill, ipw_bg_rf_kill);
10790         INIT_WORK(&priv->up, ipw_bg_up);
10791         INIT_WORK(&priv->down, ipw_bg_down);
10792         INIT_DELAYED_WORK(&priv->request_scan, ipw_request_scan);
10793         INIT_DELAYED_WORK(&priv->request_direct_scan, ipw_request_direct_scan);
10794         INIT_DELAYED_WORK(&priv->request_passive_scan, ipw_request_passive_scan);
10795         INIT_DELAYED_WORK(&priv->scan_event, ipw_scan_event);
10796         INIT_DELAYED_WORK(&priv->gather_stats, ipw_bg_gather_stats);
10797         INIT_WORK(&priv->abort_scan, ipw_bg_abort_scan);
10798         INIT_WORK(&priv->roam, ipw_bg_roam);
10799         INIT_DELAYED_WORK(&priv->scan_check, ipw_bg_scan_check);
10800         INIT_WORK(&priv->link_up, ipw_bg_link_up);
10801         INIT_WORK(&priv->link_down, ipw_bg_link_down);
10802         INIT_DELAYED_WORK(&priv->led_link_on, ipw_bg_led_link_on);
10803         INIT_DELAYED_WORK(&priv->led_link_off, ipw_bg_led_link_off);
10804         INIT_DELAYED_WORK(&priv->led_act_off, ipw_bg_led_activity_off);
10805         INIT_WORK(&priv->merge_networks, ipw_merge_adhoc_network);
10806
10807 #ifdef CONFIG_IPW2200_QOS
10808         INIT_WORK(&priv->qos_activate, ipw_bg_qos_activate);
10809 #endif                          /* CONFIG_IPW2200_QOS */
10810
10811         tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10812                      ipw_irq_tasklet, (unsigned long)priv);
10813
10814         return ret;
10815 }
10816
10817 static void shim__set_security(struct net_device *dev,
10818                                struct libipw_security *sec)
10819 {
10820         struct ipw_priv *priv = libipw_priv(dev);
10821         int i;
10822         for (i = 0; i < 4; i++) {
10823                 if (sec->flags & (1 << i)) {
10824                         priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10825                         priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
10826                         if (sec->key_sizes[i] == 0)
10827                                 priv->ieee->sec.flags &= ~(1 << i);
10828                         else {
10829                                 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
10830                                        sec->key_sizes[i]);
10831                                 priv->ieee->sec.flags |= (1 << i);
10832                         }
10833                         priv->status |= STATUS_SECURITY_UPDATED;
10834                 } else if (sec->level != SEC_LEVEL_1)
10835                         priv->ieee->sec.flags &= ~(1 << i);
10836         }
10837
10838         if (sec->flags & SEC_ACTIVE_KEY) {
10839                 if (sec->active_key <= 3) {
10840                         priv->ieee->sec.active_key = sec->active_key;
10841                         priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10842                 } else
10843                         priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10844                 priv->status |= STATUS_SECURITY_UPDATED;
10845         } else
10846                 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10847
10848         if ((sec->flags & SEC_AUTH_MODE) &&
10849             (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10850                 priv->ieee->sec.auth_mode = sec->auth_mode;
10851                 priv->ieee->sec.flags |= SEC_AUTH_MODE;
10852                 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10853                         priv->capability |= CAP_SHARED_KEY;
10854                 else
10855                         priv->capability &= ~CAP_SHARED_KEY;
10856                 priv->status |= STATUS_SECURITY_UPDATED;
10857         }
10858
10859         if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10860                 priv->ieee->sec.flags |= SEC_ENABLED;
10861                 priv->ieee->sec.enabled = sec->enabled;
10862                 priv->status |= STATUS_SECURITY_UPDATED;
10863                 if (sec->enabled)
10864                         priv->capability |= CAP_PRIVACY_ON;
10865                 else
10866                         priv->capability &= ~CAP_PRIVACY_ON;
10867         }
10868
10869         if (sec->flags & SEC_ENCRYPT)
10870                 priv->ieee->sec.encrypt = sec->encrypt;
10871
10872         if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10873                 priv->ieee->sec.level = sec->level;
10874                 priv->ieee->sec.flags |= SEC_LEVEL;
10875                 priv->status |= STATUS_SECURITY_UPDATED;
10876         }
10877
10878         if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10879                 ipw_set_hwcrypto_keys(priv);
10880
10881         /* To match current functionality of ipw2100 (which works well w/
10882          * various supplicants, we don't force a disassociate if the
10883          * privacy capability changes ... */
10884 #if 0
10885         if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10886             (((priv->assoc_request.capability &
10887                cpu_to_le16(WLAN_CAPABILITY_PRIVACY)) && !sec->enabled) ||
10888              (!(priv->assoc_request.capability &
10889                 cpu_to_le16(WLAN_CAPABILITY_PRIVACY)) && sec->enabled))) {
10890                 IPW_DEBUG_ASSOC("Disassociating due to capability "
10891                                 "change.\n");
10892                 ipw_disassociate(priv);
10893         }
10894 #endif
10895 }
10896
10897 static int init_supported_rates(struct ipw_priv *priv,
10898                                 struct ipw_supported_rates *rates)
10899 {
10900         /* TODO: Mask out rates based on priv->rates_mask */
10901
10902         memset(rates, 0, sizeof(*rates));
10903         /* configure supported rates */
10904         switch (priv->ieee->freq_band) {
10905         case LIBIPW_52GHZ_BAND:
10906                 rates->ieee_mode = IPW_A_MODE;
10907                 rates->purpose = IPW_RATE_CAPABILITIES;
10908                 ipw_add_ofdm_scan_rates(rates, LIBIPW_CCK_MODULATION,
10909                                         LIBIPW_OFDM_DEFAULT_RATES_MASK);
10910                 break;
10911
10912         default:                /* Mixed or 2.4Ghz */
10913                 rates->ieee_mode = IPW_G_MODE;
10914                 rates->purpose = IPW_RATE_CAPABILITIES;
10915                 ipw_add_cck_scan_rates(rates, LIBIPW_CCK_MODULATION,
10916                                        LIBIPW_CCK_DEFAULT_RATES_MASK);
10917                 if (priv->ieee->modulation & LIBIPW_OFDM_MODULATION) {
10918                         ipw_add_ofdm_scan_rates(rates, LIBIPW_CCK_MODULATION,
10919                                                 LIBIPW_OFDM_DEFAULT_RATES_MASK);
10920                 }
10921                 break;
10922         }
10923
10924         return 0;
10925 }
10926
10927 static int ipw_config(struct ipw_priv *priv)
10928 {
10929         /* This is only called from ipw_up, which resets/reloads the firmware
10930            so, we don't need to first disable the card before we configure
10931            it */
10932         if (ipw_set_tx_power(priv))
10933                 goto error;
10934
10935         /* initialize adapter address */
10936         if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10937                 goto error;
10938
10939         /* set basic system config settings */
10940         init_sys_config(&priv->sys_config);
10941
10942         /* Support Bluetooth if we have BT h/w on board, and user wants to.
10943          * Does not support BT priority yet (don't abort or defer our Tx) */
10944         if (bt_coexist) {
10945                 unsigned char bt_caps = priv->eeprom[EEPROM_SKU_CAPABILITY];
10946
10947                 if (bt_caps & EEPROM_SKU_CAP_BT_CHANNEL_SIG)
10948                         priv->sys_config.bt_coexistence
10949                             |= CFG_BT_COEXISTENCE_SIGNAL_CHNL;
10950                 if (bt_caps & EEPROM_SKU_CAP_BT_OOB)
10951                         priv->sys_config.bt_coexistence
10952                             |= CFG_BT_COEXISTENCE_OOB;
10953         }
10954
10955 #ifdef CONFIG_IPW2200_PROMISCUOUS
10956         if (priv->prom_net_dev && netif_running(priv->prom_net_dev)) {
10957                 priv->sys_config.accept_all_data_frames = 1;
10958                 priv->sys_config.accept_non_directed_frames = 1;
10959                 priv->sys_config.accept_all_mgmt_bcpr = 1;
10960                 priv->sys_config.accept_all_mgmt_frames = 1;
10961         }
10962 #endif
10963
10964         if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10965                 priv->sys_config.answer_broadcast_ssid_probe = 1;
10966         else
10967                 priv->sys_config.answer_broadcast_ssid_probe = 0;
10968
10969         if (ipw_send_system_config(priv))
10970                 goto error;
10971
10972         init_supported_rates(priv, &priv->rates);
10973         if (ipw_send_supported_rates(priv, &priv->rates))
10974                 goto error;
10975
10976         /* Set request-to-send threshold */
10977         if (priv->rts_threshold) {
10978                 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10979                         goto error;
10980         }
10981 #ifdef CONFIG_IPW2200_QOS
10982         IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10983         ipw_qos_activate(priv, NULL);
10984 #endif                          /* CONFIG_IPW2200_QOS */
10985
10986         if (ipw_set_random_seed(priv))
10987                 goto error;
10988
10989         /* final state transition to the RUN state */
10990         if (ipw_send_host_complete(priv))
10991                 goto error;
10992
10993         priv->status |= STATUS_INIT;
10994
10995         ipw_led_init(priv);
10996         ipw_led_radio_on(priv);
10997         priv->notif_missed_beacons = 0;
10998
10999         /* Set hardware WEP key if it is configured. */
11000         if ((priv->capability & CAP_PRIVACY_ON) &&
11001             (priv->ieee->sec.level == SEC_LEVEL_1) &&
11002             !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
11003                 ipw_set_hwcrypto_keys(priv);
11004
11005         return 0;
11006
11007       error:
11008         return -EIO;
11009 }
11010
11011 /*
11012  * NOTE:
11013  *
11014  * These tables have been tested in conjunction with the
11015  * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
11016  *
11017  * Altering this values, using it on other hardware, or in geographies
11018  * not intended for resale of the above mentioned Intel adapters has
11019  * not been tested.
11020  *
11021  * Remember to update the table in README.ipw2200 when changing this
11022  * table.
11023  *
11024  */
11025 static const struct libipw_geo ipw_geos[] = {
11026         {                       /* Restricted */
11027          "---",
11028          .bg_channels = 11,
11029          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11030                 {2427, 4}, {2432, 5}, {2437, 6},
11031                 {2442, 7}, {2447, 8}, {2452, 9},
11032                 {2457, 10}, {2462, 11}},
11033          },
11034
11035         {                       /* Custom US/Canada */
11036          "ZZF",
11037          .bg_channels = 11,
11038          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11039                 {2427, 4}, {2432, 5}, {2437, 6},
11040                 {2442, 7}, {2447, 8}, {2452, 9},
11041                 {2457, 10}, {2462, 11}},
11042          .a_channels = 8,
11043          .a = {{5180, 36},
11044                {5200, 40},
11045                {5220, 44},
11046                {5240, 48},
11047                {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11048                {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11049                {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11050                {5320, 64, LIBIPW_CH_PASSIVE_ONLY}},
11051          },
11052
11053         {                       /* Rest of World */
11054          "ZZD",
11055          .bg_channels = 13,
11056          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11057                 {2427, 4}, {2432, 5}, {2437, 6},
11058                 {2442, 7}, {2447, 8}, {2452, 9},
11059                 {2457, 10}, {2462, 11}, {2467, 12},
11060                 {2472, 13}},
11061          },
11062
11063         {                       /* Custom USA & Europe & High */
11064          "ZZA",
11065          .bg_channels = 11,
11066          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11067                 {2427, 4}, {2432, 5}, {2437, 6},
11068                 {2442, 7}, {2447, 8}, {2452, 9},
11069                 {2457, 10}, {2462, 11}},
11070          .a_channels = 13,
11071          .a = {{5180, 36},
11072                {5200, 40},
11073                {5220, 44},
11074                {5240, 48},
11075                {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11076                {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11077                {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11078                {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11079                {5745, 149},
11080                {5765, 153},
11081                {5785, 157},
11082                {5805, 161},
11083                {5825, 165}},
11084          },
11085
11086         {                       /* Custom NA & Europe */
11087          "ZZB",
11088          .bg_channels = 11,
11089          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11090                 {2427, 4}, {2432, 5}, {2437, 6},
11091                 {2442, 7}, {2447, 8}, {2452, 9},
11092                 {2457, 10}, {2462, 11}},
11093          .a_channels = 13,
11094          .a = {{5180, 36},
11095                {5200, 40},
11096                {5220, 44},
11097                {5240, 48},
11098                {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11099                {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11100                {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11101                {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11102                {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11103                {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11104                {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11105                {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11106                {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
11107          },
11108
11109         {                       /* Custom Japan */
11110          "ZZC",
11111          .bg_channels = 11,
11112          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11113                 {2427, 4}, {2432, 5}, {2437, 6},
11114                 {2442, 7}, {2447, 8}, {2452, 9},
11115                 {2457, 10}, {2462, 11}},
11116          .a_channels = 4,
11117          .a = {{5170, 34}, {5190, 38},
11118                {5210, 42}, {5230, 46}},
11119          },
11120
11121         {                       /* Custom */
11122          "ZZM",
11123          .bg_channels = 11,
11124          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11125                 {2427, 4}, {2432, 5}, {2437, 6},
11126                 {2442, 7}, {2447, 8}, {2452, 9},
11127                 {2457, 10}, {2462, 11}},
11128          },
11129
11130         {                       /* Europe */
11131          "ZZE",
11132          .bg_channels = 13,
11133          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11134                 {2427, 4}, {2432, 5}, {2437, 6},
11135                 {2442, 7}, {2447, 8}, {2452, 9},
11136                 {2457, 10}, {2462, 11}, {2467, 12},
11137                 {2472, 13}},
11138          .a_channels = 19,
11139          .a = {{5180, 36},
11140                {5200, 40},
11141                {5220, 44},
11142                {5240, 48},
11143                {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11144                {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11145                {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11146                {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11147                {5500, 100, LIBIPW_CH_PASSIVE_ONLY},
11148                {5520, 104, LIBIPW_CH_PASSIVE_ONLY},
11149                {5540, 108, LIBIPW_CH_PASSIVE_ONLY},
11150                {5560, 112, LIBIPW_CH_PASSIVE_ONLY},
11151                {5580, 116, LIBIPW_CH_PASSIVE_ONLY},
11152                {5600, 120, LIBIPW_CH_PASSIVE_ONLY},
11153                {5620, 124, LIBIPW_CH_PASSIVE_ONLY},
11154                {5640, 128, LIBIPW_CH_PASSIVE_ONLY},
11155                {5660, 132, LIBIPW_CH_PASSIVE_ONLY},
11156                {5680, 136, LIBIPW_CH_PASSIVE_ONLY},
11157                {5700, 140, LIBIPW_CH_PASSIVE_ONLY}},
11158          },
11159
11160         {                       /* Custom Japan */
11161          "ZZJ",
11162          .bg_channels = 14,
11163          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11164                 {2427, 4}, {2432, 5}, {2437, 6},
11165                 {2442, 7}, {2447, 8}, {2452, 9},
11166                 {2457, 10}, {2462, 11}, {2467, 12},
11167                 {2472, 13}, {2484, 14, LIBIPW_CH_B_ONLY}},
11168          .a_channels = 4,
11169          .a = {{5170, 34}, {5190, 38},
11170                {5210, 42}, {5230, 46}},
11171          },
11172
11173         {                       /* Rest of World */
11174          "ZZR",
11175          .bg_channels = 14,
11176          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11177                 {2427, 4}, {2432, 5}, {2437, 6},
11178                 {2442, 7}, {2447, 8}, {2452, 9},
11179                 {2457, 10}, {2462, 11}, {2467, 12},
11180                 {2472, 13}, {2484, 14, LIBIPW_CH_B_ONLY |
11181                              LIBIPW_CH_PASSIVE_ONLY}},
11182          },
11183
11184         {                       /* High Band */
11185          "ZZH",
11186          .bg_channels = 13,
11187          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11188                 {2427, 4}, {2432, 5}, {2437, 6},
11189                 {2442, 7}, {2447, 8}, {2452, 9},
11190                 {2457, 10}, {2462, 11},
11191                 {2467, 12, LIBIPW_CH_PASSIVE_ONLY},
11192                 {2472, 13, LIBIPW_CH_PASSIVE_ONLY}},
11193          .a_channels = 4,
11194          .a = {{5745, 149}, {5765, 153},
11195                {5785, 157}, {5805, 161}},
11196          },
11197
11198         {                       /* Custom Europe */
11199          "ZZG",
11200          .bg_channels = 13,
11201          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11202                 {2427, 4}, {2432, 5}, {2437, 6},
11203                 {2442, 7}, {2447, 8}, {2452, 9},
11204                 {2457, 10}, {2462, 11},
11205                 {2467, 12}, {2472, 13}},
11206          .a_channels = 4,
11207          .a = {{5180, 36}, {5200, 40},
11208                {5220, 44}, {5240, 48}},
11209          },
11210
11211         {                       /* Europe */
11212          "ZZK",
11213          .bg_channels = 13,
11214          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11215                 {2427, 4}, {2432, 5}, {2437, 6},
11216                 {2442, 7}, {2447, 8}, {2452, 9},
11217                 {2457, 10}, {2462, 11},
11218                 {2467, 12, LIBIPW_CH_PASSIVE_ONLY},
11219                 {2472, 13, LIBIPW_CH_PASSIVE_ONLY}},
11220          .a_channels = 24,
11221          .a = {{5180, 36, LIBIPW_CH_PASSIVE_ONLY},
11222                {5200, 40, LIBIPW_CH_PASSIVE_ONLY},
11223                {5220, 44, LIBIPW_CH_PASSIVE_ONLY},
11224                {5240, 48, LIBIPW_CH_PASSIVE_ONLY},
11225                {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11226                {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11227                {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11228                {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11229                {5500, 100, LIBIPW_CH_PASSIVE_ONLY},
11230                {5520, 104, LIBIPW_CH_PASSIVE_ONLY},
11231                {5540, 108, LIBIPW_CH_PASSIVE_ONLY},
11232                {5560, 112, LIBIPW_CH_PASSIVE_ONLY},
11233                {5580, 116, LIBIPW_CH_PASSIVE_ONLY},
11234                {5600, 120, LIBIPW_CH_PASSIVE_ONLY},
11235                {5620, 124, LIBIPW_CH_PASSIVE_ONLY},
11236                {5640, 128, LIBIPW_CH_PASSIVE_ONLY},
11237                {5660, 132, LIBIPW_CH_PASSIVE_ONLY},
11238                {5680, 136, LIBIPW_CH_PASSIVE_ONLY},
11239                {5700, 140, LIBIPW_CH_PASSIVE_ONLY},
11240                {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11241                {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11242                {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11243                {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11244                {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
11245          },
11246
11247         {                       /* Europe */
11248          "ZZL",
11249          .bg_channels = 11,
11250          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11251                 {2427, 4}, {2432, 5}, {2437, 6},
11252                 {2442, 7}, {2447, 8}, {2452, 9},
11253                 {2457, 10}, {2462, 11}},
11254          .a_channels = 13,
11255          .a = {{5180, 36, LIBIPW_CH_PASSIVE_ONLY},
11256                {5200, 40, LIBIPW_CH_PASSIVE_ONLY},
11257                {5220, 44, LIBIPW_CH_PASSIVE_ONLY},
11258                {5240, 48, LIBIPW_CH_PASSIVE_ONLY},
11259                {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11260                {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11261                {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11262                {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11263                {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11264                {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11265                {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11266                {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11267                {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
11268          }
11269 };
11270
11271 #define MAX_HW_RESTARTS 5
11272 static int ipw_up(struct ipw_priv *priv)
11273 {
11274         int rc, i, j;
11275
11276         /* Age scan list entries found before suspend */
11277         if (priv->suspend_time) {
11278                 libipw_networks_age(priv->ieee, priv->suspend_time);
11279                 priv->suspend_time = 0;
11280         }
11281
11282         if (priv->status & STATUS_EXIT_PENDING)
11283                 return -EIO;
11284
11285         if (cmdlog && !priv->cmdlog) {
11286                 priv->cmdlog = kcalloc(cmdlog, sizeof(*priv->cmdlog),
11287                                        GFP_KERNEL);
11288                 if (priv->cmdlog == NULL) {
11289                         IPW_ERROR("Error allocating %d command log entries.\n",
11290                                   cmdlog);
11291                         return -ENOMEM;
11292                 } else {
11293                         priv->cmdlog_len = cmdlog;
11294                 }
11295         }
11296
11297         for (i = 0; i < MAX_HW_RESTARTS; i++) {
11298                 /* Load the microcode, firmware, and eeprom.
11299                  * Also start the clocks. */
11300                 rc = ipw_load(priv);
11301                 if (rc) {
11302                         IPW_ERROR("Unable to load firmware: %d\n", rc);
11303                         return rc;
11304                 }
11305
11306                 ipw_init_ordinals(priv);
11307                 if (!(priv->config & CFG_CUSTOM_MAC))
11308                         eeprom_parse_mac(priv, priv->mac_addr);
11309                 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
11310                 memcpy(priv->net_dev->perm_addr, priv->mac_addr, ETH_ALEN);
11311
11312                 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
11313                         if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
11314                                     ipw_geos[j].name, 3))
11315                                 break;
11316                 }
11317                 if (j == ARRAY_SIZE(ipw_geos)) {
11318                         IPW_WARNING("SKU [%c%c%c] not recognized.\n",
11319                                     priv->eeprom[EEPROM_COUNTRY_CODE + 0],
11320                                     priv->eeprom[EEPROM_COUNTRY_CODE + 1],
11321                                     priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
11322                         j = 0;
11323                 }
11324                 if (libipw_set_geo(priv->ieee, &ipw_geos[j])) {
11325                         IPW_WARNING("Could not set geography.");
11326                         return 0;
11327                 }
11328
11329                 if (priv->status & STATUS_RF_KILL_SW) {
11330                         IPW_WARNING("Radio disabled by module parameter.\n");
11331                         return 0;
11332                 } else if (rf_kill_active(priv)) {
11333                         IPW_WARNING("Radio Frequency Kill Switch is On:\n"
11334                                     "Kill switch must be turned off for "
11335                                     "wireless networking to work.\n");
11336                         queue_delayed_work(priv->workqueue, &priv->rf_kill,
11337                                            2 * HZ);
11338                         return 0;
11339                 }
11340
11341                 rc = ipw_config(priv);
11342                 if (!rc) {
11343                         IPW_DEBUG_INFO("Configured device on count %i\n", i);
11344
11345                         /* If configure to try and auto-associate, kick
11346                          * off a scan. */
11347                         queue_delayed_work(priv->workqueue,
11348                                            &priv->request_scan, 0);
11349
11350                         return 0;
11351                 }
11352
11353                 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
11354                 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
11355                                i, MAX_HW_RESTARTS);
11356
11357                 /* We had an error bringing up the hardware, so take it
11358                  * all the way back down so we can try again */
11359                 ipw_down(priv);
11360         }
11361
11362         /* tried to restart and config the device for as long as our
11363          * patience could withstand */
11364         IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
11365
11366         return -EIO;
11367 }
11368
11369 static void ipw_bg_up(struct work_struct *work)
11370 {
11371         struct ipw_priv *priv =
11372                 container_of(work, struct ipw_priv, up);
11373         mutex_lock(&priv->mutex);
11374         ipw_up(priv);
11375         mutex_unlock(&priv->mutex);
11376 }
11377
11378 static void ipw_deinit(struct ipw_priv *priv)
11379 {
11380         int i;
11381
11382         if (priv->status & STATUS_SCANNING) {
11383                 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
11384                 ipw_abort_scan(priv);
11385         }
11386
11387         if (priv->status & STATUS_ASSOCIATED) {
11388                 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
11389                 ipw_disassociate(priv);
11390         }
11391
11392         ipw_led_shutdown(priv);
11393
11394         /* Wait up to 1s for status to change to not scanning and not
11395          * associated (disassociation can take a while for a ful 802.11
11396          * exchange */
11397         for (i = 1000; i && (priv->status &
11398                              (STATUS_DISASSOCIATING |
11399                               STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
11400                 udelay(10);
11401
11402         if (priv->status & (STATUS_DISASSOCIATING |
11403                             STATUS_ASSOCIATED | STATUS_SCANNING))
11404                 IPW_DEBUG_INFO("Still associated or scanning...\n");
11405         else
11406                 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
11407
11408         /* Attempt to disable the card */
11409         ipw_send_card_disable(priv, 0);
11410
11411         priv->status &= ~STATUS_INIT;
11412 }
11413
11414 static void ipw_down(struct ipw_priv *priv)
11415 {
11416         int exit_pending = priv->status & STATUS_EXIT_PENDING;
11417
11418         priv->status |= STATUS_EXIT_PENDING;
11419
11420         if (ipw_is_init(priv))
11421                 ipw_deinit(priv);
11422
11423         /* Wipe out the EXIT_PENDING status bit if we are not actually
11424          * exiting the module */
11425         if (!exit_pending)
11426                 priv->status &= ~STATUS_EXIT_PENDING;
11427
11428         /* tell the device to stop sending interrupts */
11429         ipw_disable_interrupts(priv);
11430
11431         /* Clear all bits but the RF Kill */
11432         priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
11433         netif_carrier_off(priv->net_dev);
11434
11435         ipw_stop_nic(priv);
11436
11437         ipw_led_radio_off(priv);
11438 }
11439
11440 static void ipw_bg_down(struct work_struct *work)
11441 {
11442         struct ipw_priv *priv =
11443                 container_of(work, struct ipw_priv, down);
11444         mutex_lock(&priv->mutex);
11445         ipw_down(priv);
11446         mutex_unlock(&priv->mutex);
11447 }
11448
11449 /* Called by register_netdev() */
11450 static int ipw_net_init(struct net_device *dev)
11451 {
11452         int i, rc = 0;
11453         struct ipw_priv *priv = libipw_priv(dev);
11454         const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
11455         struct wireless_dev *wdev = &priv->ieee->wdev;
11456         mutex_lock(&priv->mutex);
11457
11458         if (ipw_up(priv)) {
11459                 rc = -EIO;
11460                 goto out;
11461         }
11462
11463         memcpy(wdev->wiphy->perm_addr, priv->mac_addr, ETH_ALEN);
11464
11465         /* fill-out priv->ieee->bg_band */
11466         if (geo->bg_channels) {
11467                 struct ieee80211_supported_band *bg_band = &priv->ieee->bg_band;
11468
11469                 bg_band->band = IEEE80211_BAND_2GHZ;
11470                 bg_band->n_channels = geo->bg_channels;
11471                 bg_band->channels =
11472                         kzalloc(geo->bg_channels *
11473                                 sizeof(struct ieee80211_channel), GFP_KERNEL);
11474                 /* translate geo->bg to bg_band.channels */
11475                 for (i = 0; i < geo->bg_channels; i++) {
11476                         bg_band->channels[i].band = IEEE80211_BAND_2GHZ;
11477                         bg_band->channels[i].center_freq = geo->bg[i].freq;
11478                         bg_band->channels[i].hw_value = geo->bg[i].channel;
11479                         bg_band->channels[i].max_power = geo->bg[i].max_power;
11480                         if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY)
11481                                 bg_band->channels[i].flags |=
11482                                         IEEE80211_CHAN_PASSIVE_SCAN;
11483                         if (geo->bg[i].flags & LIBIPW_CH_NO_IBSS)
11484                                 bg_band->channels[i].flags |=
11485                                         IEEE80211_CHAN_NO_IBSS;
11486                         if (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT)
11487                                 bg_band->channels[i].flags |=
11488                                         IEEE80211_CHAN_RADAR;
11489                         /* No equivalent for LIBIPW_CH_80211H_RULES,
11490                            LIBIPW_CH_UNIFORM_SPREADING, or
11491                            LIBIPW_CH_B_ONLY... */
11492                 }
11493                 /* point at bitrate info */
11494                 bg_band->bitrates = ipw2200_bg_rates;
11495                 bg_band->n_bitrates = ipw2200_num_bg_rates;
11496
11497                 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = bg_band;
11498         }
11499
11500         /* fill-out priv->ieee->a_band */
11501         if (geo->a_channels) {
11502                 struct ieee80211_supported_band *a_band = &priv->ieee->a_band;
11503
11504                 a_band->band = IEEE80211_BAND_5GHZ;
11505                 a_band->n_channels = geo->a_channels;
11506                 a_band->channels =
11507                         kzalloc(geo->a_channels *
11508                                 sizeof(struct ieee80211_channel), GFP_KERNEL);
11509                 /* translate geo->bg to a_band.channels */
11510                 for (i = 0; i < geo->a_channels; i++) {
11511                         a_band->channels[i].band = IEEE80211_BAND_2GHZ;
11512                         a_band->channels[i].center_freq = geo->a[i].freq;
11513                         a_band->channels[i].hw_value = geo->a[i].channel;
11514                         a_band->channels[i].max_power = geo->a[i].max_power;
11515                         if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY)
11516                                 a_band->channels[i].flags |=
11517                                         IEEE80211_CHAN_PASSIVE_SCAN;
11518                         if (geo->a[i].flags & LIBIPW_CH_NO_IBSS)
11519                                 a_band->channels[i].flags |=
11520                                         IEEE80211_CHAN_NO_IBSS;
11521                         if (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT)
11522                                 a_band->channels[i].flags |=
11523                                         IEEE80211_CHAN_RADAR;
11524                         /* No equivalent for LIBIPW_CH_80211H_RULES,
11525                            LIBIPW_CH_UNIFORM_SPREADING, or
11526                            LIBIPW_CH_B_ONLY... */
11527                 }
11528                 /* point at bitrate info */
11529                 a_band->bitrates = ipw2200_a_rates;
11530                 a_band->n_bitrates = ipw2200_num_a_rates;
11531
11532                 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = a_band;
11533         }
11534
11535         set_wiphy_dev(wdev->wiphy, &priv->pci_dev->dev);
11536
11537         /* With that information in place, we can now register the wiphy... */
11538         if (wiphy_register(wdev->wiphy)) {
11539                 rc = -EIO;
11540                 goto out;
11541         }
11542
11543 out:
11544         mutex_unlock(&priv->mutex);
11545         return rc;
11546 }
11547
11548 /* PCI driver stuff */
11549 static DEFINE_PCI_DEVICE_TABLE(card_ids) = {
11550         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
11551         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
11552         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
11553         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
11554         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
11555         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
11556         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
11557         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
11558         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
11559         {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
11560         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
11561         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
11562         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
11563         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
11564         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
11565         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
11566         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
11567         {PCI_VDEVICE(INTEL, 0x104f), 0},
11568         {PCI_VDEVICE(INTEL, 0x4220), 0},        /* BG */
11569         {PCI_VDEVICE(INTEL, 0x4221), 0},        /* BG */
11570         {PCI_VDEVICE(INTEL, 0x4223), 0},        /* ABG */
11571         {PCI_VDEVICE(INTEL, 0x4224), 0},        /* ABG */
11572
11573         /* required last entry */
11574         {0,}
11575 };
11576
11577 MODULE_DEVICE_TABLE(pci, card_ids);
11578
11579 static struct attribute *ipw_sysfs_entries[] = {
11580         &dev_attr_rf_kill.attr,
11581         &dev_attr_direct_dword.attr,
11582         &dev_attr_indirect_byte.attr,
11583         &dev_attr_indirect_dword.attr,
11584         &dev_attr_mem_gpio_reg.attr,
11585         &dev_attr_command_event_reg.attr,
11586         &dev_attr_nic_type.attr,
11587         &dev_attr_status.attr,
11588         &dev_attr_cfg.attr,
11589         &dev_attr_error.attr,
11590         &dev_attr_event_log.attr,
11591         &dev_attr_cmd_log.attr,
11592         &dev_attr_eeprom_delay.attr,
11593         &dev_attr_ucode_version.attr,
11594         &dev_attr_rtc.attr,
11595         &dev_attr_scan_age.attr,
11596         &dev_attr_led.attr,
11597         &dev_attr_speed_scan.attr,
11598         &dev_attr_net_stats.attr,
11599         &dev_attr_channels.attr,
11600 #ifdef CONFIG_IPW2200_PROMISCUOUS
11601         &dev_attr_rtap_iface.attr,
11602         &dev_attr_rtap_filter.attr,
11603 #endif
11604         NULL
11605 };
11606
11607 static struct attribute_group ipw_attribute_group = {
11608         .name = NULL,           /* put in device directory */
11609         .attrs = ipw_sysfs_entries,
11610 };
11611
11612 #ifdef CONFIG_IPW2200_PROMISCUOUS
11613 static int ipw_prom_open(struct net_device *dev)
11614 {
11615         struct ipw_prom_priv *prom_priv = libipw_priv(dev);
11616         struct ipw_priv *priv = prom_priv->priv;
11617
11618         IPW_DEBUG_INFO("prom dev->open\n");
11619         netif_carrier_off(dev);
11620
11621         if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
11622                 priv->sys_config.accept_all_data_frames = 1;
11623                 priv->sys_config.accept_non_directed_frames = 1;
11624                 priv->sys_config.accept_all_mgmt_bcpr = 1;
11625                 priv->sys_config.accept_all_mgmt_frames = 1;
11626
11627                 ipw_send_system_config(priv);
11628         }
11629
11630         return 0;
11631 }
11632
11633 static int ipw_prom_stop(struct net_device *dev)
11634 {
11635         struct ipw_prom_priv *prom_priv = libipw_priv(dev);
11636         struct ipw_priv *priv = prom_priv->priv;
11637
11638         IPW_DEBUG_INFO("prom dev->stop\n");
11639
11640         if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
11641                 priv->sys_config.accept_all_data_frames = 0;
11642                 priv->sys_config.accept_non_directed_frames = 0;
11643                 priv->sys_config.accept_all_mgmt_bcpr = 0;
11644                 priv->sys_config.accept_all_mgmt_frames = 0;
11645
11646                 ipw_send_system_config(priv);
11647         }
11648
11649         return 0;
11650 }
11651
11652 static netdev_tx_t ipw_prom_hard_start_xmit(struct sk_buff *skb,
11653                                             struct net_device *dev)
11654 {
11655         IPW_DEBUG_INFO("prom dev->xmit\n");
11656         dev_kfree_skb(skb);
11657         return NETDEV_TX_OK;
11658 }
11659
11660 static const struct net_device_ops ipw_prom_netdev_ops = {
11661         .ndo_open               = ipw_prom_open,
11662         .ndo_stop               = ipw_prom_stop,
11663         .ndo_start_xmit         = ipw_prom_hard_start_xmit,
11664         .ndo_change_mtu         = libipw_change_mtu,
11665         .ndo_set_mac_address    = eth_mac_addr,
11666         .ndo_validate_addr      = eth_validate_addr,
11667 };
11668
11669 static int ipw_prom_alloc(struct ipw_priv *priv)
11670 {
11671         int rc = 0;
11672
11673         if (priv->prom_net_dev)
11674                 return -EPERM;
11675
11676         priv->prom_net_dev = alloc_libipw(sizeof(struct ipw_prom_priv), 1);
11677         if (priv->prom_net_dev == NULL)
11678                 return -ENOMEM;
11679
11680         priv->prom_priv = libipw_priv(priv->prom_net_dev);
11681         priv->prom_priv->ieee = netdev_priv(priv->prom_net_dev);
11682         priv->prom_priv->priv = priv;
11683
11684         strcpy(priv->prom_net_dev->name, "rtap%d");
11685         memcpy(priv->prom_net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
11686
11687         priv->prom_net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
11688         priv->prom_net_dev->netdev_ops = &ipw_prom_netdev_ops;
11689
11690         priv->prom_priv->ieee->iw_mode = IW_MODE_MONITOR;
11691         SET_NETDEV_DEV(priv->prom_net_dev, &priv->pci_dev->dev);
11692
11693         rc = register_netdev(priv->prom_net_dev);
11694         if (rc) {
11695                 free_libipw(priv->prom_net_dev, 1);
11696                 priv->prom_net_dev = NULL;
11697                 return rc;
11698         }
11699
11700         return 0;
11701 }
11702
11703 static void ipw_prom_free(struct ipw_priv *priv)
11704 {
11705         if (!priv->prom_net_dev)
11706                 return;
11707
11708         unregister_netdev(priv->prom_net_dev);
11709         free_libipw(priv->prom_net_dev, 1);
11710
11711         priv->prom_net_dev = NULL;
11712 }
11713
11714 #endif
11715
11716 static const struct net_device_ops ipw_netdev_ops = {
11717         .ndo_init               = ipw_net_init,
11718         .ndo_open               = ipw_net_open,
11719         .ndo_stop               = ipw_net_stop,
11720         .ndo_set_multicast_list = ipw_net_set_multicast_list,
11721         .ndo_set_mac_address    = ipw_net_set_mac_address,
11722         .ndo_start_xmit         = libipw_xmit,
11723         .ndo_change_mtu         = libipw_change_mtu,
11724         .ndo_validate_addr      = eth_validate_addr,
11725 };
11726
11727 static int __devinit ipw_pci_probe(struct pci_dev *pdev,
11728                                    const struct pci_device_id *ent)
11729 {
11730         int err = 0;
11731         struct net_device *net_dev;
11732         void __iomem *base;
11733         u32 length, val;
11734         struct ipw_priv *priv;
11735         int i;
11736
11737         net_dev = alloc_libipw(sizeof(struct ipw_priv), 0);
11738         if (net_dev == NULL) {
11739                 err = -ENOMEM;
11740                 goto out;
11741         }
11742
11743         priv = libipw_priv(net_dev);
11744         priv->ieee = netdev_priv(net_dev);
11745
11746         priv->net_dev = net_dev;
11747         priv->pci_dev = pdev;
11748         ipw_debug_level = debug;
11749         spin_lock_init(&priv->irq_lock);
11750         spin_lock_init(&priv->lock);
11751         for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
11752                 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
11753
11754         mutex_init(&priv->mutex);
11755         if (pci_enable_device(pdev)) {
11756                 err = -ENODEV;
11757                 goto out_free_libipw;
11758         }
11759
11760         pci_set_master(pdev);
11761
11762         err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
11763         if (!err)
11764                 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
11765         if (err) {
11766                 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
11767                 goto out_pci_disable_device;
11768         }
11769
11770         pci_set_drvdata(pdev, priv);
11771
11772         err = pci_request_regions(pdev, DRV_NAME);
11773         if (err)
11774                 goto out_pci_disable_device;
11775
11776         /* We disable the RETRY_TIMEOUT register (0x41) to keep
11777          * PCI Tx retries from interfering with C3 CPU state */
11778         pci_read_config_dword(pdev, 0x40, &val);
11779         if ((val & 0x0000ff00) != 0)
11780                 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11781
11782         length = pci_resource_len(pdev, 0);
11783         priv->hw_len = length;
11784
11785         base = pci_ioremap_bar(pdev, 0);
11786         if (!base) {
11787                 err = -ENODEV;
11788                 goto out_pci_release_regions;
11789         }
11790
11791         priv->hw_base = base;
11792         IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
11793         IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
11794
11795         err = ipw_setup_deferred_work(priv);
11796         if (err) {
11797                 IPW_ERROR("Unable to setup deferred work\n");
11798                 goto out_iounmap;
11799         }
11800
11801         ipw_sw_reset(priv, 1);
11802
11803         err = request_irq(pdev->irq, ipw_isr, IRQF_SHARED, DRV_NAME, priv);
11804         if (err) {
11805                 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
11806                 goto out_destroy_workqueue;
11807         }
11808
11809         SET_NETDEV_DEV(net_dev, &pdev->dev);
11810
11811         mutex_lock(&priv->mutex);
11812
11813         priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11814         priv->ieee->set_security = shim__set_security;
11815         priv->ieee->is_queue_full = ipw_net_is_queue_full;
11816
11817 #ifdef CONFIG_IPW2200_QOS
11818         priv->ieee->is_qos_active = ipw_is_qos_active;
11819         priv->ieee->handle_probe_response = ipw_handle_beacon;
11820         priv->ieee->handle_beacon = ipw_handle_probe_response;
11821         priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
11822 #endif                          /* CONFIG_IPW2200_QOS */
11823
11824         priv->ieee->perfect_rssi = -20;
11825         priv->ieee->worst_rssi = -85;
11826
11827         net_dev->netdev_ops = &ipw_netdev_ops;
11828         priv->wireless_data.spy_data = &priv->ieee->spy_data;
11829         net_dev->wireless_data = &priv->wireless_data;
11830         net_dev->wireless_handlers = &ipw_wx_handler_def;
11831         net_dev->ethtool_ops = &ipw_ethtool_ops;
11832         net_dev->irq = pdev->irq;
11833         net_dev->base_addr = (unsigned long)priv->hw_base;
11834         net_dev->mem_start = pci_resource_start(pdev, 0);
11835         net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
11836
11837         err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11838         if (err) {
11839                 IPW_ERROR("failed to create sysfs device attributes\n");
11840                 mutex_unlock(&priv->mutex);
11841                 goto out_release_irq;
11842         }
11843
11844         mutex_unlock(&priv->mutex);
11845         err = register_netdev(net_dev);
11846         if (err) {
11847                 IPW_ERROR("failed to register network device\n");
11848                 goto out_remove_sysfs;
11849         }
11850
11851 #ifdef CONFIG_IPW2200_PROMISCUOUS
11852         if (rtap_iface) {
11853                 err = ipw_prom_alloc(priv);
11854                 if (err) {
11855                         IPW_ERROR("Failed to register promiscuous network "
11856                                   "device (error %d).\n", err);
11857                         unregister_netdev(priv->net_dev);
11858                         goto out_remove_sysfs;
11859                 }
11860         }
11861 #endif
11862
11863         printk(KERN_INFO DRV_NAME ": Detected geography %s (%d 802.11bg "
11864                "channels, %d 802.11a channels)\n",
11865                priv->ieee->geo.name, priv->ieee->geo.bg_channels,
11866                priv->ieee->geo.a_channels);
11867
11868         return 0;
11869
11870       out_remove_sysfs:
11871         sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11872       out_release_irq:
11873         free_irq(pdev->irq, priv);
11874       out_destroy_workqueue:
11875         destroy_workqueue(priv->workqueue);
11876         priv->workqueue = NULL;
11877       out_iounmap:
11878         iounmap(priv->hw_base);
11879       out_pci_release_regions:
11880         pci_release_regions(pdev);
11881       out_pci_disable_device:
11882         pci_disable_device(pdev);
11883         pci_set_drvdata(pdev, NULL);
11884       out_free_libipw:
11885         free_libipw(priv->net_dev, 0);
11886       out:
11887         return err;
11888 }
11889
11890 static void __devexit ipw_pci_remove(struct pci_dev *pdev)
11891 {
11892         struct ipw_priv *priv = pci_get_drvdata(pdev);
11893         struct list_head *p, *q;
11894         int i;
11895
11896         if (!priv)
11897                 return;
11898
11899         mutex_lock(&priv->mutex);
11900
11901         priv->status |= STATUS_EXIT_PENDING;
11902         ipw_down(priv);
11903         sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11904
11905         mutex_unlock(&priv->mutex);
11906
11907         unregister_netdev(priv->net_dev);
11908
11909         if (priv->rxq) {
11910                 ipw_rx_queue_free(priv, priv->rxq);
11911                 priv->rxq = NULL;
11912         }
11913         ipw_tx_queue_free(priv);
11914
11915         if (priv->cmdlog) {
11916                 kfree(priv->cmdlog);
11917                 priv->cmdlog = NULL;
11918         }
11919         /* ipw_down will ensure that there is no more pending work
11920          * in the workqueue's, so we can safely remove them now. */
11921         cancel_delayed_work(&priv->adhoc_check);
11922         cancel_delayed_work(&priv->gather_stats);
11923         cancel_delayed_work(&priv->request_scan);
11924         cancel_delayed_work(&priv->request_direct_scan);
11925         cancel_delayed_work(&priv->request_passive_scan);
11926         cancel_delayed_work(&priv->scan_event);
11927         cancel_delayed_work(&priv->rf_kill);
11928         cancel_delayed_work(&priv->scan_check);
11929         destroy_workqueue(priv->workqueue);
11930         priv->workqueue = NULL;
11931
11932         /* Free MAC hash list for ADHOC */
11933         for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11934                 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11935                         list_del(p);
11936                         kfree(list_entry(p, struct ipw_ibss_seq, list));
11937                 }
11938         }
11939
11940         kfree(priv->error);
11941         priv->error = NULL;
11942
11943 #ifdef CONFIG_IPW2200_PROMISCUOUS
11944         ipw_prom_free(priv);
11945 #endif
11946
11947         free_irq(pdev->irq, priv);
11948         iounmap(priv->hw_base);
11949         pci_release_regions(pdev);
11950         pci_disable_device(pdev);
11951         pci_set_drvdata(pdev, NULL);
11952         /* wiphy_unregister needs to be here, before free_libipw */
11953         wiphy_unregister(priv->ieee->wdev.wiphy);
11954         kfree(priv->ieee->a_band.channels);
11955         kfree(priv->ieee->bg_band.channels);
11956         free_libipw(priv->net_dev, 0);
11957         free_firmware();
11958 }
11959
11960 #ifdef CONFIG_PM
11961 static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
11962 {
11963         struct ipw_priv *priv = pci_get_drvdata(pdev);
11964         struct net_device *dev = priv->net_dev;
11965
11966         printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11967
11968         /* Take down the device; powers it off, etc. */
11969         ipw_down(priv);
11970
11971         /* Remove the PRESENT state of the device */
11972         netif_device_detach(dev);
11973
11974         pci_save_state(pdev);
11975         pci_disable_device(pdev);
11976         pci_set_power_state(pdev, pci_choose_state(pdev, state));
11977
11978         priv->suspend_at = get_seconds();
11979
11980         return 0;
11981 }
11982
11983 static int ipw_pci_resume(struct pci_dev *pdev)
11984 {
11985         struct ipw_priv *priv = pci_get_drvdata(pdev);
11986         struct net_device *dev = priv->net_dev;
11987         int err;
11988         u32 val;
11989
11990         printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11991
11992         pci_set_power_state(pdev, PCI_D0);
11993         err = pci_enable_device(pdev);
11994         if (err) {
11995                 printk(KERN_ERR "%s: pci_enable_device failed on resume\n",
11996                        dev->name);
11997                 return err;
11998         }
11999         pci_restore_state(pdev);
12000
12001         /*
12002          * Suspend/Resume resets the PCI configuration space, so we have to
12003          * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
12004          * from interfering with C3 CPU state. pci_restore_state won't help
12005          * here since it only restores the first 64 bytes pci config header.
12006          */
12007         pci_read_config_dword(pdev, 0x40, &val);
12008         if ((val & 0x0000ff00) != 0)
12009                 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
12010
12011         /* Set the device back into the PRESENT state; this will also wake
12012          * the queue of needed */
12013         netif_device_attach(dev);
12014
12015         priv->suspend_time = get_seconds() - priv->suspend_at;
12016
12017         /* Bring the device back up */
12018         queue_work(priv->workqueue, &priv->up);
12019
12020         return 0;
12021 }
12022 #endif
12023
12024 static void ipw_pci_shutdown(struct pci_dev *pdev)
12025 {
12026         struct ipw_priv *priv = pci_get_drvdata(pdev);
12027
12028         /* Take down the device; powers it off, etc. */
12029         ipw_down(priv);
12030
12031         pci_disable_device(pdev);
12032 }
12033
12034 /* driver initialization stuff */
12035 static struct pci_driver ipw_driver = {
12036         .name = DRV_NAME,
12037         .id_table = card_ids,
12038         .probe = ipw_pci_probe,
12039         .remove = __devexit_p(ipw_pci_remove),
12040 #ifdef CONFIG_PM
12041         .suspend = ipw_pci_suspend,
12042         .resume = ipw_pci_resume,
12043 #endif
12044         .shutdown = ipw_pci_shutdown,
12045 };
12046
12047 static int __init ipw_init(void)
12048 {
12049         int ret;
12050
12051         printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
12052         printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
12053
12054         ret = pci_register_driver(&ipw_driver);
12055         if (ret) {
12056                 IPW_ERROR("Unable to initialize PCI module\n");
12057                 return ret;
12058         }
12059
12060         ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
12061         if (ret) {
12062                 IPW_ERROR("Unable to create driver sysfs file\n");
12063                 pci_unregister_driver(&ipw_driver);
12064                 return ret;
12065         }
12066
12067         return ret;
12068 }
12069
12070 static void __exit ipw_exit(void)
12071 {
12072         driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
12073         pci_unregister_driver(&ipw_driver);
12074 }
12075
12076 module_param(disable, int, 0444);
12077 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
12078
12079 module_param(associate, int, 0444);
12080 MODULE_PARM_DESC(associate, "auto associate when scanning (default off)");
12081
12082 module_param(auto_create, int, 0444);
12083 MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
12084
12085 module_param_named(led, led_support, int, 0444);
12086 MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)");
12087
12088 module_param(debug, int, 0444);
12089 MODULE_PARM_DESC(debug, "debug output mask");
12090
12091 module_param_named(channel, default_channel, int, 0444);
12092 MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
12093
12094 #ifdef CONFIG_IPW2200_PROMISCUOUS
12095 module_param(rtap_iface, int, 0444);
12096 MODULE_PARM_DESC(rtap_iface, "create the rtap interface (1 - create, default 0)");
12097 #endif
12098
12099 #ifdef CONFIG_IPW2200_QOS
12100 module_param(qos_enable, int, 0444);
12101 MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
12102
12103 module_param(qos_burst_enable, int, 0444);
12104 MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
12105
12106 module_param(qos_no_ack_mask, int, 0444);
12107 MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
12108
12109 module_param(burst_duration_CCK, int, 0444);
12110 MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
12111
12112 module_param(burst_duration_OFDM, int, 0444);
12113 MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
12114 #endif                          /* CONFIG_IPW2200_QOS */
12115
12116 #ifdef CONFIG_IPW2200_MONITOR
12117 module_param_named(mode, network_mode, int, 0444);
12118 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
12119 #else
12120 module_param_named(mode, network_mode, int, 0444);
12121 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
12122 #endif
12123
12124 module_param(bt_coexist, int, 0444);
12125 MODULE_PARM_DESC(bt_coexist, "enable bluetooth coexistence (default off)");
12126
12127 module_param(hwcrypto, int, 0444);
12128 MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default off)");
12129
12130 module_param(cmdlog, int, 0444);
12131 MODULE_PARM_DESC(cmdlog,
12132                  "allocate a ring buffer for logging firmware commands");
12133
12134 module_param(roaming, int, 0444);
12135 MODULE_PARM_DESC(roaming, "enable roaming support (default on)");
12136
12137 module_param(antenna, int, 0444);
12138 MODULE_PARM_DESC(antenna, "select antenna 1=Main, 3=Aux, default 0 [both], 2=slow_diversity (choose the one with lower background noise)");
12139
12140 module_exit(ipw_exit);
12141 module_init(ipw_init);