SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/wireless/ipw2200.c

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