drivers/net/wireless/intel/ipw2x00/ipw2200.c

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