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