git.oblomov.eu Git - linux-2.6/blob - drivers/net/wireless/ipw2200.c

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