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         if (!(priv->status & STATUS_INIT) ||
8930             (priv->status & STATUS_EXIT_PENDING))
8931                 return 0;
8932
8933         down(&priv->sem);
8934
8935         if (priv->status & STATUS_RF_KILL_MASK) {
8936                 IPW_DEBUG_HC("Aborting scan due to RF kill activation\n");
8937                 priv->status |= STATUS_SCAN_PENDING;
8938                 goto done;
8939         }
8940
8941         IPW_DEBUG_HC("starting request direct scan!\n");
8942
8943         if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
8944                 err = wait_event_interruptible(priv->wait_state,
8945                                                !(priv->
8946                                                  status & (STATUS_SCANNING |
8947                                                            STATUS_SCAN_ABORTING)));
8948                 if (err) {
8949                         IPW_DEBUG_HC("aborting direct scan");
8950                         goto done;
8951                 }
8952         }
8953         memset(&scan, 0, sizeof(scan));
8954
8955         if (priv->config & CFG_SPEED_SCAN)
8956                 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8957                     cpu_to_le16(30);
8958         else
8959                 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8960                     cpu_to_le16(20);
8961
8962         scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
8963             cpu_to_le16(20);
8964         scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
8965         scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
8966
8967         scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
8968
8969         err = ipw_send_ssid(priv, essid, essid_len);
8970         if (err) {
8971                 IPW_DEBUG_HC("Attempt to send SSID command failed\n");
8972                 goto done;
8973         }
8974         scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
8975
8976         ipw_add_scan_channels(priv, &scan, scan_type);
8977
8978         err = ipw_send_scan_request_ext(priv, &scan);
8979         if (err) {
8980                 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
8981                 goto done;
8982         }
8983
8984         priv->status |= STATUS_SCANNING;
8985
8986       done:
8987         up(&priv->sem);
8988         return err;
8989 }
8990
8991 static int ipw_wx_set_scan(struct net_device *dev,
8992                            struct iw_request_info *info,
8993                            union iwreq_data *wrqu, char *extra)
8994 {
8995         struct ipw_priv *priv = ieee80211_priv(dev);
8996         struct iw_scan_req *req = NULL;
8997         if (wrqu->data.length
8998             && wrqu->data.length == sizeof(struct iw_scan_req)) {
8999                 req = (struct iw_scan_req *)extra;
9000                 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
9001                         ipw_request_direct_scan(priv, req->essid,
9002                                                 req->essid_len);
9003                         return 0;
9004                 }
9005         }
9006
9007         IPW_DEBUG_WX("Start scan\n");
9008
9009         queue_work(priv->workqueue, &priv->request_scan);
9010
9011         return 0;
9012 }
9013
9014 static int ipw_wx_get_scan(struct net_device *dev,
9015                            struct iw_request_info *info,
9016                            union iwreq_data *wrqu, char *extra)
9017 {
9018         struct ipw_priv *priv = ieee80211_priv(dev);
9019         return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
9020 }
9021
9022 static int ipw_wx_set_encode(struct net_device *dev,
9023                              struct iw_request_info *info,
9024                              union iwreq_data *wrqu, char *key)
9025 {
9026         struct ipw_priv *priv = ieee80211_priv(dev);
9027         int ret;
9028         u32 cap = priv->capability;
9029
9030         down(&priv->sem);
9031         ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
9032
9033         /* In IBSS mode, we need to notify the firmware to update
9034          * the beacon info after we changed the capability. */
9035         if (cap != priv->capability &&
9036             priv->ieee->iw_mode == IW_MODE_ADHOC &&
9037             priv->status & STATUS_ASSOCIATED)
9038                 ipw_disassociate(priv);
9039
9040         up(&priv->sem);
9041         return ret;
9042 }
9043
9044 static int ipw_wx_get_encode(struct net_device *dev,
9045                              struct iw_request_info *info,
9046                              union iwreq_data *wrqu, char *key)
9047 {
9048         struct ipw_priv *priv = ieee80211_priv(dev);
9049         return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
9050 }
9051
9052 static int ipw_wx_set_power(struct net_device *dev,
9053                             struct iw_request_info *info,
9054                             union iwreq_data *wrqu, char *extra)
9055 {
9056         struct ipw_priv *priv = ieee80211_priv(dev);
9057         int err;
9058         down(&priv->sem);
9059         if (wrqu->power.disabled) {
9060                 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9061                 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9062                 if (err) {
9063                         IPW_DEBUG_WX("failed setting power mode.\n");
9064                         up(&priv->sem);
9065                         return err;
9066                 }
9067                 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9068                 up(&priv->sem);
9069                 return 0;
9070         }
9071
9072         switch (wrqu->power.flags & IW_POWER_MODE) {
9073         case IW_POWER_ON:       /* If not specified */
9074         case IW_POWER_MODE:     /* If set all mask */
9075         case IW_POWER_ALL_R:    /* If explicitely state all */
9076                 break;
9077         default:                /* Otherwise we don't support it */
9078                 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9079                              wrqu->power.flags);
9080                 up(&priv->sem);
9081                 return -EOPNOTSUPP;
9082         }
9083
9084         /* If the user hasn't specified a power management mode yet, default
9085          * to BATTERY */
9086         if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
9087                 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9088         else
9089                 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9090         err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9091         if (err) {
9092                 IPW_DEBUG_WX("failed setting power mode.\n");
9093                 up(&priv->sem);
9094                 return err;
9095         }
9096
9097         IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9098         up(&priv->sem);
9099         return 0;
9100 }
9101
9102 static int ipw_wx_get_power(struct net_device *dev,
9103                             struct iw_request_info *info,
9104                             union iwreq_data *wrqu, char *extra)
9105 {
9106         struct ipw_priv *priv = ieee80211_priv(dev);
9107         down(&priv->sem);
9108         if (!(priv->power_mode & IPW_POWER_ENABLED))
9109                 wrqu->power.disabled = 1;
9110         else
9111                 wrqu->power.disabled = 0;
9112
9113         up(&priv->sem);
9114         IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9115
9116         return 0;
9117 }
9118
9119 static int ipw_wx_set_powermode(struct net_device *dev,
9120                                 struct iw_request_info *info,
9121                                 union iwreq_data *wrqu, char *extra)
9122 {
9123         struct ipw_priv *priv = ieee80211_priv(dev);
9124         int mode = *(int *)extra;
9125         int err;
9126         down(&priv->sem);
9127         if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
9128                 mode = IPW_POWER_AC;
9129                 priv->power_mode = mode;
9130         } else {
9131                 priv->power_mode = IPW_POWER_ENABLED | mode;
9132         }
9133
9134         if (priv->power_mode != mode) {
9135                 err = ipw_send_power_mode(priv, mode);
9136
9137                 if (err) {
9138                         IPW_DEBUG_WX("failed setting power mode.\n");
9139                         up(&priv->sem);
9140                         return err;
9141                 }
9142         }
9143         up(&priv->sem);
9144         return 0;
9145 }
9146
9147 #define MAX_WX_STRING 80
9148 static int ipw_wx_get_powermode(struct net_device *dev,
9149                                 struct iw_request_info *info,
9150                                 union iwreq_data *wrqu, char *extra)
9151 {
9152         struct ipw_priv *priv = ieee80211_priv(dev);
9153         int level = IPW_POWER_LEVEL(priv->power_mode);
9154         char *p = extra;
9155
9156         p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9157
9158         switch (level) {
9159         case IPW_POWER_AC:
9160                 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9161                 break;
9162         case IPW_POWER_BATTERY:
9163                 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9164                 break;
9165         default:
9166                 p += snprintf(p, MAX_WX_STRING - (p - extra),
9167                               "(Timeout %dms, Period %dms)",
9168                               timeout_duration[level - 1] / 1000,
9169                               period_duration[level - 1] / 1000);
9170         }
9171
9172         if (!(priv->power_mode & IPW_POWER_ENABLED))
9173                 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
9174
9175         wrqu->data.length = p - extra + 1;
9176
9177         return 0;
9178 }
9179
9180 static int ipw_wx_set_wireless_mode(struct net_device *dev,
9181                                     struct iw_request_info *info,
9182                                     union iwreq_data *wrqu, char *extra)
9183 {
9184         struct ipw_priv *priv = ieee80211_priv(dev);
9185         int mode = *(int *)extra;
9186         u8 band = 0, modulation = 0;
9187
9188         if (mode == 0 || mode & ~IEEE_MODE_MASK) {
9189                 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
9190                 return -EINVAL;
9191         }
9192         down(&priv->sem);
9193         if (priv->adapter == IPW_2915ABG) {
9194                 priv->ieee->abg_true = 1;
9195                 if (mode & IEEE_A) {
9196                         band |= IEEE80211_52GHZ_BAND;
9197                         modulation |= IEEE80211_OFDM_MODULATION;
9198                 } else
9199                         priv->ieee->abg_true = 0;
9200         } else {
9201                 if (mode & IEEE_A) {
9202                         IPW_WARNING("Attempt to set 2200BG into "
9203                                     "802.11a mode\n");
9204                         up(&priv->sem);
9205                         return -EINVAL;
9206                 }
9207
9208                 priv->ieee->abg_true = 0;
9209         }
9210
9211         if (mode & IEEE_B) {
9212                 band |= IEEE80211_24GHZ_BAND;
9213                 modulation |= IEEE80211_CCK_MODULATION;
9214         } else
9215                 priv->ieee->abg_true = 0;
9216
9217         if (mode & IEEE_G) {
9218                 band |= IEEE80211_24GHZ_BAND;
9219                 modulation |= IEEE80211_OFDM_MODULATION;
9220         } else
9221                 priv->ieee->abg_true = 0;
9222
9223         priv->ieee->mode = mode;
9224         priv->ieee->freq_band = band;
9225         priv->ieee->modulation = modulation;
9226         init_supported_rates(priv, &priv->rates);
9227
9228         /* Network configuration changed -- force [re]association */
9229         IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9230         if (!ipw_disassociate(priv)) {
9231                 ipw_send_supported_rates(priv, &priv->rates);
9232                 ipw_associate(priv);
9233         }
9234
9235         /* Update the band LEDs */
9236         ipw_led_band_on(priv);
9237
9238         IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
9239                      mode & IEEE_A ? 'a' : '.',
9240                      mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9241         up(&priv->sem);
9242         return 0;
9243 }
9244
9245 static int ipw_wx_get_wireless_mode(struct net_device *dev,
9246                                     struct iw_request_info *info,
9247                                     union iwreq_data *wrqu, char *extra)
9248 {
9249         struct ipw_priv *priv = ieee80211_priv(dev);
9250         down(&priv->sem);
9251         switch (priv->ieee->mode) {
9252         case IEEE_A:
9253                 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9254                 break;
9255         case IEEE_B:
9256                 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9257                 break;
9258         case IEEE_A | IEEE_B:
9259                 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9260                 break;
9261         case IEEE_G:
9262                 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9263                 break;
9264         case IEEE_A | IEEE_G:
9265                 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9266                 break;
9267         case IEEE_B | IEEE_G:
9268                 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9269                 break;
9270         case IEEE_A | IEEE_B | IEEE_G:
9271                 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9272                 break;
9273         default:
9274                 strncpy(extra, "unknown", MAX_WX_STRING);
9275                 break;
9276         }
9277
9278         IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9279
9280         wrqu->data.length = strlen(extra) + 1;
9281         up(&priv->sem);
9282
9283         return 0;
9284 }
9285
9286 static int ipw_wx_set_preamble(struct net_device *dev,
9287                                struct iw_request_info *info,
9288                                union iwreq_data *wrqu, char *extra)
9289 {
9290         struct ipw_priv *priv = ieee80211_priv(dev);
9291         int mode = *(int *)extra;
9292         down(&priv->sem);
9293         /* Switching from SHORT -> LONG requires a disassociation */
9294         if (mode == 1) {
9295                 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9296                         priv->config |= CFG_PREAMBLE_LONG;
9297
9298                         /* Network configuration changed -- force [re]association */
9299                         IPW_DEBUG_ASSOC
9300                             ("[re]association triggered due to preamble change.\n");
9301                         if (!ipw_disassociate(priv))
9302                                 ipw_associate(priv);
9303                 }
9304                 goto done;
9305         }
9306
9307         if (mode == 0) {
9308                 priv->config &= ~CFG_PREAMBLE_LONG;
9309                 goto done;
9310         }
9311         up(&priv->sem);
9312         return -EINVAL;
9313
9314       done:
9315         up(&priv->sem);
9316         return 0;
9317 }
9318
9319 static int ipw_wx_get_preamble(struct net_device *dev,
9320                                struct iw_request_info *info,
9321                                union iwreq_data *wrqu, char *extra)
9322 {
9323         struct ipw_priv *priv = ieee80211_priv(dev);
9324         down(&priv->sem);
9325         if (priv->config & CFG_PREAMBLE_LONG)
9326                 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9327         else
9328                 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9329         up(&priv->sem);
9330         return 0;
9331 }
9332
9333 #ifdef CONFIG_IPW2200_MONITOR
9334 static int ipw_wx_set_monitor(struct net_device *dev,
9335                               struct iw_request_info *info,
9336                               union iwreq_data *wrqu, char *extra)
9337 {
9338         struct ipw_priv *priv = ieee80211_priv(dev);
9339         int *parms = (int *)extra;
9340         int enable = (parms[0] > 0);
9341         down(&priv->sem);
9342         IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
9343         if (enable) {
9344                 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9345 #ifdef CONFIG_IEEE80211_RADIOTAP
9346                         priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9347 #else
9348                         priv->net_dev->type = ARPHRD_IEEE80211;
9349 #endif
9350                         queue_work(priv->workqueue, &priv->adapter_restart);
9351                 }
9352
9353                 ipw_set_channel(priv, parms[1]);
9354         } else {
9355                 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9356                         up(&priv->sem);
9357                         return 0;
9358                 }
9359                 priv->net_dev->type = ARPHRD_ETHER;
9360                 queue_work(priv->workqueue, &priv->adapter_restart);
9361         }
9362         up(&priv->sem);
9363         return 0;
9364 }
9365
9366 #endif                          // CONFIG_IPW2200_MONITOR
9367
9368 static int ipw_wx_reset(struct net_device *dev,
9369                         struct iw_request_info *info,
9370                         union iwreq_data *wrqu, char *extra)
9371 {
9372         struct ipw_priv *priv = ieee80211_priv(dev);
9373         IPW_DEBUG_WX("RESET\n");
9374         queue_work(priv->workqueue, &priv->adapter_restart);
9375         return 0;
9376 }
9377
9378 static int ipw_wx_sw_reset(struct net_device *dev,
9379                            struct iw_request_info *info,
9380                            union iwreq_data *wrqu, char *extra)
9381 {
9382         struct ipw_priv *priv = ieee80211_priv(dev);
9383         union iwreq_data wrqu_sec = {
9384                 .encoding = {
9385                              .flags = IW_ENCODE_DISABLED,
9386                              },
9387         };
9388         int ret;
9389
9390         IPW_DEBUG_WX("SW_RESET\n");
9391
9392         down(&priv->sem);
9393
9394         ret = ipw_sw_reset(priv, 0);
9395         if (!ret) {
9396                 free_firmware();
9397                 ipw_adapter_restart(priv);
9398         }
9399
9400         /* The SW reset bit might have been toggled on by the 'disable'
9401          * module parameter, so take appropriate action */
9402         ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9403
9404         up(&priv->sem);
9405         ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9406         down(&priv->sem);
9407
9408         if (!(priv->status & STATUS_RF_KILL_MASK)) {
9409                 /* Configuration likely changed -- force [re]association */
9410                 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9411                                 "reset.\n");
9412                 if (!ipw_disassociate(priv))
9413                         ipw_associate(priv);
9414         }
9415
9416         up(&priv->sem);
9417
9418         return 0;
9419 }
9420
9421 /* Rebase the WE IOCTLs to zero for the handler array */
9422 #define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
9423 static iw_handler ipw_wx_handlers[] = {
9424         IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
9425         IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
9426         IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
9427         IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
9428         IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
9429         IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
9430         IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
9431         IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
9432         IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
9433         IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
9434         IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
9435         IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
9436         IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
9437         IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
9438         IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
9439         IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
9440         IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
9441         IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
9442         IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
9443         IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
9444         IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
9445         IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
9446         IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
9447         IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
9448         IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
9449         IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
9450         IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
9451         IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
9452         IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
9453         IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
9454         IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
9455         IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
9456         IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
9457         IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
9458         IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
9459         IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
9460         IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
9461         IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
9462         IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
9463 };
9464
9465 enum {
9466         IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9467         IPW_PRIV_GET_POWER,
9468         IPW_PRIV_SET_MODE,
9469         IPW_PRIV_GET_MODE,
9470         IPW_PRIV_SET_PREAMBLE,
9471         IPW_PRIV_GET_PREAMBLE,
9472         IPW_PRIV_RESET,
9473         IPW_PRIV_SW_RESET,
9474 #ifdef CONFIG_IPW2200_MONITOR
9475         IPW_PRIV_SET_MONITOR,
9476 #endif
9477 };
9478
9479 static struct iw_priv_args ipw_priv_args[] = {
9480         {
9481          .cmd = IPW_PRIV_SET_POWER,
9482          .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9483          .name = "set_power"},
9484         {
9485          .cmd = IPW_PRIV_GET_POWER,
9486          .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9487          .name = "get_power"},
9488         {
9489          .cmd = IPW_PRIV_SET_MODE,
9490          .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9491          .name = "set_mode"},
9492         {
9493          .cmd = IPW_PRIV_GET_MODE,
9494          .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9495          .name = "get_mode"},
9496         {
9497          .cmd = IPW_PRIV_SET_PREAMBLE,
9498          .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9499          .name = "set_preamble"},
9500         {
9501          .cmd = IPW_PRIV_GET_PREAMBLE,
9502          .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9503          .name = "get_preamble"},
9504         {
9505          IPW_PRIV_RESET,
9506          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
9507         {
9508          IPW_PRIV_SW_RESET,
9509          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9510 #ifdef CONFIG_IPW2200_MONITOR
9511         {
9512          IPW_PRIV_SET_MONITOR,
9513          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9514 #endif                          /* CONFIG_IPW2200_MONITOR */
9515 };
9516
9517 static iw_handler ipw_priv_handler[] = {
9518         ipw_wx_set_powermode,
9519         ipw_wx_get_powermode,
9520         ipw_wx_set_wireless_mode,
9521         ipw_wx_get_wireless_mode,
9522         ipw_wx_set_preamble,
9523         ipw_wx_get_preamble,
9524         ipw_wx_reset,
9525         ipw_wx_sw_reset,
9526 #ifdef CONFIG_IPW2200_MONITOR
9527         ipw_wx_set_monitor,
9528 #endif
9529 };
9530
9531 static struct iw_handler_def ipw_wx_handler_def = {
9532         .standard = ipw_wx_handlers,
9533         .num_standard = ARRAY_SIZE(ipw_wx_handlers),
9534         .num_private = ARRAY_SIZE(ipw_priv_handler),
9535         .num_private_args = ARRAY_SIZE(ipw_priv_args),
9536         .private = ipw_priv_handler,
9537         .private_args = ipw_priv_args,
9538         .get_wireless_stats = ipw_get_wireless_stats,
9539 };
9540
9541 /*
9542  * Get wireless statistics.
9543  * Called by /proc/net/wireless
9544  * Also called by SIOCGIWSTATS
9545  */
9546 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
9547 {
9548         struct ipw_priv *priv = ieee80211_priv(dev);
9549         struct iw_statistics *wstats;
9550
9551         wstats = &priv->wstats;
9552
9553         /* if hw is disabled, then ipw_get_ordinal() can't be called.
9554          * netdev->get_wireless_stats seems to be called before fw is
9555          * initialized.  STATUS_ASSOCIATED will only be set if the hw is up
9556          * and associated; if not associcated, the values are all meaningless
9557          * anyway, so set them all to NULL and INVALID */
9558         if (!(priv->status & STATUS_ASSOCIATED)) {
9559                 wstats->miss.beacon = 0;
9560                 wstats->discard.retries = 0;
9561                 wstats->qual.qual = 0;
9562                 wstats->qual.level = 0;
9563                 wstats->qual.noise = 0;
9564                 wstats->qual.updated = 7;
9565                 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
9566                     IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
9567                 return wstats;
9568         }
9569
9570         wstats->qual.qual = priv->quality;
9571         wstats->qual.level = average_value(&priv->average_rssi);
9572         wstats->qual.noise = average_value(&priv->average_noise);
9573         wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
9574             IW_QUAL_NOISE_UPDATED;
9575
9576         wstats->miss.beacon = average_value(&priv->average_missed_beacons);
9577         wstats->discard.retries = priv->last_tx_failures;
9578         wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
9579
9580 /*      if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
9581         goto fail_get_ordinal;
9582         wstats->discard.retries += tx_retry; */
9583
9584         return wstats;
9585 }
9586
9587 /* net device stuff */
9588
9589 static inline void init_sys_config(struct ipw_sys_config *sys_config)
9590 {
9591         memset(sys_config, 0, sizeof(struct ipw_sys_config));
9592         sys_config->bt_coexistence = 1; /* We may need to look into prvStaBtConfig */
9593         sys_config->answer_broadcast_ssid_probe = 0;
9594         sys_config->accept_all_data_frames = 0;
9595         sys_config->accept_non_directed_frames = 1;
9596         sys_config->exclude_unicast_unencrypted = 0;
9597         sys_config->disable_unicast_decryption = 1;
9598         sys_config->exclude_multicast_unencrypted = 0;
9599         sys_config->disable_multicast_decryption = 1;
9600         sys_config->antenna_diversity = CFG_SYS_ANTENNA_BOTH;
9601         sys_config->pass_crc_to_host = 0;       /* TODO: See if 1 gives us FCS */
9602         sys_config->dot11g_auto_detection = 0;
9603         sys_config->enable_cts_to_self = 0;
9604         sys_config->bt_coexist_collision_thr = 0;
9605         sys_config->pass_noise_stats_to_host = 1;       //1 -- fix for 256
9606 }
9607
9608 static int ipw_net_open(struct net_device *dev)
9609 {
9610         struct ipw_priv *priv = ieee80211_priv(dev);
9611         IPW_DEBUG_INFO("dev->open\n");
9612         /* we should be verifying the device is ready to be opened */
9613         down(&priv->sem);
9614         if (!(priv->status & STATUS_RF_KILL_MASK) &&
9615             (priv->status & STATUS_ASSOCIATED))
9616                 netif_start_queue(dev);
9617         up(&priv->sem);
9618         return 0;
9619 }
9620
9621 static int ipw_net_stop(struct net_device *dev)
9622 {
9623         IPW_DEBUG_INFO("dev->close\n");
9624         netif_stop_queue(dev);
9625         return 0;
9626 }
9627
9628 /*
9629 todo:
9630
9631 modify to send one tfd per fragment instead of using chunking.  otherwise
9632 we need to heavily modify the ieee80211_skb_to_txb.
9633 */
9634
9635 static inline int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
9636                              int pri)
9637 {
9638         struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
9639             txb->fragments[0]->data;
9640         int i = 0;
9641         struct tfd_frame *tfd;
9642 #ifdef CONFIG_IPW_QOS
9643         int tx_id = ipw_get_tx_queue_number(priv, pri);
9644         struct clx2_tx_queue *txq = &priv->txq[tx_id];
9645 #else
9646         struct clx2_tx_queue *txq = &priv->txq[0];
9647 #endif
9648         struct clx2_queue *q = &txq->q;
9649         u8 id, hdr_len, unicast;
9650         u16 remaining_bytes;
9651         int fc;
9652
9653         /* If there isn't room in the queue, we return busy and let the
9654          * network stack requeue the packet for us */
9655         if (ipw_queue_space(q) < q->high_mark)
9656                 return NETDEV_TX_BUSY;
9657
9658         switch (priv->ieee->iw_mode) {
9659         case IW_MODE_ADHOC:
9660                 hdr_len = IEEE80211_3ADDR_LEN;
9661                 unicast = !(is_multicast_ether_addr(hdr->addr1) ||
9662                             is_broadcast_ether_addr(hdr->addr1));
9663                 id = ipw_find_station(priv, hdr->addr1);
9664                 if (id == IPW_INVALID_STATION) {
9665                         id = ipw_add_station(priv, hdr->addr1);
9666                         if (id == IPW_INVALID_STATION) {
9667                                 IPW_WARNING("Attempt to send data to "
9668                                             "invalid cell: " MAC_FMT "\n",
9669                                             MAC_ARG(hdr->addr1));
9670                                 goto drop;
9671                         }
9672                 }
9673                 break;
9674
9675         case IW_MODE_INFRA:
9676         default:
9677                 unicast = !(is_multicast_ether_addr(hdr->addr3) ||
9678                             is_broadcast_ether_addr(hdr->addr3));
9679                 hdr_len = IEEE80211_3ADDR_LEN;
9680                 id = 0;
9681                 break;
9682         }
9683
9684         tfd = &txq->bd[q->first_empty];
9685         txq->txb[q->first_empty] = txb;
9686         memset(tfd, 0, sizeof(*tfd));
9687         tfd->u.data.station_number = id;
9688
9689         tfd->control_flags.message_type = TX_FRAME_TYPE;
9690         tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
9691
9692         tfd->u.data.cmd_id = DINO_CMD_TX;
9693         tfd->u.data.len = cpu_to_le16(txb->payload_size);
9694         remaining_bytes = txb->payload_size;
9695
9696         if (priv->assoc_request.ieee_mode == IPW_B_MODE)
9697                 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
9698         else
9699                 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
9700
9701         if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
9702                 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
9703
9704         fc = le16_to_cpu(hdr->frame_ctl);
9705         hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
9706
9707         memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
9708
9709         if (likely(unicast))
9710                 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9711
9712         if (txb->encrypted && !priv->ieee->host_encrypt) {
9713                 switch (priv->ieee->sec.level) {
9714                 case SEC_LEVEL_3:
9715                         tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9716                             IEEE80211_FCTL_PROTECTED;
9717                         /* XXX: ACK flag must be set for CCMP even if it
9718                          * is a multicast/broadcast packet, because CCMP
9719                          * group communication encrypted by GTK is
9720                          * actually done by the AP. */
9721                         if (!unicast)
9722                                 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9723
9724                         tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9725                         tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
9726                         tfd->u.data.key_index = 0;
9727                         tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
9728                         break;
9729                 case SEC_LEVEL_2:
9730                         tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9731                             IEEE80211_FCTL_PROTECTED;
9732                         tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9733                         tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
9734                         tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
9735                         break;
9736                 case SEC_LEVEL_1:
9737                         tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9738                             IEEE80211_FCTL_PROTECTED;
9739                         tfd->u.data.key_index = priv->ieee->tx_keyidx;
9740                         if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
9741                             40)
9742                                 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
9743                         else
9744                                 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
9745                         break;
9746                 case SEC_LEVEL_0:
9747                         break;
9748                 default:
9749                         printk(KERN_ERR "Unknow security level %d\n",
9750                                priv->ieee->sec.level);
9751                         break;
9752                 }
9753         } else
9754                 /* No hardware encryption */
9755                 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
9756
9757 #ifdef CONFIG_IPW_QOS
9758         ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
9759 #endif                          /* CONFIG_IPW_QOS */
9760
9761         /* payload */
9762         tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
9763                                                  txb->nr_frags));
9764         IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
9765                        txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
9766         for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
9767                 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
9768                                i, le32_to_cpu(tfd->u.data.num_chunks),
9769                                txb->fragments[i]->len - hdr_len);
9770                 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
9771                              i, tfd->u.data.num_chunks,
9772                              txb->fragments[i]->len - hdr_len);
9773                 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
9774                            txb->fragments[i]->len - hdr_len);
9775
9776                 tfd->u.data.chunk_ptr[i] =
9777                     cpu_to_le32(pci_map_single
9778                                 (priv->pci_dev,
9779                                  txb->fragments[i]->data + hdr_len,
9780                                  txb->fragments[i]->len - hdr_len,
9781                                  PCI_DMA_TODEVICE));
9782                 tfd->u.data.chunk_len[i] =
9783                     cpu_to_le16(txb->fragments[i]->len - hdr_len);
9784         }
9785
9786         if (i != txb->nr_frags) {
9787                 struct sk_buff *skb;
9788                 u16 remaining_bytes = 0;
9789                 int j;
9790
9791                 for (j = i; j < txb->nr_frags; j++)
9792                         remaining_bytes += txb->fragments[j]->len - hdr_len;
9793
9794                 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
9795                        remaining_bytes);
9796                 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
9797                 if (skb != NULL) {
9798                         tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
9799                         for (j = i; j < txb->nr_frags; j++) {
9800                                 int size = txb->fragments[j]->len - hdr_len;
9801
9802                                 printk(KERN_INFO "Adding frag %d %d...\n",
9803                                        j, size);
9804                                 memcpy(skb_put(skb, size),
9805                                        txb->fragments[j]->data + hdr_len, size);
9806                         }
9807                         dev_kfree_skb_any(txb->fragments[i]);
9808                         txb->fragments[i] = skb;
9809                         tfd->u.data.chunk_ptr[i] =
9810                             cpu_to_le32(pci_map_single
9811                                         (priv->pci_dev, skb->data,
9812                                          tfd->u.data.chunk_len[i],
9813                                          PCI_DMA_TODEVICE));
9814
9815                         tfd->u.data.num_chunks =
9816                             cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
9817                                         1);
9818                 }
9819         }
9820
9821         /* kick DMA */
9822         q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
9823         ipw_write32(priv, q->reg_w, q->first_empty);
9824
9825         return NETDEV_TX_OK;
9826
9827       drop:
9828         IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
9829         ieee80211_txb_free(txb);
9830         return NETDEV_TX_OK;
9831 }
9832
9833 static int ipw_net_is_queue_full(struct net_device *dev, int pri)
9834 {
9835         struct ipw_priv *priv = ieee80211_priv(dev);
9836 #ifdef CONFIG_IPW_QOS
9837         int tx_id = ipw_get_tx_queue_number(priv, pri);
9838         struct clx2_tx_queue *txq = &priv->txq[tx_id];
9839 #else
9840         struct clx2_tx_queue *txq = &priv->txq[0];
9841 #endif                          /* CONFIG_IPW_QOS */
9842
9843         if (ipw_queue_space(&txq->q) < txq->q.high_mark)
9844                 return 1;
9845
9846         return 0;
9847 }
9848
9849 static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
9850                                    struct net_device *dev, int pri)
9851 {
9852         struct ipw_priv *priv = ieee80211_priv(dev);
9853         unsigned long flags;
9854         int ret;
9855
9856         IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
9857         spin_lock_irqsave(&priv->lock, flags);
9858
9859         if (!(priv->status & STATUS_ASSOCIATED)) {
9860                 IPW_DEBUG_INFO("Tx attempt while not associated.\n");
9861                 priv->ieee->stats.tx_carrier_errors++;
9862                 netif_stop_queue(dev);
9863                 goto fail_unlock;
9864         }
9865
9866         ret = ipw_tx_skb(priv, txb, pri);
9867         if (ret == NETDEV_TX_OK)
9868                 __ipw_led_activity_on(priv);
9869         spin_unlock_irqrestore(&priv->lock, flags);
9870
9871         return ret;
9872
9873       fail_unlock:
9874         spin_unlock_irqrestore(&priv->lock, flags);
9875         return 1;
9876 }
9877
9878 static struct net_device_stats *ipw_net_get_stats(struct net_device *dev)
9879 {
9880         struct ipw_priv *priv = ieee80211_priv(dev);
9881
9882         priv->ieee->stats.tx_packets = priv->tx_packets;
9883         priv->ieee->stats.rx_packets = priv->rx_packets;
9884         return &priv->ieee->stats;
9885 }
9886
9887 static void ipw_net_set_multicast_list(struct net_device *dev)
9888 {
9889
9890 }
9891
9892 static int ipw_net_set_mac_address(struct net_device *dev, void *p)
9893 {
9894         struct ipw_priv *priv = ieee80211_priv(dev);
9895         struct sockaddr *addr = p;
9896         if (!is_valid_ether_addr(addr->sa_data))
9897                 return -EADDRNOTAVAIL;
9898         down(&priv->sem);
9899         priv->config |= CFG_CUSTOM_MAC;
9900         memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
9901         printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
9902                priv->net_dev->name, MAC_ARG(priv->mac_addr));
9903         queue_work(priv->workqueue, &priv->adapter_restart);
9904         up(&priv->sem);
9905         return 0;
9906 }
9907
9908 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
9909                                     struct ethtool_drvinfo *info)
9910 {
9911         struct ipw_priv *p = ieee80211_priv(dev);
9912         char vers[64];
9913         char date[32];
9914         u32 len;
9915
9916         strcpy(info->driver, DRV_NAME);
9917         strcpy(info->version, DRV_VERSION);
9918
9919         len = sizeof(vers);
9920         ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
9921         len = sizeof(date);
9922         ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
9923
9924         snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
9925                  vers, date);
9926         strcpy(info->bus_info, pci_name(p->pci_dev));
9927         info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
9928 }
9929
9930 static u32 ipw_ethtool_get_link(struct net_device *dev)
9931 {
9932         struct ipw_priv *priv = ieee80211_priv(dev);
9933         return (priv->status & STATUS_ASSOCIATED) != 0;
9934 }
9935
9936 static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
9937 {
9938         return IPW_EEPROM_IMAGE_SIZE;
9939 }
9940
9941 static int ipw_ethtool_get_eeprom(struct net_device *dev,
9942                                   struct ethtool_eeprom *eeprom, u8 * bytes)
9943 {
9944         struct ipw_priv *p = ieee80211_priv(dev);
9945
9946         if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9947                 return -EINVAL;
9948         down(&p->sem);
9949         memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
9950         up(&p->sem);
9951         return 0;
9952 }
9953
9954 static int ipw_ethtool_set_eeprom(struct net_device *dev,
9955                                   struct ethtool_eeprom *eeprom, u8 * bytes)
9956 {
9957         struct ipw_priv *p = ieee80211_priv(dev);
9958         int i;
9959
9960         if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9961                 return -EINVAL;
9962         down(&p->sem);
9963         memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
9964         for (i = IPW_EEPROM_DATA;
9965              i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
9966                 ipw_write8(p, i, p->eeprom[i]);
9967         up(&p->sem);
9968         return 0;
9969 }
9970
9971 static struct ethtool_ops ipw_ethtool_ops = {
9972         .get_link = ipw_ethtool_get_link,
9973         .get_drvinfo = ipw_ethtool_get_drvinfo,
9974         .get_eeprom_len = ipw_ethtool_get_eeprom_len,
9975         .get_eeprom = ipw_ethtool_get_eeprom,
9976         .set_eeprom = ipw_ethtool_set_eeprom,
9977 };
9978
9979 static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
9980 {
9981         struct ipw_priv *priv = data;
9982         u32 inta, inta_mask;
9983
9984         if (!priv)
9985                 return IRQ_NONE;
9986
9987         spin_lock(&priv->lock);
9988
9989         if (!(priv->status & STATUS_INT_ENABLED)) {
9990                 /* Shared IRQ */
9991                 goto none;
9992         }
9993
9994         inta = ipw_read32(priv, IPW_INTA_RW);
9995         inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
9996
9997         if (inta == 0xFFFFFFFF) {
9998                 /* Hardware disappeared */
9999                 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10000                 goto none;
10001         }
10002
10003         if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
10004                 /* Shared interrupt */
10005                 goto none;
10006         }
10007
10008         /* tell the device to stop sending interrupts */
10009         ipw_disable_interrupts(priv);
10010
10011         /* ack current interrupts */
10012         inta &= (IPW_INTA_MASK_ALL & inta_mask);
10013         ipw_write32(priv, IPW_INTA_RW, inta);
10014
10015         /* Cache INTA value for our tasklet */
10016         priv->isr_inta = inta;
10017
10018         tasklet_schedule(&priv->irq_tasklet);
10019
10020         spin_unlock(&priv->lock);
10021
10022         return IRQ_HANDLED;
10023       none:
10024         spin_unlock(&priv->lock);
10025         return IRQ_NONE;
10026 }
10027
10028 static void ipw_rf_kill(void *adapter)
10029 {
10030         struct ipw_priv *priv = adapter;
10031         unsigned long flags;
10032
10033         spin_lock_irqsave(&priv->lock, flags);
10034
10035         if (rf_kill_active(priv)) {
10036                 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10037                 if (priv->workqueue)
10038                         queue_delayed_work(priv->workqueue,
10039                                            &priv->rf_kill, 2 * HZ);
10040                 goto exit_unlock;
10041         }
10042
10043         /* RF Kill is now disabled, so bring the device back up */
10044
10045         if (!(priv->status & STATUS_RF_KILL_MASK)) {
10046                 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10047                                   "device\n");
10048
10049                 /* we can not do an adapter restart while inside an irq lock */
10050                 queue_work(priv->workqueue, &priv->adapter_restart);
10051         } else
10052                 IPW_DEBUG_RF_KILL("HW RF Kill deactivated.  SW RF Kill still "
10053                                   "enabled\n");
10054
10055       exit_unlock:
10056         spin_unlock_irqrestore(&priv->lock, flags);
10057 }
10058
10059 static void ipw_bg_rf_kill(void *data)
10060 {
10061         struct ipw_priv *priv = data;
10062         down(&priv->sem);
10063         ipw_rf_kill(data);
10064         up(&priv->sem);
10065 }
10066
10067 void ipw_link_up(struct ipw_priv *priv)
10068 {
10069         priv->last_seq_num = -1;
10070         priv->last_frag_num = -1;
10071         priv->last_packet_time = 0;
10072
10073         netif_carrier_on(priv->net_dev);
10074         if (netif_queue_stopped(priv->net_dev)) {
10075                 IPW_DEBUG_NOTIF("waking queue\n");
10076                 netif_wake_queue(priv->net_dev);
10077         } else {
10078                 IPW_DEBUG_NOTIF("starting queue\n");
10079                 netif_start_queue(priv->net_dev);
10080         }
10081
10082         cancel_delayed_work(&priv->request_scan);
10083         ipw_reset_stats(priv);
10084         /* Ensure the rate is updated immediately */
10085         priv->last_rate = ipw_get_current_rate(priv);
10086         ipw_gather_stats(priv);
10087         ipw_led_link_up(priv);
10088         notify_wx_assoc_event(priv);
10089
10090         if (priv->config & CFG_BACKGROUND_SCAN)
10091                 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10092 }
10093
10094 static void ipw_bg_link_up(void *data)
10095 {
10096         struct ipw_priv *priv = data;
10097         down(&priv->sem);
10098         ipw_link_up(data);
10099         up(&priv->sem);
10100 }
10101
10102 void ipw_link_down(struct ipw_priv *priv)
10103 {
10104         ipw_led_link_down(priv);
10105         netif_carrier_off(priv->net_dev);
10106         netif_stop_queue(priv->net_dev);
10107         notify_wx_assoc_event(priv);
10108
10109         /* Cancel any queued work ... */
10110         cancel_delayed_work(&priv->request_scan);
10111         cancel_delayed_work(&priv->adhoc_check);
10112         cancel_delayed_work(&priv->gather_stats);
10113
10114         ipw_reset_stats(priv);
10115
10116         if (!(priv->status & STATUS_EXIT_PENDING)) {
10117                 /* Queue up another scan... */
10118                 queue_work(priv->workqueue, &priv->request_scan);
10119         }
10120 }
10121
10122 static void ipw_bg_link_down(void *data)
10123 {
10124         struct ipw_priv *priv = data;
10125         down(&priv->sem);
10126         ipw_link_down(data);
10127         up(&priv->sem);
10128 }
10129
10130 static int ipw_setup_deferred_work(struct ipw_priv *priv)
10131 {
10132         int ret = 0;
10133
10134         priv->workqueue = create_workqueue(DRV_NAME);
10135         init_waitqueue_head(&priv->wait_command_queue);
10136         init_waitqueue_head(&priv->wait_state);
10137
10138         INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
10139         INIT_WORK(&priv->associate, ipw_bg_associate, priv);
10140         INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
10141         INIT_WORK(&priv->system_config, ipw_system_config, priv);
10142         INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
10143         INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
10144         INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
10145         INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
10146         INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
10147         INIT_WORK(&priv->request_scan,
10148                   (void (*)(void *))ipw_request_scan, priv);
10149         INIT_WORK(&priv->gather_stats,
10150                   (void (*)(void *))ipw_bg_gather_stats, priv);
10151         INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
10152         INIT_WORK(&priv->roam, ipw_bg_roam, priv);
10153         INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
10154         INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
10155         INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
10156         INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
10157                   priv);
10158         INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
10159                   priv);
10160         INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
10161                   priv);
10162         INIT_WORK(&priv->merge_networks,
10163                   (void (*)(void *))ipw_merge_adhoc_network, priv);
10164
10165 #ifdef CONFIG_IPW_QOS
10166         INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
10167                   priv);
10168 #endif                          /* CONFIG_IPW_QOS */
10169
10170         tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10171                      ipw_irq_tasklet, (unsigned long)priv);
10172
10173         return ret;
10174 }
10175
10176 static void shim__set_security(struct net_device *dev,
10177                                struct ieee80211_security *sec)
10178 {
10179         struct ipw_priv *priv = ieee80211_priv(dev);
10180         int i;
10181         for (i = 0; i < 4; i++) {
10182                 if (sec->flags & (1 << i)) {
10183                         priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10184                         priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
10185                         if (sec->key_sizes[i] == 0)
10186                                 priv->ieee->sec.flags &= ~(1 << i);
10187                         else {
10188                                 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
10189                                        sec->key_sizes[i]);
10190                                 priv->ieee->sec.flags |= (1 << i);
10191                         }
10192                         priv->status |= STATUS_SECURITY_UPDATED;
10193                 } else if (sec->level != SEC_LEVEL_1)
10194                         priv->ieee->sec.flags &= ~(1 << i);
10195         }
10196
10197         if (sec->flags & SEC_ACTIVE_KEY) {
10198                 if (sec->active_key <= 3) {
10199                         priv->ieee->sec.active_key = sec->active_key;
10200                         priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10201                 } else
10202                         priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10203                 priv->status |= STATUS_SECURITY_UPDATED;
10204         } else
10205                 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10206
10207         if ((sec->flags & SEC_AUTH_MODE) &&
10208             (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10209                 priv->ieee->sec.auth_mode = sec->auth_mode;
10210                 priv->ieee->sec.flags |= SEC_AUTH_MODE;
10211                 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10212                         priv->capability |= CAP_SHARED_KEY;
10213                 else
10214                         priv->capability &= ~CAP_SHARED_KEY;
10215                 priv->status |= STATUS_SECURITY_UPDATED;
10216         }
10217
10218         if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10219                 priv->ieee->sec.flags |= SEC_ENABLED;
10220                 priv->ieee->sec.enabled = sec->enabled;
10221                 priv->status |= STATUS_SECURITY_UPDATED;
10222                 if (sec->enabled)
10223                         priv->capability |= CAP_PRIVACY_ON;
10224                 else
10225                         priv->capability &= ~CAP_PRIVACY_ON;
10226         }
10227
10228         if (sec->flags & SEC_ENCRYPT)
10229                 priv->ieee->sec.encrypt = sec->encrypt;
10230
10231         if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10232                 priv->ieee->sec.level = sec->level;
10233                 priv->ieee->sec.flags |= SEC_LEVEL;
10234                 priv->status |= STATUS_SECURITY_UPDATED;
10235         }
10236
10237         if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10238                 ipw_set_hwcrypto_keys(priv);
10239
10240         /* To match current functionality of ipw2100 (which works well w/
10241          * various supplicants, we don't force a disassociate if the
10242          * privacy capability changes ... */
10243 #if 0
10244         if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10245             (((priv->assoc_request.capability &
10246                WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
10247              (!(priv->assoc_request.capability &
10248                 WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
10249                 IPW_DEBUG_ASSOC("Disassociating due to capability "
10250                                 "change.\n");
10251                 ipw_disassociate(priv);
10252         }
10253 #endif
10254 }
10255
10256 static int init_supported_rates(struct ipw_priv *priv,
10257                                 struct ipw_supported_rates *rates)
10258 {
10259         /* TODO: Mask out rates based on priv->rates_mask */
10260
10261         memset(rates, 0, sizeof(*rates));
10262         /* configure supported rates */
10263         switch (priv->ieee->freq_band) {
10264         case IEEE80211_52GHZ_BAND:
10265                 rates->ieee_mode = IPW_A_MODE;
10266                 rates->purpose = IPW_RATE_CAPABILITIES;
10267                 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10268                                         IEEE80211_OFDM_DEFAULT_RATES_MASK);
10269                 break;
10270
10271         default:                /* Mixed or 2.4Ghz */
10272                 rates->ieee_mode = IPW_G_MODE;
10273                 rates->purpose = IPW_RATE_CAPABILITIES;
10274                 ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
10275                                        IEEE80211_CCK_DEFAULT_RATES_MASK);
10276                 if (priv->ieee->modulation & IEEE80211_OFDM_MODULATION) {
10277                         ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10278                                                 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10279                 }
10280                 break;
10281         }
10282
10283         return 0;
10284 }
10285
10286 static int ipw_config(struct ipw_priv *priv)
10287 {
10288         /* This is only called from ipw_up, which resets/reloads the firmware
10289            so, we don't need to first disable the card before we configure
10290            it */
10291         if (ipw_set_tx_power(priv))
10292                 goto error;
10293
10294         /* initialize adapter address */
10295         if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10296                 goto error;
10297
10298         /* set basic system config settings */
10299         init_sys_config(&priv->sys_config);
10300         if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10301                 priv->sys_config.answer_broadcast_ssid_probe = 1;
10302         else
10303                 priv->sys_config.answer_broadcast_ssid_probe = 0;
10304
10305         if (ipw_send_system_config(priv, &priv->sys_config))
10306                 goto error;
10307
10308         init_supported_rates(priv, &priv->rates);
10309         if (ipw_send_supported_rates(priv, &priv->rates))
10310                 goto error;
10311
10312         /* Set request-to-send threshold */
10313         if (priv->rts_threshold) {
10314                 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10315                         goto error;
10316         }
10317 #ifdef CONFIG_IPW_QOS
10318         IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10319         ipw_qos_activate(priv, NULL);
10320 #endif                          /* CONFIG_IPW_QOS */
10321
10322         if (ipw_set_random_seed(priv))
10323                 goto error;
10324
10325         /* final state transition to the RUN state */
10326         if (ipw_send_host_complete(priv))
10327                 goto error;
10328
10329         priv->status |= STATUS_INIT;
10330
10331         ipw_led_init(priv);
10332         ipw_led_radio_on(priv);
10333         priv->notif_missed_beacons = 0;
10334
10335         /* Set hardware WEP key if it is configured. */
10336         if ((priv->capability & CAP_PRIVACY_ON) &&
10337             (priv->ieee->sec.level == SEC_LEVEL_1) &&
10338             !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10339                 ipw_set_hwcrypto_keys(priv);
10340
10341         return 0;
10342
10343       error:
10344         return -EIO;
10345 }
10346
10347 /*
10348  * NOTE:
10349  *
10350  * These tables have been tested in conjunction with the
10351  * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10352  *
10353  * Altering this values, using it on other hardware, or in geographies
10354  * not intended for resale of the above mentioned Intel adapters has
10355  * not been tested.
10356  *
10357  */
10358 static const struct ieee80211_geo ipw_geos[] = {
10359         {                       /* Restricted */
10360          "---",
10361          .bg_channels = 11,
10362          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10363                 {2427, 4}, {2432, 5}, {2437, 6},
10364                 {2442, 7}, {2447, 8}, {2452, 9},
10365                 {2457, 10}, {2462, 11}},
10366          },
10367
10368         {                       /* Custom US/Canada */
10369          "ZZF",
10370          .bg_channels = 11,
10371          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10372                 {2427, 4}, {2432, 5}, {2437, 6},
10373                 {2442, 7}, {2447, 8}, {2452, 9},
10374                 {2457, 10}, {2462, 11}},
10375          .a_channels = 8,
10376          .a = {{5180, 36},
10377                {5200, 40},
10378                {5220, 44},
10379                {5240, 48},
10380                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10381                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10382                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10383                {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
10384          },
10385
10386         {                       /* Rest of World */
10387          "ZZD",
10388          .bg_channels = 13,
10389          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10390                 {2427, 4}, {2432, 5}, {2437, 6},
10391                 {2442, 7}, {2447, 8}, {2452, 9},
10392                 {2457, 10}, {2462, 11}, {2467, 12},
10393                 {2472, 13}},
10394          },
10395
10396         {                       /* Custom USA & Europe & High */
10397          "ZZA",
10398          .bg_channels = 11,
10399          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10400                 {2427, 4}, {2432, 5}, {2437, 6},
10401                 {2442, 7}, {2447, 8}, {2452, 9},
10402                 {2457, 10}, {2462, 11}},
10403          .a_channels = 13,
10404          .a = {{5180, 36},
10405                {5200, 40},
10406                {5220, 44},
10407                {5240, 48},
10408                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10409                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10410                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10411                {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10412                {5745, 149},
10413                {5765, 153},
10414                {5785, 157},
10415                {5805, 161},
10416                {5825, 165}},
10417          },
10418
10419         {                       /* Custom NA & Europe */
10420          "ZZB",
10421          .bg_channels = 11,
10422          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10423                 {2427, 4}, {2432, 5}, {2437, 6},
10424                 {2442, 7}, {2447, 8}, {2452, 9},
10425                 {2457, 10}, {2462, 11}},
10426          .a_channels = 13,
10427          .a = {{5180, 36},
10428                {5200, 40},
10429                {5220, 44},
10430                {5240, 48},
10431                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10432                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10433                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10434                {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10435                {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10436                {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10437                {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10438                {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10439                {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10440          },
10441
10442         {                       /* Custom Japan */
10443          "ZZC",
10444          .bg_channels = 11,
10445          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10446                 {2427, 4}, {2432, 5}, {2437, 6},
10447                 {2442, 7}, {2447, 8}, {2452, 9},
10448                 {2457, 10}, {2462, 11}},
10449          .a_channels = 4,
10450          .a = {{5170, 34}, {5190, 38},
10451                {5210, 42}, {5230, 46}},
10452          },
10453
10454         {                       /* Custom */
10455          "ZZM",
10456          .bg_channels = 11,
10457          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10458                 {2427, 4}, {2432, 5}, {2437, 6},
10459                 {2442, 7}, {2447, 8}, {2452, 9},
10460                 {2457, 10}, {2462, 11}},
10461          },
10462
10463         {                       /* Europe */
10464          "ZZE",
10465          .bg_channels = 13,
10466          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10467                 {2427, 4}, {2432, 5}, {2437, 6},
10468                 {2442, 7}, {2447, 8}, {2452, 9},
10469                 {2457, 10}, {2462, 11}, {2467, 12},
10470                 {2472, 13}},
10471          .a_channels = 19,
10472          .a = {{5180, 36},
10473                {5200, 40},
10474                {5220, 44},
10475                {5240, 48},
10476                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10477                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10478                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10479                {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10480                {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10481                {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10482                {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10483                {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10484                {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10485                {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10486                {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10487                {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10488                {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10489                {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10490                {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
10491          },
10492
10493         {                       /* Custom Japan */
10494          "ZZJ",
10495          .bg_channels = 14,
10496          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10497                 {2427, 4}, {2432, 5}, {2437, 6},
10498                 {2442, 7}, {2447, 8}, {2452, 9},
10499                 {2457, 10}, {2462, 11}, {2467, 12},
10500                 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
10501          .a_channels = 4,
10502          .a = {{5170, 34}, {5190, 38},
10503                {5210, 42}, {5230, 46}},
10504          },
10505
10506         {                       /* Rest of World */
10507          "ZZR",
10508          .bg_channels = 14,
10509          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10510                 {2427, 4}, {2432, 5}, {2437, 6},
10511                 {2442, 7}, {2447, 8}, {2452, 9},
10512                 {2457, 10}, {2462, 11}, {2467, 12},
10513                 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY |
10514                              IEEE80211_CH_PASSIVE_ONLY}},
10515          },
10516
10517         {                       /* High Band */
10518          "ZZH",
10519          .bg_channels = 13,
10520          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10521                 {2427, 4}, {2432, 5}, {2437, 6},
10522                 {2442, 7}, {2447, 8}, {2452, 9},
10523                 {2457, 10}, {2462, 11},
10524                 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10525                 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10526          .a_channels = 4,
10527          .a = {{5745, 149}, {5765, 153},
10528                {5785, 157}, {5805, 161}},
10529          },
10530
10531         {                       /* Custom Europe */
10532          "ZZG",
10533          .bg_channels = 13,
10534          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10535                 {2427, 4}, {2432, 5}, {2437, 6},
10536                 {2442, 7}, {2447, 8}, {2452, 9},
10537                 {2457, 10}, {2462, 11},
10538                 {2467, 12}, {2472, 13}},
10539          .a_channels = 4,
10540          .a = {{5180, 36}, {5200, 40},
10541                {5220, 44}, {5240, 48}},
10542          },
10543
10544         {                       /* Europe */
10545          "ZZK",
10546          .bg_channels = 13,
10547          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10548                 {2427, 4}, {2432, 5}, {2437, 6},
10549                 {2442, 7}, {2447, 8}, {2452, 9},
10550                 {2457, 10}, {2462, 11},
10551                 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10552                 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10553          .a_channels = 24,
10554          .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10555                {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10556                {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10557                {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10558                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10559                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10560                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10561                {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10562                {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10563                {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10564                {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10565                {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10566                {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10567                {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10568                {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10569                {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10570                {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10571                {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10572                {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
10573                {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10574                {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10575                {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10576                {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10577                {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10578          },
10579
10580         {                       /* Europe */
10581          "ZZL",
10582          .bg_channels = 11,
10583          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10584                 {2427, 4}, {2432, 5}, {2437, 6},
10585                 {2442, 7}, {2447, 8}, {2452, 9},
10586                 {2457, 10}, {2462, 11}},
10587          .a_channels = 13,
10588          .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10589                {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10590                {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10591                {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10592                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10593                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10594                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10595                {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10596                {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10597                {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10598                {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10599                {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10600                {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10601          }
10602 };
10603
10604 /* GEO code borrowed from ieee80211_geo.c */
10605 static int ipw_is_valid_channel(struct ieee80211_device *ieee, u8 channel)
10606 {
10607         int i;
10608
10609         /* Driver needs to initialize the geography map before using
10610          * these helper functions */
10611         BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10612
10613         if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10614                 for (i = 0; i < ieee->geo.bg_channels; i++)
10615                         /* NOTE: If G mode is currently supported but
10616                          * this is a B only channel, we don't see it
10617                          * as valid. */
10618                         if ((ieee->geo.bg[i].channel == channel) &&
10619                             (!(ieee->mode & IEEE_G) ||
10620                              !(ieee->geo.bg[i].flags & IEEE80211_CH_B_ONLY)))
10621                                 return IEEE80211_24GHZ_BAND;
10622
10623         if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10624                 for (i = 0; i < ieee->geo.a_channels; i++)
10625                         if (ieee->geo.a[i].channel == channel)
10626                                 return IEEE80211_52GHZ_BAND;
10627
10628         return 0;
10629 }
10630
10631 static int ipw_channel_to_index(struct ieee80211_device *ieee, u8 channel)
10632 {
10633         int i;
10634
10635         /* Driver needs to initialize the geography map before using
10636          * these helper functions */
10637         BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10638
10639         if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10640                 for (i = 0; i < ieee->geo.bg_channels; i++)
10641                         if (ieee->geo.bg[i].channel == channel)
10642                                 return i;
10643
10644         if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10645                 for (i = 0; i < ieee->geo.a_channels; i++)
10646                         if (ieee->geo.a[i].channel == channel)
10647                                 return i;
10648
10649         return -1;
10650 }
10651
10652 static u8 ipw_freq_to_channel(struct ieee80211_device *ieee, u32 freq)
10653 {
10654         int i;
10655
10656         /* Driver needs to initialize the geography map before using
10657          * these helper functions */
10658         BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10659
10660         freq /= 100000;
10661
10662         if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10663                 for (i = 0; i < ieee->geo.bg_channels; i++)
10664                         if (ieee->geo.bg[i].freq == freq)
10665                                 return ieee->geo.bg[i].channel;
10666
10667         if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10668                 for (i = 0; i < ieee->geo.a_channels; i++)
10669                         if (ieee->geo.a[i].freq == freq)
10670                                 return ieee->geo.a[i].channel;
10671
10672         return 0;
10673 }
10674
10675 static int ipw_set_geo(struct ieee80211_device *ieee,
10676                        const struct ieee80211_geo *geo)
10677 {
10678         memcpy(ieee->geo.name, geo->name, 3);
10679         ieee->geo.name[3] = '\0';
10680         ieee->geo.bg_channels = geo->bg_channels;
10681         ieee->geo.a_channels = geo->a_channels;
10682         memcpy(ieee->geo.bg, geo->bg, geo->bg_channels *
10683                sizeof(struct ieee80211_channel));
10684         memcpy(ieee->geo.a, geo->a, ieee->geo.a_channels *
10685                sizeof(struct ieee80211_channel));
10686         return 0;
10687 }
10688
10689 static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *ieee)
10690 {
10691         return &ieee->geo;
10692 }
10693
10694 #define MAX_HW_RESTARTS 5
10695 static int ipw_up(struct ipw_priv *priv)
10696 {
10697         int rc, i, j;
10698
10699         if (priv->status & STATUS_EXIT_PENDING)
10700                 return -EIO;
10701
10702         if (cmdlog && !priv->cmdlog) {
10703                 priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
10704                                        GFP_KERNEL);
10705                 if (priv->cmdlog == NULL) {
10706                         IPW_ERROR("Error allocating %d command log entries.\n",
10707                                   cmdlog);
10708                 } else {
10709                         memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
10710                         priv->cmdlog_len = cmdlog;
10711                 }
10712         }
10713
10714         for (i = 0; i < MAX_HW_RESTARTS; i++) {
10715                 /* Load the microcode, firmware, and eeprom.
10716                  * Also start the clocks. */
10717                 rc = ipw_load(priv);
10718                 if (rc) {
10719                         IPW_ERROR("Unable to load firmware: %d\n", rc);
10720                         return rc;
10721                 }
10722
10723                 ipw_init_ordinals(priv);
10724                 if (!(priv->config & CFG_CUSTOM_MAC))
10725                         eeprom_parse_mac(priv, priv->mac_addr);
10726                 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
10727
10728                 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
10729                         if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
10730                                     ipw_geos[j].name, 3))
10731                                 break;
10732                 }
10733                 if (j == ARRAY_SIZE(ipw_geos)) {
10734                         IPW_WARNING("SKU [%c%c%c] not recognized.\n",
10735                                     priv->eeprom[EEPROM_COUNTRY_CODE + 0],
10736                                     priv->eeprom[EEPROM_COUNTRY_CODE + 1],
10737                                     priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
10738                         j = 0;
10739                 }
10740                 if (ipw_set_geo(priv->ieee, &ipw_geos[j])) {
10741                         IPW_WARNING("Could not set geography.");
10742                         return 0;
10743                 }
10744
10745                 IPW_DEBUG_INFO("Geography %03d [%s] detected.\n",
10746                                j, priv->ieee->geo.name);
10747
10748                 if (priv->status & STATUS_RF_KILL_SW) {
10749                         IPW_WARNING("Radio disabled by module parameter.\n");
10750                         return 0;
10751                 } else if (rf_kill_active(priv)) {
10752                         IPW_WARNING("Radio Frequency Kill Switch is On:\n"
10753                                     "Kill switch must be turned off for "
10754                                     "wireless networking to work.\n");
10755                         queue_delayed_work(priv->workqueue, &priv->rf_kill,
10756                                            2 * HZ);
10757                         return 0;
10758                 }
10759
10760                 rc = ipw_config(priv);
10761                 if (!rc) {
10762                         IPW_DEBUG_INFO("Configured device on count %i\n", i);
10763
10764                         /* If configure to try and auto-associate, kick
10765                          * off a scan. */
10766                         queue_work(priv->workqueue, &priv->request_scan);
10767
10768                         return 0;
10769                 }
10770
10771                 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
10772                 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
10773                                i, MAX_HW_RESTARTS);
10774
10775                 /* We had an error bringing up the hardware, so take it
10776                  * all the way back down so we can try again */
10777                 ipw_down(priv);
10778         }
10779
10780         /* tried to restart and config the device for as long as our
10781          * patience could withstand */
10782         IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
10783
10784         return -EIO;
10785 }
10786
10787 static void ipw_bg_up(void *data)
10788 {
10789         struct ipw_priv *priv = data;
10790         down(&priv->sem);
10791         ipw_up(data);
10792         up(&priv->sem);
10793 }
10794
10795 static void ipw_deinit(struct ipw_priv *priv)
10796 {
10797         int i;
10798
10799         if (priv->status & STATUS_SCANNING) {
10800                 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
10801                 ipw_abort_scan(priv);
10802         }
10803
10804         if (priv->status & STATUS_ASSOCIATED) {
10805                 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
10806                 ipw_disassociate(priv);
10807         }
10808
10809         ipw_led_shutdown(priv);
10810
10811         /* Wait up to 1s for status to change to not scanning and not
10812          * associated (disassociation can take a while for a ful 802.11
10813          * exchange */
10814         for (i = 1000; i && (priv->status &
10815                              (STATUS_DISASSOCIATING |
10816                               STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
10817                 udelay(10);
10818
10819         if (priv->status & (STATUS_DISASSOCIATING |
10820                             STATUS_ASSOCIATED | STATUS_SCANNING))
10821                 IPW_DEBUG_INFO("Still associated or scanning...\n");
10822         else
10823                 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
10824
10825         /* Attempt to disable the card */
10826         ipw_send_card_disable(priv, 0);
10827
10828         priv->status &= ~STATUS_INIT;
10829 }
10830
10831 static void ipw_down(struct ipw_priv *priv)
10832 {
10833         int exit_pending = priv->status & STATUS_EXIT_PENDING;
10834
10835         priv->status |= STATUS_EXIT_PENDING;
10836
10837         if (ipw_is_init(priv))
10838                 ipw_deinit(priv);
10839
10840         /* Wipe out the EXIT_PENDING status bit if we are not actually
10841          * exiting the module */
10842         if (!exit_pending)
10843                 priv->status &= ~STATUS_EXIT_PENDING;
10844
10845         /* tell the device to stop sending interrupts */
10846         ipw_disable_interrupts(priv);
10847
10848         /* Clear all bits but the RF Kill */
10849         priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
10850         netif_carrier_off(priv->net_dev);
10851         netif_stop_queue(priv->net_dev);
10852
10853         ipw_stop_nic(priv);
10854
10855         ipw_led_radio_off(priv);
10856 }
10857
10858 static void ipw_bg_down(void *data)
10859 {
10860         struct ipw_priv *priv = data;
10861         down(&priv->sem);
10862         ipw_down(data);
10863         up(&priv->sem);
10864 }
10865
10866 /* Called by register_netdev() */
10867 static int ipw_net_init(struct net_device *dev)
10868 {
10869         struct ipw_priv *priv = ieee80211_priv(dev);
10870         down(&priv->sem);
10871
10872         if (ipw_up(priv)) {
10873                 up(&priv->sem);
10874                 return -EIO;
10875         }
10876
10877         up(&priv->sem);
10878         return 0;
10879 }
10880
10881 /* PCI driver stuff */
10882 static struct pci_device_id card_ids[] = {
10883         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
10884         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
10885         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
10886         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
10887         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
10888         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
10889         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
10890         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
10891         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
10892         {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
10893         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
10894         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
10895         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
10896         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
10897         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
10898         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
10899         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
10900         {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
10901         {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10902         {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10903         {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10904         {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10905
10906         /* required last entry */
10907         {0,}
10908 };
10909
10910 MODULE_DEVICE_TABLE(pci, card_ids);
10911
10912 static struct attribute *ipw_sysfs_entries[] = {
10913         &dev_attr_rf_kill.attr,
10914         &dev_attr_direct_dword.attr,
10915         &dev_attr_indirect_byte.attr,
10916         &dev_attr_indirect_dword.attr,
10917         &dev_attr_mem_gpio_reg.attr,
10918         &dev_attr_command_event_reg.attr,
10919         &dev_attr_nic_type.attr,
10920         &dev_attr_status.attr,
10921         &dev_attr_cfg.attr,
10922         &dev_attr_error.attr,
10923         &dev_attr_event_log.attr,
10924         &dev_attr_cmd_log.attr,
10925         &dev_attr_eeprom_delay.attr,
10926         &dev_attr_ucode_version.attr,
10927         &dev_attr_rtc.attr,
10928         &dev_attr_scan_age.attr,
10929         &dev_attr_led.attr,
10930         &dev_attr_speed_scan.attr,
10931         &dev_attr_net_stats.attr,
10932         NULL
10933 };
10934
10935 static struct attribute_group ipw_attribute_group = {
10936         .name = NULL,           /* put in device directory */
10937         .attrs = ipw_sysfs_entries,
10938 };
10939
10940 static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
10941 {
10942         int err = 0;
10943         struct net_device *net_dev;
10944         void __iomem *base;
10945         u32 length, val;
10946         struct ipw_priv *priv;
10947         int i;
10948
10949         net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
10950         if (net_dev == NULL) {
10951                 err = -ENOMEM;
10952                 goto out;
10953         }
10954
10955         priv = ieee80211_priv(net_dev);
10956         priv->ieee = netdev_priv(net_dev);
10957
10958         priv->net_dev = net_dev;
10959         priv->pci_dev = pdev;
10960 #ifdef CONFIG_IPW_DEBUG
10961         ipw_debug_level = debug;
10962 #endif
10963         spin_lock_init(&priv->lock);
10964         for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
10965                 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
10966
10967         init_MUTEX(&priv->sem);
10968         if (pci_enable_device(pdev)) {
10969                 err = -ENODEV;
10970                 goto out_free_ieee80211;
10971         }
10972
10973         pci_set_master(pdev);
10974
10975         err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
10976         if (!err)
10977                 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
10978         if (err) {
10979                 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
10980                 goto out_pci_disable_device;
10981         }
10982
10983         pci_set_drvdata(pdev, priv);
10984
10985         err = pci_request_regions(pdev, DRV_NAME);
10986         if (err)
10987                 goto out_pci_disable_device;
10988
10989         /* We disable the RETRY_TIMEOUT register (0x41) to keep
10990          * PCI Tx retries from interfering with C3 CPU state */
10991         pci_read_config_dword(pdev, 0x40, &val);
10992         if ((val & 0x0000ff00) != 0)
10993                 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
10994
10995         length = pci_resource_len(pdev, 0);
10996         priv->hw_len = length;
10997
10998         base = ioremap_nocache(pci_resource_start(pdev, 0), length);
10999         if (!base) {
11000                 err = -ENODEV;
11001                 goto out_pci_release_regions;
11002         }
11003
11004         priv->hw_base = base;
11005         IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
11006         IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
11007
11008         err = ipw_setup_deferred_work(priv);
11009         if (err) {
11010                 IPW_ERROR("Unable to setup deferred work\n");
11011                 goto out_iounmap;
11012         }
11013
11014         ipw_sw_reset(priv, 1);
11015
11016         err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
11017         if (err) {
11018                 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
11019                 goto out_destroy_workqueue;
11020         }
11021
11022         SET_MODULE_OWNER(net_dev);
11023         SET_NETDEV_DEV(net_dev, &pdev->dev);
11024
11025         down(&priv->sem);
11026
11027         priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11028         priv->ieee->set_security = shim__set_security;
11029         priv->ieee->is_queue_full = ipw_net_is_queue_full;
11030
11031 #ifdef CONFIG_IPW_QOS
11032         priv->ieee->handle_probe_response = ipw_handle_beacon;
11033         priv->ieee->handle_beacon = ipw_handle_probe_response;
11034         priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
11035 #endif                          /* CONFIG_IPW_QOS */
11036
11037         priv->ieee->perfect_rssi = -20;
11038         priv->ieee->worst_rssi = -85;
11039
11040         net_dev->open = ipw_net_open;
11041         net_dev->stop = ipw_net_stop;
11042         net_dev->init = ipw_net_init;
11043         net_dev->get_stats = ipw_net_get_stats;
11044         net_dev->set_multicast_list = ipw_net_set_multicast_list;
11045         net_dev->set_mac_address = ipw_net_set_mac_address;
11046         priv->wireless_data.spy_data = &priv->ieee->spy_data;
11047         priv->wireless_data.ieee80211 = priv->ieee;
11048         net_dev->wireless_data = &priv->wireless_data;
11049         net_dev->wireless_handlers = &ipw_wx_handler_def;
11050         net_dev->ethtool_ops = &ipw_ethtool_ops;
11051         net_dev->irq = pdev->irq;
11052         net_dev->base_addr = (unsigned long)priv->hw_base;
11053         net_dev->mem_start = pci_resource_start(pdev, 0);
11054         net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
11055
11056         err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11057         if (err) {
11058                 IPW_ERROR("failed to create sysfs device attributes\n");
11059                 up(&priv->sem);
11060                 goto out_release_irq;
11061         }
11062
11063         up(&priv->sem);
11064         err = register_netdev(net_dev);
11065         if (err) {
11066                 IPW_ERROR("failed to register network device\n");
11067                 goto out_remove_sysfs;
11068         }
11069         return 0;
11070
11071       out_remove_sysfs:
11072         sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11073       out_release_irq:
11074         free_irq(pdev->irq, priv);
11075       out_destroy_workqueue:
11076         destroy_workqueue(priv->workqueue);
11077         priv->workqueue = NULL;
11078       out_iounmap:
11079         iounmap(priv->hw_base);
11080       out_pci_release_regions:
11081         pci_release_regions(pdev);
11082       out_pci_disable_device:
11083         pci_disable_device(pdev);
11084         pci_set_drvdata(pdev, NULL);
11085       out_free_ieee80211:
11086         free_ieee80211(priv->net_dev);
11087       out:
11088         return err;
11089 }
11090
11091 static void ipw_pci_remove(struct pci_dev *pdev)
11092 {
11093         struct ipw_priv *priv = pci_get_drvdata(pdev);
11094         struct list_head *p, *q;
11095         int i;
11096
11097         if (!priv)
11098                 return;
11099
11100         down(&priv->sem);
11101
11102         priv->status |= STATUS_EXIT_PENDING;
11103         ipw_down(priv);
11104         sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11105
11106         up(&priv->sem);
11107
11108         unregister_netdev(priv->net_dev);
11109
11110         if (priv->rxq) {
11111                 ipw_rx_queue_free(priv, priv->rxq);
11112                 priv->rxq = NULL;
11113         }
11114         ipw_tx_queue_free(priv);
11115
11116         if (priv->cmdlog) {
11117                 kfree(priv->cmdlog);
11118                 priv->cmdlog = NULL;
11119         }
11120         /* ipw_down will ensure that there is no more pending work
11121          * in the workqueue's, so we can safely remove them now. */
11122         cancel_delayed_work(&priv->adhoc_check);
11123         cancel_delayed_work(&priv->gather_stats);
11124         cancel_delayed_work(&priv->request_scan);
11125         cancel_delayed_work(&priv->rf_kill);
11126         cancel_delayed_work(&priv->scan_check);
11127         destroy_workqueue(priv->workqueue);
11128         priv->workqueue = NULL;
11129
11130         /* Free MAC hash list for ADHOC */
11131         for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11132                 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11133                         kfree(list_entry(p, struct ipw_ibss_seq, list));
11134                         list_del(p);
11135                 }
11136         }
11137
11138         if (priv->error) {
11139                 ipw_free_error_log(priv->error);
11140                 priv->error = NULL;
11141         }
11142
11143         free_irq(pdev->irq, priv);
11144         iounmap(priv->hw_base);
11145         pci_release_regions(pdev);
11146         pci_disable_device(pdev);
11147         pci_set_drvdata(pdev, NULL);
11148         free_ieee80211(priv->net_dev);
11149         free_firmware();
11150 }
11151
11152 #ifdef CONFIG_PM
11153 static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
11154 {
11155         struct ipw_priv *priv = pci_get_drvdata(pdev);
11156         struct net_device *dev = priv->net_dev;
11157
11158         printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11159
11160         /* Take down the device; powers it off, etc. */
11161         ipw_down(priv);
11162
11163         /* Remove the PRESENT state of the device */
11164         netif_device_detach(dev);
11165
11166         pci_save_state(pdev);
11167         pci_disable_device(pdev);
11168         pci_set_power_state(pdev, pci_choose_state(pdev, state));
11169
11170         return 0;
11171 }
11172
11173 static int ipw_pci_resume(struct pci_dev *pdev)
11174 {
11175         struct ipw_priv *priv = pci_get_drvdata(pdev);
11176         struct net_device *dev = priv->net_dev;
11177         u32 val;
11178
11179         printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11180
11181         pci_set_power_state(pdev, PCI_D0);
11182         pci_enable_device(pdev);
11183         pci_restore_state(pdev);
11184
11185         /*
11186          * Suspend/Resume resets the PCI configuration space, so we have to
11187          * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11188          * from interfering with C3 CPU state. pci_restore_state won't help
11189          * here since it only restores the first 64 bytes pci config header.
11190          */
11191         pci_read_config_dword(pdev, 0x40, &val);
11192         if ((val & 0x0000ff00) != 0)
11193                 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11194
11195         /* Set the device back into the PRESENT state; this will also wake
11196          * the queue of needed */
11197         netif_device_attach(dev);
11198
11199         /* Bring the device back up */
11200         queue_work(priv->workqueue, &priv->up);
11201
11202         return 0;
11203 }
11204 #endif
11205
11206 /* driver initialization stuff */
11207 static struct pci_driver ipw_driver = {
11208         .name = DRV_NAME,
11209         .id_table = card_ids,
11210         .probe = ipw_pci_probe,
11211         .remove = __devexit_p(ipw_pci_remove),
11212 #ifdef CONFIG_PM
11213         .suspend = ipw_pci_suspend,
11214         .resume = ipw_pci_resume,
11215 #endif
11216 };
11217
11218 static int __init ipw_init(void)
11219 {
11220         int ret;
11221
11222         printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11223         printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11224
11225         ret = pci_module_init(&ipw_driver);
11226         if (ret) {
11227                 IPW_ERROR("Unable to initialize PCI module\n");
11228                 return ret;
11229         }
11230
11231         ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
11232         if (ret) {
11233                 IPW_ERROR("Unable to create driver sysfs file\n");
11234                 pci_unregister_driver(&ipw_driver);
11235                 return ret;
11236         }
11237
11238         return ret;
11239 }
11240
11241 static void __exit ipw_exit(void)
11242 {
11243         driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11244         pci_unregister_driver(&ipw_driver);
11245 }
11246
11247 module_param(disable, int, 0444);
11248 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11249
11250 module_param(associate, int, 0444);
11251 MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
11252
11253 module_param(auto_create, int, 0444);
11254 MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11255
11256 module_param(led, int, 0444);
11257 MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
11258
11259 module_param(debug, int, 0444);
11260 MODULE_PARM_DESC(debug, "debug output mask");
11261
11262 module_param(channel, int, 0444);
11263 MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
11264
11265 #ifdef CONFIG_IPW_QOS
11266 module_param(qos_enable, int, 0444);
11267 MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
11268
11269 module_param(qos_burst_enable, int, 0444);
11270 MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11271
11272 module_param(qos_no_ack_mask, int, 0444);
11273 MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
11274
11275 module_param(burst_duration_CCK, int, 0444);
11276 MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11277
11278 module_param(burst_duration_OFDM, int, 0444);
11279 MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11280 #endif                          /* CONFIG_IPW_QOS */
11281
11282 #ifdef CONFIG_IPW2200_MONITOR
11283 module_param(mode, int, 0444);
11284 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
11285 #else
11286 module_param(mode, int, 0444);
11287 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
11288 #endif
11289
11290 module_param(hwcrypto, int, 0444);
11291 MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default on)");
11292
11293 module_param(cmdlog, int, 0444);
11294 MODULE_PARM_DESC(cmdlog,
11295                  "allocate a ring buffer for logging firmware commands");
11296
11297 module_exit(ipw_exit);
11298 module_init(ipw_init);