drivers/net/wireless/ipw2200.c

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