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

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