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