git.oblomov.eu Git - linux-2.6/blob - 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;
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%8X\n",
2782                           (int)priv->sram_desc.last_cb_index);
2783
2784         while (current_index < priv->sram_desc.last_cb_index) {
2785                 udelay(50);
2786                 current_index = ipw_fw_dma_command_block_index(priv);
2787
2788                 watchdog++;
2789
2790                 if (watchdog > 400) {
2791                         IPW_DEBUG_FW_INFO("Timeout\n");
2792                         ipw_fw_dma_dump_command_block(priv);
2793                         ipw_fw_dma_abort(priv);
2794                         return -1;
2795                 }
2796         }
2797
2798         ipw_fw_dma_abort(priv);
2799
2800         /*Disable the DMA in the CSR register */
2801         ipw_set_bit(priv, IPW_RESET_REG,
2802                     IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
2803
2804         IPW_DEBUG_FW("<< dmaWaitSync \n");
2805         return 0;
2806 }
2807
2808 static void ipw_remove_current_network(struct ipw_priv *priv)
2809 {
2810         struct list_head *element, *safe;
2811         struct ieee80211_network *network = NULL;
2812         unsigned long flags;
2813
2814         spin_lock_irqsave(&priv->ieee->lock, flags);
2815         list_for_each_safe(element, safe, &priv->ieee->network_list) {
2816                 network = list_entry(element, struct ieee80211_network, list);
2817                 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
2818                         list_del(element);
2819                         list_add_tail(&network->list,
2820                                       &priv->ieee->network_free_list);
2821                 }
2822         }
2823         spin_unlock_irqrestore(&priv->ieee->lock, flags);
2824 }
2825
2826 /**
2827  * Check that card is still alive.
2828  * Reads debug register from domain0.
2829  * If card is present, pre-defined value should
2830  * be found there.
2831  *
2832  * @param priv
2833  * @return 1 if card is present, 0 otherwise
2834  */
2835 static inline int ipw_alive(struct ipw_priv *priv)
2836 {
2837         return ipw_read32(priv, 0x90) == 0xd55555d5;
2838 }
2839
2840 /* timeout in msec, attempted in 10-msec quanta */
2841 static int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
2842                                int timeout)
2843 {
2844         int i = 0;
2845
2846         do {
2847                 if ((ipw_read32(priv, addr) & mask) == mask)
2848                         return i;
2849                 mdelay(10);
2850                 i += 10;
2851         } while (i < timeout);
2852
2853         return -ETIME;
2854 }
2855
2856 /* These functions load the firmware and micro code for the operation of
2857  * the ipw hardware.  It assumes the buffer has all the bits for the
2858  * image and the caller is handling the memory allocation and clean up.
2859  */
2860
2861 static int ipw_stop_master(struct ipw_priv *priv)
2862 {
2863         int rc;
2864
2865         IPW_DEBUG_TRACE(">> \n");
2866         /* stop master. typical delay - 0 */
2867         ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
2868
2869         /* timeout is in msec, polled in 10-msec quanta */
2870         rc = ipw_poll_bit(priv, IPW_RESET_REG,
2871                           IPW_RESET_REG_MASTER_DISABLED, 100);
2872         if (rc < 0) {
2873                 IPW_ERROR("wait for stop master failed after 100ms\n");
2874                 return -1;
2875         }
2876
2877         IPW_DEBUG_INFO("stop master %dms\n", rc);
2878
2879         return rc;
2880 }
2881
2882 static void ipw_arc_release(struct ipw_priv *priv)
2883 {
2884         IPW_DEBUG_TRACE(">> \n");
2885         mdelay(5);
2886
2887         ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
2888
2889         /* no one knows timing, for safety add some delay */
2890         mdelay(5);
2891 }
2892
2893 struct fw_header {
2894         u32 version;
2895         u32 mode;
2896 };
2897
2898 struct fw_chunk {
2899         u32 address;
2900         u32 length;
2901 };
2902
2903 #define IPW_FW_MAJOR_VERSION 2
2904 #define IPW_FW_MINOR_VERSION 4
2905
2906 #define IPW_FW_MINOR(x) ((x & 0xff) >> 8)
2907 #define IPW_FW_MAJOR(x) (x & 0xff)
2908
2909 #define IPW_FW_VERSION ((IPW_FW_MINOR_VERSION << 8) | IPW_FW_MAJOR_VERSION)
2910
2911 #define IPW_FW_PREFIX "ipw-" __stringify(IPW_FW_MAJOR_VERSION) \
2912 "." __stringify(IPW_FW_MINOR_VERSION) "-"
2913
2914 #if IPW_FW_MAJOR_VERSION >= 2 && IPW_FW_MINOR_VERSION > 0
2915 #define IPW_FW_NAME(x) IPW_FW_PREFIX "" x ".fw"
2916 #else
2917 #define IPW_FW_NAME(x) "ipw2200_" x ".fw"
2918 #endif
2919
2920 static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
2921 {
2922         int rc = 0, i, addr;
2923         u8 cr = 0;
2924         u16 *image;
2925
2926         image = (u16 *) data;
2927
2928         IPW_DEBUG_TRACE(">> \n");
2929
2930         rc = ipw_stop_master(priv);
2931
2932         if (rc < 0)
2933                 return rc;
2934
2935 //      spin_lock_irqsave(&priv->lock, flags);
2936
2937         for (addr = IPW_SHARED_LOWER_BOUND;
2938              addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
2939                 ipw_write32(priv, addr, 0);
2940         }
2941
2942         /* no ucode (yet) */
2943         memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
2944         /* destroy DMA queues */
2945         /* reset sequence */
2946
2947         ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
2948         ipw_arc_release(priv);
2949         ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
2950         mdelay(1);
2951
2952         /* reset PHY */
2953         ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
2954         mdelay(1);
2955
2956         ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
2957         mdelay(1);
2958
2959         /* enable ucode store */
2960         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0x0);
2961         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_CS);
2962         mdelay(1);
2963
2964         /* write ucode */
2965         /**
2966          * @bug
2967          * Do NOT set indirect address register once and then
2968          * store data to indirect data register in the loop.
2969          * It seems very reasonable, but in this case DINO do not
2970          * accept ucode. It is essential to set address each time.
2971          */
2972         /* load new ipw uCode */
2973         for (i = 0; i < len / 2; i++)
2974                 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
2975                                 cpu_to_le16(image[i]));
2976
2977         /* enable DINO */
2978         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2979         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
2980
2981         /* this is where the igx / win driver deveates from the VAP driver. */
2982
2983         /* wait for alive response */
2984         for (i = 0; i < 100; i++) {
2985                 /* poll for incoming data */
2986                 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
2987                 if (cr & DINO_RXFIFO_DATA)
2988                         break;
2989                 mdelay(1);
2990         }
2991
2992         if (cr & DINO_RXFIFO_DATA) {
2993                 /* alive_command_responce size is NOT multiple of 4 */
2994                 u32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
2995
2996                 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
2997                         response_buffer[i] =
2998                             le32_to_cpu(ipw_read_reg32(priv,
2999                                                        IPW_BASEBAND_RX_FIFO_READ));
3000                 memcpy(&priv->dino_alive, response_buffer,
3001                        sizeof(priv->dino_alive));
3002                 if (priv->dino_alive.alive_command == 1
3003                     && priv->dino_alive.ucode_valid == 1) {
3004                         rc = 0;
3005                         IPW_DEBUG_INFO
3006                             ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
3007                              "of %02d/%02d/%02d %02d:%02d\n",
3008                              priv->dino_alive.software_revision,
3009                              priv->dino_alive.software_revision,
3010                              priv->dino_alive.device_identifier,
3011                              priv->dino_alive.device_identifier,
3012                              priv->dino_alive.time_stamp[0],
3013                              priv->dino_alive.time_stamp[1],
3014                              priv->dino_alive.time_stamp[2],
3015                              priv->dino_alive.time_stamp[3],
3016                              priv->dino_alive.time_stamp[4]);
3017                 } else {
3018                         IPW_DEBUG_INFO("Microcode is not alive\n");
3019                         rc = -EINVAL;
3020                 }
3021         } else {
3022                 IPW_DEBUG_INFO("No alive response from DINO\n");
3023                 rc = -ETIME;
3024         }
3025
3026         /* disable DINO, otherwise for some reason
3027            firmware have problem getting alive resp. */
3028         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
3029
3030 //      spin_unlock_irqrestore(&priv->lock, flags);
3031
3032         return rc;
3033 }
3034
3035 static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
3036 {
3037         int rc = -1;
3038         int offset = 0;
3039         struct fw_chunk *chunk;
3040         dma_addr_t shared_phys;
3041         u8 *shared_virt;
3042
3043         IPW_DEBUG_TRACE("<< : \n");
3044         shared_virt = pci_alloc_consistent(priv->pci_dev, len, &shared_phys);
3045
3046         if (!shared_virt)
3047                 return -ENOMEM;
3048
3049         memmove(shared_virt, data, len);
3050
3051         /* Start the Dma */
3052         rc = ipw_fw_dma_enable(priv);
3053
3054         if (priv->sram_desc.last_cb_index > 0) {
3055                 /* the DMA is already ready this would be a bug. */
3056                 BUG();
3057                 goto out;
3058         }
3059
3060         do {
3061                 chunk = (struct fw_chunk *)(data + offset);
3062                 offset += sizeof(struct fw_chunk);
3063                 /* build DMA packet and queue up for sending */
3064                 /* dma to chunk->address, the chunk->length bytes from data +
3065                  * offeset*/
3066                 /* Dma loading */
3067                 rc = ipw_fw_dma_add_buffer(priv, shared_phys + offset,
3068                                            le32_to_cpu(chunk->address),
3069                                            le32_to_cpu(chunk->length));
3070                 if (rc) {
3071                         IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3072                         goto out;
3073                 }
3074
3075                 offset += le32_to_cpu(chunk->length);
3076         } while (offset < len);
3077
3078         /* Run the DMA and wait for the answer */
3079         rc = ipw_fw_dma_kick(priv);
3080         if (rc) {
3081                 IPW_ERROR("dmaKick Failed\n");
3082                 goto out;
3083         }
3084
3085         rc = ipw_fw_dma_wait(priv);
3086         if (rc) {
3087                 IPW_ERROR("dmaWaitSync Failed\n");
3088                 goto out;
3089         }
3090       out:
3091         pci_free_consistent(priv->pci_dev, len, shared_virt, shared_phys);
3092         return rc;
3093 }
3094
3095 /* stop nic */
3096 static int ipw_stop_nic(struct ipw_priv *priv)
3097 {
3098         int rc = 0;
3099
3100         /* stop */
3101         ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
3102
3103         rc = ipw_poll_bit(priv, IPW_RESET_REG,
3104                           IPW_RESET_REG_MASTER_DISABLED, 500);
3105         if (rc < 0) {
3106                 IPW_ERROR("wait for reg master disabled failed after 500ms\n");
3107                 return rc;
3108         }
3109
3110         ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
3111
3112         return rc;
3113 }
3114
3115 static void ipw_start_nic(struct ipw_priv *priv)
3116 {
3117         IPW_DEBUG_TRACE(">>\n");
3118
3119         /* prvHwStartNic  release ARC */
3120         ipw_clear_bit(priv, IPW_RESET_REG,
3121                       IPW_RESET_REG_MASTER_DISABLED |
3122                       IPW_RESET_REG_STOP_MASTER |
3123                       CBD_RESET_REG_PRINCETON_RESET);
3124
3125         /* enable power management */
3126         ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3127                     IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
3128
3129         IPW_DEBUG_TRACE("<<\n");
3130 }
3131
3132 static int ipw_init_nic(struct ipw_priv *priv)
3133 {
3134         int rc;
3135
3136         IPW_DEBUG_TRACE(">>\n");
3137         /* reset */
3138         /*prvHwInitNic */
3139         /* set "initialization complete" bit to move adapter to D0 state */
3140         ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3141
3142         /* low-level PLL activation */
3143         ipw_write32(priv, IPW_READ_INT_REGISTER,
3144                     IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
3145
3146         /* wait for clock stabilization */
3147         rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3148                           IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
3149         if (rc < 0)
3150                 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3151
3152         /* assert SW reset */
3153         ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
3154
3155         udelay(10);
3156
3157         /* set "initialization complete" bit to move adapter to D0 state */
3158         ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3159
3160         IPW_DEBUG_TRACE(">>\n");
3161         return 0;
3162 }
3163
3164 /* Call this function from process context, it will sleep in request_firmware.
3165  * Probe is an ok place to call this from.
3166  */
3167 static int ipw_reset_nic(struct ipw_priv *priv)
3168 {
3169         int rc = 0;
3170         unsigned long flags;
3171
3172         IPW_DEBUG_TRACE(">>\n");
3173
3174         rc = ipw_init_nic(priv);
3175
3176         spin_lock_irqsave(&priv->lock, flags);
3177         /* Clear the 'host command active' bit... */
3178         priv->status &= ~STATUS_HCMD_ACTIVE;
3179         wake_up_interruptible(&priv->wait_command_queue);
3180         priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3181         wake_up_interruptible(&priv->wait_state);
3182         spin_unlock_irqrestore(&priv->lock, flags);
3183
3184         IPW_DEBUG_TRACE("<<\n");
3185         return rc;
3186 }
3187
3188 static int ipw_get_fw(struct ipw_priv *priv,
3189                       const struct firmware **fw, const char *name)
3190 {
3191         struct fw_header *header;
3192         int rc;
3193
3194         /* ask firmware_class module to get the boot firmware off disk */
3195         rc = request_firmware(fw, name, &priv->pci_dev->dev);
3196         if (rc < 0) {
3197                 IPW_ERROR("%s load failed: Reason %d\n", name, rc);
3198                 return rc;
3199         }
3200
3201         header = (struct fw_header *)(*fw)->data;
3202         if (IPW_FW_MAJOR(le32_to_cpu(header->version)) != IPW_FW_MAJOR_VERSION) {
3203                 IPW_ERROR("'%s' firmware version not compatible (%d != %d)\n",
3204                           name,
3205                           IPW_FW_MAJOR(le32_to_cpu(header->version)),
3206                           IPW_FW_MAJOR_VERSION);
3207                 return -EINVAL;
3208         }
3209
3210         IPW_DEBUG_INFO("Loading firmware '%s' file v%d.%d (%zd bytes)\n",
3211                        name,
3212                        IPW_FW_MAJOR(le32_to_cpu(header->version)),
3213                        IPW_FW_MINOR(le32_to_cpu(header->version)),
3214                        (*fw)->size - sizeof(struct fw_header));
3215         return 0;
3216 }
3217
3218 #define IPW_RX_BUF_SIZE (3000)
3219
3220 static void ipw_rx_queue_reset(struct ipw_priv *priv,
3221                                       struct ipw_rx_queue *rxq)
3222 {
3223         unsigned long flags;
3224         int i;
3225
3226         spin_lock_irqsave(&rxq->lock, flags);
3227
3228         INIT_LIST_HEAD(&rxq->rx_free);
3229         INIT_LIST_HEAD(&rxq->rx_used);
3230
3231         /* Fill the rx_used queue with _all_ of the Rx buffers */
3232         for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3233                 /* In the reset function, these buffers may have been allocated
3234                  * to an SKB, so we need to unmap and free potential storage */
3235                 if (rxq->pool[i].skb != NULL) {
3236                         pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
3237                                          IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
3238                         dev_kfree_skb(rxq->pool[i].skb);
3239                         rxq->pool[i].skb = NULL;
3240                 }
3241                 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3242         }
3243
3244         /* Set us so that we have processed and used all buffers, but have
3245          * not restocked the Rx queue with fresh buffers */
3246         rxq->read = rxq->write = 0;
3247         rxq->processed = RX_QUEUE_SIZE - 1;
3248         rxq->free_count = 0;
3249         spin_unlock_irqrestore(&rxq->lock, flags);
3250 }
3251
3252 #ifdef CONFIG_PM
3253 static int fw_loaded = 0;
3254 static const struct firmware *bootfw = NULL;
3255 static const struct firmware *firmware = NULL;
3256 static const struct firmware *ucode = NULL;
3257
3258 static void free_firmware(void)
3259 {
3260         if (fw_loaded) {
3261                 release_firmware(bootfw);
3262                 release_firmware(ucode);
3263                 release_firmware(firmware);
3264                 bootfw = ucode = firmware = NULL;
3265                 fw_loaded = 0;
3266         }
3267 }
3268 #else
3269 #define free_firmware() do {} while (0)
3270 #endif
3271
3272 static int ipw_load(struct ipw_priv *priv)
3273 {
3274 #ifndef CONFIG_PM
3275         const struct firmware *bootfw = NULL;
3276         const struct firmware *firmware = NULL;
3277         const struct firmware *ucode = NULL;
3278 #endif
3279         int rc = 0, retries = 3;
3280
3281 #ifdef CONFIG_PM
3282         if (!fw_loaded) {
3283 #endif
3284                 rc = ipw_get_fw(priv, &bootfw, IPW_FW_NAME("boot"));
3285                 if (rc)
3286                         goto error;
3287
3288                 switch (priv->ieee->iw_mode) {
3289                 case IW_MODE_ADHOC:
3290                         rc = ipw_get_fw(priv, &ucode,
3291                                         IPW_FW_NAME("ibss_ucode"));
3292                         if (rc)
3293                                 goto error;
3294
3295                         rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("ibss"));
3296                         break;
3297
3298 #ifdef CONFIG_IPW2200_MONITOR
3299                 case IW_MODE_MONITOR:
3300                         rc = ipw_get_fw(priv, &ucode,
3301                                         IPW_FW_NAME("sniffer_ucode"));
3302                         if (rc)
3303                                 goto error;
3304
3305                         rc = ipw_get_fw(priv, &firmware,
3306                                         IPW_FW_NAME("sniffer"));
3307                         break;
3308 #endif
3309                 case IW_MODE_INFRA:
3310                         rc = ipw_get_fw(priv, &ucode, IPW_FW_NAME("bss_ucode"));
3311                         if (rc)
3312                                 goto error;
3313
3314                         rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("bss"));
3315                         break;
3316
3317                 default:
3318                         rc = -EINVAL;
3319                 }
3320
3321                 if (rc)
3322                         goto error;
3323
3324 #ifdef CONFIG_PM
3325                 fw_loaded = 1;
3326         }
3327 #endif
3328
3329         if (!priv->rxq)
3330                 priv->rxq = ipw_rx_queue_alloc(priv);
3331         else
3332                 ipw_rx_queue_reset(priv, priv->rxq);
3333         if (!priv->rxq) {
3334                 IPW_ERROR("Unable to initialize Rx queue\n");
3335                 goto error;
3336         }
3337
3338       retry:
3339         /* Ensure interrupts are disabled */
3340         ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3341         priv->status &= ~STATUS_INT_ENABLED;
3342
3343         /* ack pending interrupts */
3344         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3345
3346         ipw_stop_nic(priv);
3347
3348         rc = ipw_reset_nic(priv);
3349         if (rc) {
3350                 IPW_ERROR("Unable to reset NIC\n");
3351                 goto error;
3352         }
3353
3354         ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3355                         IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
3356
3357         /* DMA the initial boot firmware into the device */
3358         rc = ipw_load_firmware(priv, bootfw->data + sizeof(struct fw_header),
3359                                bootfw->size - sizeof(struct fw_header));
3360         if (rc < 0) {
3361                 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
3362                 goto error;
3363         }
3364
3365         /* kick start the device */
3366         ipw_start_nic(priv);
3367
3368         /* wait for the device to finish its initial startup sequence */
3369         rc = ipw_poll_bit(priv, IPW_INTA_RW,
3370                           IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3371         if (rc < 0) {
3372                 IPW_ERROR("device failed to boot initial fw image\n");
3373                 goto error;
3374         }
3375         IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3376
3377         /* ack fw init done interrupt */
3378         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3379
3380         /* DMA the ucode into the device */
3381         rc = ipw_load_ucode(priv, ucode->data + sizeof(struct fw_header),
3382                             ucode->size - sizeof(struct fw_header));
3383         if (rc < 0) {
3384                 IPW_ERROR("Unable to load ucode: %d\n", rc);
3385                 goto error;
3386         }
3387
3388         /* stop nic */
3389         ipw_stop_nic(priv);
3390
3391         /* DMA bss firmware into the device */
3392         rc = ipw_load_firmware(priv, firmware->data +
3393                                sizeof(struct fw_header),
3394                                firmware->size - sizeof(struct fw_header));
3395         if (rc < 0) {
3396                 IPW_ERROR("Unable to load firmware: %d\n", rc);
3397                 goto error;
3398         }
3399
3400         ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3401
3402         rc = ipw_queue_reset(priv);
3403         if (rc) {
3404                 IPW_ERROR("Unable to initialize queues\n");
3405                 goto error;
3406         }
3407
3408         /* Ensure interrupts are disabled */
3409         ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3410         /* ack pending interrupts */
3411         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3412
3413         /* kick start the device */
3414         ipw_start_nic(priv);
3415
3416         if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
3417                 if (retries > 0) {
3418                         IPW_WARNING("Parity error.  Retrying init.\n");
3419                         retries--;
3420                         goto retry;
3421                 }
3422
3423                 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3424                 rc = -EIO;
3425                 goto error;
3426         }
3427
3428         /* wait for the device */
3429         rc = ipw_poll_bit(priv, IPW_INTA_RW,
3430                           IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3431         if (rc < 0) {
3432                 IPW_ERROR("device failed to start within 500ms\n");
3433                 goto error;
3434         }
3435         IPW_DEBUG_INFO("device response after %dms\n", rc);
3436
3437         /* ack fw init done interrupt */
3438         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3439
3440         /* read eeprom data and initialize the eeprom region of sram */
3441         priv->eeprom_delay = 1;
3442         ipw_eeprom_init_sram(priv);
3443
3444         /* enable interrupts */
3445         ipw_enable_interrupts(priv);
3446
3447         /* Ensure our queue has valid packets */
3448         ipw_rx_queue_replenish(priv);
3449
3450         ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
3451
3452         /* ack pending interrupts */
3453         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3454
3455 #ifndef CONFIG_PM
3456         release_firmware(bootfw);
3457         release_firmware(ucode);
3458         release_firmware(firmware);
3459 #endif
3460         return 0;
3461
3462       error:
3463         if (priv->rxq) {
3464                 ipw_rx_queue_free(priv, priv->rxq);
3465                 priv->rxq = NULL;
3466         }
3467         ipw_tx_queue_free(priv);
3468         if (bootfw)
3469                 release_firmware(bootfw);
3470         if (ucode)
3471                 release_firmware(ucode);
3472         if (firmware)
3473                 release_firmware(firmware);
3474 #ifdef CONFIG_PM
3475         fw_loaded = 0;
3476         bootfw = ucode = firmware = NULL;
3477 #endif
3478
3479         return rc;
3480 }
3481
3482 /**
3483  * DMA services
3484  *
3485  * Theory of operation
3486  *
3487  * A queue is a circular buffers with 'Read' and 'Write' pointers.
3488  * 2 empty entries always kept in the buffer to protect from overflow.
3489  *
3490  * For Tx queue, there are low mark and high mark limits. If, after queuing
3491  * the packet for Tx, free space become < low mark, Tx queue stopped. When
3492  * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
3493  * Tx queue resumed.
3494  *
3495  * The IPW operates with six queues, one receive queue in the device's
3496  * sram, one transmit queue for sending commands to the device firmware,
3497  * and four transmit queues for data.
3498  *
3499  * The four transmit queues allow for performing quality of service (qos)
3500  * transmissions as per the 802.11 protocol.  Currently Linux does not
3501  * provide a mechanism to the user for utilizing prioritized queues, so
3502  * we only utilize the first data transmit queue (queue1).
3503  */
3504
3505 /**
3506  * Driver allocates buffers of this size for Rx
3507  */
3508
3509 static inline int ipw_queue_space(const struct clx2_queue *q)
3510 {
3511         int s = q->last_used - q->first_empty;
3512         if (s <= 0)
3513                 s += q->n_bd;
3514         s -= 2;                 /* keep some reserve to not confuse empty and full situations */
3515         if (s < 0)
3516                 s = 0;
3517         return s;
3518 }
3519
3520 static inline int ipw_queue_inc_wrap(int index, int n_bd)
3521 {
3522         return (++index == n_bd) ? 0 : index;
3523 }
3524
3525 /**
3526  * Initialize common DMA queue structure
3527  *
3528  * @param q                queue to init
3529  * @param count            Number of BD's to allocate. Should be power of 2
3530  * @param read_register    Address for 'read' register
3531  *                         (not offset within BAR, full address)
3532  * @param write_register   Address for 'write' register
3533  *                         (not offset within BAR, full address)
3534  * @param base_register    Address for 'base' register
3535  *                         (not offset within BAR, full address)
3536  * @param size             Address for 'size' register
3537  *                         (not offset within BAR, full address)
3538  */
3539 static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
3540                            int count, u32 read, u32 write, u32 base, u32 size)
3541 {
3542         q->n_bd = count;
3543
3544         q->low_mark = q->n_bd / 4;
3545         if (q->low_mark < 4)
3546                 q->low_mark = 4;
3547
3548         q->high_mark = q->n_bd / 8;
3549         if (q->high_mark < 2)
3550                 q->high_mark = 2;
3551
3552         q->first_empty = q->last_used = 0;
3553         q->reg_r = read;
3554         q->reg_w = write;
3555
3556         ipw_write32(priv, base, q->dma_addr);
3557         ipw_write32(priv, size, count);
3558         ipw_write32(priv, read, 0);
3559         ipw_write32(priv, write, 0);
3560
3561         _ipw_read32(priv, 0x90);
3562 }
3563
3564 static int ipw_queue_tx_init(struct ipw_priv *priv,
3565                              struct clx2_tx_queue *q,
3566                              int count, u32 read, u32 write, u32 base, u32 size)
3567 {
3568         struct pci_dev *dev = priv->pci_dev;
3569
3570         q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL);
3571         if (!q->txb) {
3572                 IPW_ERROR("vmalloc for auxilary BD structures failed\n");
3573                 return -ENOMEM;
3574         }
3575
3576         q->bd =
3577             pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
3578         if (!q->bd) {
3579                 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
3580                           sizeof(q->bd[0]) * count);
3581                 kfree(q->txb);
3582                 q->txb = NULL;
3583                 return -ENOMEM;
3584         }
3585
3586         ipw_queue_init(priv, &q->q, count, read, write, base, size);
3587         return 0;
3588 }
3589
3590 /**
3591  * Free one TFD, those at index [txq->q.last_used].
3592  * Do NOT advance any indexes
3593  *
3594  * @param dev
3595  * @param txq
3596  */
3597 static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3598                                   struct clx2_tx_queue *txq)
3599 {
3600         struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3601         struct pci_dev *dev = priv->pci_dev;
3602         int i;
3603
3604         /* classify bd */
3605         if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3606                 /* nothing to cleanup after for host commands */
3607                 return;
3608
3609         /* sanity check */
3610         if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3611                 IPW_ERROR("Too many chunks: %i\n",
3612                           le32_to_cpu(bd->u.data.num_chunks));
3613                 /** @todo issue fatal error, it is quite serious situation */
3614                 return;
3615         }
3616
3617         /* unmap chunks if any */
3618         for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3619                 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
3620                                  le16_to_cpu(bd->u.data.chunk_len[i]),
3621                                  PCI_DMA_TODEVICE);
3622                 if (txq->txb[txq->q.last_used]) {
3623                         ieee80211_txb_free(txq->txb[txq->q.last_used]);
3624                         txq->txb[txq->q.last_used] = NULL;
3625                 }
3626         }
3627 }
3628
3629 /**
3630  * Deallocate DMA queue.
3631  *
3632  * Empty queue by removing and destroying all BD's.
3633  * Free all buffers.
3634  *
3635  * @param dev
3636  * @param q
3637  */
3638 static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
3639 {
3640         struct clx2_queue *q = &txq->q;
3641         struct pci_dev *dev = priv->pci_dev;
3642
3643         if (q->n_bd == 0)
3644                 return;
3645
3646         /* first, empty all BD's */
3647         for (; q->first_empty != q->last_used;
3648              q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3649                 ipw_queue_tx_free_tfd(priv, txq);
3650         }
3651
3652         /* free buffers belonging to queue itself */
3653         pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
3654                             q->dma_addr);
3655         kfree(txq->txb);
3656
3657         /* 0 fill whole structure */
3658         memset(txq, 0, sizeof(*txq));
3659 }
3660
3661 /**
3662  * Destroy all DMA queues and structures
3663  *
3664  * @param priv
3665  */
3666 static void ipw_tx_queue_free(struct ipw_priv *priv)
3667 {
3668         /* Tx CMD queue */
3669         ipw_queue_tx_free(priv, &priv->txq_cmd);
3670
3671         /* Tx queues */
3672         ipw_queue_tx_free(priv, &priv->txq[0]);
3673         ipw_queue_tx_free(priv, &priv->txq[1]);
3674         ipw_queue_tx_free(priv, &priv->txq[2]);
3675         ipw_queue_tx_free(priv, &priv->txq[3]);
3676 }
3677
3678 static void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
3679 {
3680         /* First 3 bytes are manufacturer */
3681         bssid[0] = priv->mac_addr[0];
3682         bssid[1] = priv->mac_addr[1];
3683         bssid[2] = priv->mac_addr[2];
3684
3685         /* Last bytes are random */
3686         get_random_bytes(&bssid[3], ETH_ALEN - 3);
3687
3688         bssid[0] &= 0xfe;       /* clear multicast bit */
3689         bssid[0] |= 0x02;       /* set local assignment bit (IEEE802) */
3690 }
3691
3692 static u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
3693 {
3694         struct ipw_station_entry entry;
3695         int i;
3696
3697         for (i = 0; i < priv->num_stations; i++) {
3698                 if (!memcmp(priv->stations[i], bssid, ETH_ALEN)) {
3699                         /* Another node is active in network */
3700                         priv->missed_adhoc_beacons = 0;
3701                         if (!(priv->config & CFG_STATIC_CHANNEL))
3702                                 /* when other nodes drop out, we drop out */
3703                                 priv->config &= ~CFG_ADHOC_PERSIST;
3704
3705                         return i;
3706                 }
3707         }
3708
3709         if (i == MAX_STATIONS)
3710                 return IPW_INVALID_STATION;
3711
3712         IPW_DEBUG_SCAN("Adding AdHoc station: " MAC_FMT "\n", MAC_ARG(bssid));
3713
3714         entry.reserved = 0;
3715         entry.support_mode = 0;
3716         memcpy(entry.mac_addr, bssid, ETH_ALEN);
3717         memcpy(priv->stations[i], bssid, ETH_ALEN);
3718         ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
3719                          &entry, sizeof(entry));
3720         priv->num_stations++;
3721
3722         return i;
3723 }
3724
3725 static u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
3726 {
3727         int i;
3728
3729         for (i = 0; i < priv->num_stations; i++)
3730                 if (!memcmp(priv->stations[i], bssid, ETH_ALEN))
3731                         return i;
3732
3733         return IPW_INVALID_STATION;
3734 }
3735
3736 static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3737 {
3738         int err;
3739
3740         if (priv->status & STATUS_ASSOCIATING) {
3741                 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
3742                 queue_work(priv->workqueue, &priv->disassociate);
3743                 return;
3744         }
3745
3746         if (!(priv->status & STATUS_ASSOCIATED)) {
3747                 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3748                 return;
3749         }
3750
3751         IPW_DEBUG_ASSOC("Disassocation attempt from " MAC_FMT " "
3752                         "on channel %d.\n",
3753                         MAC_ARG(priv->assoc_request.bssid),
3754                         priv->assoc_request.channel);
3755
3756         priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3757         priv->status |= STATUS_DISASSOCIATING;
3758
3759         if (quiet)
3760                 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3761         else
3762                 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
3763
3764         err = ipw_send_associate(priv, &priv->assoc_request);
3765         if (err) {
3766                 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3767                              "failed.\n");
3768                 return;
3769         }
3770
3771 }
3772
3773 static int ipw_disassociate(void *data)
3774 {
3775         struct ipw_priv *priv = data;
3776         if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3777                 return 0;
3778         ipw_send_disassociate(data, 0);
3779         return 1;
3780 }
3781
3782 static void ipw_bg_disassociate(void *data)
3783 {
3784         struct ipw_priv *priv = data;
3785         down(&priv->sem);
3786         ipw_disassociate(data);
3787         up(&priv->sem);
3788 }
3789
3790 static void ipw_system_config(void *data)
3791 {
3792         struct ipw_priv *priv = data;
3793         ipw_send_system_config(priv, &priv->sys_config);
3794 }
3795
3796 struct ipw_status_code {
3797         u16 status;
3798         const char *reason;
3799 };
3800
3801 static const struct ipw_status_code ipw_status_codes[] = {
3802         {0x00, "Successful"},
3803         {0x01, "Unspecified failure"},
3804         {0x0A, "Cannot support all requested capabilities in the "
3805          "Capability information field"},
3806         {0x0B, "Reassociation denied due to inability to confirm that "
3807          "association exists"},
3808         {0x0C, "Association denied due to reason outside the scope of this "
3809          "standard"},
3810         {0x0D,
3811          "Responding station does not support the specified authentication "
3812          "algorithm"},
3813         {0x0E,
3814          "Received an Authentication frame with authentication sequence "
3815          "transaction sequence number out of expected sequence"},
3816         {0x0F, "Authentication rejected because of challenge failure"},
3817         {0x10, "Authentication rejected due to timeout waiting for next "
3818          "frame in sequence"},
3819         {0x11, "Association denied because AP is unable to handle additional "
3820          "associated stations"},
3821         {0x12,
3822          "Association denied due to requesting station not supporting all "
3823          "of the datarates in the BSSBasicServiceSet Parameter"},
3824         {0x13,
3825          "Association denied due to requesting station not supporting "
3826          "short preamble operation"},
3827         {0x14,
3828          "Association denied due to requesting station not supporting "
3829          "PBCC encoding"},
3830         {0x15,
3831          "Association denied due to requesting station not supporting "
3832          "channel agility"},
3833         {0x19,
3834          "Association denied due to requesting station not supporting "
3835          "short slot operation"},
3836         {0x1A,
3837          "Association denied due to requesting station not supporting "
3838          "DSSS-OFDM operation"},
3839         {0x28, "Invalid Information Element"},
3840         {0x29, "Group Cipher is not valid"},
3841         {0x2A, "Pairwise Cipher is not valid"},
3842         {0x2B, "AKMP is not valid"},
3843         {0x2C, "Unsupported RSN IE version"},
3844         {0x2D, "Invalid RSN IE Capabilities"},
3845         {0x2E, "Cipher suite is rejected per security policy"},
3846 };
3847
3848 #ifdef CONFIG_IPW2200_DEBUG
3849 static const char *ipw_get_status_code(u16 status)
3850 {
3851         int i;
3852         for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
3853                 if (ipw_status_codes[i].status == (status & 0xff))
3854                         return ipw_status_codes[i].reason;
3855         return "Unknown status value.";
3856 }
3857 #endif
3858
3859 static void inline average_init(struct average *avg)
3860 {
3861         memset(avg, 0, sizeof(*avg));
3862 }
3863
3864 static void average_add(struct average *avg, s16 val)
3865 {
3866         avg->sum -= avg->entries[avg->pos];
3867         avg->sum += val;
3868         avg->entries[avg->pos++] = val;
3869         if (unlikely(avg->pos == AVG_ENTRIES)) {
3870                 avg->init = 1;
3871                 avg->pos = 0;
3872         }
3873 }
3874
3875 static s16 average_value(struct average *avg)
3876 {
3877         if (!unlikely(avg->init)) {
3878                 if (avg->pos)
3879                         return avg->sum / avg->pos;
3880                 return 0;
3881         }
3882
3883         return avg->sum / AVG_ENTRIES;
3884 }
3885
3886 static void ipw_reset_stats(struct ipw_priv *priv)
3887 {
3888         u32 len = sizeof(u32);
3889
3890         priv->quality = 0;
3891
3892         average_init(&priv->average_missed_beacons);
3893         average_init(&priv->average_rssi);
3894         average_init(&priv->average_noise);
3895
3896         priv->last_rate = 0;
3897         priv->last_missed_beacons = 0;
3898         priv->last_rx_packets = 0;
3899         priv->last_tx_packets = 0;
3900         priv->last_tx_failures = 0;
3901
3902         /* Firmware managed, reset only when NIC is restarted, so we have to
3903          * normalize on the current value */
3904         ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
3905                         &priv->last_rx_err, &len);
3906         ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
3907                         &priv->last_tx_failures, &len);
3908
3909         /* Driver managed, reset with each association */
3910         priv->missed_adhoc_beacons = 0;
3911         priv->missed_beacons = 0;
3912         priv->tx_packets = 0;
3913         priv->rx_packets = 0;
3914
3915 }
3916
3917 static u32 ipw_get_max_rate(struct ipw_priv *priv)
3918 {
3919         u32 i = 0x80000000;
3920         u32 mask = priv->rates_mask;
3921         /* If currently associated in B mode, restrict the maximum
3922          * rate match to B rates */
3923         if (priv->assoc_request.ieee_mode == IPW_B_MODE)
3924                 mask &= IEEE80211_CCK_RATES_MASK;
3925
3926         /* TODO: Verify that the rate is supported by the current rates
3927          * list. */
3928
3929         while (i && !(mask & i))
3930                 i >>= 1;
3931         switch (i) {
3932         case IEEE80211_CCK_RATE_1MB_MASK:
3933                 return 1000000;
3934         case IEEE80211_CCK_RATE_2MB_MASK:
3935                 return 2000000;
3936         case IEEE80211_CCK_RATE_5MB_MASK:
3937                 return 5500000;
3938         case IEEE80211_OFDM_RATE_6MB_MASK:
3939                 return 6000000;
3940         case IEEE80211_OFDM_RATE_9MB_MASK:
3941                 return 9000000;
3942         case IEEE80211_CCK_RATE_11MB_MASK:
3943                 return 11000000;
3944         case IEEE80211_OFDM_RATE_12MB_MASK:
3945                 return 12000000;
3946         case IEEE80211_OFDM_RATE_18MB_MASK:
3947                 return 18000000;
3948         case IEEE80211_OFDM_RATE_24MB_MASK:
3949                 return 24000000;
3950         case IEEE80211_OFDM_RATE_36MB_MASK:
3951                 return 36000000;
3952         case IEEE80211_OFDM_RATE_48MB_MASK:
3953                 return 48000000;
3954         case IEEE80211_OFDM_RATE_54MB_MASK:
3955                 return 54000000;
3956         }
3957
3958         if (priv->ieee->mode == IEEE_B)
3959                 return 11000000;
3960         else
3961                 return 54000000;
3962 }
3963
3964 static u32 ipw_get_current_rate(struct ipw_priv *priv)
3965 {
3966         u32 rate, len = sizeof(rate);
3967         int err;
3968
3969         if (!(priv->status & STATUS_ASSOCIATED))
3970                 return 0;
3971
3972         if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
3973                 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
3974                                       &len);
3975                 if (err) {
3976                         IPW_DEBUG_INFO("failed querying ordinals.\n");
3977                         return 0;
3978                 }
3979         } else
3980                 return ipw_get_max_rate(priv);
3981
3982         switch (rate) {
3983         case IPW_TX_RATE_1MB:
3984                 return 1000000;
3985         case IPW_TX_RATE_2MB:
3986                 return 2000000;
3987         case IPW_TX_RATE_5MB:
3988                 return 5500000;
3989         case IPW_TX_RATE_6MB:
3990                 return 6000000;
3991         case IPW_TX_RATE_9MB:
3992                 return 9000000;
3993         case IPW_TX_RATE_11MB:
3994                 return 11000000;
3995         case IPW_TX_RATE_12MB:
3996                 return 12000000;
3997         case IPW_TX_RATE_18MB:
3998                 return 18000000;
3999         case IPW_TX_RATE_24MB:
4000                 return 24000000;
4001         case IPW_TX_RATE_36MB:
4002                 return 36000000;
4003         case IPW_TX_RATE_48MB:
4004                 return 48000000;
4005         case IPW_TX_RATE_54MB:
4006                 return 54000000;
4007         }
4008
4009         return 0;
4010 }
4011
4012 #define IPW_STATS_INTERVAL (2 * HZ)
4013 static void ipw_gather_stats(struct ipw_priv *priv)
4014 {
4015         u32 rx_err, rx_err_delta, rx_packets_delta;
4016         u32 tx_failures, tx_failures_delta, tx_packets_delta;
4017         u32 missed_beacons_percent, missed_beacons_delta;
4018         u32 quality = 0;
4019         u32 len = sizeof(u32);
4020         s16 rssi;
4021         u32 beacon_quality, signal_quality, tx_quality, rx_quality,
4022             rate_quality;
4023         u32 max_rate;
4024
4025         if (!(priv->status & STATUS_ASSOCIATED)) {
4026                 priv->quality = 0;
4027                 return;
4028         }
4029
4030         /* Update the statistics */
4031         ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
4032                         &priv->missed_beacons, &len);
4033         missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
4034         priv->last_missed_beacons = priv->missed_beacons;
4035         if (priv->assoc_request.beacon_interval) {
4036                 missed_beacons_percent = missed_beacons_delta *
4037                     (HZ * priv->assoc_request.beacon_interval) /
4038                     (IPW_STATS_INTERVAL * 10);
4039         } else {
4040                 missed_beacons_percent = 0;
4041         }
4042         average_add(&priv->average_missed_beacons, missed_beacons_percent);
4043
4044         ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
4045         rx_err_delta = rx_err - priv->last_rx_err;
4046         priv->last_rx_err = rx_err;
4047
4048         ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
4049         tx_failures_delta = tx_failures - priv->last_tx_failures;
4050         priv->last_tx_failures = tx_failures;
4051
4052         rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
4053         priv->last_rx_packets = priv->rx_packets;
4054
4055         tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
4056         priv->last_tx_packets = priv->tx_packets;
4057
4058         /* Calculate quality based on the following:
4059          *
4060          * Missed beacon: 100% = 0, 0% = 70% missed
4061          * Rate: 60% = 1Mbs, 100% = Max
4062          * Rx and Tx errors represent a straight % of total Rx/Tx
4063          * RSSI: 100% = > -50,  0% = < -80
4064          * Rx errors: 100% = 0, 0% = 50% missed
4065          *
4066          * The lowest computed quality is used.
4067          *
4068          */
4069 #define BEACON_THRESHOLD 5
4070         beacon_quality = 100 - missed_beacons_percent;
4071         if (beacon_quality < BEACON_THRESHOLD)
4072                 beacon_quality = 0;
4073         else
4074                 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
4075                     (100 - BEACON_THRESHOLD);
4076         IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
4077                         beacon_quality, missed_beacons_percent);
4078
4079         priv->last_rate = ipw_get_current_rate(priv);
4080         max_rate = ipw_get_max_rate(priv);
4081         rate_quality = priv->last_rate * 40 / max_rate + 60;
4082         IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4083                         rate_quality, priv->last_rate / 1000000);
4084
4085         if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
4086                 rx_quality = 100 - (rx_err_delta * 100) /
4087                     (rx_packets_delta + rx_err_delta);
4088         else
4089                 rx_quality = 100;
4090         IPW_DEBUG_STATS("Rx quality   : %3d%% (%u errors, %u packets)\n",
4091                         rx_quality, rx_err_delta, rx_packets_delta);
4092
4093         if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
4094                 tx_quality = 100 - (tx_failures_delta * 100) /
4095                     (tx_packets_delta + tx_failures_delta);
4096         else
4097                 tx_quality = 100;
4098         IPW_DEBUG_STATS("Tx quality   : %3d%% (%u errors, %u packets)\n",
4099                         tx_quality, tx_failures_delta, tx_packets_delta);
4100
4101         rssi = average_value(&priv->average_rssi);
4102         signal_quality =
4103             (100 *
4104              (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4105              (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4106              (priv->ieee->perfect_rssi - rssi) *
4107              (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4108               62 * (priv->ieee->perfect_rssi - rssi))) /
4109             ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4110              (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4111         if (signal_quality > 100)
4112                 signal_quality = 100;
4113         else if (signal_quality < 1)
4114                 signal_quality = 0;
4115
4116         IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
4117                         signal_quality, rssi);
4118
4119         quality = min(beacon_quality,
4120                       min(rate_quality,
4121                           min(tx_quality, min(rx_quality, signal_quality))));
4122         if (quality == beacon_quality)
4123                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4124                                 quality);
4125         if (quality == rate_quality)
4126                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4127                                 quality);
4128         if (quality == tx_quality)
4129                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4130                                 quality);
4131         if (quality == rx_quality)
4132                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4133                                 quality);
4134         if (quality == signal_quality)
4135                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4136                                 quality);
4137
4138         priv->quality = quality;
4139
4140         queue_delayed_work(priv->workqueue, &priv->gather_stats,
4141                            IPW_STATS_INTERVAL);
4142 }
4143
4144 static void ipw_bg_gather_stats(void *data)
4145 {
4146         struct ipw_priv *priv = data;
4147         down(&priv->sem);
4148         ipw_gather_stats(data);
4149         up(&priv->sem);
4150 }
4151
4152 /* Missed beacon behavior:
4153  * 1st missed -> roaming_threshold, just wait, don't do any scan/roam.
4154  * roaming_threshold -> disassociate_threshold, scan and roam for better signal.
4155  * Above disassociate threshold, give up and stop scanning.
4156  * Roaming is disabled if disassociate_threshold <= roaming_threshold  */
4157 static void ipw_handle_missed_beacon(struct ipw_priv *priv,
4158                                             int missed_count)
4159 {
4160         priv->notif_missed_beacons = missed_count;
4161
4162         if (missed_count > priv->disassociate_threshold &&
4163             priv->status & STATUS_ASSOCIATED) {
4164                 /* If associated and we've hit the missed
4165                  * beacon threshold, disassociate, turn
4166                  * off roaming, and abort any active scans */
4167                 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4168                           IPW_DL_STATE | IPW_DL_ASSOC,
4169                           "Missed beacon: %d - disassociate\n", missed_count);
4170                 priv->status &= ~STATUS_ROAMING;
4171                 if (priv->status & STATUS_SCANNING) {
4172                         IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4173                                   IPW_DL_STATE,
4174                                   "Aborting scan with missed beacon.\n");
4175                         queue_work(priv->workqueue, &priv->abort_scan);
4176                 }
4177
4178                 queue_work(priv->workqueue, &priv->disassociate);
4179                 return;
4180         }
4181
4182         if (priv->status & STATUS_ROAMING) {
4183                 /* If we are currently roaming, then just
4184                  * print a debug statement... */
4185                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4186                           "Missed beacon: %d - roam in progress\n",
4187                           missed_count);
4188                 return;
4189         }
4190
4191         if (roaming &&
4192             (missed_count > priv->roaming_threshold &&
4193              missed_count <= priv->disassociate_threshold)) {
4194                 /* If we are not already roaming, set the ROAM
4195                  * bit in the status and kick off a scan.
4196                  * This can happen several times before we reach
4197                  * disassociate_threshold. */
4198                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4199                           "Missed beacon: %d - initiate "
4200                           "roaming\n", missed_count);
4201                 if (!(priv->status & STATUS_ROAMING)) {
4202                         priv->status |= STATUS_ROAMING;
4203                         if (!(priv->status & STATUS_SCANNING))
4204                                 queue_work(priv->workqueue,
4205                                            &priv->request_scan);
4206                 }
4207                 return;
4208         }
4209
4210         if (priv->status & STATUS_SCANNING) {
4211                 /* Stop scan to keep fw from getting
4212                  * stuck (only if we aren't roaming --
4213                  * otherwise we'll never scan more than 2 or 3
4214                  * channels..) */
4215                 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4216                           "Aborting scan with missed beacon.\n");
4217                 queue_work(priv->workqueue, &priv->abort_scan);
4218         }
4219
4220         IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
4221 }
4222
4223 /**
4224  * Handle host notification packet.
4225  * Called from interrupt routine
4226  */
4227 static void ipw_rx_notification(struct ipw_priv *priv,
4228                                        struct ipw_rx_notification *notif)
4229 {
4230         notif->size = le16_to_cpu(notif->size);
4231
4232         IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size);
4233
4234         switch (notif->subtype) {
4235         case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4236                         struct notif_association *assoc = &notif->u.assoc;
4237
4238                         switch (assoc->state) {
4239                         case CMAS_ASSOCIATED:{
4240                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4241                                                   IPW_DL_ASSOC,
4242                                                   "associated: '%s' " MAC_FMT
4243                                                   " \n",
4244                                                   escape_essid(priv->essid,
4245                                                                priv->essid_len),
4246                                                   MAC_ARG(priv->bssid));
4247
4248                                         switch (priv->ieee->iw_mode) {
4249                                         case IW_MODE_INFRA:
4250                                                 memcpy(priv->ieee->bssid,
4251                                                        priv->bssid, ETH_ALEN);
4252                                                 break;
4253
4254                                         case IW_MODE_ADHOC:
4255                                                 memcpy(priv->ieee->bssid,
4256                                                        priv->bssid, ETH_ALEN);
4257
4258                                                 /* clear out the station table */
4259                                                 priv->num_stations = 0;
4260
4261                                                 IPW_DEBUG_ASSOC
4262                                                     ("queueing adhoc check\n");
4263                                                 queue_delayed_work(priv->
4264                                                                    workqueue,
4265                                                                    &priv->
4266                                                                    adhoc_check,
4267                                                                    priv->
4268                                                                    assoc_request.
4269                                                                    beacon_interval);
4270                                                 break;
4271                                         }
4272
4273                                         priv->status &= ~STATUS_ASSOCIATING;
4274                                         priv->status |= STATUS_ASSOCIATED;
4275                                         queue_work(priv->workqueue,
4276                                                    &priv->system_config);
4277
4278 #ifdef CONFIG_IPW_QOS
4279 #define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
4280                          le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_ctl))
4281                                         if ((priv->status & STATUS_AUTH) &&
4282                                             (IPW_GET_PACKET_STYPE(&notif->u.raw)
4283                                              == IEEE80211_STYPE_ASSOC_RESP)) {
4284                                                 if ((sizeof
4285                                                      (struct
4286                                                       ieee80211_assoc_response)
4287                                                      <= notif->size)
4288                                                     && (notif->size <= 2314)) {
4289                                                         struct
4290                                                         ieee80211_rx_stats
4291                                                             stats = {
4292                                                                 .len =
4293                                                                     notif->
4294                                                                     size - 1,
4295                                                         };
4296
4297                                                         IPW_DEBUG_QOS
4298                                                             ("QoS Associate "
4299                                                              "size %d\n",
4300                                                              notif->size);
4301                                                         ieee80211_rx_mgt(priv->
4302                                                                          ieee,
4303                                                                          (struct
4304                                                                           ieee80211_hdr_4addr
4305                                                                           *)
4306                                                                          &notif->u.raw, &stats);
4307                                                 }
4308                                         }
4309 #endif
4310
4311                                         schedule_work(&priv->link_up);
4312
4313                                         break;
4314                                 }
4315
4316                         case CMAS_AUTHENTICATED:{
4317                                         if (priv->
4318                                             status & (STATUS_ASSOCIATED |
4319                                                       STATUS_AUTH)) {
4320 #ifdef CONFIG_IPW2200_DEBUG
4321                                                 struct notif_authenticate *auth
4322                                                     = &notif->u.auth;
4323                                                 IPW_DEBUG(IPW_DL_NOTIF |
4324                                                           IPW_DL_STATE |
4325                                                           IPW_DL_ASSOC,
4326                                                           "deauthenticated: '%s' "
4327                                                           MAC_FMT
4328                                                           ": (0x%04X) - %s \n",
4329                                                           escape_essid(priv->
4330                                                                        essid,
4331                                                                        priv->
4332                                                                        essid_len),
4333                                                           MAC_ARG(priv->bssid),
4334                                                           ntohs(auth->status),
4335                                                           ipw_get_status_code
4336                                                           (ntohs
4337                                                            (auth->status)));
4338 #endif
4339
4340                                                 priv->status &=
4341                                                     ~(STATUS_ASSOCIATING |
4342                                                       STATUS_AUTH |
4343                                                       STATUS_ASSOCIATED);
4344
4345                                                 schedule_work(&priv->link_down);
4346                                                 break;
4347                                         }
4348
4349                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4350                                                   IPW_DL_ASSOC,
4351                                                   "authenticated: '%s' " MAC_FMT
4352                                                   "\n",
4353                                                   escape_essid(priv->essid,
4354                                                                priv->essid_len),
4355                                                   MAC_ARG(priv->bssid));
4356                                         break;
4357                                 }
4358
4359                         case CMAS_INIT:{
4360                                         if (priv->status & STATUS_AUTH) {
4361                                                 struct
4362                                                     ieee80211_assoc_response
4363                                                 *resp;
4364                                                 resp =
4365                                                     (struct
4366                                                      ieee80211_assoc_response
4367                                                      *)&notif->u.raw;
4368                                                 IPW_DEBUG(IPW_DL_NOTIF |
4369                                                           IPW_DL_STATE |
4370                                                           IPW_DL_ASSOC,
4371                                                           "association failed (0x%04X): %s\n",
4372                                                           ntohs(resp->status),
4373                                                           ipw_get_status_code
4374                                                           (ntohs
4375                                                            (resp->status)));
4376                                         }
4377
4378                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4379                                                   IPW_DL_ASSOC,
4380                                                   "disassociated: '%s' " MAC_FMT
4381                                                   " \n",
4382                                                   escape_essid(priv->essid,
4383                                                                priv->essid_len),
4384                                                   MAC_ARG(priv->bssid));
4385
4386                                         priv->status &=
4387                                             ~(STATUS_DISASSOCIATING |
4388                                               STATUS_ASSOCIATING |
4389                                               STATUS_ASSOCIATED | STATUS_AUTH);
4390                                         if (priv->assoc_network
4391                                             && (priv->assoc_network->
4392                                                 capability &
4393                                                 WLAN_CAPABILITY_IBSS))
4394                                                 ipw_remove_current_network
4395                                                     (priv);
4396
4397                                         schedule_work(&priv->link_down);
4398
4399                                         break;
4400                                 }
4401
4402                         case CMAS_RX_ASSOC_RESP:
4403                                 break;
4404
4405                         default:
4406                                 IPW_ERROR("assoc: unknown (%d)\n",
4407                                           assoc->state);
4408                                 break;
4409                         }
4410
4411                         break;
4412                 }
4413
4414         case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4415                         struct notif_authenticate *auth = &notif->u.auth;
4416                         switch (auth->state) {
4417                         case CMAS_AUTHENTICATED:
4418                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4419                                           "authenticated: '%s' " MAC_FMT " \n",
4420                                           escape_essid(priv->essid,
4421                                                        priv->essid_len),
4422                                           MAC_ARG(priv->bssid));
4423                                 priv->status |= STATUS_AUTH;
4424                                 break;
4425
4426                         case CMAS_INIT:
4427                                 if (priv->status & STATUS_AUTH) {
4428                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4429                                                   IPW_DL_ASSOC,
4430                                                   "authentication failed (0x%04X): %s\n",
4431                                                   ntohs(auth->status),
4432                                                   ipw_get_status_code(ntohs
4433                                                                       (auth->
4434                                                                        status)));
4435                                 }
4436                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4437                                           IPW_DL_ASSOC,
4438                                           "deauthenticated: '%s' " MAC_FMT "\n",
4439                                           escape_essid(priv->essid,
4440                                                        priv->essid_len),
4441                                           MAC_ARG(priv->bssid));
4442
4443                                 priv->status &= ~(STATUS_ASSOCIATING |
4444                                                   STATUS_AUTH |
4445                                                   STATUS_ASSOCIATED);
4446
4447                                 schedule_work(&priv->link_down);
4448                                 break;
4449
4450                         case CMAS_TX_AUTH_SEQ_1:
4451                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4452                                           IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4453                                 break;
4454                         case CMAS_RX_AUTH_SEQ_2:
4455                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4456                                           IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4457                                 break;
4458                         case CMAS_AUTH_SEQ_1_PASS:
4459                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4460                                           IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4461                                 break;
4462                         case CMAS_AUTH_SEQ_1_FAIL:
4463                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4464                                           IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4465                                 break;
4466                         case CMAS_TX_AUTH_SEQ_3:
4467                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4468                                           IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4469                                 break;
4470                         case CMAS_RX_AUTH_SEQ_4:
4471                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4472                                           IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4473                                 break;
4474                         case CMAS_AUTH_SEQ_2_PASS:
4475                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4476                                           IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4477                                 break;
4478                         case CMAS_AUTH_SEQ_2_FAIL:
4479                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4480                                           IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4481                                 break;
4482                         case CMAS_TX_ASSOC:
4483                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4484                                           IPW_DL_ASSOC, "TX_ASSOC\n");
4485                                 break;
4486                         case CMAS_RX_ASSOC_RESP:
4487                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4488                                           IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
4489
4490                                 break;
4491                         case CMAS_ASSOCIATED:
4492                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4493                                           IPW_DL_ASSOC, "ASSOCIATED\n");
4494                                 break;
4495                         default:
4496                                 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4497                                                 auth->state);
4498                                 break;
4499                         }
4500                         break;
4501                 }
4502
4503         case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4504                         struct notif_channel_result *x =
4505                             &notif->u.channel_result;
4506
4507                         if (notif->size == sizeof(*x)) {
4508                                 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4509                                                x->channel_num);
4510                         } else {
4511                                 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4512                                                "(should be %zd)\n",
4513                                                notif->size, sizeof(*x));
4514                         }
4515                         break;
4516                 }
4517
4518         case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4519                         struct notif_scan_complete *x = &notif->u.scan_complete;
4520                         if (notif->size == sizeof(*x)) {
4521                                 IPW_DEBUG_SCAN
4522                                     ("Scan completed: type %d, %d channels, "
4523                                      "%d status\n", x->scan_type,
4524                                      x->num_channels, x->status);
4525                         } else {
4526                                 IPW_ERROR("Scan completed of wrong size %d "
4527                                           "(should be %zd)\n",
4528                                           notif->size, sizeof(*x));
4529                         }
4530
4531                         priv->status &=
4532                             ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4533
4534                         wake_up_interruptible(&priv->wait_state);
4535                         cancel_delayed_work(&priv->scan_check);
4536
4537                         if (priv->status & STATUS_EXIT_PENDING)
4538                                 break;
4539
4540                         priv->ieee->scans++;
4541
4542 #ifdef CONFIG_IPW2200_MONITOR
4543                         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
4544                                 priv->status |= STATUS_SCAN_FORCED;
4545                                 queue_work(priv->workqueue,
4546                                            &priv->request_scan);
4547                                 break;
4548                         }
4549                         priv->status &= ~STATUS_SCAN_FORCED;
4550 #endif                          /* CONFIG_IPW2200_MONITOR */
4551
4552                         if (!(priv->status & (STATUS_ASSOCIATED |
4553                                               STATUS_ASSOCIATING |
4554                                               STATUS_ROAMING |
4555                                               STATUS_DISASSOCIATING)))
4556                                 queue_work(priv->workqueue, &priv->associate);
4557                         else if (priv->status & STATUS_ROAMING) {
4558                                 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4559                                         /* If a scan completed and we are in roam mode, then
4560                                          * the scan that completed was the one requested as a
4561                                          * result of entering roam... so, schedule the
4562                                          * roam work */
4563                                         queue_work(priv->workqueue,
4564                                                    &priv->roam);
4565                                 else
4566                                         /* Don't schedule if we aborted the scan */
4567                                         priv->status &= ~STATUS_ROAMING;
4568                         } else if (priv->status & STATUS_SCAN_PENDING)
4569                                 queue_work(priv->workqueue,
4570                                            &priv->request_scan);
4571                         else if (priv->config & CFG_BACKGROUND_SCAN
4572                                  && priv->status & STATUS_ASSOCIATED)
4573                                 queue_delayed_work(priv->workqueue,
4574                                                    &priv->request_scan, HZ);
4575                         break;
4576                 }
4577
4578         case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4579                         struct notif_frag_length *x = &notif->u.frag_len;
4580
4581                         if (notif->size == sizeof(*x))
4582                                 IPW_ERROR("Frag length: %d\n",
4583                                           le16_to_cpu(x->frag_length));
4584                         else
4585                                 IPW_ERROR("Frag length of wrong size %d "
4586                                           "(should be %zd)\n",
4587                                           notif->size, sizeof(*x));
4588                         break;
4589                 }
4590
4591         case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4592                         struct notif_link_deterioration *x =
4593                             &notif->u.link_deterioration;
4594
4595                         if (notif->size == sizeof(*x)) {
4596                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4597                                           "link deterioration: '%s' " MAC_FMT
4598                                           " \n", escape_essid(priv->essid,
4599                                                               priv->essid_len),
4600                                           MAC_ARG(priv->bssid));
4601                                 memcpy(&priv->last_link_deterioration, x,
4602                                        sizeof(*x));
4603                         } else {
4604                                 IPW_ERROR("Link Deterioration of wrong size %d "
4605                                           "(should be %zd)\n",
4606                                           notif->size, sizeof(*x));
4607                         }
4608                         break;
4609                 }
4610
4611         case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4612                         IPW_ERROR("Dino config\n");
4613                         if (priv->hcmd
4614                             && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
4615                                 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
4616
4617                         break;
4618                 }
4619
4620         case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4621                         struct notif_beacon_state *x = &notif->u.beacon_state;
4622                         if (notif->size != sizeof(*x)) {
4623                                 IPW_ERROR
4624                                     ("Beacon state of wrong size %d (should "
4625                                      "be %zd)\n", notif->size, sizeof(*x));
4626                                 break;
4627                         }
4628
4629                         if (le32_to_cpu(x->state) ==
4630                             HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4631                                 ipw_handle_missed_beacon(priv,
4632                                                          le32_to_cpu(x->
4633                                                                      number));
4634
4635                         break;
4636                 }
4637
4638         case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4639                         struct notif_tgi_tx_key *x = &notif->u.tgi_tx_key;
4640                         if (notif->size == sizeof(*x)) {
4641                                 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4642                                           "0x%02x station %d\n",
4643                                           x->key_state, x->security_type,
4644                                           x->station_index);
4645                                 break;
4646                         }
4647
4648                         IPW_ERROR
4649                             ("TGi Tx Key of wrong size %d (should be %zd)\n",
4650                              notif->size, sizeof(*x));
4651                         break;
4652                 }
4653
4654         case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4655                         struct notif_calibration *x = &notif->u.calibration;
4656
4657                         if (notif->size == sizeof(*x)) {
4658                                 memcpy(&priv->calib, x, sizeof(*x));
4659                                 IPW_DEBUG_INFO("TODO: Calibration\n");
4660                                 break;
4661                         }
4662
4663                         IPW_ERROR
4664                             ("Calibration of wrong size %d (should be %zd)\n",
4665                              notif->size, sizeof(*x));
4666                         break;
4667                 }
4668
4669         case HOST_NOTIFICATION_NOISE_STATS:{
4670                         if (notif->size == sizeof(u32)) {
4671                                 priv->last_noise =
4672                                     (u8) (le32_to_cpu(notif->u.noise.value) &
4673                                           0xff);
4674                                 average_add(&priv->average_noise,
4675                                             priv->last_noise);
4676                                 break;
4677                         }
4678
4679                         IPW_ERROR
4680                             ("Noise stat is wrong size %d (should be %zd)\n",
4681                              notif->size, sizeof(u32));
4682                         break;
4683                 }
4684
4685         default:
4686                 IPW_ERROR("Unknown notification: "
4687                           "subtype=%d,flags=0x%2x,size=%d\n",
4688                           notif->subtype, notif->flags, notif->size);
4689         }
4690 }
4691
4692 /**
4693  * Destroys all DMA structures and initialise them again
4694  *
4695  * @param priv
4696  * @return error code
4697  */
4698 static int ipw_queue_reset(struct ipw_priv *priv)
4699 {
4700         int rc = 0;
4701         /** @todo customize queue sizes */
4702         int nTx = 64, nTxCmd = 8;
4703         ipw_tx_queue_free(priv);
4704         /* Tx CMD queue */
4705         rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
4706                                IPW_TX_CMD_QUEUE_READ_INDEX,
4707                                IPW_TX_CMD_QUEUE_WRITE_INDEX,
4708                                IPW_TX_CMD_QUEUE_BD_BASE,
4709                                IPW_TX_CMD_QUEUE_BD_SIZE);
4710         if (rc) {
4711                 IPW_ERROR("Tx Cmd queue init failed\n");
4712                 goto error;
4713         }
4714         /* Tx queue(s) */
4715         rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
4716                                IPW_TX_QUEUE_0_READ_INDEX,
4717                                IPW_TX_QUEUE_0_WRITE_INDEX,
4718                                IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
4719         if (rc) {
4720                 IPW_ERROR("Tx 0 queue init failed\n");
4721                 goto error;
4722         }
4723         rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
4724                                IPW_TX_QUEUE_1_READ_INDEX,
4725                                IPW_TX_QUEUE_1_WRITE_INDEX,
4726                                IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
4727         if (rc) {
4728                 IPW_ERROR("Tx 1 queue init failed\n");
4729                 goto error;
4730         }
4731         rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
4732                                IPW_TX_QUEUE_2_READ_INDEX,
4733                                IPW_TX_QUEUE_2_WRITE_INDEX,
4734                                IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
4735         if (rc) {
4736                 IPW_ERROR("Tx 2 queue init failed\n");
4737                 goto error;
4738         }
4739         rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
4740                                IPW_TX_QUEUE_3_READ_INDEX,
4741                                IPW_TX_QUEUE_3_WRITE_INDEX,
4742                                IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
4743         if (rc) {
4744                 IPW_ERROR("Tx 3 queue init failed\n");
4745                 goto error;
4746         }
4747         /* statistics */
4748         priv->rx_bufs_min = 0;
4749         priv->rx_pend_max = 0;
4750         return rc;
4751
4752       error:
4753         ipw_tx_queue_free(priv);
4754         return rc;
4755 }
4756
4757 /**
4758  * Reclaim Tx queue entries no more used by NIC.
4759  *
4760  * When FW adwances 'R' index, all entries between old and
4761  * new 'R' index need to be reclaimed. As result, some free space
4762  * forms. If there is enough free space (> low mark), wake Tx queue.
4763  *
4764  * @note Need to protect against garbage in 'R' index
4765  * @param priv
4766  * @param txq
4767  * @param qindex
4768  * @return Number of used entries remains in the queue
4769  */
4770 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
4771                                 struct clx2_tx_queue *txq, int qindex)
4772 {
4773         u32 hw_tail;
4774         int used;
4775         struct clx2_queue *q = &txq->q;
4776
4777         hw_tail = ipw_read32(priv, q->reg_r);
4778         if (hw_tail >= q->n_bd) {
4779                 IPW_ERROR
4780                     ("Read index for DMA queue (%d) is out of range [0-%d)\n",
4781                      hw_tail, q->n_bd);
4782                 goto done;
4783         }
4784         for (; q->last_used != hw_tail;
4785              q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
4786                 ipw_queue_tx_free_tfd(priv, txq);
4787                 priv->tx_packets++;
4788         }
4789       done:
4790         if ((ipw_queue_space(q) > q->low_mark) &&
4791             (qindex >= 0) &&
4792             (priv->status & STATUS_ASSOCIATED) && netif_running(priv->net_dev))
4793                 netif_wake_queue(priv->net_dev);
4794         used = q->first_empty - q->last_used;
4795         if (used < 0)
4796                 used += q->n_bd;
4797
4798         return used;
4799 }
4800
4801 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
4802                              int len, int sync)
4803 {
4804         struct clx2_tx_queue *txq = &priv->txq_cmd;
4805         struct clx2_queue *q = &txq->q;
4806         struct tfd_frame *tfd;
4807
4808         if (ipw_queue_space(q) < (sync ? 1 : 2)) {
4809                 IPW_ERROR("No space for Tx\n");
4810                 return -EBUSY;
4811         }
4812
4813         tfd = &txq->bd[q->first_empty];
4814         txq->txb[q->first_empty] = NULL;
4815
4816         memset(tfd, 0, sizeof(*tfd));
4817         tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
4818         tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
4819         priv->hcmd_seq++;
4820         tfd->u.cmd.index = hcmd;
4821         tfd->u.cmd.length = len;
4822         memcpy(tfd->u.cmd.payload, buf, len);
4823         q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
4824         ipw_write32(priv, q->reg_w, q->first_empty);
4825         _ipw_read32(priv, 0x90);
4826
4827         return 0;
4828 }
4829
4830 /*
4831  * Rx theory of operation
4832  *
4833  * The host allocates 32 DMA target addresses and passes the host address
4834  * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
4835  * 0 to 31
4836  *
4837  * Rx Queue Indexes
4838  * The host/firmware share two index registers for managing the Rx buffers.
4839  *
4840  * The READ index maps to the first position that the firmware may be writing
4841  * to -- the driver can read up to (but not including) this position and get
4842  * good data.
4843  * The READ index is managed by the firmware once the card is enabled.
4844  *
4845  * The WRITE index maps to the last position the driver has read from -- the
4846  * position preceding WRITE is the last slot the firmware can place a packet.
4847  *
4848  * The queue is empty (no good data) if WRITE = READ - 1, and is full if
4849  * WRITE = READ.
4850  *
4851  * During initialization the host sets up the READ queue position to the first
4852  * INDEX position, and WRITE to the last (READ - 1 wrapped)
4853  *
4854  * When the firmware places a packet in a buffer it will advance the READ index
4855  * and fire the RX interrupt.  The driver can then query the READ index and
4856  * process as many packets as possible, moving the WRITE index forward as it
4857  * resets the Rx queue buffers with new memory.
4858  *
4859  * The management in the driver is as follows:
4860  * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free.  When
4861  *   ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
4862  *   to replensish the ipw->rxq->rx_free.
4863  * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
4864  *   ipw->rxq is replenished and the READ INDEX is updated (updating the
4865  *   'processed' and 'read' driver indexes as well)
4866  * + A received packet is processed and handed to the kernel network stack,
4867  *   detached from the ipw->rxq.  The driver 'processed' index is updated.
4868  * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
4869  *   list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
4870  *   INDEX is not incremented and ipw->status(RX_STALLED) is set.  If there
4871  *   were enough free buffers and RX_STALLED is set it is cleared.
4872  *
4873  *
4874  * Driver sequence:
4875  *
4876  * ipw_rx_queue_alloc()       Allocates rx_free
4877  * ipw_rx_queue_replenish()   Replenishes rx_free list from rx_used, and calls
4878  *                            ipw_rx_queue_restock
4879  * ipw_rx_queue_restock()     Moves available buffers from rx_free into Rx
4880  *                            queue, updates firmware pointers, and updates
4881  *                            the WRITE index.  If insufficient rx_free buffers
4882  *                            are available, schedules ipw_rx_queue_replenish
4883  *
4884  * -- enable interrupts --
4885  * ISR - ipw_rx()             Detach ipw_rx_mem_buffers from pool up to the
4886  *                            READ INDEX, detaching the SKB from the pool.
4887  *                            Moves the packet buffer from queue to rx_used.
4888  *                            Calls ipw_rx_queue_restock to refill any empty
4889  *                            slots.
4890  * ...
4891  *
4892  */
4893
4894 /*
4895  * If there are slots in the RX queue that  need to be restocked,
4896  * and we have free pre-allocated buffers, fill the ranks as much
4897  * as we can pulling from rx_free.
4898  *
4899  * This moves the 'write' index forward to catch up with 'processed', and
4900  * also updates the memory address in the firmware to reference the new
4901  * target buffer.
4902  */
4903 static void ipw_rx_queue_restock(struct ipw_priv *priv)
4904 {
4905         struct ipw_rx_queue *rxq = priv->rxq;
4906         struct list_head *element;
4907         struct ipw_rx_mem_buffer *rxb;
4908         unsigned long flags;
4909         int write;
4910
4911         spin_lock_irqsave(&rxq->lock, flags);
4912         write = rxq->write;
4913         while ((rxq->write != rxq->processed) && (rxq->free_count)) {
4914                 element = rxq->rx_free.next;
4915                 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4916                 list_del(element);
4917
4918                 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
4919                             rxb->dma_addr);
4920                 rxq->queue[rxq->write] = rxb;
4921                 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
4922                 rxq->free_count--;
4923         }
4924         spin_unlock_irqrestore(&rxq->lock, flags);
4925
4926         /* If the pre-allocated buffer pool is dropping low, schedule to
4927          * refill it */
4928         if (rxq->free_count <= RX_LOW_WATERMARK)
4929                 queue_work(priv->workqueue, &priv->rx_replenish);
4930
4931         /* If we've added more space for the firmware to place data, tell it */
4932         if (write != rxq->write)
4933                 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
4934 }
4935
4936 /*
4937  * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
4938  * Also restock the Rx queue via ipw_rx_queue_restock.
4939  *
4940  * This is called as a scheduled work item (except for during intialization)
4941  */
4942 static void ipw_rx_queue_replenish(void *data)
4943 {
4944         struct ipw_priv *priv = data;
4945         struct ipw_rx_queue *rxq = priv->rxq;
4946         struct list_head *element;
4947         struct ipw_rx_mem_buffer *rxb;
4948         unsigned long flags;
4949
4950         spin_lock_irqsave(&rxq->lock, flags);
4951         while (!list_empty(&rxq->rx_used)) {
4952                 element = rxq->rx_used.next;
4953                 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4954                 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
4955                 if (!rxb->skb) {
4956                         printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
4957                                priv->net_dev->name);
4958                         /* We don't reschedule replenish work here -- we will
4959                          * call the restock method and if it still needs
4960                          * more buffers it will schedule replenish */
4961                         break;
4962                 }
4963                 list_del(element);
4964
4965                 rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data;
4966                 rxb->dma_addr =
4967                     pci_map_single(priv->pci_dev, rxb->skb->data,
4968                                    IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4969
4970                 list_add_tail(&rxb->list, &rxq->rx_free);
4971                 rxq->free_count++;
4972         }
4973         spin_unlock_irqrestore(&rxq->lock, flags);
4974
4975         ipw_rx_queue_restock(priv);
4976 }
4977
4978 static void ipw_bg_rx_queue_replenish(void *data)
4979 {
4980         struct ipw_priv *priv = data;
4981         down(&priv->sem);
4982         ipw_rx_queue_replenish(data);
4983         up(&priv->sem);
4984 }
4985
4986 /* Assumes that the skb field of the buffers in 'pool' is kept accurate.
4987  * If an SKB has been detached, the POOL needs to have its SKB set to NULL
4988  * This free routine walks the list of POOL entries and if SKB is set to
4989  * non NULL it is unmapped and freed
4990  */
4991 static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
4992 {
4993         int i;
4994
4995         if (!rxq)
4996                 return;
4997
4998         for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
4999                 if (rxq->pool[i].skb != NULL) {
5000                         pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
5001                                          IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
5002                         dev_kfree_skb(rxq->pool[i].skb);
5003                 }
5004         }
5005
5006         kfree(rxq);
5007 }
5008
5009 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
5010 {
5011         struct ipw_rx_queue *rxq;
5012         int i;
5013
5014         rxq = kzalloc(sizeof(*rxq), GFP_KERNEL);
5015         if (unlikely(!rxq)) {
5016                 IPW_ERROR("memory allocation failed\n");
5017                 return NULL;
5018         }
5019         spin_lock_init(&rxq->lock);
5020         INIT_LIST_HEAD(&rxq->rx_free);
5021         INIT_LIST_HEAD(&rxq->rx_used);
5022
5023         /* Fill the rx_used queue with _all_ of the Rx buffers */
5024         for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
5025                 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
5026
5027         /* Set us so that we have processed and used all buffers, but have
5028          * not restocked the Rx queue with fresh buffers */
5029         rxq->read = rxq->write = 0;
5030         rxq->processed = RX_QUEUE_SIZE - 1;
5031         rxq->free_count = 0;
5032
5033         return rxq;
5034 }
5035
5036 static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
5037 {
5038         rate &= ~IEEE80211_BASIC_RATE_MASK;
5039         if (ieee_mode == IEEE_A) {
5040                 switch (rate) {
5041                 case IEEE80211_OFDM_RATE_6MB:
5042                         return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ?
5043                             1 : 0;
5044                 case IEEE80211_OFDM_RATE_9MB:
5045                         return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ?
5046                             1 : 0;
5047                 case IEEE80211_OFDM_RATE_12MB:
5048                         return priv->
5049                             rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
5050                 case IEEE80211_OFDM_RATE_18MB:
5051                         return priv->
5052                             rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
5053                 case IEEE80211_OFDM_RATE_24MB:
5054                         return priv->
5055                             rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
5056                 case IEEE80211_OFDM_RATE_36MB:
5057                         return priv->
5058                             rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
5059                 case IEEE80211_OFDM_RATE_48MB:
5060                         return priv->
5061                             rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
5062                 case IEEE80211_OFDM_RATE_54MB:
5063                         return priv->
5064                             rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5065                 default:
5066                         return 0;
5067                 }
5068         }
5069
5070         /* B and G mixed */
5071         switch (rate) {
5072         case IEEE80211_CCK_RATE_1MB:
5073                 return priv->rates_mask & IEEE80211_CCK_RATE_1MB_MASK ? 1 : 0;
5074         case IEEE80211_CCK_RATE_2MB:
5075                 return priv->rates_mask & IEEE80211_CCK_RATE_2MB_MASK ? 1 : 0;
5076         case IEEE80211_CCK_RATE_5MB:
5077                 return priv->rates_mask & IEEE80211_CCK_RATE_5MB_MASK ? 1 : 0;
5078         case IEEE80211_CCK_RATE_11MB:
5079                 return priv->rates_mask & IEEE80211_CCK_RATE_11MB_MASK ? 1 : 0;
5080         }
5081
5082         /* If we are limited to B modulations, bail at this point */
5083         if (ieee_mode == IEEE_B)
5084                 return 0;
5085
5086         /* G */
5087         switch (rate) {
5088         case IEEE80211_OFDM_RATE_6MB:
5089                 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ? 1 : 0;
5090         case IEEE80211_OFDM_RATE_9MB:
5091                 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ? 1 : 0;
5092         case IEEE80211_OFDM_RATE_12MB:
5093                 return priv->rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
5094         case IEEE80211_OFDM_RATE_18MB:
5095                 return priv->rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
5096         case IEEE80211_OFDM_RATE_24MB:
5097                 return priv->rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
5098         case IEEE80211_OFDM_RATE_36MB:
5099                 return priv->rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
5100         case IEEE80211_OFDM_RATE_48MB:
5101                 return priv->rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
5102         case IEEE80211_OFDM_RATE_54MB:
5103                 return priv->rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5104         }
5105
5106         return 0;
5107 }
5108
5109 static int ipw_compatible_rates(struct ipw_priv *priv,
5110                                 const struct ieee80211_network *network,
5111                                 struct ipw_supported_rates *rates)
5112 {
5113         int num_rates, i;
5114
5115         memset(rates, 0, sizeof(*rates));
5116         num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
5117         rates->num_rates = 0;
5118         for (i = 0; i < num_rates; i++) {
5119                 if (!ipw_is_rate_in_mask(priv, network->mode,
5120                                          network->rates[i])) {
5121
5122                         if (network->rates[i] & IEEE80211_BASIC_RATE_MASK) {
5123                                 IPW_DEBUG_SCAN("Adding masked mandatory "
5124                                                "rate %02X\n",
5125                                                network->rates[i]);
5126                                 rates->supported_rates[rates->num_rates++] =
5127                                     network->rates[i];
5128                                 continue;
5129                         }
5130
5131                         IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5132                                        network->rates[i], priv->rates_mask);
5133                         continue;
5134                 }
5135
5136                 rates->supported_rates[rates->num_rates++] = network->rates[i];
5137         }
5138
5139         num_rates = min(network->rates_ex_len,
5140                         (u8) (IPW_MAX_RATES - num_rates));
5141         for (i = 0; i < num_rates; i++) {
5142                 if (!ipw_is_rate_in_mask(priv, network->mode,
5143                                          network->rates_ex[i])) {
5144                         if (network->rates_ex[i] & IEEE80211_BASIC_RATE_MASK) {
5145                                 IPW_DEBUG_SCAN("Adding masked mandatory "
5146                                                "rate %02X\n",
5147                                                network->rates_ex[i]);
5148                                 rates->supported_rates[rates->num_rates++] =
5149                                     network->rates[i];
5150                                 continue;
5151                         }
5152
5153                         IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5154                                        network->rates_ex[i], priv->rates_mask);
5155                         continue;
5156                 }
5157
5158                 rates->supported_rates[rates->num_rates++] =
5159                     network->rates_ex[i];
5160         }
5161
5162         return 1;
5163 }
5164
5165 static void ipw_copy_rates(struct ipw_supported_rates *dest,
5166                                   const struct ipw_supported_rates *src)
5167 {
5168         u8 i;
5169         for (i = 0; i < src->num_rates; i++)
5170                 dest->supported_rates[i] = src->supported_rates[i];
5171         dest->num_rates = src->num_rates;
5172 }
5173
5174 /* TODO: Look at sniffed packets in the air to determine if the basic rate
5175  * mask should ever be used -- right now all callers to add the scan rates are
5176  * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5177 static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
5178                                    u8 modulation, u32 rate_mask)
5179 {
5180         u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5181             IEEE80211_BASIC_RATE_MASK : 0;
5182
5183         if (rate_mask & IEEE80211_CCK_RATE_1MB_MASK)
5184                 rates->supported_rates[rates->num_rates++] =
5185                     IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
5186
5187         if (rate_mask & IEEE80211_CCK_RATE_2MB_MASK)
5188                 rates->supported_rates[rates->num_rates++] =
5189                     IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
5190
5191         if (rate_mask & IEEE80211_CCK_RATE_5MB_MASK)
5192                 rates->supported_rates[rates->num_rates++] = basic_mask |
5193                     IEEE80211_CCK_RATE_5MB;
5194
5195         if (rate_mask & IEEE80211_CCK_RATE_11MB_MASK)
5196                 rates->supported_rates[rates->num_rates++] = basic_mask |
5197                     IEEE80211_CCK_RATE_11MB;
5198 }
5199
5200 static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
5201                                     u8 modulation, u32 rate_mask)
5202 {
5203         u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5204             IEEE80211_BASIC_RATE_MASK : 0;
5205
5206         if (rate_mask & IEEE80211_OFDM_RATE_6MB_MASK)
5207                 rates->supported_rates[rates->num_rates++] = basic_mask |
5208                     IEEE80211_OFDM_RATE_6MB;
5209
5210         if (rate_mask & IEEE80211_OFDM_RATE_9MB_MASK)
5211                 rates->supported_rates[rates->num_rates++] =
5212                     IEEE80211_OFDM_RATE_9MB;
5213
5214         if (rate_mask & IEEE80211_OFDM_RATE_12MB_MASK)
5215                 rates->supported_rates[rates->num_rates++] = basic_mask |
5216                     IEEE80211_OFDM_RATE_12MB;
5217
5218         if (rate_mask & IEEE80211_OFDM_RATE_18MB_MASK)
5219                 rates->supported_rates[rates->num_rates++] =
5220                     IEEE80211_OFDM_RATE_18MB;
5221
5222         if (rate_mask & IEEE80211_OFDM_RATE_24MB_MASK)
5223                 rates->supported_rates[rates->num_rates++] = basic_mask |
5224                     IEEE80211_OFDM_RATE_24MB;
5225
5226         if (rate_mask & IEEE80211_OFDM_RATE_36MB_MASK)
5227                 rates->supported_rates[rates->num_rates++] =
5228                     IEEE80211_OFDM_RATE_36MB;
5229
5230         if (rate_mask & IEEE80211_OFDM_RATE_48MB_MASK)
5231                 rates->supported_rates[rates->num_rates++] =
5232                     IEEE80211_OFDM_RATE_48MB;
5233
5234         if (rate_mask & IEEE80211_OFDM_RATE_54MB_MASK)
5235                 rates->supported_rates[rates->num_rates++] =
5236                     IEEE80211_OFDM_RATE_54MB;
5237 }
5238
5239 struct ipw_network_match {
5240         struct ieee80211_network *network;
5241         struct ipw_supported_rates rates;
5242 };
5243
5244 static int ipw_find_adhoc_network(struct ipw_priv *priv,
5245                                   struct ipw_network_match *match,
5246                                   struct ieee80211_network *network,
5247                                   int roaming)
5248 {
5249         struct ipw_supported_rates rates;
5250
5251         /* Verify that this network's capability is compatible with the
5252          * current mode (AdHoc or Infrastructure) */
5253         if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
5254              !(network->capability & WLAN_CAPABILITY_IBSS))) {
5255                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded due to "
5256                                 "capability mismatch.\n",
5257                                 escape_essid(network->ssid, network->ssid_len),
5258                                 MAC_ARG(network->bssid));
5259                 return 0;
5260         }
5261
5262         /* If we do not have an ESSID for this AP, we can not associate with
5263          * it */
5264         if (network->flags & NETWORK_EMPTY_ESSID) {
5265                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5266                                 "because of hidden ESSID.\n",
5267                                 escape_essid(network->ssid, network->ssid_len),
5268                                 MAC_ARG(network->bssid));
5269                 return 0;
5270         }
5271
5272         if (unlikely(roaming)) {
5273                 /* If we are roaming, then ensure check if this is a valid
5274                  * network to try and roam to */
5275                 if ((network->ssid_len != match->network->ssid_len) ||
5276                     memcmp(network->ssid, match->network->ssid,
5277                            network->ssid_len)) {
5278                         IPW_DEBUG_MERGE("Netowrk '%s (" MAC_FMT ")' excluded "
5279                                         "because of non-network ESSID.\n",
5280                                         escape_essid(network->ssid,
5281                                                      network->ssid_len),
5282                                         MAC_ARG(network->bssid));
5283                         return 0;
5284                 }
5285         } else {
5286                 /* If an ESSID has been configured then compare the broadcast
5287                  * ESSID to ours */
5288                 if ((priv->config & CFG_STATIC_ESSID) &&
5289                     ((network->ssid_len != priv->essid_len) ||
5290                      memcmp(network->ssid, priv->essid,
5291                             min(network->ssid_len, priv->essid_len)))) {
5292                         char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5293
5294                         strncpy(escaped,
5295                                 escape_essid(network->ssid, network->ssid_len),
5296                                 sizeof(escaped));
5297                         IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5298                                         "because of ESSID mismatch: '%s'.\n",
5299                                         escaped, MAC_ARG(network->bssid),
5300                                         escape_essid(priv->essid,
5301                                                      priv->essid_len));
5302                         return 0;
5303                 }
5304         }
5305
5306         /* If the old network rate is better than this one, don't bother
5307          * testing everything else. */
5308
5309         if (network->time_stamp[0] < match->network->time_stamp[0]) {
5310                 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5311                                 "current network.\n",
5312                                 escape_essid(match->network->ssid,
5313                                              match->network->ssid_len));
5314                 return 0;
5315         } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
5316                 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5317                                 "current network.\n",
5318                                 escape_essid(match->network->ssid,
5319                                              match->network->ssid_len));
5320                 return 0;
5321         }
5322
5323         /* Now go through and see if the requested network is valid... */
5324         if (priv->ieee->scan_age != 0 &&
5325             time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5326                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5327                                 "because of age: %ums.\n",
5328                                 escape_essid(network->ssid, network->ssid_len),
5329                                 MAC_ARG(network->bssid),
5330                                 jiffies_to_msecs(jiffies - network->last_scanned));
5331                 return 0;
5332         }
5333
5334         if ((priv->config & CFG_STATIC_CHANNEL) &&
5335             (network->channel != priv->channel)) {
5336                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5337                                 "because of channel mismatch: %d != %d.\n",
5338                                 escape_essid(network->ssid, network->ssid_len),
5339                                 MAC_ARG(network->bssid),
5340                                 network->channel, priv->channel);
5341                 return 0;
5342         }
5343
5344         /* Verify privacy compatability */
5345         if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5346             ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5347                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5348                                 "because of privacy mismatch: %s != %s.\n",
5349                                 escape_essid(network->ssid, network->ssid_len),
5350                                 MAC_ARG(network->bssid),
5351                                 priv->
5352                                 capability & CAP_PRIVACY_ON ? "on" : "off",
5353                                 network->
5354                                 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5355                                 "off");
5356                 return 0;
5357         }
5358
5359         if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5360                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5361                                 "because of the same BSSID match: " MAC_FMT
5362                                 ".\n", escape_essid(network->ssid,
5363                                                     network->ssid_len),
5364                                 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5365                 return 0;
5366         }
5367
5368         /* Filter out any incompatible freq / mode combinations */
5369         if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5370                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5371                                 "because of invalid frequency/mode "
5372                                 "combination.\n",
5373                                 escape_essid(network->ssid, network->ssid_len),
5374                                 MAC_ARG(network->bssid));
5375                 return 0;
5376         }
5377
5378         /* Ensure that the rates supported by the driver are compatible with
5379          * this AP, including verification of basic rates (mandatory) */
5380         if (!ipw_compatible_rates(priv, network, &rates)) {
5381                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5382                                 "because configured rate mask excludes "
5383                                 "AP mandatory rate.\n",
5384                                 escape_essid(network->ssid, network->ssid_len),
5385                                 MAC_ARG(network->bssid));
5386                 return 0;
5387         }
5388
5389         if (rates.num_rates == 0) {
5390                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5391                                 "because of no compatible rates.\n",
5392                                 escape_essid(network->ssid, network->ssid_len),
5393                                 MAC_ARG(network->bssid));
5394                 return 0;
5395         }
5396
5397         /* TODO: Perform any further minimal comparititive tests.  We do not
5398          * want to put too much policy logic here; intelligent scan selection
5399          * should occur within a generic IEEE 802.11 user space tool.  */
5400
5401         /* Set up 'new' AP to this network */
5402         ipw_copy_rates(&match->rates, &rates);
5403         match->network = network;
5404         IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' is a viable match.\n",
5405                         escape_essid(network->ssid, network->ssid_len),
5406                         MAC_ARG(network->bssid));
5407
5408         return 1;
5409 }
5410
5411 static void ipw_merge_adhoc_network(void *data)
5412 {
5413         struct ipw_priv *priv = data;
5414         struct ieee80211_network *network = NULL;
5415         struct ipw_network_match match = {
5416                 .network = priv->assoc_network
5417         };
5418
5419         if ((priv->status & STATUS_ASSOCIATED) &&
5420             (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5421                 /* First pass through ROAM process -- look for a better
5422                  * network */
5423                 unsigned long flags;
5424
5425                 spin_lock_irqsave(&priv->ieee->lock, flags);
5426                 list_for_each_entry(network, &priv->ieee->network_list, list) {
5427                         if (network != priv->assoc_network)
5428                                 ipw_find_adhoc_network(priv, &match, network,
5429                                                        1);
5430                 }
5431                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5432
5433                 if (match.network == priv->assoc_network) {
5434                         IPW_DEBUG_MERGE("No better ADHOC in this network to "
5435                                         "merge to.\n");
5436                         return;
5437                 }
5438
5439                 down(&priv->sem);
5440                 if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5441                         IPW_DEBUG_MERGE("remove network %s\n",
5442                                         escape_essid(priv->essid,
5443                                                      priv->essid_len));
5444                         ipw_remove_current_network(priv);
5445                 }
5446
5447                 ipw_disassociate(priv);
5448                 priv->assoc_network = match.network;
5449                 up(&priv->sem);
5450                 return;
5451         }
5452 }
5453
5454 static int ipw_best_network(struct ipw_priv *priv,
5455                             struct ipw_network_match *match,
5456                             struct ieee80211_network *network, int roaming)
5457 {
5458         struct ipw_supported_rates rates;
5459
5460         /* Verify that this network's capability is compatible with the
5461          * current mode (AdHoc or Infrastructure) */
5462         if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
5463              !(network->capability & WLAN_CAPABILITY_ESS)) ||
5464             (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5465              !(network->capability & WLAN_CAPABILITY_IBSS))) {
5466                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded due to "
5467                                 "capability mismatch.\n",
5468                                 escape_essid(network->ssid, network->ssid_len),
5469                                 MAC_ARG(network->bssid));
5470                 return 0;
5471         }
5472
5473         /* If we do not have an ESSID for this AP, we can not associate with
5474          * it */
5475         if (network->flags & NETWORK_EMPTY_ESSID) {
5476                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5477                                 "because of hidden ESSID.\n",
5478                                 escape_essid(network->ssid, network->ssid_len),
5479                                 MAC_ARG(network->bssid));
5480                 return 0;
5481         }
5482
5483         if (unlikely(roaming)) {
5484                 /* If we are roaming, then ensure check if this is a valid
5485                  * network to try and roam to */
5486                 if ((network->ssid_len != match->network->ssid_len) ||
5487                     memcmp(network->ssid, match->network->ssid,
5488                            network->ssid_len)) {
5489                         IPW_DEBUG_ASSOC("Netowrk '%s (" MAC_FMT ")' excluded "
5490                                         "because of non-network ESSID.\n",
5491                                         escape_essid(network->ssid,
5492                                                      network->ssid_len),
5493                                         MAC_ARG(network->bssid));
5494                         return 0;
5495                 }
5496         } else {
5497                 /* If an ESSID has been configured then compare the broadcast
5498                  * ESSID to ours */
5499                 if ((priv->config & CFG_STATIC_ESSID) &&
5500                     ((network->ssid_len != priv->essid_len) ||
5501                      memcmp(network->ssid, priv->essid,
5502                             min(network->ssid_len, priv->essid_len)))) {
5503                         char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5504                         strncpy(escaped,
5505                                 escape_essid(network->ssid, network->ssid_len),
5506                                 sizeof(escaped));
5507                         IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5508                                         "because of ESSID mismatch: '%s'.\n",
5509                                         escaped, MAC_ARG(network->bssid),
5510                                         escape_essid(priv->essid,
5511                                                      priv->essid_len));
5512                         return 0;
5513                 }
5514         }
5515
5516         /* If the old network rate is better than this one, don't bother
5517          * testing everything else. */
5518         if (match->network && match->network->stats.rssi > network->stats.rssi) {
5519                 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5520                 strncpy(escaped,
5521                         escape_essid(network->ssid, network->ssid_len),
5522                         sizeof(escaped));
5523                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded because "
5524                                 "'%s (" MAC_FMT ")' has a stronger signal.\n",
5525                                 escaped, MAC_ARG(network->bssid),
5526                                 escape_essid(match->network->ssid,
5527                                              match->network->ssid_len),
5528                                 MAC_ARG(match->network->bssid));
5529                 return 0;
5530         }
5531
5532         /* If this network has already had an association attempt within the
5533          * last 3 seconds, do not try and associate again... */
5534         if (network->last_associate &&
5535             time_after(network->last_associate + (HZ * 3UL), jiffies)) {
5536                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5537                                 "because of storming (%ums since last "
5538                                 "assoc attempt).\n",
5539                                 escape_essid(network->ssid, network->ssid_len),
5540                                 MAC_ARG(network->bssid),
5541                                 jiffies_to_msecs(jiffies - network->last_associate));
5542                 return 0;
5543         }
5544
5545         /* Now go through and see if the requested network is valid... */
5546         if (priv->ieee->scan_age != 0 &&
5547             time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5548                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5549                                 "because of age: %ums.\n",
5550                                 escape_essid(network->ssid, network->ssid_len),
5551                                 MAC_ARG(network->bssid),
5552                                 jiffies_to_msecs(jiffies - network->last_scanned));
5553                 return 0;
5554         }
5555
5556         if ((priv->config & CFG_STATIC_CHANNEL) &&
5557             (network->channel != priv->channel)) {
5558                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5559                                 "because of channel mismatch: %d != %d.\n",
5560                                 escape_essid(network->ssid, network->ssid_len),
5561                                 MAC_ARG(network->bssid),
5562                                 network->channel, priv->channel);
5563                 return 0;
5564         }
5565
5566         /* Verify privacy compatability */
5567         if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5568             ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5569                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5570                                 "because of privacy mismatch: %s != %s.\n",
5571                                 escape_essid(network->ssid, network->ssid_len),
5572                                 MAC_ARG(network->bssid),
5573                                 priv->capability & CAP_PRIVACY_ON ? "on" :
5574                                 "off",
5575                                 network->capability &
5576                                 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
5577                 return 0;
5578         }
5579
5580         if (!priv->ieee->wpa_enabled && (network->wpa_ie_len > 0 ||
5581                                          network->rsn_ie_len > 0)) {
5582                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5583                                 "because of WPA capability mismatch.\n",
5584                                 escape_essid(network->ssid, network->ssid_len),
5585                                 MAC_ARG(network->bssid));
5586                 return 0;
5587         }
5588
5589         if ((priv->config & CFG_STATIC_BSSID) &&
5590             memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5591                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5592                                 "because of BSSID mismatch: " MAC_FMT ".\n",
5593                                 escape_essid(network->ssid, network->ssid_len),
5594                                 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5595                 return 0;
5596         }
5597
5598         /* Filter out any incompatible freq / mode combinations */
5599         if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5600                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5601                                 "because of invalid frequency/mode "
5602                                 "combination.\n",
5603                                 escape_essid(network->ssid, network->ssid_len),
5604                                 MAC_ARG(network->bssid));
5605                 return 0;
5606         }
5607
5608         /* Filter out invalid channel in current GEO */
5609         if (!ipw_is_valid_channel(priv->ieee, network->channel)) {
5610                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5611                                 "because of invalid channel in current GEO\n",
5612                                 escape_essid(network->ssid, network->ssid_len),
5613                                 MAC_ARG(network->bssid));
5614                 return 0;
5615         }
5616
5617         /* Ensure that the rates supported by the driver are compatible with
5618          * this AP, including verification of basic rates (mandatory) */
5619         if (!ipw_compatible_rates(priv, network, &rates)) {
5620                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5621                                 "because configured rate mask excludes "
5622                                 "AP mandatory rate.\n",
5623                                 escape_essid(network->ssid, network->ssid_len),
5624                                 MAC_ARG(network->bssid));
5625                 return 0;
5626         }
5627
5628         if (rates.num_rates == 0) {
5629                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5630                                 "because of no compatible rates.\n",
5631                                 escape_essid(network->ssid, network->ssid_len),
5632                                 MAC_ARG(network->bssid));
5633                 return 0;
5634         }
5635
5636         /* TODO: Perform any further minimal comparititive tests.  We do not
5637          * want to put too much policy logic here; intelligent scan selection
5638          * should occur within a generic IEEE 802.11 user space tool.  */
5639
5640         /* Set up 'new' AP to this network */
5641         ipw_copy_rates(&match->rates, &rates);
5642         match->network = network;
5643
5644         IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' is a viable match.\n",
5645                         escape_essid(network->ssid, network->ssid_len),
5646                         MAC_ARG(network->bssid));
5647
5648         return 1;
5649 }
5650
5651 static void ipw_adhoc_create(struct ipw_priv *priv,
5652                              struct ieee80211_network *network)
5653 {
5654         const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
5655         int i;
5656
5657         /*
5658          * For the purposes of scanning, we can set our wireless mode
5659          * to trigger scans across combinations of bands, but when it
5660          * comes to creating a new ad-hoc network, we have tell the FW
5661          * exactly which band to use.
5662          *
5663          * We also have the possibility of an invalid channel for the
5664          * chossen band.  Attempting to create a new ad-hoc network
5665          * with an invalid channel for wireless mode will trigger a
5666          * FW fatal error.
5667          *
5668          */
5669         switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
5670         case IEEE80211_52GHZ_BAND:
5671                 network->mode = IEEE_A;
5672                 i = ipw_channel_to_index(priv->ieee, priv->channel);
5673                 if (i == -1)
5674                         BUG();
5675                 if (geo->a[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5676                         IPW_WARNING("Overriding invalid channel\n");
5677                         priv->channel = geo->a[0].channel;
5678                 }
5679                 break;
5680
5681         case IEEE80211_24GHZ_BAND:
5682                 if (priv->ieee->mode & IEEE_G)
5683                         network->mode = IEEE_G;
5684                 else
5685                         network->mode = IEEE_B;
5686                 i = ipw_channel_to_index(priv->ieee, priv->channel);
5687                 if (i == -1)
5688                         BUG();
5689                 if (geo->bg[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5690                         IPW_WARNING("Overriding invalid channel\n");
5691                         priv->channel = geo->bg[0].channel;
5692                 }
5693                 break;
5694
5695         default:
5696                 IPW_WARNING("Overriding invalid channel\n");
5697                 if (priv->ieee->mode & IEEE_A) {
5698                         network->mode = IEEE_A;
5699                         priv->channel = geo->a[0].channel;
5700                 } else if (priv->ieee->mode & IEEE_G) {
5701                         network->mode = IEEE_G;
5702                         priv->channel = geo->bg[0].channel;
5703                 } else {
5704                         network->mode = IEEE_B;
5705                         priv->channel = geo->bg[0].channel;
5706                 }
5707                 break;
5708         }
5709
5710         network->channel = priv->channel;
5711         priv->config |= CFG_ADHOC_PERSIST;
5712         ipw_create_bssid(priv, network->bssid);
5713         network->ssid_len = priv->essid_len;
5714         memcpy(network->ssid, priv->essid, priv->essid_len);
5715         memset(&network->stats, 0, sizeof(network->stats));
5716         network->capability = WLAN_CAPABILITY_IBSS;
5717         if (!(priv->config & CFG_PREAMBLE_LONG))
5718                 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
5719         if (priv->capability & CAP_PRIVACY_ON)
5720                 network->capability |= WLAN_CAPABILITY_PRIVACY;
5721         network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
5722         memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
5723         network->rates_ex_len = priv->rates.num_rates - network->rates_len;
5724         memcpy(network->rates_ex,
5725                &priv->rates.supported_rates[network->rates_len],
5726                network->rates_ex_len);
5727         network->last_scanned = 0;
5728         network->flags = 0;
5729         network->last_associate = 0;
5730         network->time_stamp[0] = 0;
5731         network->time_stamp[1] = 0;
5732         network->beacon_interval = 100; /* Default */
5733         network->listen_interval = 10;  /* Default */
5734         network->atim_window = 0;       /* Default */
5735         network->wpa_ie_len = 0;
5736         network->rsn_ie_len = 0;
5737 }
5738
5739 static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5740 {
5741         struct ipw_tgi_tx_key *key;
5742         struct host_cmd cmd = {
5743                 .cmd = IPW_CMD_TGI_TX_KEY,
5744                 .len = sizeof(*key)
5745         };
5746
5747         if (!(priv->ieee->sec.flags & (1 << index)))
5748                 return;
5749
5750         key = (struct ipw_tgi_tx_key *)&cmd.param;
5751         key->key_id = index;
5752         memcpy(key->key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5753         key->security_type = type;
5754         key->station_index = 0; /* always 0 for BSS */
5755         key->flags = 0;
5756         /* 0 for new key; previous value of counter (after fatal error) */
5757         key->tx_counter[0] = 0;
5758         key->tx_counter[1] = 0;
5759
5760         ipw_send_cmd(priv, &cmd);
5761 }
5762
5763 static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
5764 {
5765         struct ipw_wep_key *key;
5766         int i;
5767         struct host_cmd cmd = {
5768                 .cmd = IPW_CMD_WEP_KEY,
5769                 .len = sizeof(*key)
5770         };
5771
5772         key = (struct ipw_wep_key *)&cmd.param;
5773         key->cmd_id = DINO_CMD_WEP_KEY;
5774         key->seq_num = 0;
5775
5776         /* Note: AES keys cannot be set for multiple times.
5777          * Only set it at the first time. */
5778         for (i = 0; i < 4; i++) {
5779                 key->key_index = i | type;
5780                 if (!(priv->ieee->sec.flags & (1 << i))) {
5781                         key->key_size = 0;
5782                         continue;
5783                 }
5784
5785                 key->key_size = priv->ieee->sec.key_sizes[i];
5786                 memcpy(key->key, priv->ieee->sec.keys[i], key->key_size);
5787
5788                 ipw_send_cmd(priv, &cmd);
5789         }
5790 }
5791
5792 static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
5793 {
5794         if (priv->ieee->host_encrypt)
5795                 return;
5796
5797         switch (level) {
5798         case SEC_LEVEL_3:
5799                 priv->sys_config.disable_unicast_decryption = 0;
5800                 priv->ieee->host_decrypt = 0;
5801                 break;
5802         case SEC_LEVEL_2:
5803                 priv->sys_config.disable_unicast_decryption = 1;
5804                 priv->ieee->host_decrypt = 1;
5805                 break;
5806         case SEC_LEVEL_1:
5807                 priv->sys_config.disable_unicast_decryption = 0;
5808                 priv->ieee->host_decrypt = 0;
5809                 break;
5810         case SEC_LEVEL_0:
5811                 priv->sys_config.disable_unicast_decryption = 1;
5812                 break;
5813         default:
5814                 break;
5815         }
5816 }
5817
5818 static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
5819 {
5820         if (priv->ieee->host_encrypt)
5821                 return;
5822
5823         switch (level) {
5824         case SEC_LEVEL_3:
5825                 priv->sys_config.disable_multicast_decryption = 0;
5826                 break;
5827         case SEC_LEVEL_2:
5828                 priv->sys_config.disable_multicast_decryption = 1;
5829                 break;
5830         case SEC_LEVEL_1:
5831                 priv->sys_config.disable_multicast_decryption = 0;
5832                 break;
5833         case SEC_LEVEL_0:
5834                 priv->sys_config.disable_multicast_decryption = 1;
5835                 break;
5836         default:
5837                 break;
5838         }
5839 }
5840
5841 static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
5842 {
5843         switch (priv->ieee->sec.level) {
5844         case SEC_LEVEL_3:
5845                 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5846                         ipw_send_tgi_tx_key(priv,
5847                                             DCT_FLAG_EXT_SECURITY_CCM,
5848                                             priv->ieee->sec.active_key);
5849
5850                 if (!priv->ieee->host_mc_decrypt)
5851                         ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
5852                 break;
5853         case SEC_LEVEL_2:
5854                 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5855                         ipw_send_tgi_tx_key(priv,
5856                                             DCT_FLAG_EXT_SECURITY_TKIP,
5857                                             priv->ieee->sec.active_key);
5858                 break;
5859         case SEC_LEVEL_1:
5860                 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
5861                 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
5862                 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
5863                 break;
5864         case SEC_LEVEL_0:
5865         default:
5866                 break;
5867         }
5868 }
5869
5870 static void ipw_adhoc_check(void *data)
5871 {
5872         struct ipw_priv *priv = data;
5873
5874         if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
5875             !(priv->config & CFG_ADHOC_PERSIST)) {
5876                 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
5877                           IPW_DL_STATE | IPW_DL_ASSOC,
5878                           "Missed beacon: %d - disassociate\n",
5879                           priv->missed_adhoc_beacons);
5880                 ipw_remove_current_network(priv);
5881                 ipw_disassociate(priv);
5882                 return;
5883         }
5884
5885         queue_delayed_work(priv->workqueue, &priv->adhoc_check,
5886                            priv->assoc_request.beacon_interval);
5887 }
5888
5889 static void ipw_bg_adhoc_check(void *data)
5890 {
5891         struct ipw_priv *priv = data;
5892         down(&priv->sem);
5893         ipw_adhoc_check(data);
5894         up(&priv->sem);
5895 }
5896
5897 #ifdef CONFIG_IPW2200_DEBUG
5898 static void ipw_debug_config(struct ipw_priv *priv)
5899 {
5900         IPW_DEBUG_INFO("Scan completed, no valid APs matched "
5901                        "[CFG 0x%08X]\n", priv->config);
5902         if (priv->config & CFG_STATIC_CHANNEL)
5903                 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
5904         else
5905                 IPW_DEBUG_INFO("Channel unlocked.\n");
5906         if (priv->config & CFG_STATIC_ESSID)
5907                 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
5908                                escape_essid(priv->essid, priv->essid_len));
5909         else
5910                 IPW_DEBUG_INFO("ESSID unlocked.\n");
5911         if (priv->config & CFG_STATIC_BSSID)
5912                 IPW_DEBUG_INFO("BSSID locked to " MAC_FMT "\n",
5913                                MAC_ARG(priv->bssid));
5914         else
5915                 IPW_DEBUG_INFO("BSSID unlocked.\n");
5916         if (priv->capability & CAP_PRIVACY_ON)
5917                 IPW_DEBUG_INFO("PRIVACY on\n");
5918         else
5919                 IPW_DEBUG_INFO("PRIVACY off\n");
5920         IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
5921 }
5922 #else
5923 #define ipw_debug_config(x) do {} while (0)
5924 #endif
5925
5926 static void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
5927 {
5928         /* TODO: Verify that this works... */
5929         struct ipw_fixed_rate fr = {
5930                 .tx_rates = priv->rates_mask
5931         };
5932         u32 reg;
5933         u16 mask = 0;
5934
5935         /* Identify 'current FW band' and match it with the fixed
5936          * Tx rates */
5937
5938         switch (priv->ieee->freq_band) {
5939         case IEEE80211_52GHZ_BAND:      /* A only */
5940                 /* IEEE_A */
5941                 if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
5942                         /* Invalid fixed rate mask */
5943                         IPW_DEBUG_WX
5944                             ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5945                         fr.tx_rates = 0;
5946                         break;
5947                 }
5948
5949                 fr.tx_rates >>= IEEE80211_OFDM_SHIFT_MASK_A;
5950                 break;
5951
5952         default:                /* 2.4Ghz or Mixed */
5953                 /* IEEE_B */
5954                 if (mode == IEEE_B) {
5955                         if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
5956                                 /* Invalid fixed rate mask */
5957                                 IPW_DEBUG_WX
5958                                     ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5959                                 fr.tx_rates = 0;
5960                         }
5961                         break;
5962                 }
5963
5964                 /* IEEE_G */
5965                 if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK |
5966                                     IEEE80211_OFDM_RATES_MASK)) {
5967                         /* Invalid fixed rate mask */
5968                         IPW_DEBUG_WX
5969                             ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5970                         fr.tx_rates = 0;
5971                         break;
5972                 }
5973
5974                 if (IEEE80211_OFDM_RATE_6MB_MASK & fr.tx_rates) {
5975                         mask |= (IEEE80211_OFDM_RATE_6MB_MASK >> 1);
5976                         fr.tx_rates &= ~IEEE80211_OFDM_RATE_6MB_MASK;
5977                 }
5978
5979                 if (IEEE80211_OFDM_RATE_9MB_MASK & fr.tx_rates) {
5980                         mask |= (IEEE80211_OFDM_RATE_9MB_MASK >> 1);
5981                         fr.tx_rates &= ~IEEE80211_OFDM_RATE_9MB_MASK;
5982                 }
5983
5984                 if (IEEE80211_OFDM_RATE_12MB_MASK & fr.tx_rates) {
5985                         mask |= (IEEE80211_OFDM_RATE_12MB_MASK >> 1);
5986                         fr.tx_rates &= ~IEEE80211_OFDM_RATE_12MB_MASK;
5987                 }
5988
5989                 fr.tx_rates |= mask;
5990                 break;
5991         }
5992
5993         reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
5994         ipw_write_reg32(priv, reg, *(u32 *) & fr);
5995 }
5996
5997 static void ipw_abort_scan(struct ipw_priv *priv)
5998 {
5999         int err;
6000
6001         if (priv->status & STATUS_SCAN_ABORTING) {
6002                 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
6003                 return;
6004         }
6005         priv->status |= STATUS_SCAN_ABORTING;
6006
6007         err = ipw_send_scan_abort(priv);
6008         if (err)
6009                 IPW_DEBUG_HC("Request to abort scan failed.\n");
6010 }
6011
6012 static void ipw_add_scan_channels(struct ipw_priv *priv,
6013                                   struct ipw_scan_request_ext *scan,
6014                                   int scan_type)
6015 {
6016         int channel_index = 0;
6017         const struct ieee80211_geo *geo;
6018         int i;
6019
6020         geo = ipw_get_geo(priv->ieee);
6021
6022         if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
6023                 int start = channel_index;
6024                 for (i = 0; i < geo->a_channels; i++) {
6025                         if ((priv->status & STATUS_ASSOCIATED) &&
6026                             geo->a[i].channel == priv->channel)
6027                                 continue;
6028                         channel_index++;
6029                         scan->channels_list[channel_index] = geo->a[i].channel;
6030                         ipw_set_scan_type(scan, channel_index,
6031                                           geo->a[i].
6032                                           flags & IEEE80211_CH_PASSIVE_ONLY ?
6033                                           IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
6034                                           scan_type);
6035                 }
6036
6037                 if (start != channel_index) {
6038                         scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
6039                             (channel_index - start);
6040                         channel_index++;
6041                 }
6042         }
6043
6044         if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
6045                 int start = channel_index;
6046                 if (priv->config & CFG_SPEED_SCAN) {
6047                         int index;
6048                         u8 channels[IEEE80211_24GHZ_CHANNELS] = {
6049                                 /* nop out the list */
6050                                 [0] = 0
6051                         };
6052
6053                         u8 channel;
6054                         while (channel_index < IPW_SCAN_CHANNELS) {
6055                                 channel =
6056                                     priv->speed_scan[priv->speed_scan_pos];
6057                                 if (channel == 0) {
6058                                         priv->speed_scan_pos = 0;
6059                                         channel = priv->speed_scan[0];
6060                                 }
6061                                 if ((priv->status & STATUS_ASSOCIATED) &&
6062                                     channel == priv->channel) {
6063                                         priv->speed_scan_pos++;
6064                                         continue;
6065                                 }
6066
6067                                 /* If this channel has already been
6068                                  * added in scan, break from loop
6069                                  * and this will be the first channel
6070                                  * in the next scan.
6071                                  */
6072                                 if (channels[channel - 1] != 0)
6073                                         break;
6074
6075                                 channels[channel - 1] = 1;
6076                                 priv->speed_scan_pos++;
6077                                 channel_index++;
6078                                 scan->channels_list[channel_index] = channel;
6079                                 index =
6080                                     ipw_channel_to_index(priv->ieee, channel);
6081                                 ipw_set_scan_type(scan, channel_index,
6082                                                   geo->bg[index].
6083                                                   flags &
6084                                                   IEEE80211_CH_PASSIVE_ONLY ?
6085                                                   IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6086                                                   : scan_type);
6087                         }
6088                 } else {
6089                         for (i = 0; i < geo->bg_channels; i++) {
6090                                 if ((priv->status & STATUS_ASSOCIATED) &&
6091                                     geo->bg[i].channel == priv->channel)
6092                                         continue;
6093                                 channel_index++;
6094                                 scan->channels_list[channel_index] =
6095                                     geo->bg[i].channel;
6096                                 ipw_set_scan_type(scan, channel_index,
6097                                                   geo->bg[i].
6098                                                   flags &
6099                                                   IEEE80211_CH_PASSIVE_ONLY ?
6100                                                   IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6101                                                   : scan_type);
6102                         }
6103                 }
6104
6105                 if (start != channel_index) {
6106                         scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6107                             (channel_index - start);
6108                 }
6109         }
6110 }
6111
6112 static int ipw_request_scan(struct ipw_priv *priv)
6113 {
6114         struct ipw_scan_request_ext scan;
6115         int err = 0, scan_type;
6116
6117         if (!(priv->status & STATUS_INIT) ||
6118             (priv->status & STATUS_EXIT_PENDING))
6119                 return 0;
6120
6121         down(&priv->sem);
6122
6123         if (priv->status & STATUS_SCANNING) {
6124                 IPW_DEBUG_HC("Concurrent scan requested.  Ignoring.\n");
6125                 priv->status |= STATUS_SCAN_PENDING;
6126                 goto done;
6127         }
6128
6129         if (!(priv->status & STATUS_SCAN_FORCED) &&
6130             priv->status & STATUS_SCAN_ABORTING) {
6131                 IPW_DEBUG_HC("Scan request while abort pending.  Queuing.\n");
6132                 priv->status |= STATUS_SCAN_PENDING;
6133                 goto done;
6134         }
6135
6136         if (priv->status & STATUS_RF_KILL_MASK) {
6137                 IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n");
6138                 priv->status |= STATUS_SCAN_PENDING;
6139                 goto done;
6140         }
6141
6142         memset(&scan, 0, sizeof(scan));
6143
6144         if (priv->config & CFG_SPEED_SCAN)
6145                 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6146                     cpu_to_le16(30);
6147         else
6148                 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6149                     cpu_to_le16(20);
6150
6151         scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
6152             cpu_to_le16(20);
6153         scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
6154
6155         scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
6156
6157 #ifdef CONFIG_IPW2200_MONITOR
6158         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
6159                 u8 channel;
6160                 u8 band = 0;
6161
6162                 switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
6163                 case IEEE80211_52GHZ_BAND:
6164                         band = (u8) (IPW_A_MODE << 6) | 1;
6165                         channel = priv->channel;
6166                         break;
6167
6168                 case IEEE80211_24GHZ_BAND:
6169                         band = (u8) (IPW_B_MODE << 6) | 1;
6170                         channel = priv->channel;
6171                         break;
6172
6173                 default:
6174                         band = (u8) (IPW_B_MODE << 6) | 1;
6175                         channel = 9;
6176                         break;
6177                 }
6178
6179                 scan.channels_list[0] = band;
6180                 scan.channels_list[1] = channel;
6181                 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
6182
6183                 /* NOTE:  The card will sit on this channel for this time
6184                  * period.  Scan aborts are timing sensitive and frequently
6185                  * result in firmware restarts.  As such, it is best to
6186                  * set a small dwell_time here and just keep re-issuing
6187                  * scans.  Otherwise fast channel hopping will not actually
6188                  * hop channels.
6189                  *
6190                  * TODO: Move SPEED SCAN support to all modes and bands */
6191                 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6192                     cpu_to_le16(2000);
6193         } else {
6194 #endif                          /* CONFIG_IPW2200_MONITOR */
6195                 /* If we are roaming, then make this a directed scan for the
6196                  * current network.  Otherwise, ensure that every other scan
6197                  * is a fast channel hop scan */
6198                 if ((priv->status & STATUS_ROAMING)
6199                     || (!(priv->status & STATUS_ASSOCIATED)
6200                         && (priv->config & CFG_STATIC_ESSID)
6201                         && (le32_to_cpu(scan.full_scan_index) % 2))) {
6202                         err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6203                         if (err) {
6204                                 IPW_DEBUG_HC("Attempt to send SSID command "
6205                                              "failed.\n");
6206                                 goto done;
6207                         }
6208
6209                         scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6210                 } else
6211                         scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
6212
6213                 ipw_add_scan_channels(priv, &scan, scan_type);
6214 #ifdef CONFIG_IPW2200_MONITOR
6215         }
6216 #endif
6217
6218         err = ipw_send_scan_request_ext(priv, &scan);
6219         if (err) {
6220                 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
6221                 goto done;
6222         }
6223
6224         priv->status |= STATUS_SCANNING;
6225         priv->status &= ~STATUS_SCAN_PENDING;
6226         queue_delayed_work(priv->workqueue, &priv->scan_check,
6227                            IPW_SCAN_CHECK_WATCHDOG);
6228       done:
6229         up(&priv->sem);
6230         return err;
6231 }
6232
6233 static void ipw_bg_abort_scan(void *data)
6234 {
6235         struct ipw_priv *priv = data;
6236         down(&priv->sem);
6237         ipw_abort_scan(data);
6238         up(&priv->sem);
6239 }
6240
6241 static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6242 {
6243         /* This is called when wpa_supplicant loads and closes the driver
6244          * interface. */
6245         priv->ieee->wpa_enabled = value;
6246         return 0;
6247 }
6248
6249 static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6250 {
6251         struct ieee80211_device *ieee = priv->ieee;
6252         struct ieee80211_security sec = {
6253                 .flags = SEC_AUTH_MODE,
6254         };
6255         int ret = 0;
6256
6257         if (value & IW_AUTH_ALG_SHARED_KEY) {
6258                 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6259                 ieee->open_wep = 0;
6260         } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
6261                 sec.auth_mode = WLAN_AUTH_OPEN;
6262                 ieee->open_wep = 1;
6263         } else if (value & IW_AUTH_ALG_LEAP) {
6264                 sec.auth_mode = WLAN_AUTH_LEAP;
6265                 ieee->open_wep = 1;
6266         } else
6267                 return -EINVAL;
6268
6269         if (ieee->set_security)
6270                 ieee->set_security(ieee->dev, &sec);
6271         else
6272                 ret = -EOPNOTSUPP;
6273
6274         return ret;
6275 }
6276
6277 static void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie,
6278                                 int wpa_ie_len)
6279 {
6280         /* make sure WPA is enabled */
6281         ipw_wpa_enable(priv, 1);
6282
6283         ipw_disassociate(priv);
6284 }
6285
6286 static int ipw_set_rsn_capa(struct ipw_priv *priv,
6287                             char *capabilities, int length)
6288 {
6289         struct host_cmd cmd = {
6290                 .cmd = IPW_CMD_RSN_CAPABILITIES,
6291                 .len = length,
6292         };
6293
6294         IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6295
6296         memcpy(cmd.param, capabilities, length);
6297         return ipw_send_cmd(priv, &cmd);
6298 }
6299
6300 /*
6301  * WE-18 support
6302  */
6303
6304 /* SIOCSIWGENIE */
6305 static int ipw_wx_set_genie(struct net_device *dev,
6306                             struct iw_request_info *info,
6307                             union iwreq_data *wrqu, char *extra)
6308 {
6309         struct ipw_priv *priv = ieee80211_priv(dev);
6310         struct ieee80211_device *ieee = priv->ieee;
6311         u8 *buf;
6312         int err = 0;
6313
6314         if (wrqu->data.length > MAX_WPA_IE_LEN ||
6315             (wrqu->data.length && extra == NULL))
6316                 return -EINVAL;
6317
6318         //down(&priv->sem);
6319
6320         //if (!ieee->wpa_enabled) {
6321         //      err = -EOPNOTSUPP;
6322         //      goto out;
6323         //}
6324
6325         if (wrqu->data.length) {
6326                 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
6327                 if (buf == NULL) {
6328                         err = -ENOMEM;
6329                         goto out;
6330                 }
6331
6332                 memcpy(buf, extra, wrqu->data.length);
6333                 kfree(ieee->wpa_ie);
6334                 ieee->wpa_ie = buf;
6335                 ieee->wpa_ie_len = wrqu->data.length;
6336         } else {
6337                 kfree(ieee->wpa_ie);
6338                 ieee->wpa_ie = NULL;
6339                 ieee->wpa_ie_len = 0;
6340         }
6341
6342         ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6343       out:
6344         //up(&priv->sem);
6345         return err;
6346 }
6347
6348 /* SIOCGIWGENIE */
6349 static int ipw_wx_get_genie(struct net_device *dev,
6350                             struct iw_request_info *info,
6351                             union iwreq_data *wrqu, char *extra)
6352 {
6353         struct ipw_priv *priv = ieee80211_priv(dev);
6354         struct ieee80211_device *ieee = priv->ieee;
6355         int err = 0;
6356
6357         //down(&priv->sem);
6358
6359         //if (!ieee->wpa_enabled) {
6360         //      err = -EOPNOTSUPP;
6361         //      goto out;
6362         //}
6363
6364         if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6365                 wrqu->data.length = 0;
6366                 goto out;
6367         }
6368
6369         if (wrqu->data.length < ieee->wpa_ie_len) {
6370                 err = -E2BIG;
6371                 goto out;
6372         }
6373
6374         wrqu->data.length = ieee->wpa_ie_len;
6375         memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6376
6377       out:
6378         //up(&priv->sem);
6379         return err;
6380 }
6381
6382 static int wext_cipher2level(int cipher)
6383 {
6384         switch (cipher) {
6385         case IW_AUTH_CIPHER_NONE:
6386                 return SEC_LEVEL_0;
6387         case IW_AUTH_CIPHER_WEP40:
6388         case IW_AUTH_CIPHER_WEP104:
6389                 return SEC_LEVEL_1;
6390         case IW_AUTH_CIPHER_TKIP:
6391                 return SEC_LEVEL_2;
6392         case IW_AUTH_CIPHER_CCMP:
6393                 return SEC_LEVEL_3;
6394         default:
6395                 return -1;
6396         }
6397 }
6398
6399 /* SIOCSIWAUTH */
6400 static int ipw_wx_set_auth(struct net_device *dev,
6401                            struct iw_request_info *info,
6402                            union iwreq_data *wrqu, char *extra)
6403 {
6404         struct ipw_priv *priv = ieee80211_priv(dev);
6405         struct ieee80211_device *ieee = priv->ieee;
6406         struct iw_param *param = &wrqu->param;
6407         struct ieee80211_crypt_data *crypt;
6408         unsigned long flags;
6409         int ret = 0;
6410
6411         switch (param->flags & IW_AUTH_INDEX) {
6412         case IW_AUTH_WPA_VERSION:
6413                 break;
6414         case IW_AUTH_CIPHER_PAIRWISE:
6415                 ipw_set_hw_decrypt_unicast(priv,
6416                                            wext_cipher2level(param->value));
6417                 break;
6418         case IW_AUTH_CIPHER_GROUP:
6419                 ipw_set_hw_decrypt_multicast(priv,
6420                                              wext_cipher2level(param->value));
6421                 break;
6422         case IW_AUTH_KEY_MGMT:
6423                 /*
6424                  * ipw2200 does not use these parameters
6425                  */
6426                 break;
6427
6428         case IW_AUTH_TKIP_COUNTERMEASURES:
6429                 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6430                 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
6431                         break;
6432
6433                 flags = crypt->ops->get_flags(crypt->priv);
6434
6435                 if (param->value)
6436                         flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6437                 else
6438                         flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6439
6440                 crypt->ops->set_flags(flags, crypt->priv);
6441
6442                 break;
6443
6444         case IW_AUTH_DROP_UNENCRYPTED:{
6445                         /* HACK:
6446                          *
6447                          * wpa_supplicant calls set_wpa_enabled when the driver
6448                          * is loaded and unloaded, regardless of if WPA is being
6449                          * used.  No other calls are made which can be used to
6450                          * determine if encryption will be used or not prior to
6451                          * association being expected.  If encryption is not being
6452                          * used, drop_unencrypted is set to false, else true -- we
6453                          * can use this to determine if the CAP_PRIVACY_ON bit should
6454                          * be set.
6455                          */
6456                         struct ieee80211_security sec = {
6457                                 .flags = SEC_ENABLED,
6458                                 .enabled = param->value,
6459                         };
6460                         priv->ieee->drop_unencrypted = param->value;
6461                         /* We only change SEC_LEVEL for open mode. Others
6462                          * are set by ipw_wpa_set_encryption.
6463                          */
6464                         if (!param->value) {
6465                                 sec.flags |= SEC_LEVEL;
6466                                 sec.level = SEC_LEVEL_0;
6467                         } else {
6468                                 sec.flags |= SEC_LEVEL;
6469                                 sec.level = SEC_LEVEL_1;
6470                         }
6471                         if (priv->ieee->set_security)
6472                                 priv->ieee->set_security(priv->ieee->dev, &sec);
6473                         break;
6474                 }
6475
6476         case IW_AUTH_80211_AUTH_ALG:
6477                 ret = ipw_wpa_set_auth_algs(priv, param->value);
6478                 break;
6479
6480         case IW_AUTH_WPA_ENABLED:
6481                 ret = ipw_wpa_enable(priv, param->value);
6482                 break;
6483
6484         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6485                 ieee->ieee802_1x = param->value;
6486                 break;
6487
6488                 //case IW_AUTH_ROAMING_CONTROL:
6489         case IW_AUTH_PRIVACY_INVOKED:
6490                 ieee->privacy_invoked = param->value;
6491                 break;
6492
6493         default:
6494                 return -EOPNOTSUPP;
6495         }
6496         return ret;
6497 }
6498
6499 /* SIOCGIWAUTH */
6500 static int ipw_wx_get_auth(struct net_device *dev,
6501                            struct iw_request_info *info,
6502                            union iwreq_data *wrqu, char *extra)
6503 {
6504         struct ipw_priv *priv = ieee80211_priv(dev);
6505         struct ieee80211_device *ieee = priv->ieee;
6506         struct ieee80211_crypt_data *crypt;
6507         struct iw_param *param = &wrqu->param;
6508         int ret = 0;
6509
6510         switch (param->flags & IW_AUTH_INDEX) {
6511         case IW_AUTH_WPA_VERSION:
6512         case IW_AUTH_CIPHER_PAIRWISE:
6513         case IW_AUTH_CIPHER_GROUP:
6514         case IW_AUTH_KEY_MGMT:
6515                 /*
6516                  * wpa_supplicant will control these internally
6517                  */
6518                 ret = -EOPNOTSUPP;
6519                 break;
6520
6521         case IW_AUTH_TKIP_COUNTERMEASURES:
6522                 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6523                 if (!crypt || !crypt->ops->get_flags)
6524                         break;
6525
6526                 param->value = (crypt->ops->get_flags(crypt->priv) &
6527                                 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6528
6529                 break;
6530
6531         case IW_AUTH_DROP_UNENCRYPTED:
6532                 param->value = ieee->drop_unencrypted;
6533                 break;
6534
6535         case IW_AUTH_80211_AUTH_ALG:
6536                 param->value = ieee->sec.auth_mode;
6537                 break;
6538
6539         case IW_AUTH_WPA_ENABLED:
6540                 param->value = ieee->wpa_enabled;
6541                 break;
6542
6543         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6544                 param->value = ieee->ieee802_1x;
6545                 break;
6546
6547         case IW_AUTH_ROAMING_CONTROL:
6548         case IW_AUTH_PRIVACY_INVOKED:
6549                 param->value = ieee->privacy_invoked;
6550                 break;
6551
6552         default:
6553                 return -EOPNOTSUPP;
6554         }
6555         return 0;
6556 }
6557
6558 /* SIOCSIWENCODEEXT */
6559 static int ipw_wx_set_encodeext(struct net_device *dev,
6560                                 struct iw_request_info *info,
6561                                 union iwreq_data *wrqu, char *extra)
6562 {
6563         struct ipw_priv *priv = ieee80211_priv(dev);
6564         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6565
6566         if (hwcrypto) {
6567                 if (ext->alg == IW_ENCODE_ALG_TKIP) {
6568                         /* IPW HW can't build TKIP MIC,
6569                            host decryption still needed */
6570                         if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6571                                 priv->ieee->host_mc_decrypt = 1;
6572                         else {
6573                                 priv->ieee->host_encrypt = 0;
6574                                 priv->ieee->host_encrypt_msdu = 1;
6575                                 priv->ieee->host_decrypt = 1;
6576                         }
6577                 } else {
6578                         priv->ieee->host_encrypt = 0;
6579                         priv->ieee->host_encrypt_msdu = 0;
6580                         priv->ieee->host_decrypt = 0;
6581                         priv->ieee->host_mc_decrypt = 0;
6582                 }
6583         }
6584
6585         return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
6586 }
6587
6588 /* SIOCGIWENCODEEXT */
6589 static int ipw_wx_get_encodeext(struct net_device *dev,
6590                                 struct iw_request_info *info,
6591                                 union iwreq_data *wrqu, char *extra)
6592 {
6593         struct ipw_priv *priv = ieee80211_priv(dev);
6594         return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
6595 }
6596
6597 /* SIOCSIWMLME */
6598 static int ipw_wx_set_mlme(struct net_device *dev,
6599                            struct iw_request_info *info,
6600                            union iwreq_data *wrqu, char *extra)
6601 {
6602         struct ipw_priv *priv = ieee80211_priv(dev);
6603         struct iw_mlme *mlme = (struct iw_mlme *)extra;
6604         u16 reason;
6605
6606         reason = cpu_to_le16(mlme->reason_code);
6607
6608         switch (mlme->cmd) {
6609         case IW_MLME_DEAUTH:
6610                 // silently ignore
6611                 break;
6612
6613         case IW_MLME_DISASSOC:
6614                 ipw_disassociate(priv);
6615                 break;
6616
6617         default:
6618                 return -EOPNOTSUPP;
6619         }
6620         return 0;
6621 }
6622
6623 #ifdef CONFIG_IPW_QOS
6624
6625 /* QoS */
6626 /*
6627 * get the modulation type of the current network or
6628 * the card current mode
6629 */
6630 u8 ipw_qos_current_mode(struct ipw_priv * priv)
6631 {
6632         u8 mode = 0;
6633
6634         if (priv->status & STATUS_ASSOCIATED) {
6635                 unsigned long flags;
6636
6637                 spin_lock_irqsave(&priv->ieee->lock, flags);
6638                 mode = priv->assoc_network->mode;
6639                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6640         } else {
6641                 mode = priv->ieee->mode;
6642         }
6643         IPW_DEBUG_QOS("QoS network/card mode %d \n", mode);
6644         return mode;
6645 }
6646
6647 /*
6648 * Handle management frame beacon and probe response
6649 */
6650 static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6651                                          int active_network,
6652                                          struct ieee80211_network *network)
6653 {
6654         u32 size = sizeof(struct ieee80211_qos_parameters);
6655
6656         if (network->capability & WLAN_CAPABILITY_IBSS)
6657                 network->qos_data.active = network->qos_data.supported;
6658
6659         if (network->flags & NETWORK_HAS_QOS_MASK) {
6660                 if (active_network &&
6661                     (network->flags & NETWORK_HAS_QOS_PARAMETERS))
6662                         network->qos_data.active = network->qos_data.supported;
6663
6664                 if ((network->qos_data.active == 1) && (active_network == 1) &&
6665                     (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6666                     (network->qos_data.old_param_count !=
6667                      network->qos_data.param_count)) {
6668                         network->qos_data.old_param_count =
6669                             network->qos_data.param_count;
6670                         schedule_work(&priv->qos_activate);
6671                         IPW_DEBUG_QOS("QoS parameters change call "
6672                                       "qos_activate\n");
6673                 }
6674         } else {
6675                 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6676                         memcpy(&network->qos_data.parameters,
6677                                &def_parameters_CCK, size);
6678                 else
6679                         memcpy(&network->qos_data.parameters,
6680                                &def_parameters_OFDM, size);
6681
6682                 if ((network->qos_data.active == 1) && (active_network == 1)) {
6683                         IPW_DEBUG_QOS("QoS was disabled call qos_activate \n");
6684                         schedule_work(&priv->qos_activate);
6685                 }
6686
6687                 network->qos_data.active = 0;
6688                 network->qos_data.supported = 0;
6689         }
6690         if ((priv->status & STATUS_ASSOCIATED) &&
6691             (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6692                 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
6693                         if ((network->capability & WLAN_CAPABILITY_IBSS) &&
6694                             !(network->flags & NETWORK_EMPTY_ESSID))
6695                                 if ((network->ssid_len ==
6696                                      priv->assoc_network->ssid_len) &&
6697                                     !memcmp(network->ssid,
6698                                             priv->assoc_network->ssid,
6699                                             network->ssid_len)) {
6700                                         queue_work(priv->workqueue,
6701                                                    &priv->merge_networks);
6702                                 }
6703         }
6704
6705         return 0;
6706 }
6707
6708 /*
6709 * This function set up the firmware to support QoS. It sends
6710 * IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
6711 */
6712 static int ipw_qos_activate(struct ipw_priv *priv,
6713                             struct ieee80211_qos_data *qos_network_data)
6714 {
6715         int err;
6716         struct ieee80211_qos_parameters qos_parameters[QOS_QOS_SETS];
6717         struct ieee80211_qos_parameters *active_one = NULL;
6718         u32 size = sizeof(struct ieee80211_qos_parameters);
6719         u32 burst_duration;
6720         int i;
6721         u8 type;
6722
6723         type = ipw_qos_current_mode(priv);
6724
6725         active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
6726         memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
6727         active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
6728         memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
6729
6730         if (qos_network_data == NULL) {
6731                 if (type == IEEE_B) {
6732                         IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
6733                         active_one = &def_parameters_CCK;
6734                 } else
6735                         active_one = &def_parameters_OFDM;
6736
6737                 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6738                 burst_duration = ipw_qos_get_burst_duration(priv);
6739                 for (i = 0; i < QOS_QUEUE_NUM; i++)
6740                         qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
6741                             (u16) burst_duration;
6742         } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6743                 if (type == IEEE_B) {
6744                         IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
6745                                       type);
6746                         if (priv->qos_data.qos_enable == 0)
6747                                 active_one = &def_parameters_CCK;
6748                         else
6749                                 active_one = priv->qos_data.def_qos_parm_CCK;
6750                 } else {
6751                         if (priv->qos_data.qos_enable == 0)
6752                                 active_one = &def_parameters_OFDM;
6753                         else
6754                                 active_one = priv->qos_data.def_qos_parm_OFDM;
6755                 }
6756                 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6757         } else {
6758                 unsigned long flags;
6759                 int active;
6760
6761                 spin_lock_irqsave(&priv->ieee->lock, flags);
6762                 active_one = &(qos_network_data->parameters);
6763                 qos_network_data->old_param_count =
6764                     qos_network_data->param_count;
6765                 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6766                 active = qos_network_data->supported;
6767                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6768
6769                 if (active == 0) {
6770                         burst_duration = ipw_qos_get_burst_duration(priv);
6771                         for (i = 0; i < QOS_QUEUE_NUM; i++)
6772                                 qos_parameters[QOS_PARAM_SET_ACTIVE].
6773                                     tx_op_limit[i] = (u16) burst_duration;
6774                 }
6775         }
6776
6777         IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
6778         err = ipw_send_qos_params_command(priv,
6779                                           (struct ieee80211_qos_parameters *)
6780                                           &(qos_parameters[0]));
6781         if (err)
6782                 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
6783
6784         return err;
6785 }
6786
6787 /*
6788 * send IPW_CMD_WME_INFO to the firmware
6789 */
6790 static int ipw_qos_set_info_element(struct ipw_priv *priv)
6791 {
6792         int ret = 0;
6793         struct ieee80211_qos_information_element qos_info;
6794
6795         if (priv == NULL)
6796                 return -1;
6797
6798         qos_info.elementID = QOS_ELEMENT_ID;
6799         qos_info.length = sizeof(struct ieee80211_qos_information_element) - 2;
6800
6801         qos_info.version = QOS_VERSION_1;
6802         qos_info.ac_info = 0;
6803
6804         memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
6805         qos_info.qui_type = QOS_OUI_TYPE;
6806         qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
6807
6808         ret = ipw_send_qos_info_command(priv, &qos_info);
6809         if (ret != 0) {
6810                 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
6811         }
6812         return ret;
6813 }
6814
6815 /*
6816 * Set the QoS parameter with the association request structure
6817 */
6818 static int ipw_qos_association(struct ipw_priv *priv,
6819                                struct ieee80211_network *network)
6820 {
6821         int err = 0;
6822         struct ieee80211_qos_data *qos_data = NULL;
6823         struct ieee80211_qos_data ibss_data = {
6824                 .supported = 1,
6825                 .active = 1,
6826         };
6827
6828         switch (priv->ieee->iw_mode) {
6829         case IW_MODE_ADHOC:
6830                 if (!(network->capability & WLAN_CAPABILITY_IBSS))
6831                         BUG();
6832
6833                 qos_data = &ibss_data;
6834                 break;
6835
6836         case IW_MODE_INFRA:
6837                 qos_data = &network->qos_data;
6838                 break;
6839
6840         default:
6841                 BUG();
6842                 break;
6843         }
6844
6845         err = ipw_qos_activate(priv, qos_data);
6846         if (err) {
6847                 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
6848                 return err;
6849         }
6850
6851         if (priv->qos_data.qos_enable && qos_data->supported) {
6852                 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
6853                 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
6854                 return ipw_qos_set_info_element(priv);
6855         }
6856
6857         return 0;
6858 }
6859
6860 /*
6861 * handling the beaconing responces. if we get different QoS setting
6862 * of the network from the the associated setting adjust the QoS
6863 * setting
6864 */
6865 static int ipw_qos_association_resp(struct ipw_priv *priv,
6866                                     struct ieee80211_network *network)
6867 {
6868         int ret = 0;
6869         unsigned long flags;
6870         u32 size = sizeof(struct ieee80211_qos_parameters);
6871         int set_qos_param = 0;
6872
6873         if ((priv == NULL) || (network == NULL) ||
6874             (priv->assoc_network == NULL))
6875                 return ret;
6876
6877         if (!(priv->status & STATUS_ASSOCIATED))
6878                 return ret;
6879
6880         if ((priv->ieee->iw_mode != IW_MODE_INFRA))
6881                 return ret;
6882
6883         spin_lock_irqsave(&priv->ieee->lock, flags);
6884         if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
6885                 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
6886                        sizeof(struct ieee80211_qos_data));
6887                 priv->assoc_network->qos_data.active = 1;
6888                 if ((network->qos_data.old_param_count !=
6889                      network->qos_data.param_count)) {
6890                         set_qos_param = 1;
6891                         network->qos_data.old_param_count =
6892                             network->qos_data.param_count;
6893                 }
6894
6895         } else {
6896                 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
6897                         memcpy(&priv->assoc_network->qos_data.parameters,
6898                                &def_parameters_CCK, size);
6899                 else
6900                         memcpy(&priv->assoc_network->qos_data.parameters,
6901                                &def_parameters_OFDM, size);
6902                 priv->assoc_network->qos_data.active = 0;
6903                 priv->assoc_network->qos_data.supported = 0;
6904                 set_qos_param = 1;
6905         }
6906
6907         spin_unlock_irqrestore(&priv->ieee->lock, flags);
6908
6909         if (set_qos_param == 1)
6910                 schedule_work(&priv->qos_activate);
6911
6912         return ret;
6913 }
6914
6915 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
6916 {
6917         u32 ret = 0;
6918
6919         if ((priv == NULL))
6920                 return 0;
6921
6922         if (!(priv->ieee->modulation & IEEE80211_OFDM_MODULATION))
6923                 ret = priv->qos_data.burst_duration_CCK;
6924         else
6925                 ret = priv->qos_data.burst_duration_OFDM;
6926
6927         return ret;
6928 }
6929
6930 /*
6931 * Initialize the setting of QoS global
6932 */
6933 static void ipw_qos_init(struct ipw_priv *priv, int enable,
6934                          int burst_enable, u32 burst_duration_CCK,
6935                          u32 burst_duration_OFDM)
6936 {
6937         priv->qos_data.qos_enable = enable;
6938
6939         if (priv->qos_data.qos_enable) {
6940                 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
6941                 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
6942                 IPW_DEBUG_QOS("QoS is enabled\n");
6943         } else {
6944                 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
6945                 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
6946                 IPW_DEBUG_QOS("QoS is not enabled\n");
6947         }
6948
6949         priv->qos_data.burst_enable = burst_enable;
6950
6951         if (burst_enable) {
6952                 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
6953                 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
6954         } else {
6955                 priv->qos_data.burst_duration_CCK = 0;
6956                 priv->qos_data.burst_duration_OFDM = 0;
6957         }
6958 }
6959
6960 /*
6961 * map the packet priority to the right TX Queue
6962 */
6963 static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
6964 {
6965         if (priority > 7 || !priv->qos_data.qos_enable)
6966                 priority = 0;
6967
6968         return from_priority_to_tx_queue[priority] - 1;
6969 }
6970
6971 /*
6972 * add QoS parameter to the TX command
6973 */
6974 static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
6975                                         u16 priority,
6976                                         struct tfd_data *tfd, u8 unicast)
6977 {
6978         int ret = 0;
6979         int tx_queue_id = 0;
6980         struct ieee80211_qos_data *qos_data = NULL;
6981         int active, supported;
6982         unsigned long flags;
6983
6984         if (!(priv->status & STATUS_ASSOCIATED))
6985                 return 0;
6986
6987         qos_data = &priv->assoc_network->qos_data;
6988
6989         spin_lock_irqsave(&priv->ieee->lock, flags);
6990
6991         if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6992                 if (unicast == 0)
6993                         qos_data->active = 0;
6994                 else
6995                         qos_data->active = qos_data->supported;
6996         }
6997
6998         active = qos_data->active;
6999         supported = qos_data->supported;
7000
7001         spin_unlock_irqrestore(&priv->ieee->lock, flags);
7002
7003         IPW_DEBUG_QOS("QoS  %d network is QoS active %d  supported %d  "
7004                       "unicast %d\n",
7005                       priv->qos_data.qos_enable, active, supported, unicast);
7006         if (active && priv->qos_data.qos_enable) {
7007                 ret = from_priority_to_tx_queue[priority];
7008                 tx_queue_id = ret - 1;
7009                 IPW_DEBUG_QOS("QoS packet priority is %d \n", priority);
7010                 if (priority <= 7) {
7011                         tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
7012                         tfd->tfd.tfd_26.mchdr.qos_ctrl = priority;
7013                         tfd->tfd.tfd_26.mchdr.frame_ctl |=
7014                             IEEE80211_STYPE_QOS_DATA;
7015
7016                         if (priv->qos_data.qos_no_ack_mask &
7017                             (1UL << tx_queue_id)) {
7018                                 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
7019                                 tfd->tfd.tfd_26.mchdr.qos_ctrl |=
7020                                     CTRL_QOS_NO_ACK;
7021                         }
7022                 }
7023         }
7024
7025         return ret;
7026 }
7027
7028 /*
7029 * background support to run QoS activate functionality
7030 */
7031 static void ipw_bg_qos_activate(void *data)
7032 {
7033         struct ipw_priv *priv = data;
7034
7035         if (priv == NULL)
7036                 return;
7037
7038         down(&priv->sem);
7039
7040         if (priv->status & STATUS_ASSOCIATED)
7041                 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
7042
7043         up(&priv->sem);
7044 }
7045
7046 static int ipw_handle_probe_response(struct net_device *dev,
7047                                      struct ieee80211_probe_response *resp,
7048                                      struct ieee80211_network *network)
7049 {
7050         struct ipw_priv *priv = ieee80211_priv(dev);
7051         int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7052                               (network == priv->assoc_network));
7053
7054         ipw_qos_handle_probe_response(priv, active_network, network);
7055
7056         return 0;
7057 }
7058
7059 static int ipw_handle_beacon(struct net_device *dev,
7060                              struct ieee80211_beacon *resp,
7061                              struct ieee80211_network *network)
7062 {
7063         struct ipw_priv *priv = ieee80211_priv(dev);
7064         int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7065                               (network == priv->assoc_network));
7066
7067         ipw_qos_handle_probe_response(priv, active_network, network);
7068
7069         return 0;
7070 }
7071
7072 static int ipw_handle_assoc_response(struct net_device *dev,
7073                                      struct ieee80211_assoc_response *resp,
7074                                      struct ieee80211_network *network)
7075 {
7076         struct ipw_priv *priv = ieee80211_priv(dev);
7077         ipw_qos_association_resp(priv, network);
7078         return 0;
7079 }
7080
7081 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
7082                                        *qos_param)
7083 {
7084         struct host_cmd cmd = {
7085                 .cmd = IPW_CMD_QOS_PARAMETERS,
7086                 .len = (sizeof(struct ieee80211_qos_parameters) * 3)
7087         };
7088
7089         memcpy(cmd.param, qos_param, sizeof(*qos_param) * 3);
7090         return ipw_send_cmd(priv, &cmd);
7091 }
7092
7093 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
7094                                      *qos_param)
7095 {
7096         struct host_cmd cmd = {
7097                 .cmd = IPW_CMD_WME_INFO,
7098                 .len = sizeof(*qos_param)
7099         };
7100
7101         memcpy(cmd.param, qos_param, sizeof(*qos_param));
7102         return ipw_send_cmd(priv, &cmd);
7103 }
7104
7105 #endif                          /* CONFIG_IPW_QOS */
7106
7107 static int ipw_associate_network(struct ipw_priv *priv,
7108                                  struct ieee80211_network *network,
7109                                  struct ipw_supported_rates *rates, int roaming)
7110 {
7111         int err;
7112
7113         if (priv->config & CFG_FIXED_RATE)
7114                 ipw_set_fixed_rate(priv, network->mode);
7115
7116         if (!(priv->config & CFG_STATIC_ESSID)) {
7117                 priv->essid_len = min(network->ssid_len,
7118                                       (u8) IW_ESSID_MAX_SIZE);
7119                 memcpy(priv->essid, network->ssid, priv->essid_len);
7120         }
7121
7122         network->last_associate = jiffies;
7123
7124         memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7125         priv->assoc_request.channel = network->channel;
7126         priv->assoc_request.auth_key = 0;
7127
7128         if ((priv->capability & CAP_PRIVACY_ON) &&
7129             (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)) {
7130                 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
7131                 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7132
7133                 if ((priv->ieee->sec.level == SEC_LEVEL_1) &&
7134                     !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
7135                         ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
7136
7137         } else if ((priv->capability & CAP_PRIVACY_ON) &&
7138                    (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP))
7139                 priv->assoc_request.auth_type = AUTH_LEAP;
7140         else
7141                 priv->assoc_request.auth_type = AUTH_OPEN;
7142
7143         if (priv->ieee->wpa_ie_len) {
7144                 priv->assoc_request.policy_support = 0x02;      /* RSN active */
7145                 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7146                                  priv->ieee->wpa_ie_len);
7147         }
7148
7149         /*
7150          * It is valid for our ieee device to support multiple modes, but
7151          * when it comes to associating to a given network we have to choose
7152          * just one mode.
7153          */
7154         if (network->mode & priv->ieee->mode & IEEE_A)
7155                 priv->assoc_request.ieee_mode = IPW_A_MODE;
7156         else if (network->mode & priv->ieee->mode & IEEE_G)
7157                 priv->assoc_request.ieee_mode = IPW_G_MODE;
7158         else if (network->mode & priv->ieee->mode & IEEE_B)
7159                 priv->assoc_request.ieee_mode = IPW_B_MODE;
7160
7161         priv->assoc_request.capability = network->capability;
7162         if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7163             && !(priv->config & CFG_PREAMBLE_LONG)) {
7164                 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7165         } else {
7166                 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7167
7168                 /* Clear the short preamble if we won't be supporting it */
7169                 priv->assoc_request.capability &=
7170                     ~WLAN_CAPABILITY_SHORT_PREAMBLE;
7171         }
7172
7173         /* Clear capability bits that aren't used in Ad Hoc */
7174         if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7175                 priv->assoc_request.capability &=
7176                     ~WLAN_CAPABILITY_SHORT_SLOT_TIME;
7177
7178         IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
7179                         "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
7180                         roaming ? "Rea" : "A",
7181                         escape_essid(priv->essid, priv->essid_len),
7182                         network->channel,
7183                         ipw_modes[priv->assoc_request.ieee_mode],
7184                         rates->num_rates,
7185                         (priv->assoc_request.preamble_length ==
7186                          DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7187                         network->capability &
7188                         WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
7189                         priv->capability & CAP_PRIVACY_ON ? "on " : "off",
7190                         priv->capability & CAP_PRIVACY_ON ?
7191                         (priv->capability & CAP_SHARED_KEY ? "(shared)" :
7192                          "(open)") : "",
7193                         priv->capability & CAP_PRIVACY_ON ? " key=" : "",
7194                         priv->capability & CAP_PRIVACY_ON ?
7195                         '1' + priv->ieee->sec.active_key : '.',
7196                         priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
7197
7198         priv->assoc_request.beacon_interval = network->beacon_interval;
7199         if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
7200             (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
7201                 priv->assoc_request.assoc_type = HC_IBSS_START;
7202                 priv->assoc_request.assoc_tsf_msw = 0;
7203                 priv->assoc_request.assoc_tsf_lsw = 0;
7204         } else {
7205                 if (unlikely(roaming))
7206                         priv->assoc_request.assoc_type = HC_REASSOCIATE;
7207                 else
7208                         priv->assoc_request.assoc_type = HC_ASSOCIATE;
7209                 priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
7210                 priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
7211         }
7212
7213         memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
7214
7215         if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7216                 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
7217                 priv->assoc_request.atim_window = network->atim_window;
7218         } else {
7219                 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
7220                 priv->assoc_request.atim_window = 0;
7221         }
7222
7223         priv->assoc_request.listen_interval = network->listen_interval;
7224
7225         err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7226         if (err) {
7227                 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7228                 return err;
7229         }
7230
7231         rates->ieee_mode = priv->assoc_request.ieee_mode;
7232         rates->purpose = IPW_RATE_CONNECT;
7233         ipw_send_supported_rates(priv, rates);
7234
7235         if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7236                 priv->sys_config.dot11g_auto_detection = 1;
7237         else
7238                 priv->sys_config.dot11g_auto_detection = 0;
7239
7240         if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7241                 priv->sys_config.answer_broadcast_ssid_probe = 1;
7242         else
7243                 priv->sys_config.answer_broadcast_ssid_probe = 0;
7244
7245         err = ipw_send_system_config(priv, &priv->sys_config);
7246         if (err) {
7247                 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7248                 return err;
7249         }
7250
7251         IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
7252         err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
7253         if (err) {
7254                 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7255                 return err;
7256         }
7257
7258         /*
7259          * If preemption is enabled, it is possible for the association
7260          * to complete before we return from ipw_send_associate.  Therefore
7261          * we have to be sure and update our priviate data first.
7262          */
7263         priv->channel = network->channel;
7264         memcpy(priv->bssid, network->bssid, ETH_ALEN);
7265         priv->status |= STATUS_ASSOCIATING;
7266         priv->status &= ~STATUS_SECURITY_UPDATED;
7267
7268         priv->assoc_network = network;
7269
7270 #ifdef CONFIG_IPW_QOS
7271         ipw_qos_association(priv, network);
7272 #endif
7273
7274         err = ipw_send_associate(priv, &priv->assoc_request);
7275         if (err) {
7276                 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7277                 return err;
7278         }
7279
7280         IPW_DEBUG(IPW_DL_STATE, "associating: '%s' " MAC_FMT " \n",
7281                   escape_essid(priv->essid, priv->essid_len),
7282                   MAC_ARG(priv->bssid));
7283
7284         return 0;
7285 }
7286
7287 static void ipw_roam(void *data)
7288 {
7289         struct ipw_priv *priv = data;
7290         struct ieee80211_network *network = NULL;
7291         struct ipw_network_match match = {
7292                 .network = priv->assoc_network
7293         };
7294
7295         /* The roaming process is as follows:
7296          *
7297          * 1.  Missed beacon threshold triggers the roaming process by
7298          *     setting the status ROAM bit and requesting a scan.
7299          * 2.  When the scan completes, it schedules the ROAM work
7300          * 3.  The ROAM work looks at all of the known networks for one that
7301          *     is a better network than the currently associated.  If none
7302          *     found, the ROAM process is over (ROAM bit cleared)
7303          * 4.  If a better network is found, a disassociation request is
7304          *     sent.
7305          * 5.  When the disassociation completes, the roam work is again
7306          *     scheduled.  The second time through, the driver is no longer
7307          *     associated, and the newly selected network is sent an
7308          *     association request.
7309          * 6.  At this point ,the roaming process is complete and the ROAM
7310          *     status bit is cleared.
7311          */
7312
7313         /* If we are no longer associated, and the roaming bit is no longer
7314          * set, then we are not actively roaming, so just return */
7315         if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7316                 return;
7317
7318         if (priv->status & STATUS_ASSOCIATED) {
7319                 /* First pass through ROAM process -- look for a better
7320                  * network */
7321                 unsigned long flags;
7322                 u8 rssi = priv->assoc_network->stats.rssi;
7323                 priv->assoc_network->stats.rssi = -128;
7324                 spin_lock_irqsave(&priv->ieee->lock, flags);
7325                 list_for_each_entry(network, &priv->ieee->network_list, list) {
7326                         if (network != priv->assoc_network)
7327                                 ipw_best_network(priv, &match, network, 1);
7328                 }
7329                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7330                 priv->assoc_network->stats.rssi = rssi;
7331
7332                 if (match.network == priv->assoc_network) {
7333                         IPW_DEBUG_ASSOC("No better APs in this network to "
7334                                         "roam to.\n");
7335                         priv->status &= ~STATUS_ROAMING;
7336                         ipw_debug_config(priv);
7337                         return;
7338                 }
7339
7340                 ipw_send_disassociate(priv, 1);
7341                 priv->assoc_network = match.network;
7342
7343                 return;
7344         }
7345
7346         /* Second pass through ROAM process -- request association */
7347         ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7348         ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7349         priv->status &= ~STATUS_ROAMING;
7350 }
7351
7352 static void ipw_bg_roam(void *data)
7353 {
7354         struct ipw_priv *priv = data;
7355         down(&priv->sem);
7356         ipw_roam(data);
7357         up(&priv->sem);
7358 }
7359
7360 static int ipw_associate(void *data)
7361 {
7362         struct ipw_priv *priv = data;
7363
7364         struct ieee80211_network *network = NULL;
7365         struct ipw_network_match match = {
7366                 .network = NULL
7367         };
7368         struct ipw_supported_rates *rates;
7369         struct list_head *element;
7370         unsigned long flags;
7371
7372         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7373                 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7374                 return 0;
7375         }
7376
7377         if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
7378                 IPW_DEBUG_ASSOC("Not attempting association (already in "
7379                                 "progress)\n");
7380                 return 0;
7381         }
7382
7383         if (priv->status & STATUS_DISASSOCIATING) {
7384                 IPW_DEBUG_ASSOC("Not attempting association (in "
7385                                 "disassociating)\n ");
7386                 queue_work(priv->workqueue, &priv->associate);
7387                 return 0;
7388         }
7389
7390         if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
7391                 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7392                                 "initialized)\n");
7393                 return 0;
7394         }
7395
7396         if (!(priv->config & CFG_ASSOCIATE) &&
7397             !(priv->config & (CFG_STATIC_ESSID |
7398                               CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
7399                 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
7400                 return 0;
7401         }
7402
7403         /* Protect our use of the network_list */
7404         spin_lock_irqsave(&priv->ieee->lock, flags);
7405         list_for_each_entry(network, &priv->ieee->network_list, list)
7406             ipw_best_network(priv, &match, network, 0);
7407
7408         network = match.network;
7409         rates = &match.rates;
7410
7411         if (network == NULL &&
7412             priv->ieee->iw_mode == IW_MODE_ADHOC &&
7413             priv->config & CFG_ADHOC_CREATE &&
7414             priv->config & CFG_STATIC_ESSID &&
7415             priv->config & CFG_STATIC_CHANNEL &&
7416             !list_empty(&priv->ieee->network_free_list)) {
7417                 element = priv->ieee->network_free_list.next;
7418                 network = list_entry(element, struct ieee80211_network, list);
7419                 ipw_adhoc_create(priv, network);
7420                 rates = &priv->rates;
7421                 list_del(element);
7422                 list_add_tail(&network->list, &priv->ieee->network_list);
7423         }
7424         spin_unlock_irqrestore(&priv->ieee->lock, flags);
7425
7426         /* If we reached the end of the list, then we don't have any valid
7427          * matching APs */
7428         if (!network) {
7429                 ipw_debug_config(priv);
7430
7431                 if (!(priv->status & STATUS_SCANNING)) {
7432                         if (!(priv->config & CFG_SPEED_SCAN))
7433                                 queue_delayed_work(priv->workqueue,
7434                                                    &priv->request_scan,
7435                                                    SCAN_INTERVAL);
7436                         else
7437                                 queue_work(priv->workqueue,
7438                                            &priv->request_scan);
7439                 }
7440
7441                 return 0;
7442         }
7443
7444         ipw_associate_network(priv, network, rates, 0);
7445
7446         return 1;
7447 }
7448
7449 static void ipw_bg_associate(void *data)
7450 {
7451         struct ipw_priv *priv = data;
7452         down(&priv->sem);
7453         ipw_associate(data);
7454         up(&priv->sem);
7455 }
7456
7457 static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7458                                       struct sk_buff *skb)
7459 {
7460         struct ieee80211_hdr *hdr;
7461         u16 fc;
7462
7463         hdr = (struct ieee80211_hdr *)skb->data;
7464         fc = le16_to_cpu(hdr->frame_ctl);
7465         if (!(fc & IEEE80211_FCTL_PROTECTED))
7466                 return;
7467
7468         fc &= ~IEEE80211_FCTL_PROTECTED;
7469         hdr->frame_ctl = cpu_to_le16(fc);
7470         switch (priv->ieee->sec.level) {
7471         case SEC_LEVEL_3:
7472                 /* Remove CCMP HDR */
7473                 memmove(skb->data + IEEE80211_3ADDR_LEN,
7474                         skb->data + IEEE80211_3ADDR_LEN + 8,
7475                         skb->len - IEEE80211_3ADDR_LEN - 8);
7476                 skb_trim(skb, skb->len - 16);   /* CCMP_HDR_LEN + CCMP_MIC_LEN */
7477                 break;
7478         case SEC_LEVEL_2:
7479                 break;
7480         case SEC_LEVEL_1:
7481                 /* Remove IV */
7482                 memmove(skb->data + IEEE80211_3ADDR_LEN,
7483                         skb->data + IEEE80211_3ADDR_LEN + 4,
7484                         skb->len - IEEE80211_3ADDR_LEN - 4);
7485                 skb_trim(skb, skb->len - 8);    /* IV + ICV */
7486                 break;
7487         case SEC_LEVEL_0:
7488                 break;
7489         default:
7490                 printk(KERN_ERR "Unknow security level %d\n",
7491                        priv->ieee->sec.level);
7492                 break;
7493         }
7494 }
7495
7496 static void ipw_handle_data_packet(struct ipw_priv *priv,
7497                                    struct ipw_rx_mem_buffer *rxb,
7498                                    struct ieee80211_rx_stats *stats)
7499 {
7500         struct ieee80211_hdr_4addr *hdr;
7501         struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7502
7503         /* We received data from the HW, so stop the watchdog */
7504         priv->net_dev->trans_start = jiffies;
7505
7506         /* We only process data packets if the
7507          * interface is open */
7508         if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7509                      skb_tailroom(rxb->skb))) {
7510                 priv->ieee->stats.rx_errors++;
7511                 priv->wstats.discard.misc++;
7512                 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7513                 return;
7514         } else if (unlikely(!netif_running(priv->net_dev))) {
7515                 priv->ieee->stats.rx_dropped++;
7516                 priv->wstats.discard.misc++;
7517                 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7518                 return;
7519         }
7520
7521         /* Advance skb->data to the start of the actual payload */
7522         skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7523
7524         /* Set the size of the skb to the size of the frame */
7525         skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
7526
7527         IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7528
7529         /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
7530         hdr = (struct ieee80211_hdr_4addr *)rxb->skb->data;
7531         if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
7532             (is_multicast_ether_addr(hdr->addr1) ?
7533              !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
7534                 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7535
7536         if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7537                 priv->ieee->stats.rx_errors++;
7538         else {                  /* ieee80211_rx succeeded, so it now owns the SKB */
7539                 rxb->skb = NULL;
7540                 __ipw_led_activity_on(priv);
7541         }
7542 }
7543
7544 #ifdef CONFIG_IEEE80211_RADIOTAP
7545 static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7546                                            struct ipw_rx_mem_buffer *rxb,
7547                                            struct ieee80211_rx_stats *stats)
7548 {
7549         struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7550         struct ipw_rx_frame *frame = &pkt->u.frame;
7551
7552         /* initial pull of some data */
7553         u16 received_channel = frame->received_channel;
7554         u8 antennaAndPhy = frame->antennaAndPhy;
7555         s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM;       /* call it signed anyhow */
7556         u16 pktrate = frame->rate;
7557
7558         /* Magic struct that slots into the radiotap header -- no reason
7559          * to build this manually element by element, we can write it much
7560          * more efficiently than we can parse it. ORDER MATTERS HERE */
7561         struct ipw_rt_hdr {
7562                 struct ieee80211_radiotap_header rt_hdr;
7563                 u8 rt_flags;    /* radiotap packet flags */
7564                 u8 rt_rate;     /* rate in 500kb/s */
7565                 u16 rt_channel; /* channel in mhz */
7566                 u16 rt_chbitmask;       /* channel bitfield */
7567                 s8 rt_dbmsignal;        /* signal in dbM, kluged to signed */
7568                 u8 rt_antenna;  /* antenna number */
7569         } *ipw_rt;
7570
7571         short len = le16_to_cpu(pkt->u.frame.length);
7572
7573         /* We received data from the HW, so stop the watchdog */
7574         priv->net_dev->trans_start = jiffies;
7575
7576         /* We only process data packets if the
7577          * interface is open */
7578         if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7579                      skb_tailroom(rxb->skb))) {
7580                 priv->ieee->stats.rx_errors++;
7581                 priv->wstats.discard.misc++;
7582                 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7583                 return;
7584         } else if (unlikely(!netif_running(priv->net_dev))) {
7585                 priv->ieee->stats.rx_dropped++;
7586                 priv->wstats.discard.misc++;
7587                 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7588                 return;
7589         }
7590
7591         /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7592          * that now */
7593         if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7594                 /* FIXME: Should alloc bigger skb instead */
7595                 priv->ieee->stats.rx_dropped++;
7596                 priv->wstats.discard.misc++;
7597                 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7598                 return;
7599         }
7600
7601         /* copy the frame itself */
7602         memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7603                 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7604
7605         /* Zero the radiotap static buffer  ...  We only need to zero the bytes NOT
7606          * part of our real header, saves a little time.
7607          *
7608          * No longer necessary since we fill in all our data.  Purge before merging
7609          * patch officially.
7610          * memset(rxb->skb->data + sizeof(struct ipw_rt_hdr), 0,
7611          *        IEEE80211_RADIOTAP_HDRLEN - sizeof(struct ipw_rt_hdr));
7612          */
7613
7614         ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7615
7616         ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7617         ipw_rt->rt_hdr.it_pad = 0;      /* always good to zero */
7618         ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr);      /* total header+data */
7619
7620         /* Big bitfield of all the fields we provide in radiotap */
7621         ipw_rt->rt_hdr.it_present =
7622             ((1 << IEEE80211_RADIOTAP_FLAGS) |
7623              (1 << IEEE80211_RADIOTAP_RATE) |
7624              (1 << IEEE80211_RADIOTAP_CHANNEL) |
7625              (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
7626              (1 << IEEE80211_RADIOTAP_ANTENNA));
7627
7628         /* Zero the flags, we'll add to them as we go */
7629         ipw_rt->rt_flags = 0;
7630
7631         /* Convert signal to DBM */
7632         ipw_rt->rt_dbmsignal = antsignal;
7633
7634         /* Convert the channel data and set the flags */
7635         ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7636         if (received_channel > 14) {    /* 802.11a */
7637                 ipw_rt->rt_chbitmask =
7638                     cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7639         } else if (antennaAndPhy & 32) {        /* 802.11b */
7640                 ipw_rt->rt_chbitmask =
7641                     cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7642         } else {                /* 802.11g */
7643                 ipw_rt->rt_chbitmask =
7644                     (IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
7645         }
7646
7647         /* set the rate in multiples of 500k/s */
7648         switch (pktrate) {
7649         case IPW_TX_RATE_1MB:
7650                 ipw_rt->rt_rate = 2;
7651                 break;
7652         case IPW_TX_RATE_2MB:
7653                 ipw_rt->rt_rate = 4;
7654                 break;
7655         case IPW_TX_RATE_5MB:
7656                 ipw_rt->rt_rate = 10;
7657                 break;
7658         case IPW_TX_RATE_6MB:
7659                 ipw_rt->rt_rate = 12;
7660                 break;
7661         case IPW_TX_RATE_9MB:
7662                 ipw_rt->rt_rate = 18;
7663                 break;
7664         case IPW_TX_RATE_11MB:
7665                 ipw_rt->rt_rate = 22;
7666                 break;
7667         case IPW_TX_RATE_12MB:
7668                 ipw_rt->rt_rate = 24;
7669                 break;
7670         case IPW_TX_RATE_18MB:
7671                 ipw_rt->rt_rate = 36;
7672                 break;
7673         case IPW_TX_RATE_24MB:
7674                 ipw_rt->rt_rate = 48;
7675                 break;
7676         case IPW_TX_RATE_36MB:
7677                 ipw_rt->rt_rate = 72;
7678                 break;
7679         case IPW_TX_RATE_48MB:
7680                 ipw_rt->rt_rate = 96;
7681                 break;
7682         case IPW_TX_RATE_54MB:
7683                 ipw_rt->rt_rate = 108;
7684                 break;
7685         default:
7686                 ipw_rt->rt_rate = 0;
7687                 break;
7688         }
7689
7690         /* antenna number */
7691         ipw_rt->rt_antenna = (antennaAndPhy & 3);       /* Is this right? */
7692
7693         /* set the preamble flag if we have it */
7694         if ((antennaAndPhy & 64))
7695                 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7696
7697         /* Set the size of the skb to the size of the frame */
7698         skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
7699
7700         IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7701
7702         if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7703                 priv->ieee->stats.rx_errors++;
7704         else {                  /* ieee80211_rx succeeded, so it now owns the SKB */
7705                 rxb->skb = NULL;
7706                 /* no LED during capture */
7707         }
7708 }
7709 #endif
7710
7711 static int is_network_packet(struct ipw_priv *priv,
7712                                     struct ieee80211_hdr_4addr *header)
7713 {
7714         /* Filter incoming packets to determine if they are targetted toward
7715          * this network, discarding packets coming from ourselves */
7716         switch (priv->ieee->iw_mode) {
7717         case IW_MODE_ADHOC:     /* Header: Dest. | Source    | BSSID */
7718                 /* packets from our adapter are dropped (echo) */
7719                 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
7720                         return 0;
7721
7722                 /* {broad,multi}cast packets to our BSSID go through */
7723                 if (is_multicast_ether_addr(header->addr1))
7724                         return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
7725
7726                 /* packets to our adapter go through */
7727                 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7728                                ETH_ALEN);
7729
7730         case IW_MODE_INFRA:     /* Header: Dest. | BSSID | Source */
7731                 /* packets from our adapter are dropped (echo) */
7732                 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
7733                         return 0;
7734
7735                 /* {broad,multi}cast packets to our BSS go through */
7736                 if (is_multicast_ether_addr(header->addr1))
7737                         return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
7738
7739                 /* packets to our adapter go through */
7740                 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7741                                ETH_ALEN);
7742         }
7743
7744         return 1;
7745 }
7746
7747 #define IPW_PACKET_RETRY_TIME HZ
7748
7749 static  int is_duplicate_packet(struct ipw_priv *priv,
7750                                       struct ieee80211_hdr_4addr *header)
7751 {
7752         u16 sc = le16_to_cpu(header->seq_ctl);
7753         u16 seq = WLAN_GET_SEQ_SEQ(sc);
7754         u16 frag = WLAN_GET_SEQ_FRAG(sc);
7755         u16 *last_seq, *last_frag;
7756         unsigned long *last_time;
7757
7758         switch (priv->ieee->iw_mode) {
7759         case IW_MODE_ADHOC:
7760                 {
7761                         struct list_head *p;
7762                         struct ipw_ibss_seq *entry = NULL;
7763                         u8 *mac = header->addr2;
7764                         int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
7765
7766                         __list_for_each(p, &priv->ibss_mac_hash[index]) {
7767                                 entry =
7768                                     list_entry(p, struct ipw_ibss_seq, list);
7769                                 if (!memcmp(entry->mac, mac, ETH_ALEN))
7770                                         break;
7771                         }
7772                         if (p == &priv->ibss_mac_hash[index]) {
7773                                 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
7774                                 if (!entry) {
7775                                         IPW_ERROR
7776                                             ("Cannot malloc new mac entry\n");
7777                                         return 0;
7778                                 }
7779                                 memcpy(entry->mac, mac, ETH_ALEN);
7780                                 entry->seq_num = seq;
7781                                 entry->frag_num = frag;
7782                                 entry->packet_time = jiffies;
7783                                 list_add(&entry->list,
7784                                          &priv->ibss_mac_hash[index]);
7785                                 return 0;
7786                         }
7787                         last_seq = &entry->seq_num;
7788                         last_frag = &entry->frag_num;
7789                         last_time = &entry->packet_time;
7790                         break;
7791                 }
7792         case IW_MODE_INFRA:
7793                 last_seq = &priv->last_seq_num;
7794                 last_frag = &priv->last_frag_num;
7795                 last_time = &priv->last_packet_time;
7796                 break;
7797         default:
7798                 return 0;
7799         }
7800         if ((*last_seq == seq) &&
7801             time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
7802                 if (*last_frag == frag)
7803                         goto drop;
7804                 if (*last_frag + 1 != frag)
7805                         /* out-of-order fragment */
7806                         goto drop;
7807         } else
7808                 *last_seq = seq;
7809
7810         *last_frag = frag;
7811         *last_time = jiffies;
7812         return 0;
7813
7814       drop:
7815         /* Comment this line now since we observed the card receives
7816          * duplicate packets but the FCTL_RETRY bit is not set in the
7817          * IBSS mode with fragmentation enabled.
7818          BUG_ON(!(le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_RETRY)); */
7819         return 1;
7820 }
7821
7822 static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
7823                                    struct ipw_rx_mem_buffer *rxb,
7824                                    struct ieee80211_rx_stats *stats)
7825 {
7826         struct sk_buff *skb = rxb->skb;
7827         struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
7828         struct ieee80211_hdr_4addr *header = (struct ieee80211_hdr_4addr *)
7829             (skb->data + IPW_RX_FRAME_SIZE);
7830
7831         ieee80211_rx_mgt(priv->ieee, header, stats);
7832
7833         if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
7834             ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7835               IEEE80211_STYPE_PROBE_RESP) ||
7836              (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7837               IEEE80211_STYPE_BEACON))) {
7838                 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
7839                         ipw_add_station(priv, header->addr2);
7840         }
7841
7842         if (priv->config & CFG_NET_STATS) {
7843                 IPW_DEBUG_HC("sending stat packet\n");
7844
7845                 /* Set the size of the skb to the size of the full
7846                  * ipw header and 802.11 frame */
7847                 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
7848                         IPW_RX_FRAME_SIZE);
7849
7850                 /* Advance past the ipw packet header to the 802.11 frame */
7851                 skb_pull(skb, IPW_RX_FRAME_SIZE);
7852
7853                 /* Push the ieee80211_rx_stats before the 802.11 frame */
7854                 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
7855
7856                 skb->dev = priv->ieee->dev;
7857
7858                 /* Point raw at the ieee80211_stats */
7859                 skb->mac.raw = skb->data;
7860
7861                 skb->pkt_type = PACKET_OTHERHOST;
7862                 skb->protocol = __constant_htons(ETH_P_80211_STATS);
7863                 memset(skb->cb, 0, sizeof(rxb->skb->cb));
7864                 netif_rx(skb);
7865                 rxb->skb = NULL;
7866         }
7867 }
7868
7869 /*
7870  * Main entry function for recieving a packet with 80211 headers.  This
7871  * should be called when ever the FW has notified us that there is a new
7872  * skb in the recieve queue.
7873  */
7874 static void ipw_rx(struct ipw_priv *priv)
7875 {
7876         struct ipw_rx_mem_buffer *rxb;
7877         struct ipw_rx_packet *pkt;
7878         struct ieee80211_hdr_4addr *header;
7879         u32 r, w, i;
7880         u8 network_packet;
7881
7882         r = ipw_read32(priv, IPW_RX_READ_INDEX);
7883         w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
7884         i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE;
7885
7886         while (i != r) {
7887                 rxb = priv->rxq->queue[i];
7888 #ifdef CONFIG_IPW2200_DEBUG
7889                 if (unlikely(rxb == NULL)) {
7890                         printk(KERN_CRIT "Queue not allocated!\n");
7891                         break;
7892                 }
7893 #endif
7894                 priv->rxq->queue[i] = NULL;
7895
7896                 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
7897                                             IPW_RX_BUF_SIZE,
7898                                             PCI_DMA_FROMDEVICE);
7899
7900                 pkt = (struct ipw_rx_packet *)rxb->skb->data;
7901                 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
7902                              pkt->header.message_type,
7903                              pkt->header.rx_seq_num, pkt->header.control_bits);
7904
7905                 switch (pkt->header.message_type) {
7906                 case RX_FRAME_TYPE:     /* 802.11 frame */  {
7907                                 struct ieee80211_rx_stats stats = {
7908                                         .rssi =
7909                                             le16_to_cpu(pkt->u.frame.rssi_dbm) -
7910                                             IPW_RSSI_TO_DBM,
7911                                         .signal =
7912                                             le16_to_cpu(pkt->u.frame.signal),
7913                                         .noise =
7914                                             le16_to_cpu(pkt->u.frame.noise),
7915                                         .rate = pkt->u.frame.rate,
7916                                         .mac_time = jiffies,
7917                                         .received_channel =
7918                                             pkt->u.frame.received_channel,
7919                                         .freq =
7920                                             (pkt->u.frame.
7921                                              control & (1 << 0)) ?
7922                                             IEEE80211_24GHZ_BAND :
7923                                             IEEE80211_52GHZ_BAND,
7924                                         .len = le16_to_cpu(pkt->u.frame.length),
7925                                 };
7926
7927                                 if (stats.rssi != 0)
7928                                         stats.mask |= IEEE80211_STATMASK_RSSI;
7929                                 if (stats.signal != 0)
7930                                         stats.mask |= IEEE80211_STATMASK_SIGNAL;
7931                                 if (stats.noise != 0)
7932                                         stats.mask |= IEEE80211_STATMASK_NOISE;
7933                                 if (stats.rate != 0)
7934                                         stats.mask |= IEEE80211_STATMASK_RATE;
7935
7936                                 priv->rx_packets++;
7937
7938 #ifdef CONFIG_IPW2200_MONITOR
7939                                 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7940 #ifdef CONFIG_IEEE80211_RADIOTAP
7941                                         ipw_handle_data_packet_monitor(priv,
7942                                                                        rxb,
7943                                                                        &stats);
7944 #else
7945                                         ipw_handle_data_packet(priv, rxb,
7946                                                                &stats);
7947 #endif
7948                                         break;
7949                                 }
7950 #endif
7951
7952                                 header =
7953                                     (struct ieee80211_hdr_4addr *)(rxb->skb->
7954                                                                    data +
7955                                                                    IPW_RX_FRAME_SIZE);
7956                                 /* TODO: Check Ad-Hoc dest/source and make sure
7957                                  * that we are actually parsing these packets
7958                                  * correctly -- we should probably use the
7959                                  * frame control of the packet and disregard
7960                                  * the current iw_mode */
7961
7962                                 network_packet =
7963                                     is_network_packet(priv, header);
7964                                 if (network_packet && priv->assoc_network) {
7965                                         priv->assoc_network->stats.rssi =
7966                                             stats.rssi;
7967                                         average_add(&priv->average_rssi,
7968                                                     stats.rssi);
7969                                         priv->last_rx_rssi = stats.rssi;
7970                                 }
7971
7972                                 IPW_DEBUG_RX("Frame: len=%u\n",
7973                                              le16_to_cpu(pkt->u.frame.length));
7974
7975                                 if (le16_to_cpu(pkt->u.frame.length) <
7976                                     frame_hdr_len(header)) {
7977                                         IPW_DEBUG_DROP
7978                                             ("Received packet is too small. "
7979                                              "Dropping.\n");
7980                                         priv->ieee->stats.rx_errors++;
7981                                         priv->wstats.discard.misc++;
7982                                         break;
7983                                 }
7984
7985                                 switch (WLAN_FC_GET_TYPE
7986                                         (le16_to_cpu(header->frame_ctl))) {
7987
7988                                 case IEEE80211_FTYPE_MGMT:
7989                                         ipw_handle_mgmt_packet(priv, rxb,
7990                                                                &stats);
7991                                         break;
7992
7993                                 case IEEE80211_FTYPE_CTL:
7994                                         break;
7995
7996                                 case IEEE80211_FTYPE_DATA:
7997                                         if (unlikely(!network_packet ||
7998                                                      is_duplicate_packet(priv,
7999                                                                          header)))
8000                                         {
8001                                                 IPW_DEBUG_DROP("Dropping: "
8002                                                                MAC_FMT ", "
8003                                                                MAC_FMT ", "
8004                                                                MAC_FMT "\n",
8005                                                                MAC_ARG(header->
8006                                                                        addr1),
8007                                                                MAC_ARG(header->
8008                                                                        addr2),
8009                                                                MAC_ARG(header->
8010                                                                        addr3));
8011                                                 break;
8012                                         }
8013
8014                                         ipw_handle_data_packet(priv, rxb,
8015                                                                &stats);
8016
8017                                         break;
8018                                 }
8019                                 break;
8020                         }
8021
8022                 case RX_HOST_NOTIFICATION_TYPE:{
8023                                 IPW_DEBUG_RX
8024                                     ("Notification: subtype=%02X flags=%02X size=%d\n",
8025                                      pkt->u.notification.subtype,
8026                                      pkt->u.notification.flags,
8027                                      pkt->u.notification.size);
8028                                 ipw_rx_notification(priv, &pkt->u.notification);
8029                                 break;
8030                         }
8031
8032                 default:
8033                         IPW_DEBUG_RX("Bad Rx packet of type %d\n",
8034                                      pkt->header.message_type);
8035                         break;
8036                 }
8037
8038                 /* For now we just don't re-use anything.  We can tweak this
8039                  * later to try and re-use notification packets and SKBs that
8040                  * fail to Rx correctly */
8041                 if (rxb->skb != NULL) {
8042                         dev_kfree_skb_any(rxb->skb);
8043                         rxb->skb = NULL;
8044                 }
8045
8046                 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
8047                                  IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
8048                 list_add_tail(&rxb->list, &priv->rxq->rx_used);
8049
8050                 i = (i + 1) % RX_QUEUE_SIZE;
8051         }
8052
8053         /* Backtrack one entry */
8054         priv->rxq->processed = (i ? i : RX_QUEUE_SIZE) - 1;
8055
8056         ipw_rx_queue_restock(priv);
8057 }
8058
8059 #define DEFAULT_RTS_THRESHOLD     2304U
8060 #define MIN_RTS_THRESHOLD         1U
8061 #define MAX_RTS_THRESHOLD         2304U
8062 #define DEFAULT_BEACON_INTERVAL   100U
8063 #define DEFAULT_SHORT_RETRY_LIMIT 7U
8064 #define DEFAULT_LONG_RETRY_LIMIT  4U
8065
8066 static int ipw_sw_reset(struct ipw_priv *priv, int init)
8067 {
8068         int band, modulation;
8069         int old_mode = priv->ieee->iw_mode;
8070
8071         /* Initialize module parameter values here */
8072         priv->config = 0;
8073
8074         /* We default to disabling the LED code as right now it causes
8075          * too many systems to lock up... */
8076         if (!led)
8077                 priv->config |= CFG_NO_LED;
8078
8079         if (associate)
8080                 priv->config |= CFG_ASSOCIATE;
8081         else
8082                 IPW_DEBUG_INFO("Auto associate disabled.\n");
8083
8084         if (auto_create)
8085                 priv->config |= CFG_ADHOC_CREATE;
8086         else
8087                 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
8088
8089         priv->config &= ~CFG_STATIC_ESSID;
8090         priv->essid_len = 0;
8091         memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
8092
8093         if (disable) {
8094                 priv->status |= STATUS_RF_KILL_SW;
8095                 IPW_DEBUG_INFO("Radio disabled.\n");
8096         }
8097
8098         if (channel != 0) {
8099                 priv->config |= CFG_STATIC_CHANNEL;
8100                 priv->channel = channel;
8101                 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
8102                 /* TODO: Validate that provided channel is in range */
8103         }
8104 #ifdef CONFIG_IPW_QOS
8105         ipw_qos_init(priv, qos_enable, qos_burst_enable,
8106                      burst_duration_CCK, burst_duration_OFDM);
8107 #endif                          /* CONFIG_IPW_QOS */
8108
8109         switch (mode) {
8110         case 1:
8111                 priv->ieee->iw_mode = IW_MODE_ADHOC;
8112                 priv->net_dev->type = ARPHRD_ETHER;
8113
8114                 break;
8115 #ifdef CONFIG_IPW2200_MONITOR
8116         case 2:
8117                 priv->ieee->iw_mode = IW_MODE_MONITOR;
8118 #ifdef CONFIG_IEEE80211_RADIOTAP
8119                 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8120 #else
8121                 priv->net_dev->type = ARPHRD_IEEE80211;
8122 #endif
8123                 break;
8124 #endif
8125         default:
8126         case 0:
8127                 priv->net_dev->type = ARPHRD_ETHER;
8128                 priv->ieee->iw_mode = IW_MODE_INFRA;
8129                 break;
8130         }
8131
8132         if (hwcrypto) {
8133                 priv->ieee->host_encrypt = 0;
8134                 priv->ieee->host_encrypt_msdu = 0;
8135                 priv->ieee->host_decrypt = 0;
8136                 priv->ieee->host_mc_decrypt = 0;
8137         }
8138         IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
8139
8140         /* IPW2200/2915 is abled to do hardware fragmentation. */
8141         priv->ieee->host_open_frag = 0;
8142
8143         if ((priv->pci_dev->device == 0x4223) ||
8144             (priv->pci_dev->device == 0x4224)) {
8145                 if (init)
8146                         printk(KERN_INFO DRV_NAME
8147                                ": Detected Intel PRO/Wireless 2915ABG Network "
8148                                "Connection\n");
8149                 priv->ieee->abg_true = 1;
8150                 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
8151                 modulation = IEEE80211_OFDM_MODULATION |
8152                     IEEE80211_CCK_MODULATION;
8153                 priv->adapter = IPW_2915ABG;
8154                 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
8155         } else {
8156                 if (init)
8157                         printk(KERN_INFO DRV_NAME
8158                                ": Detected Intel PRO/Wireless 2200BG Network "
8159                                "Connection\n");
8160
8161                 priv->ieee->abg_true = 0;
8162                 band = IEEE80211_24GHZ_BAND;
8163                 modulation = IEEE80211_OFDM_MODULATION |
8164                     IEEE80211_CCK_MODULATION;
8165                 priv->adapter = IPW_2200BG;
8166                 priv->ieee->mode = IEEE_G | IEEE_B;
8167         }
8168
8169         priv->ieee->freq_band = band;
8170         priv->ieee->modulation = modulation;
8171
8172         priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;
8173
8174         priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8175         priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
8176
8177         priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8178         priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8179         priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
8180
8181         /* If power management is turned on, default to AC mode */
8182         priv->power_mode = IPW_POWER_AC;
8183         priv->tx_power = IPW_TX_POWER_DEFAULT;
8184
8185         return old_mode == priv->ieee->iw_mode;
8186 }
8187
8188 /*
8189  * This file defines the Wireless Extension handlers.  It does not
8190  * define any methods of hardware manipulation and relies on the
8191  * functions defined in ipw_main to provide the HW interaction.
8192  *
8193  * The exception to this is the use of the ipw_get_ordinal()
8194  * function used to poll the hardware vs. making unecessary calls.
8195  *
8196  */
8197
8198 static int ipw_wx_get_name(struct net_device *dev,
8199                            struct iw_request_info *info,
8200                            union iwreq_data *wrqu, char *extra)
8201 {
8202         struct ipw_priv *priv = ieee80211_priv(dev);
8203         down(&priv->sem);
8204         if (priv->status & STATUS_RF_KILL_MASK)
8205                 strcpy(wrqu->name, "radio off");
8206         else if (!(priv->status & STATUS_ASSOCIATED))
8207                 strcpy(wrqu->name, "unassociated");
8208         else
8209                 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c",
8210                          ipw_modes[priv->assoc_request.ieee_mode]);
8211         IPW_DEBUG_WX("Name: %s\n", wrqu->name);
8212         up(&priv->sem);
8213         return 0;
8214 }
8215
8216 static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8217 {
8218         if (channel == 0) {
8219                 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8220                 priv->config &= ~CFG_STATIC_CHANNEL;
8221                 IPW_DEBUG_ASSOC("Attempting to associate with new "
8222                                 "parameters.\n");
8223                 ipw_associate(priv);
8224                 return 0;
8225         }
8226
8227         priv->config |= CFG_STATIC_CHANNEL;
8228
8229         if (priv->channel == channel) {
8230                 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8231                                channel);
8232                 return 0;
8233         }
8234
8235         IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8236         priv->channel = channel;
8237
8238 #ifdef CONFIG_IPW2200_MONITOR
8239         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8240                 int i;
8241                 if (priv->status & STATUS_SCANNING) {
8242                         IPW_DEBUG_SCAN("Scan abort triggered due to "
8243                                        "channel change.\n");
8244                         ipw_abort_scan(priv);
8245                 }
8246
8247                 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8248                         udelay(10);
8249
8250                 if (priv->status & STATUS_SCANNING)
8251                         IPW_DEBUG_SCAN("Still scanning...\n");
8252                 else
8253                         IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8254                                        1000 - i);
8255
8256                 return 0;
8257         }
8258 #endif                          /* CONFIG_IPW2200_MONITOR */
8259
8260         /* Network configuration changed -- force [re]association */
8261         IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8262         if (!ipw_disassociate(priv))
8263                 ipw_associate(priv);
8264
8265         return 0;
8266 }
8267
8268 static int ipw_wx_set_freq(struct net_device *dev,
8269                            struct iw_request_info *info,
8270                            union iwreq_data *wrqu, char *extra)
8271 {
8272         struct ipw_priv *priv = ieee80211_priv(dev);
8273         const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
8274         struct iw_freq *fwrq = &wrqu->freq;
8275         int ret = 0, i;
8276         u8 channel, flags;
8277         int band;
8278
8279         if (fwrq->m == 0) {
8280                 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
8281                 down(&priv->sem);
8282                 ret = ipw_set_channel(priv, 0);
8283                 up(&priv->sem);
8284                 return ret;
8285         }
8286         /* if setting by freq convert to channel */
8287         if (fwrq->e == 1) {
8288                 channel = ipw_freq_to_channel(priv->ieee, fwrq->m);
8289                 if (channel == 0)
8290                         return -EINVAL;
8291         } else
8292                 channel = fwrq->m;
8293
8294         if (!(band = ipw_is_valid_channel(priv->ieee, channel)))
8295                 return -EINVAL;
8296
8297         if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
8298                 i = ipw_channel_to_index(priv->ieee, channel);
8299                 if (i == -1)
8300                         return -EINVAL;
8301
8302                 flags = (band == IEEE80211_24GHZ_BAND) ?
8303                     geo->bg[i].flags : geo->a[i].flags;
8304                 if (flags & IEEE80211_CH_PASSIVE_ONLY) {
8305                         IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8306                         return -EINVAL;
8307                 }
8308         }
8309
8310         IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
8311         down(&priv->sem);
8312         ret = ipw_set_channel(priv, channel);
8313         up(&priv->sem);
8314         return ret;
8315 }
8316
8317 static int ipw_wx_get_freq(struct net_device *dev,
8318                            struct iw_request_info *info,
8319                            union iwreq_data *wrqu, char *extra)
8320 {
8321         struct ipw_priv *priv = ieee80211_priv(dev);
8322
8323         wrqu->freq.e = 0;
8324
8325         /* If we are associated, trying to associate, or have a statically
8326          * configured CHANNEL then return that; otherwise return ANY */
8327         down(&priv->sem);
8328         if (priv->config & CFG_STATIC_CHANNEL ||
8329             priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))
8330                 wrqu->freq.m = priv->channel;
8331         else
8332                 wrqu->freq.m = 0;
8333
8334         up(&priv->sem);
8335         IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
8336         return 0;
8337 }
8338
8339 static int ipw_wx_set_mode(struct net_device *dev,
8340                            struct iw_request_info *info,
8341                            union iwreq_data *wrqu, char *extra)
8342 {
8343         struct ipw_priv *priv = ieee80211_priv(dev);
8344         int err = 0;
8345
8346         IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8347
8348         switch (wrqu->mode) {
8349 #ifdef CONFIG_IPW2200_MONITOR
8350         case IW_MODE_MONITOR:
8351 #endif
8352         case IW_MODE_ADHOC:
8353         case IW_MODE_INFRA:
8354                 break;
8355         case IW_MODE_AUTO:
8356                 wrqu->mode = IW_MODE_INFRA;
8357                 break;
8358         default:
8359                 return -EINVAL;
8360         }
8361         if (wrqu->mode == priv->ieee->iw_mode)
8362                 return 0;
8363
8364         down(&priv->sem);
8365
8366         ipw_sw_reset(priv, 0);
8367
8368 #ifdef CONFIG_IPW2200_MONITOR
8369         if (priv->ieee->iw_mode == IW_MODE_MONITOR)
8370                 priv->net_dev->type = ARPHRD_ETHER;
8371
8372         if (wrqu->mode == IW_MODE_MONITOR)
8373 #ifdef CONFIG_IEEE80211_RADIOTAP
8374                 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8375 #else
8376                 priv->net_dev->type = ARPHRD_IEEE80211;
8377 #endif
8378 #endif                          /* CONFIG_IPW2200_MONITOR */
8379
8380         /* Free the existing firmware and reset the fw_loaded
8381          * flag so ipw_load() will bring in the new firmawre */
8382         free_firmware();
8383
8384         priv->ieee->iw_mode = wrqu->mode;
8385
8386         queue_work(priv->workqueue, &priv->adapter_restart);
8387         up(&priv->sem);
8388         return err;
8389 }
8390
8391 static int ipw_wx_get_mode(struct net_device *dev,
8392                            struct iw_request_info *info,
8393                            union iwreq_data *wrqu, char *extra)
8394 {
8395         struct ipw_priv *priv = ieee80211_priv(dev);
8396         down(&priv->sem);
8397         wrqu->mode = priv->ieee->iw_mode;
8398         IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
8399         up(&priv->sem);
8400         return 0;
8401 }
8402
8403 /* Values are in microsecond */
8404 static const s32 timeout_duration[] = {
8405         350000,
8406         250000,
8407         75000,
8408         37000,
8409         25000,
8410 };
8411
8412 static const s32 period_duration[] = {
8413         400000,
8414         700000,
8415         1000000,
8416         1000000,
8417         1000000
8418 };
8419
8420 static int ipw_wx_get_range(struct net_device *dev,
8421                             struct iw_request_info *info,
8422                             union iwreq_data *wrqu, char *extra)
8423 {
8424         struct ipw_priv *priv = ieee80211_priv(dev);
8425         struct iw_range *range = (struct iw_range *)extra;
8426         const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
8427         int i = 0, j;
8428
8429         wrqu->data.length = sizeof(*range);
8430         memset(range, 0, sizeof(*range));
8431
8432         /* 54Mbs == ~27 Mb/s real (802.11g) */
8433         range->throughput = 27 * 1000 * 1000;
8434
8435         range->max_qual.qual = 100;
8436         /* TODO: Find real max RSSI and stick here */
8437         range->max_qual.level = 0;
8438         range->max_qual.noise = priv->ieee->worst_rssi + 0x100;
8439         range->max_qual.updated = 7;    /* Updated all three */
8440
8441         range->avg_qual.qual = 70;
8442         /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
8443         range->avg_qual.level = 0;      /* FIXME to real average level */
8444         range->avg_qual.noise = 0;
8445         range->avg_qual.updated = 7;    /* Updated all three */
8446         down(&priv->sem);
8447         range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
8448
8449         for (i = 0; i < range->num_bitrates; i++)
8450                 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
8451                     500000;
8452
8453         range->max_rts = DEFAULT_RTS_THRESHOLD;
8454         range->min_frag = MIN_FRAG_THRESHOLD;
8455         range->max_frag = MAX_FRAG_THRESHOLD;
8456
8457         range->encoding_size[0] = 5;
8458         range->encoding_size[1] = 13;
8459         range->num_encoding_sizes = 2;
8460         range->max_encoding_tokens = WEP_KEYS;
8461
8462         /* Set the Wireless Extension versions */
8463         range->we_version_compiled = WIRELESS_EXT;
8464         range->we_version_source = 16;
8465
8466         i = 0;
8467         if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8468                 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES;
8469                      i++, j++) {
8470                         range->freq[i].i = geo->bg[j].channel;
8471                         range->freq[i].m = geo->bg[j].freq * 100000;
8472                         range->freq[i].e = 1;
8473                 }
8474         }
8475
8476         if (priv->ieee->mode & IEEE_A) {
8477                 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES;
8478                      i++, j++) {
8479                         range->freq[i].i = geo->a[j].channel;
8480                         range->freq[i].m = geo->a[j].freq * 100000;
8481                         range->freq[i].e = 1;
8482                 }
8483         }
8484
8485         range->num_channels = i;
8486         range->num_frequency = i;
8487
8488         up(&priv->sem);
8489
8490         /* Event capability (kernel + driver) */
8491         range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
8492                                 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
8493                                 IW_EVENT_CAPA_MASK(SIOCGIWAP));
8494         range->event_capa[1] = IW_EVENT_CAPA_K_1;
8495
8496         IPW_DEBUG_WX("GET Range\n");
8497         return 0;
8498 }
8499
8500 static int ipw_wx_set_wap(struct net_device *dev,
8501                           struct iw_request_info *info,
8502                           union iwreq_data *wrqu, char *extra)
8503 {
8504         struct ipw_priv *priv = ieee80211_priv(dev);
8505
8506         static const unsigned char any[] = {
8507                 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
8508         };
8509         static const unsigned char off[] = {
8510                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
8511         };
8512
8513         if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
8514                 return -EINVAL;
8515         down(&priv->sem);
8516         if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
8517             !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8518                 /* we disable mandatory BSSID association */
8519                 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
8520                 priv->config &= ~CFG_STATIC_BSSID;
8521                 IPW_DEBUG_ASSOC("Attempting to associate with new "
8522                                 "parameters.\n");
8523                 ipw_associate(priv);
8524                 up(&priv->sem);
8525                 return 0;
8526         }
8527
8528         priv->config |= CFG_STATIC_BSSID;
8529         if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8530                 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
8531                 up(&priv->sem);
8532                 return 0;
8533         }
8534
8535         IPW_DEBUG_WX("Setting mandatory BSSID to " MAC_FMT "\n",
8536                      MAC_ARG(wrqu->ap_addr.sa_data));
8537
8538         memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
8539
8540         /* Network configuration changed -- force [re]association */
8541         IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
8542         if (!ipw_disassociate(priv))
8543                 ipw_associate(priv);
8544
8545         up(&priv->sem);
8546         return 0;
8547 }
8548
8549 static int ipw_wx_get_wap(struct net_device *dev,
8550                           struct iw_request_info *info,
8551                           union iwreq_data *wrqu, char *extra)
8552 {
8553         struct ipw_priv *priv = ieee80211_priv(dev);
8554         /* If we are associated, trying to associate, or have a statically
8555          * configured BSSID then return that; otherwise return ANY */
8556         down(&priv->sem);
8557         if (priv->config & CFG_STATIC_BSSID ||
8558             priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8559                 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
8560                 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
8561         } else
8562                 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
8563
8564         IPW_DEBUG_WX("Getting WAP BSSID: " MAC_FMT "\n",
8565                      MAC_ARG(wrqu->ap_addr.sa_data));
8566         up(&priv->sem);
8567         return 0;
8568 }
8569
8570 static int ipw_wx_set_essid(struct net_device *dev,
8571                             struct iw_request_info *info,
8572                             union iwreq_data *wrqu, char *extra)
8573 {
8574         struct ipw_priv *priv = ieee80211_priv(dev);
8575         char *essid = "";       /* ANY */
8576         int length = 0;
8577         down(&priv->sem);
8578         if (wrqu->essid.flags && wrqu->essid.length) {
8579                 length = wrqu->essid.length - 1;
8580                 essid = extra;
8581         }
8582         if (length == 0) {
8583                 IPW_DEBUG_WX("Setting ESSID to ANY\n");
8584                 if ((priv->config & CFG_STATIC_ESSID) &&
8585                     !(priv->status & (STATUS_ASSOCIATED |
8586                                       STATUS_ASSOCIATING))) {
8587                         IPW_DEBUG_ASSOC("Attempting to associate with new "
8588                                         "parameters.\n");
8589                         priv->config &= ~CFG_STATIC_ESSID;
8590                         ipw_associate(priv);
8591                 }
8592                 up(&priv->sem);
8593                 return 0;
8594         }
8595
8596         length = min(length, IW_ESSID_MAX_SIZE);
8597
8598         priv->config |= CFG_STATIC_ESSID;
8599
8600         if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
8601                 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
8602                 up(&priv->sem);
8603                 return 0;
8604         }
8605
8606         IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n", escape_essid(essid, length),
8607                      length);
8608
8609         priv->essid_len = length;
8610         memcpy(priv->essid, essid, priv->essid_len);
8611
8612         /* Network configuration changed -- force [re]association */
8613         IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
8614         if (!ipw_disassociate(priv))
8615                 ipw_associate(priv);
8616
8617         up(&priv->sem);
8618         return 0;
8619 }
8620
8621 static int ipw_wx_get_essid(struct net_device *dev,
8622                             struct iw_request_info *info,
8623                             union iwreq_data *wrqu, char *extra)
8624 {
8625         struct ipw_priv *priv = ieee80211_priv(dev);
8626
8627         /* If we are associated, trying to associate, or have a statically
8628          * configured ESSID then return that; otherwise return ANY */
8629         down(&priv->sem);
8630         if (priv->config & CFG_STATIC_ESSID ||
8631             priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8632                 IPW_DEBUG_WX("Getting essid: '%s'\n",
8633                              escape_essid(priv->essid, priv->essid_len));
8634                 memcpy(extra, priv->essid, priv->essid_len);
8635                 wrqu->essid.length = priv->essid_len;
8636                 wrqu->essid.flags = 1;  /* active */
8637         } else {
8638                 IPW_DEBUG_WX("Getting essid: ANY\n");
8639                 wrqu->essid.length = 0;
8640                 wrqu->essid.flags = 0;  /* active */
8641         }
8642         up(&priv->sem);
8643         return 0;
8644 }
8645
8646 static int ipw_wx_set_nick(struct net_device *dev,
8647                            struct iw_request_info *info,
8648                            union iwreq_data *wrqu, char *extra)
8649 {
8650         struct ipw_priv *priv = ieee80211_priv(dev);
8651
8652         IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
8653         if (wrqu->data.length > IW_ESSID_MAX_SIZE)
8654                 return -E2BIG;
8655         down(&priv->sem);
8656         wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
8657         memset(priv->nick, 0, sizeof(priv->nick));
8658         memcpy(priv->nick, extra, wrqu->data.length);
8659         IPW_DEBUG_TRACE("<<\n");
8660         up(&priv->sem);
8661         return 0;
8662
8663 }
8664
8665 static int ipw_wx_get_nick(struct net_device *dev,
8666                            struct iw_request_info *info,
8667                            union iwreq_data *wrqu, char *extra)
8668 {
8669         struct ipw_priv *priv = ieee80211_priv(dev);
8670         IPW_DEBUG_WX("Getting nick\n");
8671         down(&priv->sem);
8672         wrqu->data.length = strlen(priv->nick) + 1;
8673         memcpy(extra, priv->nick, wrqu->data.length);
8674         wrqu->data.flags = 1;   /* active */
8675         up(&priv->sem);
8676         return 0;
8677 }
8678
8679 static int ipw_wx_set_rate(struct net_device *dev,
8680                            struct iw_request_info *info,
8681                            union iwreq_data *wrqu, char *extra)
8682 {
8683         /* TODO: We should use semaphores or locks for access to priv */
8684         struct ipw_priv *priv = ieee80211_priv(dev);
8685         u32 target_rate = wrqu->bitrate.value;
8686         u32 fixed, mask;
8687
8688         /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
8689         /* value = X, fixed = 1 means only rate X */
8690         /* value = X, fixed = 0 means all rates lower equal X */
8691
8692         if (target_rate == -1) {
8693                 fixed = 0;
8694                 mask = IEEE80211_DEFAULT_RATES_MASK;
8695                 /* Now we should reassociate */
8696                 goto apply;
8697         }
8698
8699         mask = 0;
8700         fixed = wrqu->bitrate.fixed;
8701
8702         if (target_rate == 1000000 || !fixed)
8703                 mask |= IEEE80211_CCK_RATE_1MB_MASK;
8704         if (target_rate == 1000000)
8705                 goto apply;
8706
8707         if (target_rate == 2000000 || !fixed)
8708                 mask |= IEEE80211_CCK_RATE_2MB_MASK;
8709         if (target_rate == 2000000)
8710                 goto apply;
8711
8712         if (target_rate == 5500000 || !fixed)
8713                 mask |= IEEE80211_CCK_RATE_5MB_MASK;
8714         if (target_rate == 5500000)
8715                 goto apply;
8716
8717         if (target_rate == 6000000 || !fixed)
8718                 mask |= IEEE80211_OFDM_RATE_6MB_MASK;
8719         if (target_rate == 6000000)
8720                 goto apply;
8721
8722         if (target_rate == 9000000 || !fixed)
8723                 mask |= IEEE80211_OFDM_RATE_9MB_MASK;
8724         if (target_rate == 9000000)
8725                 goto apply;
8726
8727         if (target_rate == 11000000 || !fixed)
8728                 mask |= IEEE80211_CCK_RATE_11MB_MASK;
8729         if (target_rate == 11000000)
8730                 goto apply;
8731
8732         if (target_rate == 12000000 || !fixed)
8733                 mask |= IEEE80211_OFDM_RATE_12MB_MASK;
8734         if (target_rate == 12000000)
8735                 goto apply;
8736
8737         if (target_rate == 18000000 || !fixed)
8738                 mask |= IEEE80211_OFDM_RATE_18MB_MASK;
8739         if (target_rate == 18000000)
8740                 goto apply;
8741
8742         if (target_rate == 24000000 || !fixed)
8743                 mask |= IEEE80211_OFDM_RATE_24MB_MASK;
8744         if (target_rate == 24000000)
8745                 goto apply;
8746
8747         if (target_rate == 36000000 || !fixed)
8748                 mask |= IEEE80211_OFDM_RATE_36MB_MASK;
8749         if (target_rate == 36000000)
8750                 goto apply;
8751
8752         if (target_rate == 48000000 || !fixed)
8753                 mask |= IEEE80211_OFDM_RATE_48MB_MASK;
8754         if (target_rate == 48000000)
8755                 goto apply;
8756
8757         if (target_rate == 54000000 || !fixed)
8758                 mask |= IEEE80211_OFDM_RATE_54MB_MASK;
8759         if (target_rate == 54000000)
8760                 goto apply;
8761
8762         IPW_DEBUG_WX("invalid rate specified, returning error\n");
8763         return -EINVAL;
8764
8765       apply:
8766         IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
8767                      mask, fixed ? "fixed" : "sub-rates");
8768         down(&priv->sem);
8769         if (mask == IEEE80211_DEFAULT_RATES_MASK) {
8770                 priv->config &= ~CFG_FIXED_RATE;
8771                 ipw_set_fixed_rate(priv, priv->ieee->mode);
8772         } else
8773                 priv->config |= CFG_FIXED_RATE;
8774
8775         if (priv->rates_mask == mask) {
8776                 IPW_DEBUG_WX("Mask set to current mask.\n");
8777                 up(&priv->sem);
8778                 return 0;
8779         }
8780
8781         priv->rates_mask = mask;
8782
8783         /* Network configuration changed -- force [re]association */
8784         IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
8785         if (!ipw_disassociate(priv))
8786                 ipw_associate(priv);
8787
8788         up(&priv->sem);
8789         return 0;
8790 }
8791
8792 static int ipw_wx_get_rate(struct net_device *dev,
8793                            struct iw_request_info *info,
8794                            union iwreq_data *wrqu, char *extra)
8795 {
8796         struct ipw_priv *priv = ieee80211_priv(dev);
8797         down(&priv->sem);
8798         wrqu->bitrate.value = priv->last_rate;
8799         up(&priv->sem);
8800         IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
8801         return 0;
8802 }
8803
8804 static int ipw_wx_set_rts(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         if (wrqu->rts.disabled)
8811                 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8812         else {
8813                 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
8814                     wrqu->rts.value > MAX_RTS_THRESHOLD) {
8815                         up(&priv->sem);
8816                         return -EINVAL;
8817                 }
8818                 priv->rts_threshold = wrqu->rts.value;
8819         }
8820
8821         ipw_send_rts_threshold(priv, priv->rts_threshold);
8822         up(&priv->sem);
8823         IPW_DEBUG_WX("SET RTS Threshold -> %d \n", priv->rts_threshold);
8824         return 0;
8825 }
8826
8827 static int ipw_wx_get_rts(struct net_device *dev,
8828                           struct iw_request_info *info,
8829                           union iwreq_data *wrqu, char *extra)
8830 {
8831         struct ipw_priv *priv = ieee80211_priv(dev);
8832         down(&priv->sem);
8833         wrqu->rts.value = priv->rts_threshold;
8834         wrqu->rts.fixed = 0;    /* no auto select */
8835         wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
8836         up(&priv->sem);
8837         IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value);
8838         return 0;
8839 }
8840
8841 static int ipw_wx_set_txpow(struct net_device *dev,
8842                             struct iw_request_info *info,
8843                             union iwreq_data *wrqu, char *extra)
8844 {
8845         struct ipw_priv *priv = ieee80211_priv(dev);
8846         int err = 0;
8847
8848         down(&priv->sem);
8849         if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
8850                 err = -EINPROGRESS;
8851                 goto out;
8852         }
8853
8854         if (!wrqu->power.fixed)
8855                 wrqu->power.value = IPW_TX_POWER_DEFAULT;
8856
8857         if (wrqu->power.flags != IW_TXPOW_DBM) {
8858                 err = -EINVAL;
8859                 goto out;
8860         }
8861
8862         if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
8863             (wrqu->power.value < IPW_TX_POWER_MIN)) {
8864                 err = -EINVAL;
8865                 goto out;
8866         }
8867
8868         priv->tx_power = wrqu->power.value;
8869         err = ipw_set_tx_power(priv);
8870       out:
8871         up(&priv->sem);
8872         return err;
8873 }
8874
8875 static int ipw_wx_get_txpow(struct net_device *dev,
8876                             struct iw_request_info *info,
8877                             union iwreq_data *wrqu, char *extra)
8878 {
8879         struct ipw_priv *priv = ieee80211_priv(dev);
8880         down(&priv->sem);
8881         wrqu->power.value = priv->tx_power;
8882         wrqu->power.fixed = 1;
8883         wrqu->power.flags = IW_TXPOW_DBM;
8884         wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
8885         up(&priv->sem);
8886
8887         IPW_DEBUG_WX("GET TX Power -> %s %d \n",
8888                      wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
8889
8890         return 0;
8891 }
8892
8893 static int ipw_wx_set_frag(struct net_device *dev,
8894                            struct iw_request_info *info,
8895                            union iwreq_data *wrqu, char *extra)
8896 {
8897         struct ipw_priv *priv = ieee80211_priv(dev);
8898         down(&priv->sem);
8899         if (wrqu->frag.disabled)
8900                 priv->ieee->fts = DEFAULT_FTS;
8901         else {
8902                 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
8903                     wrqu->frag.value > MAX_FRAG_THRESHOLD) {
8904                         up(&priv->sem);
8905                         return -EINVAL;
8906                 }
8907
8908                 priv->ieee->fts = wrqu->frag.value & ~0x1;
8909         }
8910
8911         ipw_send_frag_threshold(priv, wrqu->frag.value);
8912         up(&priv->sem);
8913         IPW_DEBUG_WX("SET Frag Threshold -> %d \n", wrqu->frag.value);
8914         return 0;
8915 }
8916
8917 static int ipw_wx_get_frag(struct net_device *dev,
8918                            struct iw_request_info *info,
8919                            union iwreq_data *wrqu, char *extra)
8920 {
8921         struct ipw_priv *priv = ieee80211_priv(dev);
8922         down(&priv->sem);
8923         wrqu->frag.value = priv->ieee->fts;
8924         wrqu->frag.fixed = 0;   /* no auto select */
8925         wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
8926         up(&priv->sem);
8927         IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
8928
8929         return 0;
8930 }
8931
8932 static int ipw_wx_set_retry(struct net_device *dev,
8933                             struct iw_request_info *info,
8934                             union iwreq_data *wrqu, char *extra)
8935 {
8936         struct ipw_priv *priv = ieee80211_priv(dev);
8937
8938         if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
8939                 return -EINVAL;
8940
8941         if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
8942                 return 0;
8943
8944         if (wrqu->retry.value < 0 || wrqu->retry.value > 255)
8945                 return -EINVAL;
8946
8947         down(&priv->sem);
8948         if (wrqu->retry.flags & IW_RETRY_MIN)
8949                 priv->short_retry_limit = (u8) wrqu->retry.value;
8950         else if (wrqu->retry.flags & IW_RETRY_MAX)
8951                 priv->long_retry_limit = (u8) wrqu->retry.value;
8952         else {
8953                 priv->short_retry_limit = (u8) wrqu->retry.value;
8954                 priv->long_retry_limit = (u8) wrqu->retry.value;
8955         }
8956
8957         ipw_send_retry_limit(priv, priv->short_retry_limit,
8958                              priv->long_retry_limit);
8959         up(&priv->sem);
8960         IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
8961                      priv->short_retry_limit, priv->long_retry_limit);
8962         return 0;
8963 }
8964
8965 static int ipw_wx_get_retry(struct net_device *dev,
8966                             struct iw_request_info *info,
8967                             union iwreq_data *wrqu, char *extra)
8968 {
8969         struct ipw_priv *priv = ieee80211_priv(dev);
8970
8971         down(&priv->sem);
8972         wrqu->retry.disabled = 0;
8973
8974         if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
8975                 up(&priv->sem);
8976                 return -EINVAL;
8977         }
8978
8979         if (wrqu->retry.flags & IW_RETRY_MAX) {
8980                 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
8981                 wrqu->retry.value = priv->long_retry_limit;
8982         } else if (wrqu->retry.flags & IW_RETRY_MIN) {
8983                 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
8984                 wrqu->retry.value = priv->short_retry_limit;
8985         } else {
8986                 wrqu->retry.flags = IW_RETRY_LIMIT;
8987                 wrqu->retry.value = priv->short_retry_limit;
8988         }
8989         up(&priv->sem);
8990
8991         IPW_DEBUG_WX("GET retry -> %d \n", wrqu->retry.value);
8992
8993         return 0;
8994 }
8995
8996 static int ipw_request_direct_scan(struct ipw_priv *priv, char *essid,
8997                                    int essid_len)
8998 {
8999         struct ipw_scan_request_ext scan;
9000         int err = 0, scan_type;
9001
9002         if (!(priv->status & STATUS_INIT) ||
9003             (priv->status & STATUS_EXIT_PENDING))
9004                 return 0;
9005
9006         down(&priv->sem);
9007
9008         if (priv->status & STATUS_RF_KILL_MASK) {
9009                 IPW_DEBUG_HC("Aborting scan due to RF kill activation\n");
9010                 priv->status |= STATUS_SCAN_PENDING;
9011                 goto done;
9012         }
9013
9014         IPW_DEBUG_HC("starting request direct scan!\n");
9015
9016         if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
9017                 /* We should not sleep here; otherwise we will block most
9018                  * of the system (for instance, we hold rtnl_lock when we
9019                  * get here).
9020                  */
9021                 err = -EAGAIN;
9022                 goto done;
9023         }
9024         memset(&scan, 0, sizeof(scan));
9025
9026         if (priv->config & CFG_SPEED_SCAN)
9027                 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
9028                     cpu_to_le16(30);
9029         else
9030                 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
9031                     cpu_to_le16(20);
9032
9033         scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
9034             cpu_to_le16(20);
9035         scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
9036         scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
9037
9038         scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
9039
9040         err = ipw_send_ssid(priv, essid, essid_len);
9041         if (err) {
9042                 IPW_DEBUG_HC("Attempt to send SSID command failed\n");
9043                 goto done;
9044         }
9045         scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
9046
9047         ipw_add_scan_channels(priv, &scan, scan_type);
9048
9049         err = ipw_send_scan_request_ext(priv, &scan);
9050         if (err) {
9051                 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
9052                 goto done;
9053         }
9054
9055         priv->status |= STATUS_SCANNING;
9056
9057       done:
9058         up(&priv->sem);
9059         return err;
9060 }
9061
9062 static int ipw_wx_set_scan(struct net_device *dev,
9063                            struct iw_request_info *info,
9064                            union iwreq_data *wrqu, char *extra)
9065 {
9066         struct ipw_priv *priv = ieee80211_priv(dev);
9067         struct iw_scan_req *req = NULL;
9068         if (wrqu->data.length
9069             && wrqu->data.length == sizeof(struct iw_scan_req)) {
9070                 req = (struct iw_scan_req *)extra;
9071                 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
9072                         ipw_request_direct_scan(priv, req->essid,
9073                                                 req->essid_len);
9074                         return 0;
9075                 }
9076         }
9077
9078         IPW_DEBUG_WX("Start scan\n");
9079
9080         queue_work(priv->workqueue, &priv->request_scan);
9081
9082         return 0;
9083 }
9084
9085 static int ipw_wx_get_scan(struct net_device *dev,
9086                            struct iw_request_info *info,
9087                            union iwreq_data *wrqu, char *extra)
9088 {
9089         struct ipw_priv *priv = ieee80211_priv(dev);
9090         return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
9091 }
9092
9093 static int ipw_wx_set_encode(struct net_device *dev,
9094                              struct iw_request_info *info,
9095                              union iwreq_data *wrqu, char *key)
9096 {
9097         struct ipw_priv *priv = ieee80211_priv(dev);
9098         int ret;
9099         u32 cap = priv->capability;
9100
9101         down(&priv->sem);
9102         ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
9103
9104         /* In IBSS mode, we need to notify the firmware to update
9105          * the beacon info after we changed the capability. */
9106         if (cap != priv->capability &&
9107             priv->ieee->iw_mode == IW_MODE_ADHOC &&
9108             priv->status & STATUS_ASSOCIATED)
9109                 ipw_disassociate(priv);
9110
9111         up(&priv->sem);
9112         return ret;
9113 }
9114
9115 static int ipw_wx_get_encode(struct net_device *dev,
9116                              struct iw_request_info *info,
9117                              union iwreq_data *wrqu, char *key)
9118 {
9119         struct ipw_priv *priv = ieee80211_priv(dev);
9120         return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
9121 }
9122
9123 static int ipw_wx_set_power(struct net_device *dev,
9124                             struct iw_request_info *info,
9125                             union iwreq_data *wrqu, char *extra)
9126 {
9127         struct ipw_priv *priv = ieee80211_priv(dev);
9128         int err;
9129         down(&priv->sem);
9130         if (wrqu->power.disabled) {
9131                 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9132                 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9133                 if (err) {
9134                         IPW_DEBUG_WX("failed setting power mode.\n");
9135                         up(&priv->sem);
9136                         return err;
9137                 }
9138                 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9139                 up(&priv->sem);
9140                 return 0;
9141         }
9142
9143         switch (wrqu->power.flags & IW_POWER_MODE) {
9144         case IW_POWER_ON:       /* If not specified */
9145         case IW_POWER_MODE:     /* If set all mask */
9146         case IW_POWER_ALL_R:    /* If explicitely state all */
9147                 break;
9148         default:                /* Otherwise we don't support it */
9149                 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9150                              wrqu->power.flags);
9151                 up(&priv->sem);
9152                 return -EOPNOTSUPP;
9153         }
9154
9155         /* If the user hasn't specified a power management mode yet, default
9156          * to BATTERY */
9157         if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
9158                 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9159         else
9160                 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9161         err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9162         if (err) {
9163                 IPW_DEBUG_WX("failed setting power mode.\n");
9164                 up(&priv->sem);
9165                 return err;
9166         }
9167
9168         IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9169         up(&priv->sem);
9170         return 0;
9171 }
9172
9173 static int ipw_wx_get_power(struct net_device *dev,
9174                             struct iw_request_info *info,
9175                             union iwreq_data *wrqu, char *extra)
9176 {
9177         struct ipw_priv *priv = ieee80211_priv(dev);
9178         down(&priv->sem);
9179         if (!(priv->power_mode & IPW_POWER_ENABLED))
9180                 wrqu->power.disabled = 1;
9181         else
9182                 wrqu->power.disabled = 0;
9183
9184         up(&priv->sem);
9185         IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9186
9187         return 0;
9188 }
9189
9190 static int ipw_wx_set_powermode(struct net_device *dev,
9191                                 struct iw_request_info *info,
9192                                 union iwreq_data *wrqu, char *extra)
9193 {
9194         struct ipw_priv *priv = ieee80211_priv(dev);
9195         int mode = *(int *)extra;
9196         int err;
9197         down(&priv->sem);
9198         if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
9199                 mode = IPW_POWER_AC;
9200                 priv->power_mode = mode;
9201         } else {
9202                 priv->power_mode = IPW_POWER_ENABLED | mode;
9203         }
9204
9205         if (priv->power_mode != mode) {
9206                 err = ipw_send_power_mode(priv, mode);
9207
9208                 if (err) {
9209                         IPW_DEBUG_WX("failed setting power mode.\n");
9210                         up(&priv->sem);
9211                         return err;
9212                 }
9213         }
9214         up(&priv->sem);
9215         return 0;
9216 }
9217
9218 #define MAX_WX_STRING 80
9219 static int ipw_wx_get_powermode(struct net_device *dev,
9220                                 struct iw_request_info *info,
9221                                 union iwreq_data *wrqu, char *extra)
9222 {
9223         struct ipw_priv *priv = ieee80211_priv(dev);
9224         int level = IPW_POWER_LEVEL(priv->power_mode);
9225         char *p = extra;
9226
9227         p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9228
9229         switch (level) {
9230         case IPW_POWER_AC:
9231                 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9232                 break;
9233         case IPW_POWER_BATTERY:
9234                 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9235                 break;
9236         default:
9237                 p += snprintf(p, MAX_WX_STRING - (p - extra),
9238                               "(Timeout %dms, Period %dms)",
9239                               timeout_duration[level - 1] / 1000,
9240                               period_duration[level - 1] / 1000);
9241         }
9242
9243         if (!(priv->power_mode & IPW_POWER_ENABLED))
9244                 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
9245
9246         wrqu->data.length = p - extra + 1;
9247
9248         return 0;
9249 }
9250
9251 static int ipw_wx_set_wireless_mode(struct net_device *dev,
9252                                     struct iw_request_info *info,
9253                                     union iwreq_data *wrqu, char *extra)
9254 {
9255         struct ipw_priv *priv = ieee80211_priv(dev);
9256         int mode = *(int *)extra;
9257         u8 band = 0, modulation = 0;
9258
9259         if (mode == 0 || mode & ~IEEE_MODE_MASK) {
9260                 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
9261                 return -EINVAL;
9262         }
9263         down(&priv->sem);
9264         if (priv->adapter == IPW_2915ABG) {
9265                 priv->ieee->abg_true = 1;
9266                 if (mode & IEEE_A) {
9267                         band |= IEEE80211_52GHZ_BAND;
9268                         modulation |= IEEE80211_OFDM_MODULATION;
9269                 } else
9270                         priv->ieee->abg_true = 0;
9271         } else {
9272                 if (mode & IEEE_A) {
9273                         IPW_WARNING("Attempt to set 2200BG into "
9274                                     "802.11a mode\n");
9275                         up(&priv->sem);
9276                         return -EINVAL;
9277                 }
9278
9279                 priv->ieee->abg_true = 0;
9280         }
9281
9282         if (mode & IEEE_B) {
9283                 band |= IEEE80211_24GHZ_BAND;
9284                 modulation |= IEEE80211_CCK_MODULATION;
9285         } else
9286                 priv->ieee->abg_true = 0;
9287
9288         if (mode & IEEE_G) {
9289                 band |= IEEE80211_24GHZ_BAND;
9290                 modulation |= IEEE80211_OFDM_MODULATION;
9291         } else
9292                 priv->ieee->abg_true = 0;
9293
9294         priv->ieee->mode = mode;
9295         priv->ieee->freq_band = band;
9296         priv->ieee->modulation = modulation;
9297         init_supported_rates(priv, &priv->rates);
9298
9299         /* Network configuration changed -- force [re]association */
9300         IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9301         if (!ipw_disassociate(priv)) {
9302                 ipw_send_supported_rates(priv, &priv->rates);
9303                 ipw_associate(priv);
9304         }
9305
9306         /* Update the band LEDs */
9307         ipw_led_band_on(priv);
9308
9309         IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
9310                      mode & IEEE_A ? 'a' : '.',
9311                      mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9312         up(&priv->sem);
9313         return 0;
9314 }
9315
9316 static int ipw_wx_get_wireless_mode(struct net_device *dev,
9317                                     struct iw_request_info *info,
9318                                     union iwreq_data *wrqu, char *extra)
9319 {
9320         struct ipw_priv *priv = ieee80211_priv(dev);
9321         down(&priv->sem);
9322         switch (priv->ieee->mode) {
9323         case IEEE_A:
9324                 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9325                 break;
9326         case IEEE_B:
9327                 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9328                 break;
9329         case IEEE_A | IEEE_B:
9330                 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9331                 break;
9332         case IEEE_G:
9333                 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9334                 break;
9335         case IEEE_A | IEEE_G:
9336                 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9337                 break;
9338         case IEEE_B | IEEE_G:
9339                 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9340                 break;
9341         case IEEE_A | IEEE_B | IEEE_G:
9342                 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9343                 break;
9344         default:
9345                 strncpy(extra, "unknown", MAX_WX_STRING);
9346                 break;
9347         }
9348
9349         IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9350
9351         wrqu->data.length = strlen(extra) + 1;
9352         up(&priv->sem);
9353
9354         return 0;
9355 }
9356
9357 static int ipw_wx_set_preamble(struct net_device *dev,
9358                                struct iw_request_info *info,
9359                                union iwreq_data *wrqu, char *extra)
9360 {
9361         struct ipw_priv *priv = ieee80211_priv(dev);
9362         int mode = *(int *)extra;
9363         down(&priv->sem);
9364         /* Switching from SHORT -> LONG requires a disassociation */
9365         if (mode == 1) {
9366                 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9367                         priv->config |= CFG_PREAMBLE_LONG;
9368
9369                         /* Network configuration changed -- force [re]association */
9370                         IPW_DEBUG_ASSOC
9371                             ("[re]association triggered due to preamble change.\n");
9372                         if (!ipw_disassociate(priv))
9373                                 ipw_associate(priv);
9374                 }
9375                 goto done;
9376         }
9377
9378         if (mode == 0) {
9379                 priv->config &= ~CFG_PREAMBLE_LONG;
9380                 goto done;
9381         }
9382         up(&priv->sem);
9383         return -EINVAL;
9384
9385       done:
9386         up(&priv->sem);
9387         return 0;
9388 }
9389
9390 static int ipw_wx_get_preamble(struct net_device *dev,
9391                                struct iw_request_info *info,
9392                                union iwreq_data *wrqu, char *extra)
9393 {
9394         struct ipw_priv *priv = ieee80211_priv(dev);
9395         down(&priv->sem);
9396         if (priv->config & CFG_PREAMBLE_LONG)
9397                 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9398         else
9399                 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9400         up(&priv->sem);
9401         return 0;
9402 }
9403
9404 #ifdef CONFIG_IPW2200_MONITOR
9405 static int ipw_wx_set_monitor(struct net_device *dev,
9406                               struct iw_request_info *info,
9407                               union iwreq_data *wrqu, char *extra)
9408 {
9409         struct ipw_priv *priv = ieee80211_priv(dev);
9410         int *parms = (int *)extra;
9411         int enable = (parms[0] > 0);
9412         down(&priv->sem);
9413         IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
9414         if (enable) {
9415                 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9416 #ifdef CONFIG_IEEE80211_RADIOTAP
9417                         priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9418 #else
9419                         priv->net_dev->type = ARPHRD_IEEE80211;
9420 #endif
9421                         queue_work(priv->workqueue, &priv->adapter_restart);
9422                 }
9423
9424                 ipw_set_channel(priv, parms[1]);
9425         } else {
9426                 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9427                         up(&priv->sem);
9428                         return 0;
9429                 }
9430                 priv->net_dev->type = ARPHRD_ETHER;
9431                 queue_work(priv->workqueue, &priv->adapter_restart);
9432         }
9433         up(&priv->sem);
9434         return 0;
9435 }
9436
9437 #endif                          // CONFIG_IPW2200_MONITOR
9438
9439 static int ipw_wx_reset(struct net_device *dev,
9440                         struct iw_request_info *info,
9441                         union iwreq_data *wrqu, char *extra)
9442 {
9443         struct ipw_priv *priv = ieee80211_priv(dev);
9444         IPW_DEBUG_WX("RESET\n");
9445         queue_work(priv->workqueue, &priv->adapter_restart);
9446         return 0;
9447 }
9448
9449 static int ipw_wx_sw_reset(struct net_device *dev,
9450                            struct iw_request_info *info,
9451                            union iwreq_data *wrqu, char *extra)
9452 {
9453         struct ipw_priv *priv = ieee80211_priv(dev);
9454         union iwreq_data wrqu_sec = {
9455                 .encoding = {
9456                              .flags = IW_ENCODE_DISABLED,
9457                              },
9458         };
9459         int ret;
9460
9461         IPW_DEBUG_WX("SW_RESET\n");
9462
9463         down(&priv->sem);
9464
9465         ret = ipw_sw_reset(priv, 0);
9466         if (!ret) {
9467                 free_firmware();
9468                 ipw_adapter_restart(priv);
9469         }
9470
9471         /* The SW reset bit might have been toggled on by the 'disable'
9472          * module parameter, so take appropriate action */
9473         ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9474
9475         up(&priv->sem);
9476         ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9477         down(&priv->sem);
9478
9479         if (!(priv->status & STATUS_RF_KILL_MASK)) {
9480                 /* Configuration likely changed -- force [re]association */
9481                 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9482                                 "reset.\n");
9483                 if (!ipw_disassociate(priv))
9484                         ipw_associate(priv);
9485         }
9486
9487         up(&priv->sem);
9488
9489         return 0;
9490 }
9491
9492 /* Rebase the WE IOCTLs to zero for the handler array */
9493 #define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
9494 static iw_handler ipw_wx_handlers[] = {
9495         IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
9496         IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
9497         IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
9498         IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
9499         IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
9500         IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
9501         IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
9502         IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
9503         IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
9504         IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
9505         IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
9506         IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
9507         IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
9508         IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
9509         IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
9510         IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
9511         IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
9512         IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
9513         IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
9514         IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
9515         IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
9516         IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
9517         IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
9518         IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
9519         IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
9520         IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
9521         IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
9522         IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
9523         IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
9524         IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
9525         IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
9526         IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
9527         IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
9528         IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
9529         IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
9530         IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
9531         IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
9532         IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
9533         IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
9534 };
9535
9536 enum {
9537         IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9538         IPW_PRIV_GET_POWER,
9539         IPW_PRIV_SET_MODE,
9540         IPW_PRIV_GET_MODE,
9541         IPW_PRIV_SET_PREAMBLE,
9542         IPW_PRIV_GET_PREAMBLE,
9543         IPW_PRIV_RESET,
9544         IPW_PRIV_SW_RESET,
9545 #ifdef CONFIG_IPW2200_MONITOR
9546         IPW_PRIV_SET_MONITOR,
9547 #endif
9548 };
9549
9550 static struct iw_priv_args ipw_priv_args[] = {
9551         {
9552          .cmd = IPW_PRIV_SET_POWER,
9553          .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9554          .name = "set_power"},
9555         {
9556          .cmd = IPW_PRIV_GET_POWER,
9557          .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9558          .name = "get_power"},
9559         {
9560          .cmd = IPW_PRIV_SET_MODE,
9561          .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9562          .name = "set_mode"},
9563         {
9564          .cmd = IPW_PRIV_GET_MODE,
9565          .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9566          .name = "get_mode"},
9567         {
9568          .cmd = IPW_PRIV_SET_PREAMBLE,
9569          .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9570          .name = "set_preamble"},
9571         {
9572          .cmd = IPW_PRIV_GET_PREAMBLE,
9573          .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9574          .name = "get_preamble"},
9575         {
9576          IPW_PRIV_RESET,
9577          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
9578         {
9579          IPW_PRIV_SW_RESET,
9580          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9581 #ifdef CONFIG_IPW2200_MONITOR
9582         {
9583          IPW_PRIV_SET_MONITOR,
9584          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9585 #endif                          /* CONFIG_IPW2200_MONITOR */
9586 };
9587
9588 static iw_handler ipw_priv_handler[] = {
9589         ipw_wx_set_powermode,
9590         ipw_wx_get_powermode,
9591         ipw_wx_set_wireless_mode,
9592         ipw_wx_get_wireless_mode,
9593         ipw_wx_set_preamble,
9594         ipw_wx_get_preamble,
9595         ipw_wx_reset,
9596         ipw_wx_sw_reset,
9597 #ifdef CONFIG_IPW2200_MONITOR
9598         ipw_wx_set_monitor,
9599 #endif
9600 };
9601
9602 static struct iw_handler_def ipw_wx_handler_def = {
9603         .standard = ipw_wx_handlers,
9604         .num_standard = ARRAY_SIZE(ipw_wx_handlers),
9605         .num_private = ARRAY_SIZE(ipw_priv_handler),
9606         .num_private_args = ARRAY_SIZE(ipw_priv_args),
9607         .private = ipw_priv_handler,
9608         .private_args = ipw_priv_args,
9609         .get_wireless_stats = ipw_get_wireless_stats,
9610 };
9611
9612 /*
9613  * Get wireless statistics.
9614  * Called by /proc/net/wireless
9615  * Also called by SIOCGIWSTATS
9616  */
9617 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
9618 {
9619         struct ipw_priv *priv = ieee80211_priv(dev);
9620         struct iw_statistics *wstats;
9621
9622         wstats = &priv->wstats;
9623
9624         /* if hw is disabled, then ipw_get_ordinal() can't be called.
9625          * netdev->get_wireless_stats seems to be called before fw is
9626          * initialized.  STATUS_ASSOCIATED will only be set if the hw is up
9627          * and associated; if not associcated, the values are all meaningless
9628          * anyway, so set them all to NULL and INVALID */
9629         if (!(priv->status & STATUS_ASSOCIATED)) {
9630                 wstats->miss.beacon = 0;
9631                 wstats->discard.retries = 0;
9632                 wstats->qual.qual = 0;
9633                 wstats->qual.level = 0;
9634                 wstats->qual.noise = 0;
9635                 wstats->qual.updated = 7;
9636                 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
9637                     IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
9638                 return wstats;
9639         }
9640
9641         wstats->qual.qual = priv->quality;
9642         wstats->qual.level = average_value(&priv->average_rssi);
9643         wstats->qual.noise = average_value(&priv->average_noise);
9644         wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
9645             IW_QUAL_NOISE_UPDATED;
9646
9647         wstats->miss.beacon = average_value(&priv->average_missed_beacons);
9648         wstats->discard.retries = priv->last_tx_failures;
9649         wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
9650
9651 /*      if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
9652         goto fail_get_ordinal;
9653         wstats->discard.retries += tx_retry; */
9654
9655         return wstats;
9656 }
9657
9658 /* net device stuff */
9659
9660 static  void init_sys_config(struct ipw_sys_config *sys_config)
9661 {
9662         memset(sys_config, 0, sizeof(struct ipw_sys_config));
9663         sys_config->bt_coexistence = 0;
9664         sys_config->answer_broadcast_ssid_probe = 0;
9665         sys_config->accept_all_data_frames = 0;
9666         sys_config->accept_non_directed_frames = 1;
9667         sys_config->exclude_unicast_unencrypted = 0;
9668         sys_config->disable_unicast_decryption = 1;
9669         sys_config->exclude_multicast_unencrypted = 0;
9670         sys_config->disable_multicast_decryption = 1;
9671         sys_config->antenna_diversity = CFG_SYS_ANTENNA_BOTH;
9672         sys_config->pass_crc_to_host = 0;       /* TODO: See if 1 gives us FCS */
9673         sys_config->dot11g_auto_detection = 0;
9674         sys_config->enable_cts_to_self = 0;
9675         sys_config->bt_coexist_collision_thr = 0;
9676         sys_config->pass_noise_stats_to_host = 1;       //1 -- fix for 256
9677 }
9678
9679 static int ipw_net_open(struct net_device *dev)
9680 {
9681         struct ipw_priv *priv = ieee80211_priv(dev);
9682         IPW_DEBUG_INFO("dev->open\n");
9683         /* we should be verifying the device is ready to be opened */
9684         down(&priv->sem);
9685         if (!(priv->status & STATUS_RF_KILL_MASK) &&
9686             (priv->status & STATUS_ASSOCIATED))
9687                 netif_start_queue(dev);
9688         up(&priv->sem);
9689         return 0;
9690 }
9691
9692 static int ipw_net_stop(struct net_device *dev)
9693 {
9694         IPW_DEBUG_INFO("dev->close\n");
9695         netif_stop_queue(dev);
9696         return 0;
9697 }
9698
9699 /*
9700 todo:
9701
9702 modify to send one tfd per fragment instead of using chunking.  otherwise
9703 we need to heavily modify the ieee80211_skb_to_txb.
9704 */
9705
9706 static int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
9707                              int pri)
9708 {
9709         struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
9710             txb->fragments[0]->data;
9711         int i = 0;
9712         struct tfd_frame *tfd;
9713 #ifdef CONFIG_IPW_QOS
9714         int tx_id = ipw_get_tx_queue_number(priv, pri);
9715         struct clx2_tx_queue *txq = &priv->txq[tx_id];
9716 #else
9717         struct clx2_tx_queue *txq = &priv->txq[0];
9718 #endif
9719         struct clx2_queue *q = &txq->q;
9720         u8 id, hdr_len, unicast;
9721         u16 remaining_bytes;
9722         int fc;
9723
9724         /* If there isn't room in the queue, we return busy and let the
9725          * network stack requeue the packet for us */
9726         if (ipw_queue_space(q) < q->high_mark)
9727                 return NETDEV_TX_BUSY;
9728
9729         switch (priv->ieee->iw_mode) {
9730         case IW_MODE_ADHOC:
9731                 hdr_len = IEEE80211_3ADDR_LEN;
9732                 unicast = !is_multicast_ether_addr(hdr->addr1);
9733                 id = ipw_find_station(priv, hdr->addr1);
9734                 if (id == IPW_INVALID_STATION) {
9735                         id = ipw_add_station(priv, hdr->addr1);
9736                         if (id == IPW_INVALID_STATION) {
9737                                 IPW_WARNING("Attempt to send data to "
9738                                             "invalid cell: " MAC_FMT "\n",
9739                                             MAC_ARG(hdr->addr1));
9740                                 goto drop;
9741                         }
9742                 }
9743                 break;
9744
9745         case IW_MODE_INFRA:
9746         default:
9747                 unicast = !is_multicast_ether_addr(hdr->addr3);
9748                 hdr_len = IEEE80211_3ADDR_LEN;
9749                 id = 0;
9750                 break;
9751         }
9752
9753         tfd = &txq->bd[q->first_empty];
9754         txq->txb[q->first_empty] = txb;
9755         memset(tfd, 0, sizeof(*tfd));
9756         tfd->u.data.station_number = id;
9757
9758         tfd->control_flags.message_type = TX_FRAME_TYPE;
9759         tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
9760
9761         tfd->u.data.cmd_id = DINO_CMD_TX;
9762         tfd->u.data.len = cpu_to_le16(txb->payload_size);
9763         remaining_bytes = txb->payload_size;
9764
9765         if (priv->assoc_request.ieee_mode == IPW_B_MODE)
9766                 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
9767         else
9768                 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
9769
9770         if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
9771                 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
9772
9773         fc = le16_to_cpu(hdr->frame_ctl);
9774         hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
9775
9776         memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
9777
9778         if (likely(unicast))
9779                 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9780
9781         if (txb->encrypted && !priv->ieee->host_encrypt) {
9782                 switch (priv->ieee->sec.level) {
9783                 case SEC_LEVEL_3:
9784                         tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9785                             IEEE80211_FCTL_PROTECTED;
9786                         /* XXX: ACK flag must be set for CCMP even if it
9787                          * is a multicast/broadcast packet, because CCMP
9788                          * group communication encrypted by GTK is
9789                          * actually done by the AP. */
9790                         if (!unicast)
9791                                 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9792
9793                         tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9794                         tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
9795                         tfd->u.data.key_index = 0;
9796                         tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
9797                         break;
9798                 case SEC_LEVEL_2:
9799                         tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9800                             IEEE80211_FCTL_PROTECTED;
9801                         tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9802                         tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
9803                         tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
9804                         break;
9805                 case SEC_LEVEL_1:
9806                         tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9807                             IEEE80211_FCTL_PROTECTED;
9808                         tfd->u.data.key_index = priv->ieee->tx_keyidx;
9809                         if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
9810                             40)
9811                                 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
9812                         else
9813                                 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
9814                         break;
9815                 case SEC_LEVEL_0:
9816                         break;
9817                 default:
9818                         printk(KERN_ERR "Unknow security level %d\n",
9819                                priv->ieee->sec.level);
9820                         break;
9821                 }
9822         } else
9823                 /* No hardware encryption */
9824                 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
9825
9826 #ifdef CONFIG_IPW_QOS
9827         ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
9828 #endif                          /* CONFIG_IPW_QOS */
9829
9830         /* payload */
9831         tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
9832                                                  txb->nr_frags));
9833         IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
9834                        txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
9835         for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
9836                 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
9837                                i, le32_to_cpu(tfd->u.data.num_chunks),
9838                                txb->fragments[i]->len - hdr_len);
9839                 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
9840                              i, tfd->u.data.num_chunks,
9841                              txb->fragments[i]->len - hdr_len);
9842                 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
9843                            txb->fragments[i]->len - hdr_len);
9844
9845                 tfd->u.data.chunk_ptr[i] =
9846                     cpu_to_le32(pci_map_single
9847                                 (priv->pci_dev,
9848                                  txb->fragments[i]->data + hdr_len,
9849                                  txb->fragments[i]->len - hdr_len,
9850                                  PCI_DMA_TODEVICE));
9851                 tfd->u.data.chunk_len[i] =
9852                     cpu_to_le16(txb->fragments[i]->len - hdr_len);
9853         }
9854
9855         if (i != txb->nr_frags) {
9856                 struct sk_buff *skb;
9857                 u16 remaining_bytes = 0;
9858                 int j;
9859
9860                 for (j = i; j < txb->nr_frags; j++)
9861                         remaining_bytes += txb->fragments[j]->len - hdr_len;
9862
9863                 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
9864                        remaining_bytes);
9865                 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
9866                 if (skb != NULL) {
9867                         tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
9868                         for (j = i; j < txb->nr_frags; j++) {
9869                                 int size = txb->fragments[j]->len - hdr_len;
9870
9871                                 printk(KERN_INFO "Adding frag %d %d...\n",
9872                                        j, size);
9873                                 memcpy(skb_put(skb, size),
9874                                        txb->fragments[j]->data + hdr_len, size);
9875                         }
9876                         dev_kfree_skb_any(txb->fragments[i]);
9877                         txb->fragments[i] = skb;
9878                         tfd->u.data.chunk_ptr[i] =
9879                             cpu_to_le32(pci_map_single
9880                                         (priv->pci_dev, skb->data,
9881                                          tfd->u.data.chunk_len[i],
9882                                          PCI_DMA_TODEVICE));
9883
9884                         tfd->u.data.num_chunks =
9885                             cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
9886                                         1);
9887                 }
9888         }
9889
9890         /* kick DMA */
9891         q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
9892         ipw_write32(priv, q->reg_w, q->first_empty);
9893
9894         return NETDEV_TX_OK;
9895
9896       drop:
9897         IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
9898         ieee80211_txb_free(txb);
9899         return NETDEV_TX_OK;
9900 }
9901
9902 static int ipw_net_is_queue_full(struct net_device *dev, int pri)
9903 {
9904         struct ipw_priv *priv = ieee80211_priv(dev);
9905 #ifdef CONFIG_IPW_QOS
9906         int tx_id = ipw_get_tx_queue_number(priv, pri);
9907         struct clx2_tx_queue *txq = &priv->txq[tx_id];
9908 #else
9909         struct clx2_tx_queue *txq = &priv->txq[0];
9910 #endif                          /* CONFIG_IPW_QOS */
9911
9912         if (ipw_queue_space(&txq->q) < txq->q.high_mark)
9913                 return 1;
9914
9915         return 0;
9916 }
9917
9918 static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
9919                                    struct net_device *dev, int pri)
9920 {
9921         struct ipw_priv *priv = ieee80211_priv(dev);
9922         unsigned long flags;
9923         int ret;
9924
9925         IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
9926         spin_lock_irqsave(&priv->lock, flags);
9927
9928         if (!(priv->status & STATUS_ASSOCIATED)) {
9929                 IPW_DEBUG_INFO("Tx attempt while not associated.\n");
9930                 priv->ieee->stats.tx_carrier_errors++;
9931                 netif_stop_queue(dev);
9932                 goto fail_unlock;
9933         }
9934
9935         ret = ipw_tx_skb(priv, txb, pri);
9936         if (ret == NETDEV_TX_OK)
9937                 __ipw_led_activity_on(priv);
9938         spin_unlock_irqrestore(&priv->lock, flags);
9939
9940         return ret;
9941
9942       fail_unlock:
9943         spin_unlock_irqrestore(&priv->lock, flags);
9944         return 1;
9945 }
9946
9947 static struct net_device_stats *ipw_net_get_stats(struct net_device *dev)
9948 {
9949         struct ipw_priv *priv = ieee80211_priv(dev);
9950
9951         priv->ieee->stats.tx_packets = priv->tx_packets;
9952         priv->ieee->stats.rx_packets = priv->rx_packets;
9953         return &priv->ieee->stats;
9954 }
9955
9956 static void ipw_net_set_multicast_list(struct net_device *dev)
9957 {
9958
9959 }
9960
9961 static int ipw_net_set_mac_address(struct net_device *dev, void *p)
9962 {
9963         struct ipw_priv *priv = ieee80211_priv(dev);
9964         struct sockaddr *addr = p;
9965         if (!is_valid_ether_addr(addr->sa_data))
9966                 return -EADDRNOTAVAIL;
9967         down(&priv->sem);
9968         priv->config |= CFG_CUSTOM_MAC;
9969         memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
9970         printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
9971                priv->net_dev->name, MAC_ARG(priv->mac_addr));
9972         queue_work(priv->workqueue, &priv->adapter_restart);
9973         up(&priv->sem);
9974         return 0;
9975 }
9976
9977 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
9978                                     struct ethtool_drvinfo *info)
9979 {
9980         struct ipw_priv *p = ieee80211_priv(dev);
9981         char vers[64];
9982         char date[32];
9983         u32 len;
9984
9985         strcpy(info->driver, DRV_NAME);
9986         strcpy(info->version, DRV_VERSION);
9987
9988         len = sizeof(vers);
9989         ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
9990         len = sizeof(date);
9991         ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
9992
9993         snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
9994                  vers, date);
9995         strcpy(info->bus_info, pci_name(p->pci_dev));
9996         info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
9997 }
9998
9999 static u32 ipw_ethtool_get_link(struct net_device *dev)
10000 {
10001         struct ipw_priv *priv = ieee80211_priv(dev);
10002         return (priv->status & STATUS_ASSOCIATED) != 0;
10003 }
10004
10005 static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
10006 {
10007         return IPW_EEPROM_IMAGE_SIZE;
10008 }
10009
10010 static int ipw_ethtool_get_eeprom(struct net_device *dev,
10011                                   struct ethtool_eeprom *eeprom, u8 * bytes)
10012 {
10013         struct ipw_priv *p = ieee80211_priv(dev);
10014
10015         if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
10016                 return -EINVAL;
10017         down(&p->sem);
10018         memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
10019         up(&p->sem);
10020         return 0;
10021 }
10022
10023 static int ipw_ethtool_set_eeprom(struct net_device *dev,
10024                                   struct ethtool_eeprom *eeprom, u8 * bytes)
10025 {
10026         struct ipw_priv *p = ieee80211_priv(dev);
10027         int i;
10028
10029         if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
10030                 return -EINVAL;
10031         down(&p->sem);
10032         memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
10033         for (i = IPW_EEPROM_DATA;
10034              i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
10035                 ipw_write8(p, i, p->eeprom[i]);
10036         up(&p->sem);
10037         return 0;
10038 }
10039
10040 static struct ethtool_ops ipw_ethtool_ops = {
10041         .get_link = ipw_ethtool_get_link,
10042         .get_drvinfo = ipw_ethtool_get_drvinfo,
10043         .get_eeprom_len = ipw_ethtool_get_eeprom_len,
10044         .get_eeprom = ipw_ethtool_get_eeprom,
10045         .set_eeprom = ipw_ethtool_set_eeprom,
10046 };
10047
10048 static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
10049 {
10050         struct ipw_priv *priv = data;
10051         u32 inta, inta_mask;
10052
10053         if (!priv)
10054                 return IRQ_NONE;
10055
10056         spin_lock(&priv->lock);
10057
10058         if (!(priv->status & STATUS_INT_ENABLED)) {
10059                 /* Shared IRQ */
10060                 goto none;
10061         }
10062
10063         inta = ipw_read32(priv, IPW_INTA_RW);
10064         inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
10065
10066         if (inta == 0xFFFFFFFF) {
10067                 /* Hardware disappeared */
10068                 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10069                 goto none;
10070         }
10071
10072         if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
10073                 /* Shared interrupt */
10074                 goto none;
10075         }
10076
10077         /* tell the device to stop sending interrupts */
10078         ipw_disable_interrupts(priv);
10079
10080         /* ack current interrupts */
10081         inta &= (IPW_INTA_MASK_ALL & inta_mask);
10082         ipw_write32(priv, IPW_INTA_RW, inta);
10083
10084         /* Cache INTA value for our tasklet */
10085         priv->isr_inta = inta;
10086
10087         tasklet_schedule(&priv->irq_tasklet);
10088
10089         spin_unlock(&priv->lock);
10090
10091         return IRQ_HANDLED;
10092       none:
10093         spin_unlock(&priv->lock);
10094         return IRQ_NONE;
10095 }
10096
10097 static void ipw_rf_kill(void *adapter)
10098 {
10099         struct ipw_priv *priv = adapter;
10100         unsigned long flags;
10101
10102         spin_lock_irqsave(&priv->lock, flags);
10103
10104         if (rf_kill_active(priv)) {
10105                 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10106                 if (priv->workqueue)
10107                         queue_delayed_work(priv->workqueue,
10108                                            &priv->rf_kill, 2 * HZ);
10109                 goto exit_unlock;
10110         }
10111
10112         /* RF Kill is now disabled, so bring the device back up */
10113
10114         if (!(priv->status & STATUS_RF_KILL_MASK)) {
10115                 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10116                                   "device\n");
10117
10118                 /* we can not do an adapter restart while inside an irq lock */
10119                 queue_work(priv->workqueue, &priv->adapter_restart);
10120         } else
10121                 IPW_DEBUG_RF_KILL("HW RF Kill deactivated.  SW RF Kill still "
10122                                   "enabled\n");
10123
10124       exit_unlock:
10125         spin_unlock_irqrestore(&priv->lock, flags);
10126 }
10127
10128 static void ipw_bg_rf_kill(void *data)
10129 {
10130         struct ipw_priv *priv = data;
10131         down(&priv->sem);
10132         ipw_rf_kill(data);
10133         up(&priv->sem);
10134 }
10135
10136 static void ipw_link_up(struct ipw_priv *priv)
10137 {
10138         priv->last_seq_num = -1;
10139         priv->last_frag_num = -1;
10140         priv->last_packet_time = 0;
10141
10142         netif_carrier_on(priv->net_dev);
10143         if (netif_queue_stopped(priv->net_dev)) {
10144                 IPW_DEBUG_NOTIF("waking queue\n");
10145                 netif_wake_queue(priv->net_dev);
10146         } else {
10147                 IPW_DEBUG_NOTIF("starting queue\n");
10148                 netif_start_queue(priv->net_dev);
10149         }
10150
10151         cancel_delayed_work(&priv->request_scan);
10152         ipw_reset_stats(priv);
10153         /* Ensure the rate is updated immediately */
10154         priv->last_rate = ipw_get_current_rate(priv);
10155         ipw_gather_stats(priv);
10156         ipw_led_link_up(priv);
10157         notify_wx_assoc_event(priv);
10158
10159         if (priv->config & CFG_BACKGROUND_SCAN)
10160                 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10161 }
10162
10163 static void ipw_bg_link_up(void *data)
10164 {
10165         struct ipw_priv *priv = data;
10166         down(&priv->sem);
10167         ipw_link_up(data);
10168         up(&priv->sem);
10169 }
10170
10171 static void ipw_link_down(struct ipw_priv *priv)
10172 {
10173         ipw_led_link_down(priv);
10174         netif_carrier_off(priv->net_dev);
10175         netif_stop_queue(priv->net_dev);
10176         notify_wx_assoc_event(priv);
10177
10178         /* Cancel any queued work ... */
10179         cancel_delayed_work(&priv->request_scan);
10180         cancel_delayed_work(&priv->adhoc_check);
10181         cancel_delayed_work(&priv->gather_stats);
10182
10183         ipw_reset_stats(priv);
10184
10185         if (!(priv->status & STATUS_EXIT_PENDING)) {
10186                 /* Queue up another scan... */
10187                 queue_work(priv->workqueue, &priv->request_scan);
10188         }
10189 }
10190
10191 static void ipw_bg_link_down(void *data)
10192 {
10193         struct ipw_priv *priv = data;
10194         down(&priv->sem);
10195         ipw_link_down(data);
10196         up(&priv->sem);
10197 }
10198
10199 static int ipw_setup_deferred_work(struct ipw_priv *priv)
10200 {
10201         int ret = 0;
10202
10203         priv->workqueue = create_workqueue(DRV_NAME);
10204         init_waitqueue_head(&priv->wait_command_queue);
10205         init_waitqueue_head(&priv->wait_state);
10206
10207         INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
10208         INIT_WORK(&priv->associate, ipw_bg_associate, priv);
10209         INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
10210         INIT_WORK(&priv->system_config, ipw_system_config, priv);
10211         INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
10212         INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
10213         INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
10214         INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
10215         INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
10216         INIT_WORK(&priv->request_scan,
10217                   (void (*)(void *))ipw_request_scan, priv);
10218         INIT_WORK(&priv->gather_stats,
10219                   (void (*)(void *))ipw_bg_gather_stats, priv);
10220         INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
10221         INIT_WORK(&priv->roam, ipw_bg_roam, priv);
10222         INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
10223         INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
10224         INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
10225         INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
10226                   priv);
10227         INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
10228                   priv);
10229         INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
10230                   priv);
10231         INIT_WORK(&priv->merge_networks,
10232                   (void (*)(void *))ipw_merge_adhoc_network, priv);
10233
10234 #ifdef CONFIG_IPW_QOS
10235         INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
10236                   priv);
10237 #endif                          /* CONFIG_IPW_QOS */
10238
10239         tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10240                      ipw_irq_tasklet, (unsigned long)priv);
10241
10242         return ret;
10243 }
10244
10245 static void shim__set_security(struct net_device *dev,
10246                                struct ieee80211_security *sec)
10247 {
10248         struct ipw_priv *priv = ieee80211_priv(dev);
10249         int i;
10250         for (i = 0; i < 4; i++) {
10251                 if (sec->flags & (1 << i)) {
10252                         priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10253                         priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
10254                         if (sec->key_sizes[i] == 0)
10255                                 priv->ieee->sec.flags &= ~(1 << i);
10256                         else {
10257                                 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
10258                                        sec->key_sizes[i]);
10259                                 priv->ieee->sec.flags |= (1 << i);
10260                         }
10261                         priv->status |= STATUS_SECURITY_UPDATED;
10262                 } else if (sec->level != SEC_LEVEL_1)
10263                         priv->ieee->sec.flags &= ~(1 << i);
10264         }
10265
10266         if (sec->flags & SEC_ACTIVE_KEY) {
10267                 if (sec->active_key <= 3) {
10268                         priv->ieee->sec.active_key = sec->active_key;
10269                         priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10270                 } else
10271                         priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10272                 priv->status |= STATUS_SECURITY_UPDATED;
10273         } else
10274                 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10275
10276         if ((sec->flags & SEC_AUTH_MODE) &&
10277             (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10278                 priv->ieee->sec.auth_mode = sec->auth_mode;
10279                 priv->ieee->sec.flags |= SEC_AUTH_MODE;
10280                 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10281                         priv->capability |= CAP_SHARED_KEY;
10282                 else
10283                         priv->capability &= ~CAP_SHARED_KEY;
10284                 priv->status |= STATUS_SECURITY_UPDATED;
10285         }
10286
10287         if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10288                 priv->ieee->sec.flags |= SEC_ENABLED;
10289                 priv->ieee->sec.enabled = sec->enabled;
10290                 priv->status |= STATUS_SECURITY_UPDATED;
10291                 if (sec->enabled)
10292                         priv->capability |= CAP_PRIVACY_ON;
10293                 else
10294                         priv->capability &= ~CAP_PRIVACY_ON;
10295         }
10296
10297         if (sec->flags & SEC_ENCRYPT)
10298                 priv->ieee->sec.encrypt = sec->encrypt;
10299
10300         if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10301                 priv->ieee->sec.level = sec->level;
10302                 priv->ieee->sec.flags |= SEC_LEVEL;
10303                 priv->status |= STATUS_SECURITY_UPDATED;
10304         }
10305
10306         if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10307                 ipw_set_hwcrypto_keys(priv);
10308
10309         /* To match current functionality of ipw2100 (which works well w/
10310          * various supplicants, we don't force a disassociate if the
10311          * privacy capability changes ... */
10312 #if 0
10313         if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10314             (((priv->assoc_request.capability &
10315                WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
10316              (!(priv->assoc_request.capability &
10317                 WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
10318                 IPW_DEBUG_ASSOC("Disassociating due to capability "
10319                                 "change.\n");
10320                 ipw_disassociate(priv);
10321         }
10322 #endif
10323 }
10324
10325 static int init_supported_rates(struct ipw_priv *priv,
10326                                 struct ipw_supported_rates *rates)
10327 {
10328         /* TODO: Mask out rates based on priv->rates_mask */
10329
10330         memset(rates, 0, sizeof(*rates));
10331         /* configure supported rates */
10332         switch (priv->ieee->freq_band) {
10333         case IEEE80211_52GHZ_BAND:
10334                 rates->ieee_mode = IPW_A_MODE;
10335                 rates->purpose = IPW_RATE_CAPABILITIES;
10336                 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10337                                         IEEE80211_OFDM_DEFAULT_RATES_MASK);
10338                 break;
10339
10340         default:                /* Mixed or 2.4Ghz */
10341                 rates->ieee_mode = IPW_G_MODE;
10342                 rates->purpose = IPW_RATE_CAPABILITIES;
10343                 ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
10344                                        IEEE80211_CCK_DEFAULT_RATES_MASK);
10345                 if (priv->ieee->modulation & IEEE80211_OFDM_MODULATION) {
10346                         ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10347                                                 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10348                 }
10349                 break;
10350         }
10351
10352         return 0;
10353 }
10354
10355 static int ipw_config(struct ipw_priv *priv)
10356 {
10357         /* This is only called from ipw_up, which resets/reloads the firmware
10358            so, we don't need to first disable the card before we configure
10359            it */
10360         if (ipw_set_tx_power(priv))
10361                 goto error;
10362
10363         /* initialize adapter address */
10364         if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10365                 goto error;
10366
10367         /* set basic system config settings */
10368         init_sys_config(&priv->sys_config);
10369
10370         /* Support Bluetooth if we have BT h/w on board, and user wants to.
10371          * Does not support BT priority yet (don't abort or defer our Tx) */
10372         if (bt_coexist) {
10373                 unsigned char bt_caps = priv->eeprom[EEPROM_SKU_CAPABILITY];
10374
10375                 if (bt_caps & EEPROM_SKU_CAP_BT_CHANNEL_SIG)
10376                         priv->sys_config.bt_coexistence
10377                                 |= CFG_BT_COEXISTENCE_SIGNAL_CHNL;
10378                 if (bt_caps & EEPROM_SKU_CAP_BT_OOB)
10379                         priv->sys_config.bt_coexistence
10380                                 |= CFG_BT_COEXISTENCE_OOB;
10381         }
10382
10383         if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10384                 priv->sys_config.answer_broadcast_ssid_probe = 1;
10385         else
10386                 priv->sys_config.answer_broadcast_ssid_probe = 0;
10387
10388         if (ipw_send_system_config(priv, &priv->sys_config))
10389                 goto error;
10390
10391         init_supported_rates(priv, &priv->rates);
10392         if (ipw_send_supported_rates(priv, &priv->rates))
10393                 goto error;
10394
10395         /* Set request-to-send threshold */
10396         if (priv->rts_threshold) {
10397                 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10398                         goto error;
10399         }
10400 #ifdef CONFIG_IPW_QOS
10401         IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10402         ipw_qos_activate(priv, NULL);
10403 #endif                          /* CONFIG_IPW_QOS */
10404
10405         if (ipw_set_random_seed(priv))
10406                 goto error;
10407
10408         /* final state transition to the RUN state */
10409         if (ipw_send_host_complete(priv))
10410                 goto error;
10411
10412         priv->status |= STATUS_INIT;
10413
10414         ipw_led_init(priv);
10415         ipw_led_radio_on(priv);
10416         priv->notif_missed_beacons = 0;
10417
10418         /* Set hardware WEP key if it is configured. */
10419         if ((priv->capability & CAP_PRIVACY_ON) &&
10420             (priv->ieee->sec.level == SEC_LEVEL_1) &&
10421             !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10422                 ipw_set_hwcrypto_keys(priv);
10423
10424         return 0;
10425
10426       error:
10427         return -EIO;
10428 }
10429
10430 /*
10431  * NOTE:
10432  *
10433  * These tables have been tested in conjunction with the
10434  * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10435  *
10436  * Altering this values, using it on other hardware, or in geographies
10437  * not intended for resale of the above mentioned Intel adapters has
10438  * not been tested.
10439  *
10440  */
10441 static const struct ieee80211_geo ipw_geos[] = {
10442         {                       /* Restricted */
10443          "---",
10444          .bg_channels = 11,
10445          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10446                 {2427, 4}, {2432, 5}, {2437, 6},
10447                 {2442, 7}, {2447, 8}, {2452, 9},
10448                 {2457, 10}, {2462, 11}},
10449          },
10450
10451         {                       /* Custom US/Canada */
10452          "ZZF",
10453          .bg_channels = 11,
10454          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10455                 {2427, 4}, {2432, 5}, {2437, 6},
10456                 {2442, 7}, {2447, 8}, {2452, 9},
10457                 {2457, 10}, {2462, 11}},
10458          .a_channels = 8,
10459          .a = {{5180, 36},
10460                {5200, 40},
10461                {5220, 44},
10462                {5240, 48},
10463                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10464                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10465                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10466                {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
10467          },
10468
10469         {                       /* Rest of World */
10470          "ZZD",
10471          .bg_channels = 13,
10472          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10473                 {2427, 4}, {2432, 5}, {2437, 6},
10474                 {2442, 7}, {2447, 8}, {2452, 9},
10475                 {2457, 10}, {2462, 11}, {2467, 12},
10476                 {2472, 13}},
10477          },
10478
10479         {                       /* Custom USA & Europe & High */
10480          "ZZA",
10481          .bg_channels = 11,
10482          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10483                 {2427, 4}, {2432, 5}, {2437, 6},
10484                 {2442, 7}, {2447, 8}, {2452, 9},
10485                 {2457, 10}, {2462, 11}},
10486          .a_channels = 13,
10487          .a = {{5180, 36},
10488                {5200, 40},
10489                {5220, 44},
10490                {5240, 48},
10491                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10492                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10493                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10494                {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10495                {5745, 149},
10496                {5765, 153},
10497                {5785, 157},
10498                {5805, 161},
10499                {5825, 165}},
10500          },
10501
10502         {                       /* Custom NA & Europe */
10503          "ZZB",
10504          .bg_channels = 11,
10505          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10506                 {2427, 4}, {2432, 5}, {2437, 6},
10507                 {2442, 7}, {2447, 8}, {2452, 9},
10508                 {2457, 10}, {2462, 11}},
10509          .a_channels = 13,
10510          .a = {{5180, 36},
10511                {5200, 40},
10512                {5220, 44},
10513                {5240, 48},
10514                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10515                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10516                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10517                {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10518                {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10519                {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10520                {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10521                {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10522                {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10523          },
10524
10525         {                       /* Custom Japan */
10526          "ZZC",
10527          .bg_channels = 11,
10528          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10529                 {2427, 4}, {2432, 5}, {2437, 6},
10530                 {2442, 7}, {2447, 8}, {2452, 9},
10531                 {2457, 10}, {2462, 11}},
10532          .a_channels = 4,
10533          .a = {{5170, 34}, {5190, 38},
10534                {5210, 42}, {5230, 46}},
10535          },
10536
10537         {                       /* Custom */
10538          "ZZM",
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          },
10545
10546         {                       /* Europe */
10547          "ZZE",
10548          .bg_channels = 13,
10549          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10550                 {2427, 4}, {2432, 5}, {2437, 6},
10551                 {2442, 7}, {2447, 8}, {2452, 9},
10552                 {2457, 10}, {2462, 11}, {2467, 12},
10553                 {2472, 13}},
10554          .a_channels = 19,
10555          .a = {{5180, 36},
10556                {5200, 40},
10557                {5220, 44},
10558                {5240, 48},
10559                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10560                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10561                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10562                {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10563                {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10564                {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10565                {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10566                {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10567                {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10568                {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10569                {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10570                {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10571                {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10572                {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10573                {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
10574          },
10575
10576         {                       /* Custom Japan */
10577          "ZZJ",
10578          .bg_channels = 14,
10579          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10580                 {2427, 4}, {2432, 5}, {2437, 6},
10581                 {2442, 7}, {2447, 8}, {2452, 9},
10582                 {2457, 10}, {2462, 11}, {2467, 12},
10583                 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
10584          .a_channels = 4,
10585          .a = {{5170, 34}, {5190, 38},
10586                {5210, 42}, {5230, 46}},
10587          },
10588
10589         {                       /* Rest of World */
10590          "ZZR",
10591          .bg_channels = 14,
10592          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10593                 {2427, 4}, {2432, 5}, {2437, 6},
10594                 {2442, 7}, {2447, 8}, {2452, 9},
10595                 {2457, 10}, {2462, 11}, {2467, 12},
10596                 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY |
10597                              IEEE80211_CH_PASSIVE_ONLY}},
10598          },
10599
10600         {                       /* High Band */
10601          "ZZH",
10602          .bg_channels = 13,
10603          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10604                 {2427, 4}, {2432, 5}, {2437, 6},
10605                 {2442, 7}, {2447, 8}, {2452, 9},
10606                 {2457, 10}, {2462, 11},
10607                 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10608                 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10609          .a_channels = 4,
10610          .a = {{5745, 149}, {5765, 153},
10611                {5785, 157}, {5805, 161}},
10612          },
10613
10614         {                       /* Custom Europe */
10615          "ZZG",
10616          .bg_channels = 13,
10617          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10618                 {2427, 4}, {2432, 5}, {2437, 6},
10619                 {2442, 7}, {2447, 8}, {2452, 9},
10620                 {2457, 10}, {2462, 11},
10621                 {2467, 12}, {2472, 13}},
10622          .a_channels = 4,
10623          .a = {{5180, 36}, {5200, 40},
10624                {5220, 44}, {5240, 48}},
10625          },
10626
10627         {                       /* Europe */
10628          "ZZK",
10629          .bg_channels = 13,
10630          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10631                 {2427, 4}, {2432, 5}, {2437, 6},
10632                 {2442, 7}, {2447, 8}, {2452, 9},
10633                 {2457, 10}, {2462, 11},
10634                 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10635                 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10636          .a_channels = 24,
10637          .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10638                {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10639                {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10640                {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10641                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10642                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10643                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10644                {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10645                {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10646                {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10647                {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10648                {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10649                {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10650                {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10651                {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10652                {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10653                {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10654                {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10655                {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
10656                {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10657                {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10658                {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10659                {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10660                {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10661          },
10662
10663         {                       /* Europe */
10664          "ZZL",
10665          .bg_channels = 11,
10666          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10667                 {2427, 4}, {2432, 5}, {2437, 6},
10668                 {2442, 7}, {2447, 8}, {2452, 9},
10669                 {2457, 10}, {2462, 11}},
10670          .a_channels = 13,
10671          .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10672                {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10673                {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10674                {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10675                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10676                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10677                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10678                {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10679                {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10680                {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10681                {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10682                {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10683                {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10684          }
10685 };
10686
10687 /* GEO code borrowed from ieee80211_geo.c */
10688 static int ipw_is_valid_channel(struct ieee80211_device *ieee, u8 channel)
10689 {
10690         int i;
10691
10692         /* Driver needs to initialize the geography map before using
10693          * these helper functions */
10694         BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10695
10696         if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10697                 for (i = 0; i < ieee->geo.bg_channels; i++)
10698                         /* NOTE: If G mode is currently supported but
10699                          * this is a B only channel, we don't see it
10700                          * as valid. */
10701                         if ((ieee->geo.bg[i].channel == channel) &&
10702                             (!(ieee->mode & IEEE_G) ||
10703                              !(ieee->geo.bg[i].flags & IEEE80211_CH_B_ONLY)))
10704                                 return IEEE80211_24GHZ_BAND;
10705
10706         if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10707                 for (i = 0; i < ieee->geo.a_channels; i++)
10708                         if (ieee->geo.a[i].channel == channel)
10709                                 return IEEE80211_52GHZ_BAND;
10710
10711         return 0;
10712 }
10713
10714 static int ipw_channel_to_index(struct ieee80211_device *ieee, u8 channel)
10715 {
10716         int i;
10717
10718         /* Driver needs to initialize the geography map before using
10719          * these helper functions */
10720         BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10721
10722         if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10723                 for (i = 0; i < ieee->geo.bg_channels; i++)
10724                         if (ieee->geo.bg[i].channel == channel)
10725                                 return i;
10726
10727         if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10728                 for (i = 0; i < ieee->geo.a_channels; i++)
10729                         if (ieee->geo.a[i].channel == channel)
10730                                 return i;
10731
10732         return -1;
10733 }
10734
10735 static u8 ipw_freq_to_channel(struct ieee80211_device *ieee, u32 freq)
10736 {
10737         int i;
10738
10739         /* Driver needs to initialize the geography map before using
10740          * these helper functions */
10741         BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10742
10743         freq /= 100000;
10744
10745         if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10746                 for (i = 0; i < ieee->geo.bg_channels; i++)
10747                         if (ieee->geo.bg[i].freq == freq)
10748                                 return ieee->geo.bg[i].channel;
10749
10750         if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10751                 for (i = 0; i < ieee->geo.a_channels; i++)
10752                         if (ieee->geo.a[i].freq == freq)
10753                                 return ieee->geo.a[i].channel;
10754
10755         return 0;
10756 }
10757
10758 static int ipw_set_geo(struct ieee80211_device *ieee,
10759                        const struct ieee80211_geo *geo)
10760 {
10761         memcpy(ieee->geo.name, geo->name, 3);
10762         ieee->geo.name[3] = '\0';
10763         ieee->geo.bg_channels = geo->bg_channels;
10764         ieee->geo.a_channels = geo->a_channels;
10765         memcpy(ieee->geo.bg, geo->bg, geo->bg_channels *
10766                sizeof(struct ieee80211_channel));
10767         memcpy(ieee->geo.a, geo->a, ieee->geo.a_channels *
10768                sizeof(struct ieee80211_channel));
10769         return 0;
10770 }
10771
10772 static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *ieee)
10773 {
10774         return &ieee->geo;
10775 }
10776
10777 #define MAX_HW_RESTARTS 5
10778 static int ipw_up(struct ipw_priv *priv)
10779 {
10780         int rc, i, j;
10781
10782         if (priv->status & STATUS_EXIT_PENDING)
10783                 return -EIO;
10784
10785         if (cmdlog && !priv->cmdlog) {
10786                 priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
10787                                        GFP_KERNEL);
10788                 if (priv->cmdlog == NULL) {
10789                         IPW_ERROR("Error allocating %d command log entries.\n",
10790                                   cmdlog);
10791                 } else {
10792                         memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
10793                         priv->cmdlog_len = cmdlog;
10794                 }
10795         }
10796
10797         for (i = 0; i < MAX_HW_RESTARTS; i++) {
10798                 /* Load the microcode, firmware, and eeprom.
10799                  * Also start the clocks. */
10800                 rc = ipw_load(priv);
10801                 if (rc) {
10802                         IPW_ERROR("Unable to load firmware: %d\n", rc);
10803                         return rc;
10804                 }
10805
10806                 ipw_init_ordinals(priv);
10807                 if (!(priv->config & CFG_CUSTOM_MAC))
10808                         eeprom_parse_mac(priv, priv->mac_addr);
10809                 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
10810
10811                 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
10812                         if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
10813                                     ipw_geos[j].name, 3))
10814                                 break;
10815                 }
10816                 if (j == ARRAY_SIZE(ipw_geos)) {
10817                         IPW_WARNING("SKU [%c%c%c] not recognized.\n",
10818                                     priv->eeprom[EEPROM_COUNTRY_CODE + 0],
10819                                     priv->eeprom[EEPROM_COUNTRY_CODE + 1],
10820                                     priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
10821                         j = 0;
10822                 }
10823                 if (ipw_set_geo(priv->ieee, &ipw_geos[j])) {
10824                         IPW_WARNING("Could not set geography.");
10825                         return 0;
10826                 }
10827
10828                 IPW_DEBUG_INFO("Geography %03d [%s] detected.\n",
10829                                j, priv->ieee->geo.name);
10830
10831                 if (priv->status & STATUS_RF_KILL_SW) {
10832                         IPW_WARNING("Radio disabled by module parameter.\n");
10833                         return 0;
10834                 } else if (rf_kill_active(priv)) {
10835                         IPW_WARNING("Radio Frequency Kill Switch is On:\n"
10836                                     "Kill switch must be turned off for "
10837                                     "wireless networking to work.\n");
10838                         queue_delayed_work(priv->workqueue, &priv->rf_kill,
10839                                            2 * HZ);
10840                         return 0;
10841                 }
10842
10843                 rc = ipw_config(priv);
10844                 if (!rc) {
10845                         IPW_DEBUG_INFO("Configured device on count %i\n", i);
10846
10847                         /* If configure to try and auto-associate, kick
10848                          * off a scan. */
10849                         queue_work(priv->workqueue, &priv->request_scan);
10850
10851                         return 0;
10852                 }
10853
10854                 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
10855                 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
10856                                i, MAX_HW_RESTARTS);
10857
10858                 /* We had an error bringing up the hardware, so take it
10859                  * all the way back down so we can try again */
10860                 ipw_down(priv);
10861         }
10862
10863         /* tried to restart and config the device for as long as our
10864          * patience could withstand */
10865         IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
10866
10867         return -EIO;
10868 }
10869
10870 static void ipw_bg_up(void *data)
10871 {
10872         struct ipw_priv *priv = data;
10873         down(&priv->sem);
10874         ipw_up(data);
10875         up(&priv->sem);
10876 }
10877
10878 static void ipw_deinit(struct ipw_priv *priv)
10879 {
10880         int i;
10881
10882         if (priv->status & STATUS_SCANNING) {
10883                 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
10884                 ipw_abort_scan(priv);
10885         }
10886
10887         if (priv->status & STATUS_ASSOCIATED) {
10888                 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
10889                 ipw_disassociate(priv);
10890         }
10891
10892         ipw_led_shutdown(priv);
10893
10894         /* Wait up to 1s for status to change to not scanning and not
10895          * associated (disassociation can take a while for a ful 802.11
10896          * exchange */
10897         for (i = 1000; i && (priv->status &
10898                              (STATUS_DISASSOCIATING |
10899                               STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
10900                 udelay(10);
10901
10902         if (priv->status & (STATUS_DISASSOCIATING |
10903                             STATUS_ASSOCIATED | STATUS_SCANNING))
10904                 IPW_DEBUG_INFO("Still associated or scanning...\n");
10905         else
10906                 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
10907
10908         /* Attempt to disable the card */
10909         ipw_send_card_disable(priv, 0);
10910
10911         priv->status &= ~STATUS_INIT;
10912 }
10913
10914 static void ipw_down(struct ipw_priv *priv)
10915 {
10916         int exit_pending = priv->status & STATUS_EXIT_PENDING;
10917
10918         priv->status |= STATUS_EXIT_PENDING;
10919
10920         if (ipw_is_init(priv))
10921                 ipw_deinit(priv);
10922
10923         /* Wipe out the EXIT_PENDING status bit if we are not actually
10924          * exiting the module */
10925         if (!exit_pending)
10926                 priv->status &= ~STATUS_EXIT_PENDING;
10927
10928         /* tell the device to stop sending interrupts */
10929         ipw_disable_interrupts(priv);
10930
10931         /* Clear all bits but the RF Kill */
10932         priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
10933         netif_carrier_off(priv->net_dev);
10934         netif_stop_queue(priv->net_dev);
10935
10936         ipw_stop_nic(priv);
10937
10938         ipw_led_radio_off(priv);
10939 }
10940
10941 static void ipw_bg_down(void *data)
10942 {
10943         struct ipw_priv *priv = data;
10944         down(&priv->sem);
10945         ipw_down(data);
10946         up(&priv->sem);
10947 }
10948
10949 /* Called by register_netdev() */
10950 static int ipw_net_init(struct net_device *dev)
10951 {
10952         struct ipw_priv *priv = ieee80211_priv(dev);
10953         down(&priv->sem);
10954
10955         if (ipw_up(priv)) {
10956                 up(&priv->sem);
10957                 return -EIO;
10958         }
10959
10960         up(&priv->sem);
10961         return 0;
10962 }
10963
10964 /* PCI driver stuff */
10965 static struct pci_device_id card_ids[] = {
10966         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
10967         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
10968         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
10969         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
10970         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
10971         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
10972         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
10973         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
10974         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
10975         {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
10976         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
10977         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
10978         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
10979         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
10980         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
10981         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
10982         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
10983         {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
10984         {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10985         {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10986         {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10987         {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10988
10989         /* required last entry */
10990         {0,}
10991 };
10992
10993 MODULE_DEVICE_TABLE(pci, card_ids);
10994
10995 static struct attribute *ipw_sysfs_entries[] = {
10996         &dev_attr_rf_kill.attr,
10997         &dev_attr_direct_dword.attr,
10998         &dev_attr_indirect_byte.attr,
10999         &dev_attr_indirect_dword.attr,
11000         &dev_attr_mem_gpio_reg.attr,
11001         &dev_attr_command_event_reg.attr,
11002         &dev_attr_nic_type.attr,
11003         &dev_attr_status.attr,
11004         &dev_attr_cfg.attr,
11005         &dev_attr_error.attr,
11006         &dev_attr_event_log.attr,
11007         &dev_attr_cmd_log.attr,
11008         &dev_attr_eeprom_delay.attr,
11009         &dev_attr_ucode_version.attr,
11010         &dev_attr_rtc.attr,
11011         &dev_attr_scan_age.attr,
11012         &dev_attr_led.attr,
11013         &dev_attr_speed_scan.attr,
11014         &dev_attr_net_stats.attr,
11015         NULL
11016 };
11017
11018 static struct attribute_group ipw_attribute_group = {
11019         .name = NULL,           /* put in device directory */
11020         .attrs = ipw_sysfs_entries,
11021 };
11022
11023 static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
11024 {
11025         int err = 0;
11026         struct net_device *net_dev;
11027         void __iomem *base;
11028         u32 length, val;
11029         struct ipw_priv *priv;
11030         int i;
11031
11032         net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
11033         if (net_dev == NULL) {
11034                 err = -ENOMEM;
11035                 goto out;
11036         }
11037
11038         priv = ieee80211_priv(net_dev);
11039         priv->ieee = netdev_priv(net_dev);
11040
11041         priv->net_dev = net_dev;
11042         priv->pci_dev = pdev;
11043 #ifdef CONFIG_IPW2200_DEBUG
11044         ipw_debug_level = debug;
11045 #endif
11046         spin_lock_init(&priv->lock);
11047         for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
11048                 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
11049
11050         init_MUTEX(&priv->sem);
11051         if (pci_enable_device(pdev)) {
11052                 err = -ENODEV;
11053                 goto out_free_ieee80211;
11054         }
11055
11056         pci_set_master(pdev);
11057
11058         err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
11059         if (!err)
11060                 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
11061         if (err) {
11062                 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
11063                 goto out_pci_disable_device;
11064         }
11065
11066         pci_set_drvdata(pdev, priv);
11067
11068         err = pci_request_regions(pdev, DRV_NAME);
11069         if (err)
11070                 goto out_pci_disable_device;
11071
11072         /* We disable the RETRY_TIMEOUT register (0x41) to keep
11073          * PCI Tx retries from interfering with C3 CPU state */
11074         pci_read_config_dword(pdev, 0x40, &val);
11075         if ((val & 0x0000ff00) != 0)
11076                 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11077
11078         length = pci_resource_len(pdev, 0);
11079         priv->hw_len = length;
11080
11081         base = ioremap_nocache(pci_resource_start(pdev, 0), length);
11082         if (!base) {
11083                 err = -ENODEV;
11084                 goto out_pci_release_regions;
11085         }
11086
11087         priv->hw_base = base;
11088         IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
11089         IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
11090
11091         err = ipw_setup_deferred_work(priv);
11092         if (err) {
11093                 IPW_ERROR("Unable to setup deferred work\n");
11094                 goto out_iounmap;
11095         }
11096
11097         ipw_sw_reset(priv, 1);
11098
11099         err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
11100         if (err) {
11101                 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
11102                 goto out_destroy_workqueue;
11103         }
11104
11105         SET_MODULE_OWNER(net_dev);
11106         SET_NETDEV_DEV(net_dev, &pdev->dev);
11107
11108         down(&priv->sem);
11109
11110         priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11111         priv->ieee->set_security = shim__set_security;
11112         priv->ieee->is_queue_full = ipw_net_is_queue_full;
11113
11114 #ifdef CONFIG_IPW_QOS
11115         priv->ieee->handle_probe_response = ipw_handle_beacon;
11116         priv->ieee->handle_beacon = ipw_handle_probe_response;
11117         priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
11118 #endif                          /* CONFIG_IPW_QOS */
11119
11120         priv->ieee->perfect_rssi = -20;
11121         priv->ieee->worst_rssi = -85;
11122
11123         net_dev->open = ipw_net_open;
11124         net_dev->stop = ipw_net_stop;
11125         net_dev->init = ipw_net_init;
11126         net_dev->get_stats = ipw_net_get_stats;
11127         net_dev->set_multicast_list = ipw_net_set_multicast_list;
11128         net_dev->set_mac_address = ipw_net_set_mac_address;
11129         priv->wireless_data.spy_data = &priv->ieee->spy_data;
11130         net_dev->wireless_data = &priv->wireless_data;
11131         net_dev->wireless_handlers = &ipw_wx_handler_def;
11132         net_dev->ethtool_ops = &ipw_ethtool_ops;
11133         net_dev->irq = pdev->irq;
11134         net_dev->base_addr = (unsigned long)priv->hw_base;
11135         net_dev->mem_start = pci_resource_start(pdev, 0);
11136         net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
11137
11138         err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11139         if (err) {
11140                 IPW_ERROR("failed to create sysfs device attributes\n");
11141                 up(&priv->sem);
11142                 goto out_release_irq;
11143         }
11144
11145         up(&priv->sem);
11146         err = register_netdev(net_dev);
11147         if (err) {
11148                 IPW_ERROR("failed to register network device\n");
11149                 goto out_remove_sysfs;
11150         }
11151         return 0;
11152
11153       out_remove_sysfs:
11154         sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11155       out_release_irq:
11156         free_irq(pdev->irq, priv);
11157       out_destroy_workqueue:
11158         destroy_workqueue(priv->workqueue);
11159         priv->workqueue = NULL;
11160       out_iounmap:
11161         iounmap(priv->hw_base);
11162       out_pci_release_regions:
11163         pci_release_regions(pdev);
11164       out_pci_disable_device:
11165         pci_disable_device(pdev);
11166         pci_set_drvdata(pdev, NULL);
11167       out_free_ieee80211:
11168         free_ieee80211(priv->net_dev);
11169       out:
11170         return err;
11171 }
11172
11173 static void ipw_pci_remove(struct pci_dev *pdev)
11174 {
11175         struct ipw_priv *priv = pci_get_drvdata(pdev);
11176         struct list_head *p, *q;
11177         int i;
11178
11179         if (!priv)
11180                 return;
11181
11182         down(&priv->sem);
11183
11184         priv->status |= STATUS_EXIT_PENDING;
11185         ipw_down(priv);
11186         sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11187
11188         up(&priv->sem);
11189
11190         unregister_netdev(priv->net_dev);
11191
11192         if (priv->rxq) {
11193                 ipw_rx_queue_free(priv, priv->rxq);
11194                 priv->rxq = NULL;
11195         }
11196         ipw_tx_queue_free(priv);
11197
11198         if (priv->cmdlog) {
11199                 kfree(priv->cmdlog);
11200                 priv->cmdlog = NULL;
11201         }
11202         /* ipw_down will ensure that there is no more pending work
11203          * in the workqueue's, so we can safely remove them now. */
11204         cancel_delayed_work(&priv->adhoc_check);
11205         cancel_delayed_work(&priv->gather_stats);
11206         cancel_delayed_work(&priv->request_scan);
11207         cancel_delayed_work(&priv->rf_kill);
11208         cancel_delayed_work(&priv->scan_check);
11209         destroy_workqueue(priv->workqueue);
11210         priv->workqueue = NULL;
11211
11212         /* Free MAC hash list for ADHOC */
11213         for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11214                 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11215                         list_del(p);
11216                         kfree(list_entry(p, struct ipw_ibss_seq, list));
11217                 }
11218         }
11219
11220         if (priv->error) {
11221                 ipw_free_error_log(priv->error);
11222                 priv->error = NULL;
11223         }
11224
11225         free_irq(pdev->irq, priv);
11226         iounmap(priv->hw_base);
11227         pci_release_regions(pdev);
11228         pci_disable_device(pdev);
11229         pci_set_drvdata(pdev, NULL);
11230         free_ieee80211(priv->net_dev);
11231         free_firmware();
11232 }
11233
11234 #ifdef CONFIG_PM
11235 static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
11236 {
11237         struct ipw_priv *priv = pci_get_drvdata(pdev);
11238         struct net_device *dev = priv->net_dev;
11239
11240         printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11241
11242         /* Take down the device; powers it off, etc. */
11243         ipw_down(priv);
11244
11245         /* Remove the PRESENT state of the device */
11246         netif_device_detach(dev);
11247
11248         pci_save_state(pdev);
11249         pci_disable_device(pdev);
11250         pci_set_power_state(pdev, pci_choose_state(pdev, state));
11251
11252         return 0;
11253 }
11254
11255 static int ipw_pci_resume(struct pci_dev *pdev)
11256 {
11257         struct ipw_priv *priv = pci_get_drvdata(pdev);
11258         struct net_device *dev = priv->net_dev;
11259         u32 val;
11260
11261         printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11262
11263         pci_set_power_state(pdev, PCI_D0);
11264         pci_enable_device(pdev);
11265         pci_restore_state(pdev);
11266
11267         /*
11268          * Suspend/Resume resets the PCI configuration space, so we have to
11269          * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11270          * from interfering with C3 CPU state. pci_restore_state won't help
11271          * here since it only restores the first 64 bytes pci config header.
11272          */
11273         pci_read_config_dword(pdev, 0x40, &val);
11274         if ((val & 0x0000ff00) != 0)
11275                 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11276
11277         /* Set the device back into the PRESENT state; this will also wake
11278          * the queue of needed */
11279         netif_device_attach(dev);
11280
11281         /* Bring the device back up */
11282         queue_work(priv->workqueue, &priv->up);
11283
11284         return 0;
11285 }
11286 #endif
11287
11288 /* driver initialization stuff */
11289 static struct pci_driver ipw_driver = {
11290         .name = DRV_NAME,
11291         .id_table = card_ids,
11292         .probe = ipw_pci_probe,
11293         .remove = __devexit_p(ipw_pci_remove),
11294 #ifdef CONFIG_PM
11295         .suspend = ipw_pci_suspend,
11296         .resume = ipw_pci_resume,
11297 #endif
11298 };
11299
11300 static int __init ipw_init(void)
11301 {
11302         int ret;
11303
11304         printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11305         printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11306
11307         ret = pci_module_init(&ipw_driver);
11308         if (ret) {
11309                 IPW_ERROR("Unable to initialize PCI module\n");
11310                 return ret;
11311         }
11312
11313         ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
11314         if (ret) {
11315                 IPW_ERROR("Unable to create driver sysfs file\n");
11316                 pci_unregister_driver(&ipw_driver);
11317                 return ret;
11318         }
11319
11320         return ret;
11321 }
11322
11323 static void __exit ipw_exit(void)
11324 {
11325         driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11326         pci_unregister_driver(&ipw_driver);
11327 }
11328
11329 module_param(disable, int, 0444);
11330 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11331
11332 module_param(associate, int, 0444);
11333 MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
11334
11335 module_param(auto_create, int, 0444);
11336 MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11337
11338 module_param(led, int, 0444);
11339 MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
11340
11341 module_param(debug, int, 0444);
11342 MODULE_PARM_DESC(debug, "debug output mask");
11343
11344 module_param(channel, int, 0444);
11345 MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
11346
11347 #ifdef CONFIG_IPW_QOS
11348 module_param(qos_enable, int, 0444);
11349 MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
11350
11351 module_param(qos_burst_enable, int, 0444);
11352 MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11353
11354 module_param(qos_no_ack_mask, int, 0444);
11355 MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
11356
11357 module_param(burst_duration_CCK, int, 0444);
11358 MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11359
11360 module_param(burst_duration_OFDM, int, 0444);
11361 MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11362 #endif                          /* CONFIG_IPW_QOS */
11363
11364 #ifdef CONFIG_IPW2200_MONITOR
11365 module_param(mode, int, 0444);
11366 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
11367 #else
11368 module_param(mode, int, 0444);
11369 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
11370 #endif
11371
11372 module_param(bt_coexist, int, 0444);
11373 MODULE_PARM_DESC(bt_coexist, "enable bluetooth coexistence (default off)");
11374
11375 module_param(hwcrypto, int, 0444);
11376 MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default on)");
11377
11378 module_param(cmdlog, int, 0444);
11379 MODULE_PARM_DESC(cmdlog,
11380                  "allocate a ring buffer for logging firmware commands");
11381
11382 module_param(roaming, int, 0444);
11383 MODULE_PARM_DESC(roaming, "enable roaming support (default on)");
11384
11385 module_exit(ipw_exit);
11386 module_init(ipw_init);