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