drivers/net/wireless/ipw2200.c

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