SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/staging/wlags49_h2/wl_main.c

   1 /*******************************************************************************
   2  * Agere Systems Inc.
   3  * Wireless device driver for Linux (wlags49).
   4  *
   5  * Copyright (c) 1998-2003 Agere Systems Inc.
   6  * All rights reserved.
   7  *   http://www.agere.com
   8  *
   9  * Initially developed by TriplePoint, Inc.
  10  *   http://www.triplepoint.com
  11  *
  12  *------------------------------------------------------------------------------
  13  *
  14  *   This file contains the main driver entry points and other adapter
  15  *   specific routines.
  16  *
  17  *------------------------------------------------------------------------------
  18  *
  19  * SOFTWARE LICENSE
  20  *
  21  * This software is provided subject to the following terms and conditions,
  22  * which you should read carefully before using the software.  Using this
  23  * software indicates your acceptance of these terms and conditions.  If you do
  24  * not agree with these terms and conditions, do not use the software.
  25  *
  26  * Copyright © 2003 Agere Systems Inc.
  27  * All rights reserved.
  28  *
  29  * Redistribution and use in source or binary forms, with or without
  30  * modifications, are permitted provided that the following conditions are met:
  31  *
  32  * . Redistributions of source code must retain the above copyright notice, this
  33  *    list of conditions and the following Disclaimer as comments in the code as
  34  *    well as in the documentation and/or other materials provided with the
  35  *    distribution.
  36  *
  37  * . Redistributions in binary form must reproduce the above copyright notice,
  38  *    this list of conditions and the following Disclaimer in the documentation
  39  *    and/or other materials provided with the distribution.
  40  *
  41  * . Neither the name of Agere Systems Inc. nor the names of the contributors
  42  *    may be used to endorse or promote products derived from this software
  43  *    without specific prior written permission.
  44  *
  45  * Disclaimer
  46  *
  47  * THIS SOFTWARE IS PROVIDED \93AS IS\94 AND ANY EXPRESS OR IMPLIED WARRANTIES,
  48  * INCLUDING, BUT NOT LIMITED TO, INFRINGEMENT AND THE IMPLIED WARRANTIES OF
  49  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  ANY
  50  * USE, MODIFICATION OR DISTRIBUTION OF THIS SOFTWARE IS SOLELY AT THE USERS OWN
  51  * RISK. IN NO EVENT SHALL AGERE SYSTEMS INC. OR CONTRIBUTORS BE LIABLE FOR ANY
  52  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  53  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  54  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  55  * ON ANY THEORY OF LIABILITY, INCLUDING, BUT NOT LIMITED TO, CONTRACT, STRICT
  56  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  57  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  58  * DAMAGE.
  59  *
  60  ******************************************************************************/
  61
  62 /*******************************************************************************
  63  *  constant definitions
  64  ******************************************************************************/
  65
  66 /* Allow support for calling system fcns to access F/W iamge file */
  67 #define __KERNEL_SYSCALLS__
  68
  69 /*******************************************************************************
  70  *  include files
  71  ******************************************************************************/
  72 #include <wl_version.h>
  73
  74 #include <linux/module.h>
  75 #include <linux/proc_fs.h>
  76 #include <linux/types.h>
  77 #include <linux/kernel.h>
  78 // #include <linux/sched.h>
  79 // #include <linux/ptrace.h>
  80 // #include <linux/slab.h>
  81 // #include <linux/ctype.h>
  82 // #include <linux/string.h>
  83 // #include <linux/timer.h>
  84 //#include <linux/interrupt.h>
  85 // #include <linux/tqueue.h>
  86 // #include <linux/in.h>
  87 // #include <linux/delay.h>
  88 // #include <asm/io.h>
  89 // #include <asm/system.h>
  90 // #include <asm/bitops.h>
  91 #include <linux/unistd.h>
  92 #include <asm/uaccess.h>
  93
  94 #include <linux/netdevice.h>
  95 #include <linux/etherdevice.h>
  96 // #include <linux/skbuff.h>
  97 // #include <linux/if_arp.h>
  98 // #include <linux/ioport.h>
  99
 100 #define BIN_DL 0
 101 #if BIN_DL
 102 #include <linux/vmalloc.h>
 103 #endif // BIN_DL
 104
 105
 106 #include <debug.h>
 107
 108 #include <hcf.h>
 109 #include <dhf.h>
 110 //in order to get around:: wl_main.c:2229: `HREG_EV_RDMAD' undeclared (first use in this function)
 111 #include <hcfdef.h>
 112
 113 #include <wl_if.h>
 114 #include <wl_internal.h>
 115 #include <wl_util.h>
 116 #include <wl_main.h>
 117 #include <wl_netdev.h>
 118 #include <wl_wext.h>
 119
 120 #ifdef USE_PROFILE
 121 #include <wl_profile.h>
 122 #endif  /* USE_PROFILE */
 123
 124 #ifdef BUS_PCMCIA
 125 #include <wl_cs.h>
 126 #endif  /* BUS_PCMCIA */
 127
 128 #ifdef BUS_PCI
 129 #include <wl_pci.h>
 130 #endif  /* BUS_PCI */
 131 /*******************************************************************************
 132  *      macro defintions
 133  ******************************************************************************/
 134 #define VALID_PARAM(C) \
 135         { \
 136                 if (!(C)) \
 137                 { \
 138                         printk(KERN_INFO "Wireless, parameter error: \"%s\"\n", #C); \
 139                         goto failed; \
 140                 } \
 141         }
 142 /*******************************************************************************
 143  *      local functions
 144  ******************************************************************************/
 145 void wl_isr_handler( unsigned long p );
 146
 147 #if 0 //SCULL_USE_PROC /* don't waste space if unused */
 148 //int scull_read_procmem(char *buf, char **start, off_t offset, int len, int unused);
 149 int scull_read_procmem(char *buf, char **start, off_t offset, int len, int *eof, void *data );
 150 static int write_int(struct file *file, const char *buffer, unsigned long count, void *data);
 151 static void proc_write(const char *name, write_proc_t *w, void *data);
 152
 153 #endif /* SCULL_USE_PROC */
 154
 155 /*******************************************************************************
 156  * module parameter definitions - set with 'insmod'
 157  ******************************************************************************/
 158 static p_u16    irq_mask                = 0xdeb8; // IRQ3,4,5,7,9,10,11,12,14,15
 159 static p_s8     irq_list[4]             = { -1 };
 160
 161 #if 0
 162 MODULE_PARM(irq_mask,               "h");
 163 MODULE_PARM_DESC(irq_mask,               "IRQ mask [0xdeb8]");
 164 MODULE_PARM(irq_list,               "1-4b");
 165 MODULE_PARM_DESC(irq_list,               "IRQ list [<irq_mask>]");
 166 #endif
 167
 168 static p_u8     PARM_AUTHENTICATION             = PARM_DEFAULT_AUTHENTICATION;
 169 static p_u16    PARM_AUTH_KEY_MGMT_SUITE        = PARM_DEFAULT_AUTH_KEY_MGMT_SUITE;
 170 static p_u16    PARM_BRSC_2GHZ                  = PARM_DEFAULT_BRSC_2GHZ;
 171 static p_u16    PARM_BRSC_5GHZ                  = PARM_DEFAULT_BRSC_5GHZ;
 172 static p_u16    PARM_COEXISTENCE                = PARM_DEFAULT_COEXISTENCE;
 173 static p_u16    PARM_CONNECTION_CONTROL         = PARM_DEFAULT_CONNECTION_CONTROL;  //;?rename and move
 174 static p_char  *PARM_CREATE_IBSS                = PARM_DEFAULT_CREATE_IBSS_STR;
 175 static p_char  *PARM_DESIRED_SSID               = PARM_DEFAULT_SSID;
 176 static p_char  *PARM_DOWNLOAD_FIRMWARE      = "";
 177 static p_u16    PARM_ENABLE_ENCRYPTION          = PARM_DEFAULT_ENABLE_ENCRYPTION;
 178 static p_char  *PARM_EXCLUDE_UNENCRYPTED        = PARM_DEFAULT_EXCLUDE_UNENCRYPTED_STR;
 179 static p_char  *PARM_INTRA_BSS_RELAY            = PARM_DEFAULT_INTRA_BSS_RELAY_STR;
 180 static p_char  *PARM_KEY1                       = "";
 181 static p_char  *PARM_KEY2                       = "";
 182 static p_char  *PARM_KEY3                       = "";
 183 static p_char  *PARM_KEY4                       = "";
 184 static p_char  *PARM_LOAD_BALANCING             = PARM_DEFAULT_LOAD_BALANCING_STR;
 185 static p_u16    PARM_MAX_SLEEP                  = PARM_DEFAULT_MAX_PM_SLEEP;
 186 static p_char  *PARM_MEDIUM_DISTRIBUTION        = PARM_DEFAULT_MEDIUM_DISTRIBUTION_STR;
 187 static p_char  *PARM_MICROWAVE_ROBUSTNESS       = PARM_DEFAULT_MICROWAVE_ROBUSTNESS_STR;
 188 static p_char  *PARM_MULTICAST_PM_BUFFERING     = PARM_DEFAULT_MULTICAST_PM_BUFFERING_STR;
 189 static p_u16    PARM_MULTICAST_RATE             = PARM_DEFAULT_MULTICAST_RATE_2GHZ;
 190 static p_char  *PARM_MULTICAST_RX               = PARM_DEFAULT_MULTICAST_RX_STR;
 191 static p_u8     PARM_NETWORK_ADDR[ETH_ALEN]     = PARM_DEFAULT_NETWORK_ADDR;
 192 static p_u16    PARM_OWN_ATIM_WINDOW            = PARM_DEFAULT_OWN_ATIM_WINDOW;
 193 static p_u16    PARM_OWN_BEACON_INTERVAL        = PARM_DEFAULT_OWN_BEACON_INTERVAL;
 194 static p_u8     PARM_OWN_CHANNEL                = PARM_DEFAULT_OWN_CHANNEL;
 195 static p_u8     PARM_OWN_DTIM_PERIOD            = PARM_DEFAULT_OWN_DTIM_PERIOD;
 196 static p_char  *PARM_OWN_NAME                   = PARM_DEFAULT_OWN_NAME;
 197 static p_char  *PARM_OWN_SSID                   = PARM_DEFAULT_SSID;
 198 static p_u16    PARM_PM_ENABLED                 = WVLAN_PM_STATE_DISABLED;
 199 static p_u16    PARM_PM_HOLDOVER_DURATION       = PARM_DEFAULT_PM_HOLDOVER_DURATION;
 200 static p_u8     PARM_PORT_TYPE                  = PARM_DEFAULT_PORT_TYPE;
 201 static p_char  *PARM_PROMISCUOUS_MODE           = PARM_DEFAULT_PROMISCUOUS_MODE_STR;
 202 static p_char  *PARM_REJECT_ANY                 = PARM_DEFAULT_REJECT_ANY_STR;
 203 #ifdef USE_WDS
 204 static p_u16    PARM_RTS_THRESHOLD1             = PARM_DEFAULT_RTS_THRESHOLD;
 205 static p_u16    PARM_RTS_THRESHOLD2             = PARM_DEFAULT_RTS_THRESHOLD;
 206 static p_u16    PARM_RTS_THRESHOLD3             = PARM_DEFAULT_RTS_THRESHOLD;
 207 static p_u16    PARM_RTS_THRESHOLD4             = PARM_DEFAULT_RTS_THRESHOLD;
 208 static p_u16    PARM_RTS_THRESHOLD5             = PARM_DEFAULT_RTS_THRESHOLD;
 209 static p_u16    PARM_RTS_THRESHOLD6             = PARM_DEFAULT_RTS_THRESHOLD;
 210 #endif // USE_WDS
 211 static p_u16    PARM_RTS_THRESHOLD              = PARM_DEFAULT_RTS_THRESHOLD;
 212 static p_u16    PARM_SRSC_2GHZ                  = PARM_DEFAULT_SRSC_2GHZ;
 213 static p_u16    PARM_SRSC_5GHZ                  = PARM_DEFAULT_SRSC_5GHZ;
 214 static p_u8     PARM_SYSTEM_SCALE               = PARM_DEFAULT_SYSTEM_SCALE;
 215 static p_u8     PARM_TX_KEY                     = PARM_DEFAULT_TX_KEY;
 216 static p_u16    PARM_TX_POW_LEVEL               = PARM_DEFAULT_TX_POW_LEVEL;
 217 #ifdef USE_WDS
 218 static p_u16    PARM_TX_RATE1                   = PARM_DEFAULT_TX_RATE_2GHZ;
 219 static p_u16    PARM_TX_RATE2                   = PARM_DEFAULT_TX_RATE_2GHZ;
 220 static p_u16    PARM_TX_RATE3                   = PARM_DEFAULT_TX_RATE_2GHZ;
 221 static p_u16    PARM_TX_RATE4                   = PARM_DEFAULT_TX_RATE_2GHZ;
 222 static p_u16    PARM_TX_RATE5                   = PARM_DEFAULT_TX_RATE_2GHZ;
 223 static p_u16    PARM_TX_RATE6                   = PARM_DEFAULT_TX_RATE_2GHZ;
 224 #endif // USE_WDS
 225 static p_u16    PARM_TX_RATE                    = PARM_DEFAULT_TX_RATE_2GHZ;
 226 #ifdef USE_WDS
 227 static p_u8     PARM_WDS_ADDRESS1[ETH_ALEN]     = PARM_DEFAULT_NETWORK_ADDR;
 228 static p_u8     PARM_WDS_ADDRESS2[ETH_ALEN]     = PARM_DEFAULT_NETWORK_ADDR;
 229 static p_u8     PARM_WDS_ADDRESS3[ETH_ALEN]     = PARM_DEFAULT_NETWORK_ADDR;
 230 static p_u8     PARM_WDS_ADDRESS4[ETH_ALEN]     = PARM_DEFAULT_NETWORK_ADDR;
 231 static p_u8     PARM_WDS_ADDRESS5[ETH_ALEN]     = PARM_DEFAULT_NETWORK_ADDR;
 232 static p_u8     PARM_WDS_ADDRESS6[ETH_ALEN]     = PARM_DEFAULT_NETWORK_ADDR;
 233 #endif // USE_WDS
 234
 235
 236 #if 0
 237 MODULE_PARM(PARM_DESIRED_SSID,          "s");
 238 MODULE_PARM_DESC(PARM_DESIRED_SSID,             "Network Name (<string>) [ANY]");
 239 MODULE_PARM(PARM_OWN_SSID,              "s");
 240 MODULE_PARM_DESC(PARM_OWN_SSID,                 "Network Name (<string>) [ANY]");
 241 MODULE_PARM(PARM_OWN_CHANNEL,           "b");
 242 MODULE_PARM_DESC(PARM_OWN_CHANNEL,              "Channel (0 - 14) [0]");
 243 MODULE_PARM(PARM_SYSTEM_SCALE,          "b");
 244 MODULE_PARM_DESC(PARM_SYSTEM_SCALE,             "Distance Between APs (1 - 3) [1]");
 245 MODULE_PARM(PARM_TX_RATE,               "b");
 246 MODULE_PARM_DESC(PARM_TX_RATE,                  "Transmit Rate Control");
 247 MODULE_PARM(PARM_RTS_THRESHOLD,         "h");
 248 MODULE_PARM_DESC(PARM_RTS_THRESHOLD,            "Medium Reservation (RTS/CTS Fragment Length) (256 - 2347) [2347]");
 249 MODULE_PARM(PARM_MICROWAVE_ROBUSTNESS,  "s");
 250 MODULE_PARM_DESC(PARM_MICROWAVE_ROBUSTNESS,     "Microwave Oven Robustness Enabled (<string> N or Y) [N]");
 251 MODULE_PARM(PARM_OWN_NAME,              "s");
 252 MODULE_PARM_DESC(PARM_OWN_NAME,                 "Station Name (<string>) [Linux]");
 253
 254 MODULE_PARM(PARM_ENABLE_ENCRYPTION,     "b");
 255 MODULE_PARM_DESC(PARM_ENABLE_ENCRYPTION,        "Encryption Mode (0 - 7) [0]");
 256
 257 MODULE_PARM(PARM_KEY1,                  "s");
 258 MODULE_PARM_DESC(PARM_KEY1,                     "Data Encryption Key 1 (<string>) []");
 259 MODULE_PARM(PARM_KEY2,                  "s");
 260 MODULE_PARM_DESC(PARM_KEY2,                     "Data Encryption Key 2 (<string>) []");
 261 MODULE_PARM(PARM_KEY3,                  "s");
 262 MODULE_PARM_DESC(PARM_KEY3,                     "Data Encryption Key 3 (<string>) []");
 263 MODULE_PARM(PARM_KEY4,                  "s");
 264 MODULE_PARM_DESC(PARM_KEY4,                     "Data Encryption Key 4 (<string>) []");
 265 MODULE_PARM(PARM_TX_KEY,                "b");
 266 MODULE_PARM_DESC(PARM_TX_KEY,                   "Transmit Key ID (1 - 4) [1]");
 267 MODULE_PARM(PARM_MULTICAST_RATE,        "b");
 268 MODULE_PARM_DESC(PARM_MULTICAST_RATE,           "Multicast Rate");
 269 MODULE_PARM(PARM_DOWNLOAD_FIRMWARE,     "s");
 270 MODULE_PARM_DESC(PARM_DOWNLOAD_FIRMWARE,        "filename of firmware image");
 271
 272 MODULE_PARM(PARM_AUTH_KEY_MGMT_SUITE,   "b");
 273 MODULE_PARM_DESC(PARM_AUTH_KEY_MGMT_SUITE,      "Authentication Key Management suite (0-4) [0]");
 274
 275 MODULE_PARM(PARM_LOAD_BALANCING,        "s");
 276 MODULE_PARM_DESC(PARM_LOAD_BALANCING,           "Load Balancing Enabled (<string> N or Y) [Y]");
 277 MODULE_PARM(PARM_MEDIUM_DISTRIBUTION,   "s");
 278 MODULE_PARM_DESC(PARM_MEDIUM_DISTRIBUTION,      "Medium Distribution Enabled (<string> N or Y) [Y]");
 279 MODULE_PARM(PARM_TX_POW_LEVEL,          "b");
 280 MODULE_PARM_DESC(PARM_TX_POW_LEVEL,             "Transmit Power (0 - 6) [3]");
 281 MODULE_PARM(PARM_SRSC_2GHZ,             "b");
 282 MODULE_PARM_DESC(PARM_SRSC_2GHZ,                "Supported Rate Set Control 2.4 GHz");
 283 MODULE_PARM(PARM_SRSC_5GHZ,             "b");
 284 MODULE_PARM_DESC(PARM_SRSC_5GHZ,                "Supported Rate Set Control 5.0 GHz");
 285 MODULE_PARM(PARM_BRSC_2GHZ,             "b");
 286 MODULE_PARM_DESC(PARM_BRSC_2GHZ,                "Basic Rate Set Control 2.4 GHz");
 287 MODULE_PARM(PARM_BRSC_5GHZ,             "b");
 288 MODULE_PARM_DESC(PARM_BRSC_5GHZ,                "Basic Rate Set Control 5.0 GHz");
 289 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
 290 //;?seems reasonable that even an AP-only driver could afford this small additional footprint
 291 MODULE_PARM(PARM_PM_ENABLED,            "h");
 292 MODULE_PARM_DESC(PARM_PM_ENABLED,               "Power Management State (0 - 2, 8001 - 8002) [0]");
 293 MODULE_PARM(PARM_PORT_TYPE,             "b");
 294 MODULE_PARM_DESC(PARM_PORT_TYPE,                "Port Type (1 - 3) [1]");
 295 //;?MODULE_PARM(PARM_CREATE_IBSS,           "s");
 296 //;?MODULE_PARM_DESC(PARM_CREATE_IBSS,              "Create IBSS (<string> N or Y) [N]");
 297 //;?MODULE_PARM(PARM_MULTICAST_RX,          "s");
 298 //;?MODULE_PARM_DESC(PARM_MULTICAST_RX,             "Multicast Receive Enable (<string> N or Y) [Y]");
 299 //;?MODULE_PARM(PARM_MAX_SLEEP,             "h");
 300 //;?MODULE_PARM_DESC(PARM_MAX_SLEEP,                "Maximum Power Management Sleep Duration (0 - 65535) [100]");
 301 //;?MODULE_PARM(PARM_NETWORK_ADDR,          "6b");
 302 //;?MODULE_PARM_DESC(PARM_NETWORK_ADDR,             "Hardware Ethernet Address ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [<factory value>]");
 303 //;?MODULE_PARM(PARM_AUTHENTICATION,        "b");
 304 //
 305 //tracker 12448
 306 //;?MODULE_PARM_DESC(PARM_AUTHENTICATION,           "Authentication Type (0-2) [0] 0=Open 1=SharedKey 2=LEAP");
 307 //;?MODULE_PARM_DESC(authentication,         "Authentication Type (1-2) [1] 1=Open 2=SharedKey");
 308 //tracker 12448
 309 //
 310 //;?MODULE_PARM(PARM_OWN_ATIM_WINDOW,       "b");
 311 //;?MODULE_PARM_DESC(PARM_OWN_ATIM_WINDOW,          "ATIM Window time in TU for IBSS creation (0-100) [0]");
 312 //;?MODULE_PARM(PARM_PM_HOLDOVER_DURATION,  "b");
 313 //;?MODULE_PARM_DESC(PARM_PM_HOLDOVER_DURATION,     "Time station remains awake after MAC frame transfer when PM is on (0-65535) [100]");
 314 //;?MODULE_PARM(PARM_PROMISCUOUS_MODE,      "s");
 315 //;?MODULE_PARM_DESC(PARM_PROMISCUOUS_MODE,         "Promiscuous Mode Enable (<string> Y or N ) [N]" );
 316 //;?
 317 MODULE_PARM(PARM_CONNECTION_CONTROL,    "b");
 318 MODULE_PARM_DESC(PARM_CONNECTION_CONTROL,       "Connection Control (0 - 3) [2]");
 319 #endif /* HCF_STA */
 320 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
 321                                         //;?should we restore this to allow smaller memory footprint
 322 MODULE_PARM(PARM_OWN_DTIM_PERIOD,       "b");
 323 MODULE_PARM_DESC(PARM_OWN_DTIM_PERIOD,          "DTIM Period (0 - 255) [1]");
 324 MODULE_PARM(PARM_REJECT_ANY,            "s");
 325 MODULE_PARM_DESC(PARM_REJECT_ANY,               "Closed System (<string> N or Y) [N]");
 326 MODULE_PARM(PARM_EXCLUDE_UNENCRYPTED,   "s");
 327 MODULE_PARM_DESC(PARM_EXCLUDE_UNENCRYPTED,      "Deny non-encrypted (<string> N or Y) [Y]");
 328 MODULE_PARM(PARM_MULTICAST_PM_BUFFERING,"s");
 329 MODULE_PARM_DESC(PARM_MULTICAST_PM_BUFFERING,   "Buffer MAC frames for Tx after DTIM (<string> Y or N) [Y]");
 330 MODULE_PARM(PARM_INTRA_BSS_RELAY,       "s");
 331 MODULE_PARM_DESC(PARM_INTRA_BSS_RELAY,          "IntraBSS Relay (<string> N or Y) [Y]");
 332 MODULE_PARM(PARM_RTS_THRESHOLD1,        "h");
 333 MODULE_PARM_DESC(PARM_RTS_THRESHOLD1,           "RTS Threshold, WDS Port 1 (256 - 2347) [2347]");
 334 MODULE_PARM(PARM_RTS_THRESHOLD2,        "h");
 335 MODULE_PARM_DESC(PARM_RTS_THRESHOLD2,           "RTS Threshold, WDS Port 2 (256 - 2347) [2347]");
 336 MODULE_PARM(PARM_RTS_THRESHOLD3,        "h");
 337 MODULE_PARM_DESC(PARM_RTS_THRESHOLD3,           "RTS Threshold, WDS Port 3 (256 - 2347) [2347]");
 338 MODULE_PARM(PARM_RTS_THRESHOLD4,        "h");
 339 MODULE_PARM_DESC(PARM_RTS_THRESHOLD4,           "RTS Threshold, WDS Port 4 (256 - 2347) [2347]");
 340 MODULE_PARM(PARM_RTS_THRESHOLD5,        "h");
 341 MODULE_PARM_DESC(PARM_RTS_THRESHOLD5,           "RTS Threshold, WDS Port 5 (256 - 2347) [2347]");
 342 MODULE_PARM(PARM_RTS_THRESHOLD6,        "h");
 343 MODULE_PARM_DESC(PARM_RTS_THRESHOLD6,           "RTS Threshold, WDS Port 6 (256 - 2347) [2347]");
 344 MODULE_PARM(PARM_TX_RATE1,              "b");
 345 MODULE_PARM_DESC(PARM_TX_RATE1,                 "Transmit Rate Control, WDS Port 1 (1 - 7) [3]");
 346 MODULE_PARM(PARM_TX_RATE2,              "b");
 347 MODULE_PARM_DESC(PARM_TX_RATE2,                 "Transmit Rate Control, WDS Port 2 (1 - 7) [3]");
 348 MODULE_PARM(PARM_TX_RATE3,              "b");
 349 MODULE_PARM_DESC(PARM_TX_RATE3,                 "Transmit Rate Control, WDS Port 3 (1 - 7) [3]");
 350 MODULE_PARM(PARM_TX_RATE4,              "b");
 351 MODULE_PARM_DESC(PARM_TX_RATE4,                 "Transmit Rate Control, WDS Port 4 (1 - 7) [3]");
 352 MODULE_PARM(PARM_TX_RATE5,              "b");
 353 MODULE_PARM_DESC(PARM_TX_RATE5,                 "Transmit Rate Control, WDS Port 5 (1 - 7) [3]");
 354 MODULE_PARM(PARM_TX_RATE6,              "b");
 355 MODULE_PARM_DESC(PARM_TX_RATE6,                 "Transmit Rate Control, WDS Port 6 (1 - 7) [3]");
 356 MODULE_PARM(PARM_WDS_ADDRESS1,          "6b");
 357 MODULE_PARM_DESC(PARM_WDS_ADDRESS1,             "MAC Address, WDS Port 1 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
 358 MODULE_PARM(PARM_WDS_ADDRESS2,          "6b");
 359 MODULE_PARM_DESC(PARM_WDS_ADDRESS2,             "MAC Address, WDS Port 2 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
 360 MODULE_PARM(PARM_WDS_ADDRESS3,          "6b");
 361 MODULE_PARM_DESC(PARM_WDS_ADDRESS3,             "MAC Address, WDS Port 3 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
 362 MODULE_PARM(PARM_WDS_ADDRESS4,          "6b");
 363 MODULE_PARM_DESC(PARM_WDS_ADDRESS4,             "MAC Address, WDS Port 4 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
 364 MODULE_PARM(PARM_WDS_ADDRESS5,          "6b");
 365 MODULE_PARM_DESC(PARM_WDS_ADDRESS5,             "MAC Address, WDS Port 5 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
 366 MODULE_PARM(PARM_WDS_ADDRESS6,          "6b");
 367 MODULE_PARM_DESC(PARM_WDS_ADDRESS6,             "MAC Address, WDS Port 6 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
 368
 369 MODULE_PARM(PARM_OWN_BEACON_INTERVAL,   "b");
 370 MODULE_PARM_DESC(PARM_OWN_BEACON_INTERVAL,      "Own Beacon Interval (20 - 200) [100]");
 371 MODULE_PARM(PARM_COEXISTENCE,   "b");
 372 MODULE_PARM_DESC(PARM_COEXISTENCE,      "Coexistence (0-7) [0]");
 373
 374 #endif /* HCF_AP */
 375 #endif
 376
 377 /* END NEW PARAMETERS */
 378 /*******************************************************************************
 379  * debugging specifics
 380  ******************************************************************************/
 381 #if DBG
 382
 383 static p_u32    pc_debug = DBG_LVL;
 384 //MODULE_PARM(pc_debug, "i");
 385 /*static ;?conflicts with my understanding of CL parameters and breaks now I moved
 386  * the correspondig logic to wl_profile
 387  */ p_u32    DebugFlag = ~0; //recognizable "undefined value" rather then DBG_DEFAULTS;
 388 //MODULE_PARM(DebugFlag, "l");
 389
 390 dbg_info_t   wl_info = { DBG_MOD_NAME, 0, 0 };
 391 dbg_info_t  *DbgInfo = &wl_info;
 392
 393 #endif /* DBG */
 394 #ifdef USE_RTS
 395
 396 static p_char  *useRTS = "N";
 397 MODULE_PARM( useRTS, "s" );
 398 MODULE_PARM_DESC( useRTS, "Use RTS test interface (<string> N or Y) [N]" );
 399
 400 #endif  /* USE_RTS */
 401 /*******************************************************************************
 402  * firmware download specifics
 403  ******************************************************************************/
 404 extern struct CFG_RANGE2_STRCT BASED
 405         cfg_drv_act_ranges_pri;             // describes primary-actor range of HCF
 406
 407 #if 0 //;? (HCF_TYPE) & HCF_TYPE_AP
 408 extern memimage ap;                 // AP firmware image to be downloaded
 409 #endif /* HCF_AP */
 410
 411 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
 412 //extern memimage station;            // STA firmware image to be downloaded
 413 extern memimage fw_image;            // firmware image to be downloaded
 414 #endif /* HCF_STA */
 415
 416
 417 /*******************************************************************************
 418  *      wl_insert()
 419  *******************************************************************************
 420  *
 421  *  DESCRIPTION:
 422  *
 423  *      wl_insert() is scheduled to run after a CARD_INSERTION event is
 424  *  received, to configure the PCMCIA socket, and to make the ethernet device
 425  *  available to the system.
 426  *
 427  *  PARAMETERS:
 428  *
 429  *      dev - a pointer to the net_device struct of the wireless device
 430  *
 431  *  RETURNS:
 432  *
 433  *      TRUE or FALSE
 434  *
 435  ******************************************************************************/
 436 int wl_insert( struct net_device *dev )
 437 {
 438         int                     result = 0;
 439         int                     hcf_status = HCF_SUCCESS;
 440         int                     i;
 441         unsigned long           flags = 0;
 442         struct wl_private       *lp = wl_priv(dev);
 443         /*------------------------------------------------------------------------*/
 444         DBG_FUNC( "wl_insert" );
 445         DBG_ENTER( DbgInfo );
 446
 447         /* Initialize the adapter hardware. */
 448         memset( &( lp->hcfCtx ), 0, sizeof( IFB_STRCT ));
 449
 450         /* Initialize the adapter parameters. */
 451         spin_lock_init( &( lp->slock ));
 452
 453         /* Intialize states */
 454         //lp->lockcount = 0; //PE1DNN
 455         lp->is_handling_int = WL_NOT_HANDLING_INT;
 456         lp->firmware_present = WL_FRIMWARE_NOT_PRESENT;
 457
 458         lp->dev = dev;
 459
 460         DBG_PARAM( DbgInfo, "irq_mask", "0x%04x", irq_mask & 0x0FFFF );
 461         DBG_PARAM( DbgInfo, "irq_list", "0x%02x 0x%02x 0x%02x 0x%02x",
 462                            irq_list[0] & 0x0FF, irq_list[1] & 0x0FF,
 463                            irq_list[2] & 0x0FF, irq_list[3] & 0x0FF );
 464         DBG_PARAM( DbgInfo, PARM_NAME_DESIRED_SSID, "\"%s\"", PARM_DESIRED_SSID );
 465         DBG_PARAM( DbgInfo, PARM_NAME_OWN_SSID, "\"%s\"", PARM_OWN_SSID );
 466         DBG_PARAM( DbgInfo, PARM_NAME_OWN_CHANNEL, "%d", PARM_OWN_CHANNEL);
 467         DBG_PARAM( DbgInfo, PARM_NAME_SYSTEM_SCALE, "%d", PARM_SYSTEM_SCALE );
 468         DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE, "%d", PARM_TX_RATE );
 469         DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD, "%d", PARM_RTS_THRESHOLD );
 470         DBG_PARAM( DbgInfo, PARM_NAME_MICROWAVE_ROBUSTNESS, "\"%s\"", PARM_MICROWAVE_ROBUSTNESS );
 471         DBG_PARAM( DbgInfo, PARM_NAME_OWN_NAME, "\"%s\"", PARM_OWN_NAME );
 472 //;?            DBG_PARAM( DbgInfo, PARM_NAME_ENABLE_ENCRYPTION, "\"%s\"", PARM_ENABLE_ENCRYPTION );
 473         DBG_PARAM( DbgInfo, PARM_NAME_KEY1, "\"%s\"", PARM_KEY1 );
 474         DBG_PARAM( DbgInfo, PARM_NAME_KEY2, "\"%s\"", PARM_KEY2 );
 475         DBG_PARAM( DbgInfo, PARM_NAME_KEY3, "\"%s\"", PARM_KEY3 );
 476         DBG_PARAM( DbgInfo, PARM_NAME_KEY4, "\"%s\"", PARM_KEY4 );
 477         DBG_PARAM( DbgInfo, PARM_NAME_TX_KEY, "%d", PARM_TX_KEY );
 478         DBG_PARAM( DbgInfo, PARM_NAME_MULTICAST_RATE, "%d", PARM_MULTICAST_RATE );
 479         DBG_PARAM( DbgInfo, PARM_NAME_DOWNLOAD_FIRMWARE, "\"%s\"", PARM_DOWNLOAD_FIRMWARE );
 480         DBG_PARAM( DbgInfo, PARM_NAME_AUTH_KEY_MGMT_SUITE, "%d", PARM_AUTH_KEY_MGMT_SUITE );
 481 //;?#if (HCF_TYPE) & HCF_TYPE_STA
 482                                         //;?should we make this code conditional depending on in STA mode
 483 //;?        DBG_PARAM( DbgInfo, PARM_NAME_PORT_TYPE, "%d", PARM_PORT_TYPE );
 484                 DBG_PARAM( DbgInfo, PARM_NAME_PM_ENABLED, "%04x", PARM_PM_ENABLED );
 485 //;?        DBG_PARAM( DbgInfo, PARM_NAME_CREATE_IBSS, "\"%s\"", PARM_CREATE_IBSS );
 486 //;?        DBG_PARAM( DbgInfo, PARM_NAME_MULTICAST_RX, "\"%s\"", PARM_MULTICAST_RX );
 487 //;?        DBG_PARAM( DbgInfo, PARM_NAME_MAX_SLEEP, "%d", PARM_MAX_SLEEP );
 488 //;?        DBG_PARAM( DbgInfo, PARM_NAME_NETWORK_ADDR, "\"%s\"", DbgHwAddr( PARM_NETWORK_ADDR ));
 489 //;?        DBG_PARAM( DbgInfo, PARM_NAME_AUTHENTICATION, "%d", PARM_AUTHENTICATION );
 490 //;?        DBG_PARAM( DbgInfo, PARM_NAME_OWN_ATIM_WINDOW, "%d", PARM_OWN_ATIM_WINDOW );
 491 //;?        DBG_PARAM( DbgInfo, PARM_NAME_PM_HOLDOVER_DURATION, "%d", PARM_PM_HOLDOVER_DURATION );
 492 //;?        DBG_PARAM( DbgInfo, PARM_NAME_PROMISCUOUS_MODE, "\"%s\"", PARM_PROMISCUOUS_MODE );
 493 //;?#endif /* HCF_STA */
 494 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
 495                 //;?should we restore this to allow smaller memory footprint
 496                 //;?I guess: no, since this is Debug mode only
 497         DBG_PARAM( DbgInfo, PARM_NAME_OWN_DTIM_PERIOD, "%d", PARM_OWN_DTIM_PERIOD );
 498         DBG_PARAM( DbgInfo, PARM_NAME_REJECT_ANY, "\"%s\"", PARM_REJECT_ANY );
 499         DBG_PARAM( DbgInfo, PARM_NAME_EXCLUDE_UNENCRYPTED, "\"%s\"", PARM_EXCLUDE_UNENCRYPTED );
 500         DBG_PARAM( DbgInfo, PARM_NAME_MULTICAST_PM_BUFFERING, "\"%s\"", PARM_MULTICAST_PM_BUFFERING );
 501         DBG_PARAM( DbgInfo, PARM_NAME_INTRA_BSS_RELAY, "\"%s\"", PARM_INTRA_BSS_RELAY );
 502 #ifdef USE_WDS
 503         DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD1, "%d", PARM_RTS_THRESHOLD1 );
 504         DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD2, "%d", PARM_RTS_THRESHOLD2 );
 505         DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD3, "%d", PARM_RTS_THRESHOLD3 );
 506         DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD4, "%d", PARM_RTS_THRESHOLD4 );
 507         DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD5, "%d", PARM_RTS_THRESHOLD5 );
 508         DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD6, "%d", PARM_RTS_THRESHOLD6 );
 509         DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE1, "%d", PARM_TX_RATE1 );
 510         DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE2, "%d", PARM_TX_RATE2 );
 511         DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE3, "%d", PARM_TX_RATE3 );
 512         DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE4, "%d", PARM_TX_RATE4 );
 513         DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE5, "%d", PARM_TX_RATE5 );
 514         DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE6, "%d", PARM_TX_RATE6 );
 515         DBG_PARAM( DbgInfo, PARM_NAME_WDS_ADDRESS1, "\"%s\"", DbgHwAddr( PARM_WDS_ADDRESS1 ));
 516         DBG_PARAM( DbgInfo, PARM_NAME_WDS_ADDRESS2, "\"%s\"", DbgHwAddr( PARM_WDS_ADDRESS2 ));
 517         DBG_PARAM( DbgInfo, PARM_NAME_WDS_ADDRESS3, "\"%s\"", DbgHwAddr( PARM_WDS_ADDRESS3 ));
 518         DBG_PARAM( DbgInfo, PARM_NAME_WDS_ADDRESS4, "\"%s\"", DbgHwAddr( PARM_WDS_ADDRESS4 ));
 519         DBG_PARAM( DbgInfo, PARM_NAME_WDS_ADDRESS5, "\"%s\"", DbgHwAddr( PARM_WDS_ADDRESS5 ));
 520         DBG_PARAM( DbgInfo, PARM_NAME_WDS_ADDRESS6, "\"%s\"", DbgHwAddr( PARM_WDS_ADDRESS6 ));
 521 #endif /* USE_WDS */
 522 #endif /* HCF_AP */
 523
 524         VALID_PARAM( !PARM_DESIRED_SSID || ( strlen( PARM_DESIRED_SSID ) <= PARM_MAX_NAME_LEN ));
 525         VALID_PARAM( !PARM_OWN_SSID || ( strlen( PARM_OWN_SSID ) <= PARM_MAX_NAME_LEN ));
 526         VALID_PARAM(( PARM_OWN_CHANNEL <= PARM_MAX_OWN_CHANNEL ));
 527         VALID_PARAM(( PARM_SYSTEM_SCALE >= PARM_MIN_SYSTEM_SCALE ) && ( PARM_SYSTEM_SCALE <= PARM_MAX_SYSTEM_SCALE ));
 528         VALID_PARAM(( PARM_TX_RATE >= PARM_MIN_TX_RATE ) && ( PARM_TX_RATE <= PARM_MAX_TX_RATE ));
 529         VALID_PARAM(( PARM_RTS_THRESHOLD <= PARM_MAX_RTS_THRESHOLD ));
 530         VALID_PARAM( !PARM_MICROWAVE_ROBUSTNESS || strchr( "NnYy", PARM_MICROWAVE_ROBUSTNESS[0] ) != NULL );
 531         VALID_PARAM( !PARM_OWN_NAME || ( strlen( PARM_NAME_OWN_NAME ) <= PARM_MAX_NAME_LEN ));
 532         VALID_PARAM(( PARM_ENABLE_ENCRYPTION <= PARM_MAX_ENABLE_ENCRYPTION ));
 533         VALID_PARAM( is_valid_key_string( PARM_KEY1 ));
 534         VALID_PARAM( is_valid_key_string( PARM_KEY2 ));
 535         VALID_PARAM( is_valid_key_string( PARM_KEY3 ));
 536         VALID_PARAM( is_valid_key_string( PARM_KEY4 ));
 537         VALID_PARAM(( PARM_TX_KEY >= PARM_MIN_TX_KEY ) && ( PARM_TX_KEY <= PARM_MAX_TX_KEY ));
 538
 539         VALID_PARAM(( PARM_MULTICAST_RATE >= PARM_MIN_MULTICAST_RATE ) &&
 540                                         ( PARM_MULTICAST_RATE <= PARM_MAX_MULTICAST_RATE ));
 541
 542         VALID_PARAM( !PARM_DOWNLOAD_FIRMWARE || ( strlen( PARM_DOWNLOAD_FIRMWARE ) <= 255 /*;?*/ ));
 543         VALID_PARAM(( PARM_AUTH_KEY_MGMT_SUITE < PARM_MAX_AUTH_KEY_MGMT_SUITE ));
 544
 545         VALID_PARAM( !PARM_LOAD_BALANCING || strchr( "NnYy", PARM_LOAD_BALANCING[0] ) != NULL );
 546         VALID_PARAM( !PARM_MEDIUM_DISTRIBUTION || strchr( "NnYy", PARM_MEDIUM_DISTRIBUTION[0] ) != NULL );
 547         VALID_PARAM(( PARM_TX_POW_LEVEL <= PARM_MAX_TX_POW_LEVEL ));
 548
 549         VALID_PARAM(( PARM_PORT_TYPE >= PARM_MIN_PORT_TYPE ) && ( PARM_PORT_TYPE <= PARM_MAX_PORT_TYPE ));
 550         VALID_PARAM( PARM_PM_ENABLED <= WVLAN_PM_STATE_STANDARD ||
 551                                  ( PARM_PM_ENABLED & 0x7FFF ) <= WVLAN_PM_STATE_STANDARD );
 552         VALID_PARAM( !PARM_CREATE_IBSS || strchr( "NnYy", PARM_CREATE_IBSS[0] ) != NULL );
 553         VALID_PARAM( !PARM_MULTICAST_RX || strchr( "NnYy", PARM_MULTICAST_RX[0] ) != NULL );
 554         VALID_PARAM(( PARM_MAX_SLEEP <= PARM_MAX_MAX_PM_SLEEP ));
 555         VALID_PARAM(( PARM_AUTHENTICATION <= PARM_MAX_AUTHENTICATION ));
 556         VALID_PARAM(( PARM_OWN_ATIM_WINDOW <= PARM_MAX_OWN_ATIM_WINDOW ));
 557         VALID_PARAM(( PARM_PM_HOLDOVER_DURATION <= PARM_MAX_PM_HOLDOVER_DURATION ));
 558         VALID_PARAM( !PARM_PROMISCUOUS_MODE || strchr( "NnYy", PARM_PROMISCUOUS_MODE[0] ) != NULL );
 559         VALID_PARAM(( PARM_CONNECTION_CONTROL <= PARM_MAX_CONNECTION_CONTROL ));
 560
 561         VALID_PARAM(( PARM_OWN_DTIM_PERIOD >= PARM_MIN_OWN_DTIM_PERIOD ));
 562         VALID_PARAM( !PARM_REJECT_ANY || strchr( "NnYy", PARM_REJECT_ANY[0] ) != NULL );
 563         VALID_PARAM( !PARM_EXCLUDE_UNENCRYPTED || strchr( "NnYy", PARM_EXCLUDE_UNENCRYPTED[0] ) != NULL );
 564         VALID_PARAM( !PARM_MULTICAST_PM_BUFFERING || strchr( "NnYy", PARM_MULTICAST_PM_BUFFERING[0] ) != NULL );
 565         VALID_PARAM( !PARM_INTRA_BSS_RELAY || strchr( "NnYy", PARM_INTRA_BSS_RELAY[0] ) != NULL );
 566 #ifdef USE_WDS
 567         VALID_PARAM(( PARM_RTS_THRESHOLD1 <= PARM_MAX_RTS_THRESHOLD ));
 568         VALID_PARAM(( PARM_RTS_THRESHOLD2 <= PARM_MAX_RTS_THRESHOLD ));
 569         VALID_PARAM(( PARM_RTS_THRESHOLD3 <= PARM_MAX_RTS_THRESHOLD ));
 570         VALID_PARAM(( PARM_RTS_THRESHOLD4 <= PARM_MAX_RTS_THRESHOLD ));
 571         VALID_PARAM(( PARM_RTS_THRESHOLD5 <= PARM_MAX_RTS_THRESHOLD ));
 572         VALID_PARAM(( PARM_RTS_THRESHOLD6 <= PARM_MAX_RTS_THRESHOLD ));
 573         VALID_PARAM(( PARM_TX_RATE1 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE1 <= PARM_MAX_TX_RATE ));
 574         VALID_PARAM(( PARM_TX_RATE2 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE2 <= PARM_MAX_TX_RATE ));
 575         VALID_PARAM(( PARM_TX_RATE3 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE3 <= PARM_MAX_TX_RATE ));
 576         VALID_PARAM(( PARM_TX_RATE4 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE4 <= PARM_MAX_TX_RATE ));
 577         VALID_PARAM(( PARM_TX_RATE5 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE5 <= PARM_MAX_TX_RATE ));
 578         VALID_PARAM(( PARM_TX_RATE6 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE6 <= PARM_MAX_TX_RATE ));
 579 #endif /* USE_WDS */
 580
 581         VALID_PARAM(( PARM_OWN_BEACON_INTERVAL >= PARM_MIN_OWN_BEACON_INTERVAL ) && ( PARM_OWN_BEACON_INTERVAL <= PARM_MAX_OWN_BEACON_INTERVAL ));
 582         VALID_PARAM(( PARM_COEXISTENCE <= PARM_COEXISTENCE ));
 583
 584         /* Set the driver parameters from the passed in parameters. */
 585
 586         /* THESE MODULE PARAMETERS ARE TO BE DEPRECATED IN FAVOR OF A NAMING CONVENTION
 587            WHICH IS INLINE WITH THE FORTHCOMING WAVELAN API */
 588
 589         /* START NEW PARAMETERS */
 590
 591         lp->Channel             = PARM_OWN_CHANNEL;
 592         lp->DistanceBetweenAPs  = PARM_SYSTEM_SCALE;
 593
 594         /* Need to determine how to handle the new bands for 5GHz */
 595         lp->TxRateControl[0]    = PARM_DEFAULT_TX_RATE_2GHZ;
 596         lp->TxRateControl[1]    = PARM_DEFAULT_TX_RATE_5GHZ;
 597
 598         lp->RTSThreshold        = PARM_RTS_THRESHOLD;
 599
 600         /* Need to determine how to handle the new bands for 5GHz */
 601         lp->MulticastRate[0]    = PARM_DEFAULT_MULTICAST_RATE_2GHZ;
 602         lp->MulticastRate[1]    = PARM_DEFAULT_MULTICAST_RATE_5GHZ;
 603
 604         if ( strchr( "Yy", PARM_MICROWAVE_ROBUSTNESS[0] ) != NULL ) {
 605                 lp->MicrowaveRobustness = 1;
 606         } else {
 607                 lp->MicrowaveRobustness = 0;
 608         }
 609         if ( PARM_DESIRED_SSID && ( strlen( PARM_DESIRED_SSID ) <= HCF_MAX_NAME_LEN )) {
 610                 strcpy( lp->NetworkName, PARM_DESIRED_SSID );
 611         }
 612         if ( PARM_OWN_SSID && ( strlen( PARM_OWN_SSID ) <= HCF_MAX_NAME_LEN )) {
 613                 strcpy( lp->NetworkName, PARM_OWN_SSID );
 614         }
 615         if ( PARM_OWN_NAME && ( strlen( PARM_OWN_NAME ) <= HCF_MAX_NAME_LEN )) {
 616                 strcpy( lp->StationName, PARM_OWN_NAME );
 617         }
 618         lp->EnableEncryption = PARM_ENABLE_ENCRYPTION;
 619         if ( PARM_KEY1 && ( strlen( PARM_KEY1 ) <= MAX_KEY_LEN )) {
 620                 strcpy( lp->Key1, PARM_KEY1 );
 621         }
 622         if ( PARM_KEY2 && ( strlen( PARM_KEY2 ) <= MAX_KEY_LEN )) {
 623                 strcpy( lp->Key2, PARM_KEY2 );
 624         }
 625         if ( PARM_KEY3 && ( strlen( PARM_KEY3 ) <= MAX_KEY_LEN )) {
 626                 strcpy( lp->Key3, PARM_KEY3 );
 627         }
 628         if ( PARM_KEY4 && ( strlen( PARM_KEY4 ) <= MAX_KEY_LEN )) {
 629                 strcpy( lp->Key4, PARM_KEY4 );
 630         }
 631
 632         lp->TransmitKeyID = PARM_TX_KEY;
 633
 634         key_string2key( lp->Key1, &(lp->DefaultKeys.key[0] ));
 635         key_string2key( lp->Key2, &(lp->DefaultKeys.key[1] ));
 636         key_string2key( lp->Key3, &(lp->DefaultKeys.key[2] ));
 637         key_string2key( lp->Key4, &(lp->DefaultKeys.key[3] ));
 638
 639         lp->DownloadFirmware = 1 ; //;?to be upgraded PARM_DOWNLOAD_FIRMWARE;
 640         lp->AuthKeyMgmtSuite = PARM_AUTH_KEY_MGMT_SUITE;
 641
 642         if ( strchr( "Yy", PARM_LOAD_BALANCING[0] ) != NULL ) {
 643                 lp->loadBalancing = 1;
 644         } else {
 645                 lp->loadBalancing = 0;
 646         }
 647
 648         if ( strchr( "Yy", PARM_MEDIUM_DISTRIBUTION[0] ) != NULL ) {
 649                 lp->mediumDistribution = 1;
 650         } else {
 651                 lp->mediumDistribution = 0;
 652         }
 653
 654         lp->txPowLevel = PARM_TX_POW_LEVEL;
 655
 656         lp->srsc[0] = PARM_SRSC_2GHZ;
 657         lp->srsc[1] = PARM_SRSC_5GHZ;
 658         lp->brsc[0] = PARM_BRSC_2GHZ;
 659         lp->brsc[1] = PARM_BRSC_5GHZ;
 660 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
 661 //;?seems reasonable that even an AP-only driver could afford this small additional footprint
 662         lp->PortType            = PARM_PORT_TYPE;
 663         lp->MaxSleepDuration    = PARM_MAX_SLEEP;
 664         lp->authentication      = PARM_AUTHENTICATION;
 665         lp->atimWindow          = PARM_OWN_ATIM_WINDOW;
 666         lp->holdoverDuration    = PARM_PM_HOLDOVER_DURATION;
 667         lp->PMEnabled           = PARM_PM_ENABLED;  //;?
 668         if ( strchr( "Yy", PARM_CREATE_IBSS[0] ) != NULL ) {
 669                 lp->CreateIBSS = 1;
 670         } else {
 671                 lp->CreateIBSS = 0;
 672         }
 673         if ( strchr( "Nn", PARM_MULTICAST_RX[0] ) != NULL ) {
 674                 lp->MulticastReceive = 0;
 675         } else {
 676                 lp->MulticastReceive = 1;
 677         }
 678         if ( strchr( "Yy", PARM_PROMISCUOUS_MODE[0] ) != NULL ) {
 679                 lp->promiscuousMode = 1;
 680         } else {
 681                 lp->promiscuousMode = 0;
 682         }
 683         for( i = 0; i < ETH_ALEN; i++ ) {
 684            lp->MACAddress[i] = PARM_NETWORK_ADDR[i];
 685         }
 686
 687         lp->connectionControl = PARM_CONNECTION_CONTROL;
 688
 689 #endif /* HCF_STA */
 690 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
 691         //;?should we restore this to allow smaller memory footprint
 692         lp->DTIMPeriod = PARM_OWN_DTIM_PERIOD;
 693
 694         if ( strchr( "Yy", PARM_REJECT_ANY[0] ) != NULL ) {
 695                 lp->RejectAny = 1;
 696         } else {
 697                 lp->RejectAny = 0;
 698         }
 699         if ( strchr( "Nn", PARM_EXCLUDE_UNENCRYPTED[0] ) != NULL ) {
 700                 lp->ExcludeUnencrypted = 0;
 701         } else {
 702                 lp->ExcludeUnencrypted = 1;
 703         }
 704         if ( strchr( "Yy", PARM_MULTICAST_PM_BUFFERING[0] ) != NULL ) {
 705                 lp->multicastPMBuffering = 1;
 706         } else {
 707                 lp->multicastPMBuffering = 0;
 708         }
 709         if ( strchr( "Yy", PARM_INTRA_BSS_RELAY[0] ) != NULL ) {
 710                 lp->intraBSSRelay = 1;
 711         } else {
 712                 lp->intraBSSRelay = 0;
 713         }
 714
 715         lp->ownBeaconInterval = PARM_OWN_BEACON_INTERVAL;
 716         lp->coexistence       = PARM_COEXISTENCE;
 717
 718 #ifdef USE_WDS
 719         lp->wds_port[0].rtsThreshold    = PARM_RTS_THRESHOLD1;
 720         lp->wds_port[1].rtsThreshold    = PARM_RTS_THRESHOLD2;
 721         lp->wds_port[2].rtsThreshold    = PARM_RTS_THRESHOLD3;
 722         lp->wds_port[3].rtsThreshold    = PARM_RTS_THRESHOLD4;
 723         lp->wds_port[4].rtsThreshold    = PARM_RTS_THRESHOLD5;
 724         lp->wds_port[5].rtsThreshold    = PARM_RTS_THRESHOLD6;
 725         lp->wds_port[0].txRateCntl      = PARM_TX_RATE1;
 726         lp->wds_port[1].txRateCntl      = PARM_TX_RATE2;
 727         lp->wds_port[2].txRateCntl      = PARM_TX_RATE3;
 728         lp->wds_port[3].txRateCntl      = PARM_TX_RATE4;
 729         lp->wds_port[4].txRateCntl      = PARM_TX_RATE5;
 730         lp->wds_port[5].txRateCntl      = PARM_TX_RATE6;
 731
 732         for( i = 0; i < ETH_ALEN; i++ ) {
 733                 lp->wds_port[0].wdsAddress[i] = PARM_WDS_ADDRESS1[i];
 734         }
 735         for( i = 0; i < ETH_ALEN; i++ ) {
 736                 lp->wds_port[1].wdsAddress[i] = PARM_WDS_ADDRESS2[i];
 737         }
 738         for( i = 0; i < ETH_ALEN; i++ ) {
 739                 lp->wds_port[2].wdsAddress[i] = PARM_WDS_ADDRESS3[i];
 740         }
 741         for( i = 0; i < ETH_ALEN; i++ ) {
 742                 lp->wds_port[3].wdsAddress[i] = PARM_WDS_ADDRESS4[i];
 743         }
 744         for( i = 0; i < ETH_ALEN; i++ ) {
 745                 lp->wds_port[4].wdsAddress[i] = PARM_WDS_ADDRESS5[i];
 746         }
 747         for( i = 0; i < ETH_ALEN; i++ ) {
 748                 lp->wds_port[5].wdsAddress[i] = PARM_WDS_ADDRESS6[i];
 749         }
 750 #endif  /* USE_WDS */
 751 #endif  /* HCF_AP */
 752 #ifdef USE_RTS
 753         if ( strchr( "Yy", useRTS[0] ) != NULL ) {
 754                 lp->useRTS = 1;
 755         } else {
 756                 lp->useRTS = 0;
 757         }
 758 #endif  /* USE_RTS */
 759
 760
 761         /* END NEW PARAMETERS */
 762
 763
 764         wl_lock( lp, &flags );
 765
 766         /* Initialize the portState variable */
 767         lp->portState = WVLAN_PORT_STATE_DISABLED;
 768
 769         /* Initialize the ScanResult struct */
 770         memset( &( lp->scan_results ), 0, sizeof( lp->scan_results ));
 771         lp->scan_results.scan_complete = FALSE;
 772
 773         /* Initialize the ProbeResult struct */
 774         memset( &( lp->probe_results ), 0, sizeof( lp->probe_results ));
 775         lp->probe_results.scan_complete = FALSE;
 776         lp->probe_num_aps = 0;
 777
 778
 779         /* Initialize Tx queue stuff */
 780         memset( lp->txList, 0, sizeof( lp->txList ));
 781
 782         INIT_LIST_HEAD( &( lp->txFree ));
 783
 784         lp->txF.skb  = NULL;
 785         lp->txF.port = 0;
 786
 787
 788         for( i = 0; i < DEFAULT_NUM_TX_FRAMES; i++ ) {
 789                 list_add_tail( &( lp->txList[i].node ), &( lp->txFree ));
 790         }
 791
 792
 793         for( i = 0; i < WVLAN_MAX_TX_QUEUES; i++ ) {
 794                 INIT_LIST_HEAD( &( lp->txQ[i] ));
 795         }
 796
 797         lp->netif_queue_on = TRUE;
 798         lp->txQ_count = 0;
 799         /* Initialize the use_dma element in the adapter structure. Not sure if
 800            this should be a compile-time or run-time configurable. So for now,
 801            implement as run-time and just define here */
 802 #ifdef WARP
 803 #ifdef ENABLE_DMA
 804         DBG_TRACE( DbgInfo, "HERMES 2.5 BUSMASTER DMA MODE\n" );
 805         lp->use_dma = 1;
 806 #else
 807         DBG_TRACE( DbgInfo, "HERMES 2.5 PORT I/O MODE\n" );
 808         lp->use_dma = 0;
 809 #endif // ENABLE_DMA
 810 #endif // WARP
 811
 812         /* Register the ISR handler information here, so that it's not done
 813            repeatedly in the ISR */
 814         tasklet_init(&lp->task, wl_isr_handler, (unsigned long)lp);
 815
 816         /* Connect to the adapter */
 817         DBG_TRACE( DbgInfo, "Calling hcf_connect()...\n" );
 818         hcf_status = hcf_connect( &lp->hcfCtx, dev->base_addr );
 819         //HCF_ERR_INCOMP_FW is acceptable, because download must still take place
 820         //HCF_ERR_INCOMP_PRI is not acceptable
 821         if ( hcf_status != HCF_SUCCESS && hcf_status != HCF_ERR_INCOMP_FW ) {
 822                 DBG_ERROR( DbgInfo, "hcf_connect() failed, status: 0x%x\n", hcf_status );
 823                 wl_unlock( lp, &flags );
 824                 goto hcf_failed;
 825         }
 826
 827         //;?should set HCF_version and how about driver_stat
 828         lp->driverInfo.IO_address       = dev->base_addr;
 829         lp->driverInfo.IO_range         = HCF_NUM_IO_PORTS;     //;?conditionally 0x40 or 0x80 seems better
 830         lp->driverInfo.IRQ_number       = dev->irq;
 831         lp->driverInfo.card_stat        = lp->hcfCtx.IFB_CardStat;
 832         //;? what happened to frame_type
 833
 834         /* Fill in the driver identity structure */
 835         lp->driverIdentity.len              = ( sizeof( lp->driverIdentity ) / sizeof( hcf_16 )) - 1;
 836         lp->driverIdentity.typ              = CFG_DRV_IDENTITY;
 837         lp->driverIdentity.comp_id          = DRV_IDENTITY;
 838         lp->driverIdentity.variant          = DRV_VARIANT;
 839         lp->driverIdentity.version_major    = DRV_MAJOR_VERSION;
 840         lp->driverIdentity.version_minor    = DRV_MINOR_VERSION;
 841
 842
 843         /* Start the card here - This needs to be done in order to get the
 844            MAC address for the network layer */
 845         DBG_TRACE( DbgInfo, "Calling wvlan_go() to perform a card reset...\n" );
 846         hcf_status = wl_go( lp );
 847
 848         if ( hcf_status != HCF_SUCCESS ) {
 849                 DBG_ERROR( DbgInfo, "wl_go() failed\n" );
 850                 wl_unlock( lp, &flags );
 851                 goto hcf_failed;
 852         }
 853
 854         /* Certain RIDs must be set before enabling the ports */
 855         wl_put_ltv_init( lp );
 856
 857 #if 0 //;?why was this already commented out in wl_lkm_720
 858         /* Enable the ports */
 859         if ( wl_adapter_is_open( lp->dev )) {
 860                 /* Enable the ports */
 861                 DBG_TRACE( DbgInfo, "Enabling Port 0\n" );
 862                 hcf_status = wl_enable( lp );
 863
 864                 if ( hcf_status != HCF_SUCCESS ) {
 865                         DBG_TRACE( DbgInfo, "Enable port 0 failed: 0x%x\n", hcf_status );
 866                 }
 867
 868 #if (HCF_TYPE) & HCF_TYPE_AP
 869                 DBG_TRACE( DbgInfo, "Enabling WDS Ports\n" );
 870                 //wl_enable_wds_ports( lp );
 871 #endif  /* (HCF_TYPE) & HCF_TYPE_AP */
 872
 873         }
 874 #endif
 875
 876         /* Fill out the MAC address information in the net_device struct */
 877         memcpy( lp->dev->dev_addr, lp->MACAddress, ETH_ALEN );
 878         dev->addr_len = ETH_ALEN;
 879
 880         lp->is_registered = TRUE;
 881
 882 #ifdef USE_PROFILE
 883         /* Parse the config file for the sake of creating WDS ports if WDS is
 884            configured there but not in the module options */
 885         parse_config( dev );
 886 #endif  /* USE_PROFILE */
 887
 888         /* If we're going into AP Mode, register the "virtual" ethernet devices
 889            needed for WDS */
 890         WL_WDS_NETDEV_REGISTER( lp );
 891
 892         /* Reset the DownloadFirmware variable in the private struct. If the
 893            config file is not used, this will not matter; if it is used, it
 894            will be reparsed in wl_open(). This is done because logic in wl_open
 895            used to check if a firmware download is needed is broken by parsing
 896            the file here; however, this parsing is needed to register WDS ports
 897            in AP mode, if they are configured */
 898         lp->DownloadFirmware = WVLAN_DRV_MODE_STA; //;?download_firmware;
 899
 900 #ifdef USE_RTS
 901         if ( lp->useRTS == 1 ) {
 902                 DBG_TRACE( DbgInfo, "ENTERING RTS MODE...\n" );
 903                 wl_act_int_off( lp );
 904                 lp->is_handling_int = WL_NOT_HANDLING_INT; // Not handling interrupts anymore
 905
 906                 wl_disable( lp );
 907
 908                 hcf_connect( &lp->hcfCtx, HCF_DISCONNECT);
 909         }
 910 #endif  /* USE_RTS */
 911
 912         wl_unlock( lp, &flags );
 913
 914         DBG_TRACE( DbgInfo, "%s: Wireless, io_addr %#03lx, irq %d, ""mac_address ",
 915                            dev->name, dev->base_addr, dev->irq );
 916
 917         for( i = 0; i < ETH_ALEN; i++ ) {
 918                 printk( "%02X%c", dev->dev_addr[i], (( i < ( ETH_ALEN-1 )) ? ':' : '\n' ));
 919         }
 920
 921 #if 0 //SCULL_USE_PROC /* don't waste space if unused */
 922         create_proc_read_entry( "wlags", 0, NULL, scull_read_procmem, dev );
 923         proc_mkdir("driver/wlags49", 0);
 924         proc_write("driver/wlags49/wlags49_type", write_int, &lp->wlags49_type);
 925 #endif /* SCULL_USE_PROC */
 926
 927         DBG_LEAVE( DbgInfo );
 928         return result;
 929
 930 hcf_failed:
 931         wl_hcf_error( dev, hcf_status );
 932
 933 failed:
 934
 935         DBG_ERROR( DbgInfo, "wl_insert() FAILED\n" );
 936
 937         if ( lp->is_registered == TRUE ) {
 938                 lp->is_registered = FALSE;
 939         }
 940
 941         WL_WDS_NETDEV_DEREGISTER( lp );
 942
 943         result = -EFAULT;
 944
 945
 946         DBG_LEAVE( DbgInfo );
 947         return result;
 948 } // wl_insert
 949 /*============================================================================*/
 950
 951
 952 /*******************************************************************************
 953  *      wl_reset()
 954  *******************************************************************************
 955  *
 956  *  DESCRIPTION:
 957  *
 958  *      Reset the adapter.
 959  *
 960  *  PARAMETERS:
 961  *
 962  *      dev - a pointer to the net_device struct of the wireless device
 963  *
 964  *  RETURNS:
 965  *
 966  *      an HCF status code
 967  *
 968  ******************************************************************************/
 969 int wl_reset(struct net_device *dev)
 970 {
 971         struct wl_private  *lp = wl_priv(dev);
 972         int                 hcf_status = HCF_SUCCESS;
 973         /*------------------------------------------------------------------------*/
 974         DBG_FUNC( "wl_reset" );
 975         DBG_ENTER( DbgInfo );
 976         DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
 977         DBG_PARAM( DbgInfo, "dev->base_addr", "(%#03lx)", dev->base_addr );
 978
 979         /*
 980          * The caller should already have a lock and
 981          * disable the interrupts, we do not lock here,
 982          * nor do we enable/disable interrupts!
 983          */
 984
 985         DBG_TRACE( DbgInfo, "Device Base Address: %#03lx\n", dev->base_addr );
 986         if ( dev->base_addr ) {
 987                 /* Shutdown the adapter. */
 988                 hcf_connect( &lp->hcfCtx, HCF_DISCONNECT );
 989
 990                 /* Reset the driver information. */
 991                 lp->txBytes = 0;
 992
 993                 /* Connect to the adapter. */
 994                 hcf_status = hcf_connect( &lp->hcfCtx, dev->base_addr );
 995                 if ( hcf_status != HCF_SUCCESS && hcf_status != HCF_ERR_INCOMP_FW ) {
 996                         DBG_ERROR( DbgInfo, "hcf_connect() failed, status: 0x%x\n", hcf_status );
 997                         goto out;
 998                 }
 999
1000                 /* Check if firmware is present, if not change state */
1001                 if ( hcf_status == HCF_ERR_INCOMP_FW ) {
1002                         lp->firmware_present = WL_FRIMWARE_NOT_PRESENT;
1003                 }
1004
1005                 /* Initialize the portState variable */
1006                 lp->portState = WVLAN_PORT_STATE_DISABLED;
1007
1008                 /* Restart the adapter. */
1009                 hcf_status = wl_go( lp );
1010                 if ( hcf_status != HCF_SUCCESS ) {
1011                         DBG_ERROR( DbgInfo, "wl_go() failed, status: 0x%x\n", hcf_status );
1012                         goto out;
1013                 }
1014
1015                 /* Certain RIDs must be set before enabling the ports */
1016                 wl_put_ltv_init( lp );
1017         } else {
1018                 DBG_ERROR( DbgInfo, "Device Base Address INVALID!!!\n" );
1019         }
1020
1021 out:
1022         DBG_LEAVE( DbgInfo );
1023         return hcf_status;
1024 } // wl_reset
1025 /*============================================================================*/
1026
1027
1028 /*******************************************************************************
1029  *      wl_go()
1030  *******************************************************************************
1031  *
1032  *  DESCRIPTION:
1033  *
1034  *      Reset the adapter.
1035  *
1036  *  PARAMETERS:
1037  *
1038  *      dev - a pointer to the net_device struct of the wireless device
1039  *
1040  *  RETURNS:
1041  *
1042  *      an HCF status code
1043  *
1044  ******************************************************************************/
1045 int wl_go( struct wl_private *lp )
1046 {
1047         int     hcf_status = HCF_SUCCESS;
1048         char    *cp = NULL;                     //fw_image
1049         int     retries = 0;
1050         /*------------------------------------------------------------------------*/
1051         DBG_FUNC( "wl_go" );
1052         DBG_ENTER( DbgInfo );
1053
1054         hcf_status = wl_disable( lp );
1055         if ( hcf_status != HCF_SUCCESS ) {
1056                 DBG_TRACE( DbgInfo, "Disable port 0 failed: 0x%x\n", hcf_status );
1057
1058                 while (( hcf_status != HCF_SUCCESS ) && (retries < 10)) {
1059                         retries++;
1060                         hcf_status = wl_disable( lp );
1061                 }
1062                 if ( hcf_status == HCF_SUCCESS ) {
1063                         DBG_TRACE( DbgInfo, "Disable port 0 succes : %d retries\n", retries );
1064                 } else {
1065                         DBG_TRACE( DbgInfo, "Disable port 0 failed after: %d retries\n", retries );
1066                 }
1067         }
1068
1069 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
1070         //DBG_TRACE( DbgInfo, "Disabling WDS Ports\n" );
1071         //wl_disable_wds_ports( lp );
1072 #endif  /* (HCF_TYPE) & HCF_TYPE_AP */
1073
1074 //;?what was the purpose of this
1075 //      /* load the appropriate firmware image, depending on driver mode */
1076 //      lp->ltvRecord.len   = ( sizeof( CFG_RANGE20_STRCT ) / sizeof( hcf_16 )) - 1;
1077 //      lp->ltvRecord.typ   = CFG_DRV_ACT_RANGES_PRI;
1078 //      hcf_get_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1079
1080 #if BIN_DL
1081         if ( strlen( lp->fw_image_filename ) ) {
1082 mm_segment_t    fs;
1083 int                     file_desc;
1084 int                     rc;
1085
1086                 DBG_TRACE( DbgInfo, "F/W image:%s:\n", lp->fw_image_filename );
1087                 /* Obtain a user-space process context, storing the original context */
1088                 fs = get_fs( );
1089                 set_fs( get_ds( ));
1090                 file_desc = open( lp->fw_image_filename, O_RDONLY, 0 );
1091                 if ( file_desc == -1 ) {
1092                         DBG_ERROR( DbgInfo, "No image file found\n" );
1093                 } else {
1094                         DBG_TRACE( DbgInfo, "F/W image file found\n" );
1095 #define DHF_ALLOC_SIZE 96000                    //just below 96K, let's hope it suffices for now and for the future
1096                         cp = (char*)vmalloc( DHF_ALLOC_SIZE );
1097                         if ( cp == NULL ) {
1098                                 DBG_ERROR( DbgInfo, "error in vmalloc\n" );
1099                         } else {
1100                                 rc = read( file_desc, cp, DHF_ALLOC_SIZE );
1101                                 if ( rc == DHF_ALLOC_SIZE ) {
1102                                         DBG_ERROR( DbgInfo, "buffer too small, %d\n", DHF_ALLOC_SIZE );
1103                                 } else if ( rc > 0 ) {
1104                                         DBG_TRACE( DbgInfo, "read O.K.: %d bytes  %.12s\n", rc, cp );
1105                                         rc = read( file_desc, &cp[rc], 1 );
1106                                         if ( rc == 0 ) { //;/change to an until-loop at rc<=0
1107                                                 DBG_TRACE( DbgInfo, "no more to read\n" );
1108                                         }
1109                                 }
1110                                 if ( rc != 0 ) {
1111                                         DBG_ERROR( DbgInfo, "file not read in one swoop or other error"\
1112                                                                                 ", give up, too complicated, rc = %0X\n", rc );
1113                                         DBG_ERROR( DbgInfo, "still have to change code to get a real download now !!!!!!!!\n" );
1114                                 } else {
1115                                         DBG_TRACE( DbgInfo, "before dhf_download_binary\n" );
1116                                         hcf_status = dhf_download_binary( (memimage *)cp );
1117                                         DBG_TRACE( DbgInfo, "after dhf_download_binary, before dhf_download_fw\n" );
1118                                         //;?improve error flow/handling
1119                                         hcf_status = dhf_download_fw( &lp->hcfCtx, (memimage *)cp );
1120                                         DBG_TRACE( DbgInfo, "after dhf_download_fw\n" );
1121                                 }
1122                                 vfree( cp );
1123                         }
1124                         close( file_desc );
1125                 }
1126                 set_fs( fs );                   /* Return to the original context */
1127         }
1128 #endif // BIN_DL
1129
1130         /* If firmware is present but the type is unknown then download anyway */
1131         if ( (lp->firmware_present == WL_FRIMWARE_PRESENT)
1132              &&
1133              ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) != COMP_ID_FW_STA )
1134              &&
1135              ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) != COMP_ID_FW_AP ) ) {
1136                 /* Unknown type, download needed.  */
1137                 lp->firmware_present = WL_FRIMWARE_NOT_PRESENT;
1138         }
1139
1140         if(lp->firmware_present == WL_FRIMWARE_NOT_PRESENT)
1141         {
1142                 if ( cp == NULL ) {
1143                         DBG_TRACE( DbgInfo, "Downloading STA firmware...\n" );
1144 //                      hcf_status = dhf_download_fw( &lp->hcfCtx, &station );
1145                         hcf_status = dhf_download_fw( &lp->hcfCtx, &fw_image );
1146                 }
1147                 if ( hcf_status != HCF_SUCCESS ) {
1148                         DBG_ERROR( DbgInfo, "Firmware Download failed\n" );
1149                         DBG_LEAVE( DbgInfo );
1150                         return hcf_status;
1151                 }
1152         }
1153         /* Report the FW versions */
1154         //;?obsolete, use the available IFB info:: wl_get_pri_records( lp );
1155         if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_STA  ) {
1156                 DBG_TRACE( DbgInfo, "downloaded station F/W\n" );
1157         } else if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP  ) {
1158                 DBG_TRACE( DbgInfo, "downloaded AP F/W\n" );
1159         } else {
1160                 DBG_ERROR( DbgInfo, "unknown F/W type\n" );
1161         }
1162
1163         /*
1164          * Downloaded, no need to repeat this next time, assume the
1165          * contents stays in the card until it is powered off. Note we
1166          * do not switch firmware on the fly, the firmware is fixed in
1167          * the driver for now.
1168          */
1169         lp->firmware_present = WL_FRIMWARE_PRESENT;
1170
1171         DBG_TRACE( DbgInfo, "ComponentID:%04x variant:%04x major:%04x minor:%04x\n",
1172                                 CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ),
1173                                 CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.variant ),
1174                                 CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.version_major ),
1175                                 CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.version_minor ));
1176
1177         /* now we wil get the MAC address of the card */
1178         lp->ltvRecord.len = 4;
1179         if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP  ) {
1180                 lp->ltvRecord.typ = CFG_NIC_MAC_ADDR;
1181         } else
1182         {
1183                 lp->ltvRecord.typ = CFG_CNF_OWN_MAC_ADDR;
1184         }
1185         hcf_status = hcf_get_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1186         if ( hcf_status != HCF_SUCCESS ) {
1187                 DBG_ERROR( DbgInfo, "Could not retrieve MAC address\n" );
1188                 DBG_LEAVE( DbgInfo );
1189                 return hcf_status;
1190         }
1191         memcpy( lp->MACAddress, &lp->ltvRecord.u.u8[0], ETH_ALEN );
1192         DBG_TRACE( DbgInfo, "Card MAC Address: %s\n", DbgHwAddr( lp->MACAddress ));
1193
1194         /* Write out configuration to the device, enable, and reconnect. However,
1195            only reconnect if in AP mode. For STA mode, need to wait for passive scan
1196            completion before a connect can be issued */
1197         wl_put_ltv( lp );
1198         /* Enable the ports */
1199         hcf_status = wl_enable( lp );
1200
1201         if ( lp->DownloadFirmware == WVLAN_DRV_MODE_AP ) {
1202 #ifdef USE_WDS
1203                 wl_enable_wds_ports( lp );
1204 #endif // USE_WDS
1205                 hcf_status = wl_connect( lp );
1206         }
1207         DBG_LEAVE( DbgInfo );
1208         return hcf_status;
1209 } // wl_go
1210 /*============================================================================*/
1211
1212
1213 /*******************************************************************************
1214  *      wl_set_wep_keys()
1215  *******************************************************************************
1216  *
1217  *  DESCRIPTION:
1218  *
1219  *      Write TxKeyID and WEP keys to the adapter. This is separated from
1220  *  wl_apply() to allow dynamic WEP key updates through the wireless
1221  *  extensions.
1222  *
1223  *  PARAMETERS:
1224  *
1225  *      lp  - a pointer to the wireless adapter's private structure
1226  *
1227  *  RETURNS:
1228  *
1229  *      N/A
1230  *
1231  ******************************************************************************/
1232 void wl_set_wep_keys( struct wl_private *lp )
1233 {
1234         int count = 0;
1235         /*------------------------------------------------------------------------*/
1236         DBG_FUNC( "wl_set_wep_keys" );
1237         DBG_ENTER( DbgInfo );
1238         DBG_PARAM( DbgInfo, "lp", "%s (0x%p)", lp->dev->name, lp );
1239         if ( lp->EnableEncryption ) {
1240                 /* NOTE: CFG_CNF_ENCRYPTION is set in wl_put_ltv() as it's a static
1241                                  RID */
1242
1243                 /* set TxKeyID */
1244                 lp->ltvRecord.len = 2;
1245                 lp->ltvRecord.typ       = CFG_TX_KEY_ID;
1246                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE(lp->TransmitKeyID - 1);
1247
1248                 hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1249
1250                 DBG_TRACE( DbgInfo, "Key 1 len: %d\n", lp->DefaultKeys.key[0].len );
1251                 DBG_TRACE( DbgInfo, "Key 2 len: %d\n", lp->DefaultKeys.key[1].len );
1252                 DBG_TRACE( DbgInfo, "Key 3 len: %d\n", lp->DefaultKeys.key[2].len );
1253                 DBG_TRACE( DbgInfo, "Key 4 len: %d\n", lp->DefaultKeys.key[3].len );
1254
1255                 /* write keys */
1256                 lp->DefaultKeys.len = sizeof( lp->DefaultKeys ) / sizeof( hcf_16 ) - 1;
1257                 lp->DefaultKeys.typ = CFG_DEFAULT_KEYS;
1258
1259                 /* endian translate the appropriate key information */
1260                 for( count = 0; count < MAX_KEYS; count++ ) {
1261                         lp->DefaultKeys.key[count].len = CNV_INT_TO_LITTLE( lp->DefaultKeys.key[count].len );
1262                 }
1263
1264                 hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->DefaultKeys ));
1265
1266                 /* Reverse the above endian translation, since these keys are accessed
1267                    elsewhere */
1268                 for( count = 0; count < MAX_KEYS; count++ ) {
1269                         lp->DefaultKeys.key[count].len = CNV_INT_TO_LITTLE( lp->DefaultKeys.key[count].len );
1270                 }
1271
1272                 DBG_NOTICE( DbgInfo, "encrypt: %d, ID: %d\n", lp->EnableEncryption, lp->TransmitKeyID );
1273                 DBG_NOTICE( DbgInfo, "set key: %s(%d) [%d]\n", lp->DefaultKeys.key[lp->TransmitKeyID-1].key, lp->DefaultKeys.key[lp->TransmitKeyID-1].len, lp->TransmitKeyID-1 );
1274         }
1275
1276         DBG_LEAVE( DbgInfo );
1277 } // wl_set_wep_keys
1278 /*============================================================================*/
1279
1280
1281 /*******************************************************************************
1282  *      wl_apply()
1283  *******************************************************************************
1284  *
1285  *  DESCRIPTION:
1286  *
1287  *      Write the parameters to the adapter. (re-)enables the card if device is
1288  *  open. Returns hcf_status of hcf_enable().
1289  *
1290  *  PARAMETERS:
1291  *
1292  *      lp  - a pointer to the wireless adapter's private structure
1293  *
1294  *  RETURNS:
1295  *
1296  *      an HCF status code
1297  *
1298  ******************************************************************************/
1299 int wl_apply(struct wl_private *lp)
1300 {
1301         int hcf_status = HCF_SUCCESS;
1302         /*------------------------------------------------------------------------*/
1303         DBG_FUNC( "wl_apply" );
1304         DBG_ENTER( DbgInfo );
1305         DBG_ASSERT( lp != NULL);
1306         DBG_PARAM( DbgInfo, "lp", "%s (0x%p)", lp->dev->name, lp );
1307
1308         if ( !( lp->flags & WVLAN2_UIL_BUSY )) {
1309                 /* The adapter parameters have changed:
1310                                 disable card
1311                                 reload parameters
1312                                 enable card
1313                 */
1314
1315                 if ( wl_adapter_is_open( lp->dev )) {
1316                         /* Disconnect and disable if necessary */
1317                         hcf_status = wl_disconnect( lp );
1318                         if ( hcf_status != HCF_SUCCESS ) {
1319                                 DBG_ERROR( DbgInfo, "Disconnect failed\n" );
1320                                 DBG_LEAVE( DbgInfo );
1321                                 return -1;
1322                         }
1323                         hcf_status = wl_disable( lp );
1324                         if ( hcf_status != HCF_SUCCESS ) {
1325                                 DBG_ERROR( DbgInfo, "Disable failed\n" );
1326                                 DBG_LEAVE( DbgInfo );
1327                                 return -1;
1328                         } else {
1329                                 /* Write out configuration to the device, enable, and reconnect.
1330                                    However, only reconnect if in AP mode. For STA mode, need to
1331                                    wait for passive scan completion before a connect can be
1332                                    issued */
1333                                 hcf_status = wl_put_ltv( lp );
1334
1335                                 if ( hcf_status == HCF_SUCCESS ) {
1336                                         hcf_status = wl_enable( lp );
1337
1338                                         if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP  ) {
1339                                                 hcf_status = wl_connect( lp );
1340                                         }
1341                                 } else {
1342                                         DBG_WARNING( DbgInfo, "wl_put_ltv() failed\n" );
1343                                 }
1344                         }
1345                 }
1346         }
1347
1348         DBG_LEAVE( DbgInfo );
1349         return hcf_status;
1350 } // wl_apply
1351 /*============================================================================*/
1352
1353
1354 /*******************************************************************************
1355  *      wl_put_ltv_init()
1356  *******************************************************************************
1357  *
1358  *  DESCRIPTION:
1359  *
1360  *      Used to set basic parameters for card initialization.
1361  *
1362  *  PARAMETERS:
1363  *
1364  *      lp  - a pointer to the wireless adapter's private structure
1365  *
1366  *  RETURNS:
1367  *
1368  *      an HCF status code
1369  *
1370  ******************************************************************************/
1371 int wl_put_ltv_init( struct wl_private *lp )
1372 {
1373         int i;
1374         int hcf_status;
1375         CFG_RID_LOG_STRCT *RidLog;
1376         /*------------------------------------------------------------------------*/
1377         DBG_FUNC( "wl_put_ltv_init" );
1378         DBG_ENTER( DbgInfo );
1379         if ( lp == NULL ) {
1380                 DBG_ERROR( DbgInfo, "lp pointer is NULL\n" );
1381                 DBG_LEAVE( DbgInfo );
1382                 return -1;
1383         }
1384         /* DMA/IO */
1385         lp->ltvRecord.len = 2;
1386         lp->ltvRecord.typ = CFG_CNTL_OPT;
1387
1388         /* The Card Services build must ALWAYS configure for 16-bit I/O. PCI or
1389            CardBus can be set to either 16/32 bit I/O, or Bus Master DMA, but only
1390            for Hermes-2.5 */
1391 #ifdef BUS_PCMCIA
1392         lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( USE_16BIT );
1393 #else
1394         if ( lp->use_dma ) {
1395                 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( USE_DMA );
1396         } else {
1397                 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( 0 );
1398         }
1399
1400 #endif
1401         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1402         DBG_TRACE( DbgInfo, "CFG_CNTL_OPT                      : 0x%04x\n",
1403                            lp->ltvRecord.u.u16[0] );
1404         DBG_TRACE( DbgInfo, "CFG_CNTL_OPT result               : 0x%04x\n",
1405                            hcf_status );
1406
1407         /* Register the list of RIDs on which asynchronous notification is
1408            required. Note that this mechanism replaces the mailbox, so the mailbox
1409            can be queried by the host (if desired) without contention from us */
1410         i=0;
1411
1412         lp->RidList[i].len     = sizeof( lp->ProbeResp );
1413         lp->RidList[i].typ     = CFG_ACS_SCAN;
1414         lp->RidList[i].bufp    = (wci_recordp)&lp->ProbeResp;
1415         //lp->ProbeResp.infoType = 0xFFFF;
1416         i++;
1417
1418         lp->RidList[i].len     = sizeof( lp->assoc_stat );
1419         lp->RidList[i].typ     = CFG_ASSOC_STAT;
1420         lp->RidList[i].bufp    = (wci_recordp)&lp->assoc_stat;
1421         lp->assoc_stat.len     = 0xFFFF;
1422         i++;
1423
1424         lp->RidList[i].len     = 4;
1425         lp->RidList[i].typ     = CFG_UPDATED_INFO_RECORD;
1426         lp->RidList[i].bufp    = (wci_recordp)&lp->updatedRecord;
1427         lp->updatedRecord.len  = 0xFFFF;
1428         i++;
1429
1430         lp->RidList[i].len     = sizeof( lp->sec_stat );
1431         lp->RidList[i].typ     = CFG_SECURITY_STAT;
1432         lp->RidList[i].bufp    = (wci_recordp)&lp->sec_stat;
1433         lp->sec_stat.len       = 0xFFFF;
1434         i++;
1435
1436         lp->RidList[i].typ     = 0;    // Terminate List
1437
1438         RidLog = (CFG_RID_LOG_STRCT *)&lp->ltvRecord;
1439         RidLog->len     = 3;
1440         RidLog->typ     = CFG_REG_INFO_LOG;
1441         RidLog->recordp = (RID_LOGP)&lp->RidList[0];
1442
1443         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1444         DBG_TRACE( DbgInfo, "CFG_REG_INFO_LOG\n" );
1445         DBG_TRACE( DbgInfo, "CFG_REG_INFO_LOG result           : 0x%04x\n",
1446                            hcf_status );
1447         DBG_LEAVE( DbgInfo );
1448         return hcf_status;
1449 } // wl_put_ltv_init
1450 /*============================================================================*/
1451
1452
1453 /*******************************************************************************
1454  *      wl_put_ltv()
1455  *******************************************************************************
1456  *
1457  *  DESCRIPTION:
1458  *
1459  *      Used by wvlan_apply() and wvlan_go to set the card's configuration.
1460  *
1461  *  PARAMETERS:
1462  *
1463  *      lp  - a pointer to the wireless adapter's private structure
1464  *
1465  *  RETURNS:
1466  *
1467  *      an HCF status code
1468  *
1469  ******************************************************************************/
1470 int wl_put_ltv( struct wl_private *lp )
1471 {
1472         int len;
1473         int hcf_status;
1474         /*------------------------------------------------------------------------*/
1475         DBG_FUNC( "wl_put_ltv" );
1476         DBG_ENTER( DbgInfo );
1477
1478         if ( lp == NULL ) {
1479                 DBG_ERROR( DbgInfo, "lp pointer is NULL\n" );
1480                 return -1;
1481         }
1482         if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP  ) {
1483                 lp->maxPort = 6;                        //;?why set this here and not as part of download process
1484         } else {
1485                 lp->maxPort = 0;
1486         }
1487
1488         /* Send our configuration to the card. Perform any endian translation
1489            necessary */
1490         /* Register the Mailbox; VxWorks does this elsewhere; why;? */
1491         lp->ltvRecord.len       = 4;
1492         lp->ltvRecord.typ       = CFG_REG_MB;
1493         lp->ltvRecord.u.u32[0]  = (u_long)&( lp->mailbox );
1494         lp->ltvRecord.u.u16[2]  = ( MB_SIZE / sizeof( hcf_16 ));
1495         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1496
1497         /* Max Data Length */
1498         lp->ltvRecord.len       = 2;
1499         lp->ltvRecord.typ       = CFG_CNF_MAX_DATA_LEN;
1500         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( HCF_MAX_PACKET_SIZE );
1501         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1502
1503         /* System Scale / Distance between APs */
1504         lp->ltvRecord.len       = 2;
1505         lp->ltvRecord.typ       = CFG_CNF_SYSTEM_SCALE;
1506         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->DistanceBetweenAPs );
1507         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1508
1509         /* Channel */
1510         if ( lp->CreateIBSS && ( lp->Channel == 0 )) {
1511                 DBG_TRACE( DbgInfo, "Create IBSS" );
1512                 lp->Channel = 10;
1513         }
1514         lp->ltvRecord.len       = 2;
1515         lp->ltvRecord.typ       = CFG_CNF_OWN_CHANNEL;
1516         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->Channel );
1517         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1518
1519         /* Microwave Robustness */
1520         lp->ltvRecord.len       = 2;
1521         lp->ltvRecord.typ       = CFG_CNF_MICRO_WAVE;
1522         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->MicrowaveRobustness );
1523         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1524
1525         /* Load Balancing */
1526         lp->ltvRecord.len       = 2;
1527         lp->ltvRecord.typ       = CFG_CNF_LOAD_BALANCING;
1528         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->loadBalancing );
1529         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1530
1531         /* Medium Distribution */
1532         lp->ltvRecord.len       = 2;
1533         lp->ltvRecord.typ       = CFG_CNF_MEDIUM_DISTRIBUTION;
1534         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->mediumDistribution );
1535         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1536         /* Country Code */
1537
1538 #ifdef WARP
1539         /* Tx Power Level (for supported cards) */
1540         lp->ltvRecord.len       = 2;
1541         lp->ltvRecord.typ       = CFG_CNF_TX_POW_LVL;
1542         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->txPowLevel );
1543         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1544
1545         /* Short Retry Limit */
1546         /*lp->ltvRecord.len       = 2;
1547         lp->ltvRecord.typ       = 0xFC32;
1548         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->shortRetryLimit );
1549         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1550         */
1551
1552         /* Long Retry Limit */
1553         /*lp->ltvRecord.len       = 2;
1554         lp->ltvRecord.typ       = 0xFC33;
1555         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->longRetryLimit );
1556         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1557         */
1558
1559         /* Supported Rate Set Control */
1560         lp->ltvRecord.len       = 3;
1561         lp->ltvRecord.typ       = CFG_SUPPORTED_RATE_SET_CNTL; //0xFC88;
1562         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->srsc[0] );
1563         lp->ltvRecord.u.u16[1]  = CNV_INT_TO_LITTLE( lp->srsc[1] );
1564         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1565
1566         /* Basic Rate Set Control */
1567         lp->ltvRecord.len       = 3;
1568         lp->ltvRecord.typ       = CFG_BASIC_RATE_SET_CNTL; //0xFC89;
1569         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->brsc[0] );
1570         lp->ltvRecord.u.u16[1]  = CNV_INT_TO_LITTLE( lp->brsc[1] );
1571         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1572
1573         /* Frame Burst Limit */
1574         /* Defined, but not currently available in Firmware */
1575
1576 #endif // WARP
1577
1578 #ifdef WARP
1579         /* Multicast Rate */
1580         lp->ltvRecord.len       = 3;
1581         lp->ltvRecord.typ       = CFG_CNF_MCAST_RATE;
1582         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->MulticastRate[0] );
1583         lp->ltvRecord.u.u16[1]  = CNV_INT_TO_LITTLE( lp->MulticastRate[1] );
1584 #else
1585         lp->ltvRecord.len       = 2;
1586         lp->ltvRecord.typ       = CFG_CNF_MCAST_RATE;
1587         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->MulticastRate[0] );
1588 #endif // WARP
1589         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1590
1591         /* Own Name (Station Nickname) */
1592         if (( len = ( strlen( lp->StationName ) + 1 ) & ~0x01 ) != 0 ) {
1593                 //DBG_TRACE( DbgInfo, "CFG_CNF_OWN_NAME                  : %s\n",
1594                 //           lp->StationName );
1595
1596                 lp->ltvRecord.len       = 2 + ( len / sizeof( hcf_16 ));
1597                 lp->ltvRecord.typ       = CFG_CNF_OWN_NAME;
1598                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( strlen( lp->StationName ));
1599
1600                 memcpy( &( lp->ltvRecord.u.u8[2] ), lp->StationName, len );
1601         } else {
1602                 //DBG_TRACE( DbgInfo, "CFG_CNF_OWN_NAME                  : EMPTY\n" );
1603
1604                 lp->ltvRecord.len       = 2;
1605                 lp->ltvRecord.typ       = CFG_CNF_OWN_NAME;
1606                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( 0 );
1607         }
1608
1609         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1610
1611         //DBG_TRACE( DbgInfo, "CFG_CNF_OWN_NAME result           : 0x%04x\n",
1612         //           hcf_status );
1613
1614         /* The following are set in STA mode only */
1615         if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_STA  ) {
1616
1617                 /* RTS Threshold */
1618                 lp->ltvRecord.len       = 2;
1619                 lp->ltvRecord.typ       = CFG_RTS_THRH;
1620                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->RTSThreshold );
1621                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1622
1623                 /* Port Type */
1624                 lp->ltvRecord.len       = 2;
1625                 lp->ltvRecord.typ       = CFG_CNF_PORT_TYPE;
1626                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->PortType );
1627                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1628
1629                 /* Tx Rate Control */
1630 #ifdef WARP
1631                 lp->ltvRecord.len       = 3;
1632                 lp->ltvRecord.typ       = CFG_TX_RATE_CNTL;
1633                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->TxRateControl[0] );
1634                 lp->ltvRecord.u.u16[1]  = CNV_INT_TO_LITTLE( lp->TxRateControl[1] );
1635 #else
1636                 lp->ltvRecord.len       = 2;
1637                 lp->ltvRecord.typ       = CFG_TX_RATE_CNTL;
1638                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->TxRateControl[0] );
1639 #endif  // WARP
1640
1641 //;?skip temporarily to see whether the RID or something else is the probelm hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1642
1643                 DBG_TRACE( DbgInfo, "CFG_TX_RATE_CNTL 2.4GHz           : 0x%04x\n",
1644                                    lp->TxRateControl[0] );
1645                 DBG_TRACE( DbgInfo, "CFG_TX_RATE_CNTL 5.0GHz           : 0x%04x\n",
1646                                    lp->TxRateControl[1] );
1647                 DBG_TRACE( DbgInfo, "CFG_TX_RATE_CNTL result           : 0x%04x\n",
1648                                    hcf_status );
1649                 /* Power Management */
1650                 lp->ltvRecord.len       = 2;
1651                 lp->ltvRecord.typ       = CFG_CNF_PM_ENABLED;
1652                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->PMEnabled );
1653 //              lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( 0x8001 );
1654                 DBG_TRACE( DbgInfo, "CFG_CNF_PM_ENABLED                : 0x%04x\n", lp->PMEnabled );
1655                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1656                 /* Multicast Receive */
1657                 lp->ltvRecord.len       = 2;
1658                 lp->ltvRecord.typ       = CFG_CNF_MCAST_RX;
1659                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->MulticastReceive );
1660                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1661
1662                 /* Max Sleep Duration */
1663                 lp->ltvRecord.len       = 2;
1664                 lp->ltvRecord.typ       = CFG_CNF_MAX_SLEEP_DURATION;
1665                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->MaxSleepDuration );
1666                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1667
1668                 /* Create IBSS */
1669                 lp->ltvRecord.len       = 2;
1670                 lp->ltvRecord.typ       = CFG_CREATE_IBSS;
1671                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->CreateIBSS );
1672                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1673
1674                 /* Desired SSID */
1675                 if ((( len = ( strlen( lp->NetworkName ) + 1 ) & ~0x01 ) != 0 ) &&
1676                          ( strcmp( lp->NetworkName, "ANY" ) != 0 ) &&
1677                          ( strcmp( lp->NetworkName, "any" ) != 0 )) {
1678                         //DBG_TRACE( DbgInfo, "CFG_DESIRED_SSID                  : %s\n",
1679                         //           lp->NetworkName );
1680
1681                         lp->ltvRecord.len       = 2 + (len / sizeof(hcf_16));
1682                         lp->ltvRecord.typ       = CFG_DESIRED_SSID;
1683                         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( strlen( lp->NetworkName ));
1684
1685                         memcpy( &( lp->ltvRecord.u.u8[2] ), lp->NetworkName, len );
1686                 } else {
1687                         //DBG_TRACE( DbgInfo, "CFG_DESIRED_SSID                  : ANY\n" );
1688
1689                         lp->ltvRecord.len       = 2;
1690                         lp->ltvRecord.typ       = CFG_DESIRED_SSID;
1691                         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( 0 );
1692                 }
1693
1694                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1695
1696                 //DBG_TRACE( DbgInfo, "CFG_DESIRED_SSID result           : 0x%04x\n",
1697                 //           hcf_status );
1698                 /* Own ATIM window */
1699                 lp->ltvRecord.len       = 2;
1700                 lp->ltvRecord.typ       = CFG_CNF_OWN_ATIM_WINDOW;
1701                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->atimWindow );
1702                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1703
1704
1705                 /* Holdover Duration */
1706                 lp->ltvRecord.len       = 2;
1707                 lp->ltvRecord.typ       = CFG_CNF_HOLDOVER_DURATION;
1708                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->holdoverDuration );
1709                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1710
1711                 /* Promiscuous Mode */
1712                 lp->ltvRecord.len       = 2;
1713                 lp->ltvRecord.typ       = CFG_PROMISCUOUS_MODE;
1714                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->promiscuousMode );
1715                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1716
1717                 /* Authentication */
1718                 lp->ltvRecord.len       = 2;
1719                 lp->ltvRecord.typ       = CFG_CNF_AUTHENTICATION;
1720                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->authentication );
1721                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1722 #ifdef WARP
1723                 /* Connection Control */
1724                 lp->ltvRecord.len       = 2;
1725                 lp->ltvRecord.typ       = CFG_CNF_CONNECTION_CNTL;
1726                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->connectionControl );
1727                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1728
1729
1730
1731                 /* Probe data rate */
1732                 /*lp->ltvRecord.len       = 3;
1733                 lp->ltvRecord.typ       = CFG_PROBE_DATA_RATE;
1734                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->probeDataRates[0] );
1735                 lp->ltvRecord.u.u16[1]  = CNV_INT_TO_LITTLE( lp->probeDataRates[1] );
1736                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1737
1738                 DBG_TRACE( DbgInfo, "CFG_PROBE_DATA_RATE 2.4GHz        : 0x%04x\n",
1739                                    lp->probeDataRates[0] );
1740                 DBG_TRACE( DbgInfo, "CFG_PROBE_DATA_RATE 5.0GHz        : 0x%04x\n",
1741                                    lp->probeDataRates[1] );
1742                 DBG_TRACE( DbgInfo, "CFG_PROBE_DATA_RATE result        : 0x%04x\n",
1743                                    hcf_status );*/
1744 #endif // WARP
1745         } else {
1746                 /* The following are set in AP mode only */
1747 #if 0 //;? (HCF_TYPE) & HCF_TYPE_AP
1748                 //;?should we restore this to allow smaller memory footprint
1749
1750                 /* DTIM Period */
1751                 lp->ltvRecord.len       = 2;
1752                 lp->ltvRecord.typ       = CFG_CNF_OWN_DTIM_PERIOD;
1753                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->DTIMPeriod );
1754                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1755
1756                 /* Multicast PM Buffering */
1757                 lp->ltvRecord.len       = 2;
1758                 lp->ltvRecord.typ       = CFG_CNF_MCAST_PM_BUF;
1759                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->multicastPMBuffering );
1760                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1761
1762                 /* Reject ANY - Closed System */
1763                 lp->ltvRecord.len       = 2;
1764                 lp->ltvRecord.typ       = CFG_CNF_REJECT_ANY;
1765                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->RejectAny );
1766
1767                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1768
1769                 /* Exclude Unencrypted */
1770                 lp->ltvRecord.len       = 2;
1771                 lp->ltvRecord.typ       = CFG_CNF_EXCL_UNENCRYPTED;
1772                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->ExcludeUnencrypted );
1773
1774                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1775
1776                 /* IntraBSS Relay */
1777                 lp->ltvRecord.len       = 2;
1778                 lp->ltvRecord.typ       = CFG_CNF_INTRA_BSS_RELAY;
1779                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->intraBSSRelay );
1780                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1781
1782                 /* RTS Threshold 0 */
1783                 lp->ltvRecord.len       = 2;
1784                 lp->ltvRecord.typ       = CFG_RTS_THRH0;
1785                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->RTSThreshold );
1786
1787                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1788
1789                 /* Tx Rate Control 0 */
1790 #ifdef WARP
1791                 lp->ltvRecord.len       = 3;
1792                 lp->ltvRecord.typ       = CFG_TX_RATE_CNTL0;
1793                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->TxRateControl[0] );
1794                 lp->ltvRecord.u.u16[1]  = CNV_INT_TO_LITTLE( lp->TxRateControl[1] );
1795 #else
1796                 lp->ltvRecord.len       = 2;
1797                 lp->ltvRecord.typ       = CFG_TX_RATE_CNTL0;
1798                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->TxRateControl[0] );
1799 #endif  // WARP
1800
1801                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1802
1803                 /* Own Beacon Interval */
1804                 lp->ltvRecord.len       = 2;
1805                 lp->ltvRecord.typ       = 0xFC31;
1806                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->ownBeaconInterval );
1807                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1808
1809                 /* Co-Existence Behavior */
1810                 lp->ltvRecord.len       = 2;
1811                 lp->ltvRecord.typ       = 0xFCC7;
1812                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->coexistence );
1813                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1814
1815 #ifdef USE_WDS
1816
1817                 /* RTS Threshold 1 */
1818                 lp->ltvRecord.len       = 2;
1819                 lp->ltvRecord.typ       = CFG_RTS_THRH1;
1820                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->wds_port[0].rtsThreshold );
1821                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1822
1823                 /* RTS Threshold 2 */
1824                 lp->ltvRecord.len       = 2;
1825                 lp->ltvRecord.typ       = CFG_RTS_THRH2;
1826                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->wds_port[1].rtsThreshold );
1827                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1828
1829
1830                 /* RTS Threshold 3 */
1831                 lp->ltvRecord.len       = 2;
1832                 lp->ltvRecord.typ       = CFG_RTS_THRH3;
1833                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->wds_port[2].rtsThreshold );
1834                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1835
1836
1837                 /* RTS Threshold 4 */
1838                 lp->ltvRecord.len       = 2;
1839                 lp->ltvRecord.typ       = CFG_RTS_THRH4;
1840                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->wds_port[3].rtsThreshold );
1841                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1842
1843
1844                 /* RTS Threshold 5 */
1845                 lp->ltvRecord.len       = 2;
1846                 lp->ltvRecord.typ       = CFG_RTS_THRH5;
1847                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->wds_port[4].rtsThreshold );
1848                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1849
1850                 /* RTS Threshold 6 */
1851                 lp->ltvRecord.len       = 2;
1852                 lp->ltvRecord.typ       = CFG_RTS_THRH6;
1853                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->wds_port[5].rtsThreshold );
1854                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1855 #if 0
1856                 /* TX Rate Control 1 */
1857                 lp->ltvRecord.len       = 2;
1858                 lp->ltvRecord.typ       = CFG_TX_RATE_CNTL1;
1859                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->wds_port[0].txRateCntl );
1860                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1861
1862                 /* TX Rate Control 2 */
1863                 lp->ltvRecord.len       = 2;
1864                 lp->ltvRecord.typ       = CFG_TX_RATE_CNTL2;
1865                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->wds_port[1].txRateCntl );
1866                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1867
1868                 /* TX Rate Control 3 */
1869                 lp->ltvRecord.len       = 2;
1870                 lp->ltvRecord.typ       = CFG_TX_RATE_CNTL3;
1871                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->wds_port[2].txRateCntl );
1872                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1873
1874                 /* TX Rate Control 4 */
1875                 lp->ltvRecord.len       = 2;
1876                 lp->ltvRecord.typ       = CFG_TX_RATE_CNTL4;
1877                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->wds_port[3].txRateCntl );
1878                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1879
1880                 /* TX Rate Control 5 */
1881                 lp->ltvRecord.len       = 2;
1882                 lp->ltvRecord.typ       = CFG_TX_RATE_CNTL5;
1883                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->wds_port[4].txRateCntl );
1884                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1885
1886                 /* TX Rate Control 6 */
1887                 lp->ltvRecord.len       = 2;
1888                 lp->ltvRecord.typ       = CFG_TX_RATE_CNTL6;
1889                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->wds_port[5].txRateCntl );
1890                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1891
1892 #endif
1893
1894                 /* WDS addresses.  It's okay to blindly send these parameters, because
1895                    the port needs to be enabled, before anything is done with it. */
1896
1897                 /* WDS Address 1 */
1898                 lp->ltvRecord.len      = 4;
1899                 lp->ltvRecord.typ      = CFG_CNF_WDS_ADDR1;
1900
1901                 memcpy( &lp->ltvRecord.u.u8[0], lp->wds_port[0].wdsAddress, ETH_ALEN );
1902                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1903
1904                 /* WDS Address 2 */
1905                 lp->ltvRecord.len      = 4;
1906                 lp->ltvRecord.typ      = CFG_CNF_WDS_ADDR2;
1907
1908                 memcpy( &lp->ltvRecord.u.u8[0], lp->wds_port[1].wdsAddress, ETH_ALEN );
1909                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1910
1911                 /* WDS Address 3 */
1912                 lp->ltvRecord.len      = 4;
1913                 lp->ltvRecord.typ      = CFG_CNF_WDS_ADDR3;
1914
1915                 memcpy( &lp->ltvRecord.u.u8[0], lp->wds_port[2].wdsAddress, ETH_ALEN );
1916                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1917
1918                 /* WDS Address 4 */
1919                 lp->ltvRecord.len      = 4;
1920                 lp->ltvRecord.typ      = CFG_CNF_WDS_ADDR4;
1921
1922                 memcpy( &lp->ltvRecord.u.u8[0], lp->wds_port[3].wdsAddress, ETH_ALEN );
1923                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1924
1925                 /* WDS Address 5 */
1926                 lp->ltvRecord.len      = 4;
1927                 lp->ltvRecord.typ      = CFG_CNF_WDS_ADDR5;
1928
1929                 memcpy( &lp->ltvRecord.u.u8[0], lp->wds_port[4].wdsAddress, ETH_ALEN );
1930                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1931
1932                 /* WDS Address 6 */
1933                 lp->ltvRecord.len      = 4;
1934                 lp->ltvRecord.typ      = CFG_CNF_WDS_ADDR6;
1935
1936                 memcpy( &lp->ltvRecord.u.u8[0], lp->wds_port[5].wdsAddress, ETH_ALEN );
1937                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1938 #endif  /* USE_WDS */
1939 #endif  /* (HCF_TYPE) & HCF_TYPE_AP */
1940         }
1941
1942         /* Own MAC Address */
1943         //DBG_TRACE( DbgInfo, "MAC Address                       : %s\n",
1944         //           DbgHwAddr( lp->MACAddress ));
1945
1946         if ( WVLAN_VALID_MAC_ADDRESS( lp->MACAddress )) {
1947                 /* Make the MAC address valid by:
1948                                 Clearing the multicast bit
1949                                 Setting the local MAC address bit
1950                 */
1951                 //lp->MACAddress[0] &= ~0x03;  //;?why is this commented out already in 720
1952                 //lp->MACAddress[0] |= 0x02;
1953
1954                 lp->ltvRecord.len = 1 + ( ETH_ALEN / sizeof( hcf_16 ));
1955                 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP  ) {
1956                         //DBG_TRACE( DbgInfo, "CFG_NIC_MAC_ADDR\n" );
1957                         lp->ltvRecord.typ = CFG_NIC_MAC_ADDR;
1958                 } else {
1959                         //DBG_TRACE( DbgInfo, "CFG_CNF_OWN_MAC_ADDR\n" );
1960                         lp->ltvRecord.typ = CFG_CNF_OWN_MAC_ADDR;
1961                 }
1962                 /* MAC address is byte aligned, no endian conversion needed */
1963                 memcpy( &( lp->ltvRecord.u.u8[0] ), lp->MACAddress, ETH_ALEN );
1964                 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1965                 //DBG_TRACE( DbgInfo, "CFG_XXX_MAC_ADDR result           : 0x%04x\n",
1966                 //           hcf_status );
1967
1968                 /* Update the MAC address in the netdevice struct */
1969                 memcpy( lp->dev->dev_addr, lp->MACAddress, ETH_ALEN ); //;?what is the purpose of this seemingly complex logic
1970         }
1971         /* Own SSID */
1972         if ((( len = ( strlen( lp->NetworkName ) + 1 ) & ~0x01 ) != 0 ) &&
1973                                  ( strcmp( lp->NetworkName, "ANY" ) != 0 ) &&
1974                                  ( strcmp( lp->NetworkName, "any" ) != 0 )) {
1975                 //DBG_TRACE( DbgInfo, "CFG_CNF_OWN_SSID                  : %s\n",
1976                 //           lp->NetworkName );
1977                 lp->ltvRecord.len       = 2 + (len / sizeof(hcf_16));
1978                 lp->ltvRecord.typ       = CFG_CNF_OWN_SSID;
1979                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( strlen( lp->NetworkName ));
1980
1981                 memcpy( &( lp->ltvRecord.u.u8[2] ), lp->NetworkName, len );
1982         } else {
1983                 //DBG_TRACE( DbgInfo, "CFG_CNF_OWN_SSID                  : ANY\n" );
1984                 lp->ltvRecord.len       = 2;
1985                 lp->ltvRecord.typ       = CFG_CNF_OWN_SSID;
1986                 lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( 0 );
1987         }
1988
1989         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1990
1991         //DBG_TRACE( DbgInfo, "CFG_CNF_OWN_SSID result           : 0x%04x\n",
1992         //           hcf_status );
1993         /* enable/disable encryption */
1994         lp->ltvRecord.len       = 2;
1995         lp->ltvRecord.typ       = CFG_CNF_ENCRYPTION;
1996         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->EnableEncryption );
1997         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1998
1999         /* Set the Authentication Key Management Suite */
2000         lp->ltvRecord.len       = 2;
2001         lp->ltvRecord.typ       = CFG_SET_WPA_AUTH_KEY_MGMT_SUITE;
2002         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( lp->AuthKeyMgmtSuite );
2003         hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
2004         /* WEP Keys */
2005         wl_set_wep_keys( lp );
2006
2007         /* Country Code */
2008         /* countryInfo, ltvCountryInfo, CFG_CNF_COUNTRY_INFO */
2009
2010         DBG_LEAVE( DbgInfo );
2011         return hcf_status;
2012 } // wl_put_ltv
2013 /*============================================================================*/
2014
2015
2016 /*******************************************************************************
2017  *      init_module()
2018  *******************************************************************************
2019  *
2020  *  DESCRIPTION:
2021  *
2022  *      Load the kernel module.
2023  *
2024  *  PARAMETERS:
2025  *
2026  *      N/A
2027  *
2028  *  RETURNS:
2029  *
2030  *      0 on success
2031  *      an errno value otherwise
2032  *
2033  ******************************************************************************/
2034 static int __init wl_module_init( void )
2035 {
2036         int result;
2037         /*------------------------------------------------------------------------*/
2038
2039         DBG_FUNC( "wl_module_init" );
2040
2041 #if DBG
2042         /* Convert "standard" PCMCIA parameter pc_debug to a reasonable DebugFlag value.
2043          * NOTE: The values all fall through to the lower values. */
2044         DbgInfo->DebugFlag = 0;
2045         DbgInfo->DebugFlag = DBG_TRACE_ON;              //;?get this mess resolved one day
2046         if ( pc_debug ) switch( pc_debug ) {
2047           case 8:
2048                 DbgInfo->DebugFlag |= DBG_DS_ON;
2049           case 7:
2050                 DbgInfo->DebugFlag |= DBG_RX_ON | DBG_TX_ON;
2051           case 6:
2052                 DbgInfo->DebugFlag |= DBG_PARAM_ON;
2053           case 5:
2054                 DbgInfo->DebugFlag |= DBG_TRACE_ON;
2055           case 4:
2056                 DbgInfo->DebugFlag |= DBG_VERBOSE_ON;
2057           case 1:
2058                 DbgInfo->DebugFlag |= DBG_DEFAULTS;
2059           default:
2060                 break;
2061         }
2062 #endif /* DBG */
2063
2064         DBG_ENTER( DbgInfo );
2065         printk(KERN_INFO "%s\n", VERSION_INFO);
2066         printk(KERN_INFO "*** Modified for kernel 2.6 by Henk de Groot <pe1dnn@amsat.org>\n");
2067         printk(KERN_INFO "*** Based on 7.18 version by Andrey Borzenkov <arvidjaar@mail.ru> $Revision: 39 $\n");
2068
2069
2070 // ;?#if (HCF_TYPE) & HCF_TYPE_AP
2071 //      DBG_PRINT( "Access Point Mode (AP) Support: YES\n" );
2072 // #else
2073 //      DBG_PRINT( "Access Point Mode (AP) Support: NO\n" );
2074 // #endif /* (HCF_TYPE) & HCF_TYPE_AP */
2075
2076         result = wl_adapter_init_module( );
2077         DBG_LEAVE( DbgInfo );
2078         return result;
2079 } // init_module
2080 /*============================================================================*/
2081
2082
2083 /*******************************************************************************
2084  *      cleanup_module()
2085  *******************************************************************************
2086  *
2087  *  DESCRIPTION:
2088  *
2089  *      Unload the kernel module.
2090  *
2091  *  PARAMETERS:
2092  *
2093  *      N/A
2094  *
2095  *  RETURNS:
2096  *
2097  *      N/A
2098  *
2099  ******************************************************************************/
2100 static void __exit wl_module_exit( void )
2101 {
2102         DBG_FUNC( "wl_module_exit" );
2103         DBG_ENTER(DbgInfo);
2104
2105         wl_adapter_cleanup_module( );
2106 #if 0 //SCULL_USE_PROC /* don't waste space if unused */
2107         remove_proc_entry( "wlags", NULL );             //;?why so a-symmetric compared to location of create_proc_read_entry
2108 #endif
2109
2110         DBG_LEAVE( DbgInfo );
2111         return;
2112 } // cleanup_module
2113 /*============================================================================*/
2114
2115 module_init(wl_module_init);
2116 module_exit(wl_module_exit);
2117
2118 /*******************************************************************************
2119  *      wl_isr()
2120  *******************************************************************************
2121  *
2122  *  DESCRIPTION:
2123  *
2124  *      The Interrupt Service Routine for the driver.
2125  *
2126  *  PARAMETERS:
2127  *
2128  *      irq     -   the irq the interrupt came in on
2129  *      dev_id  -   a buffer containing information about the request
2130  *      regs    -
2131  *
2132  *  RETURNS:
2133  *
2134  *      N/A
2135  *
2136  ******************************************************************************/
2137 irqreturn_t wl_isr( int irq, void *dev_id, struct pt_regs *regs )
2138 {
2139         int                 events;
2140         struct net_device   *dev = (struct net_device *) dev_id;
2141         struct wl_private   *lp = NULL;
2142         /*------------------------------------------------------------------------*/
2143         if (( dev == NULL ) || ( !netif_device_present( dev ))) {
2144                 return IRQ_NONE;
2145         }
2146
2147         /* Set the wl_private pointer (lp), now that we know that dev is non-null */
2148         lp = wl_priv(dev);
2149
2150 #ifdef USE_RTS
2151         if ( lp->useRTS == 1 ) {
2152                 DBG_PRINT( "EXITING ISR, IN RTS MODE...\n" );
2153                 return;
2154                 }
2155 #endif  /* USE_RTS */
2156
2157         /* If we have interrupts pending, then put them on a system task
2158            queue. Otherwise turn interrupts back on */
2159         events = hcf_action( &lp->hcfCtx, HCF_ACT_INT_OFF );
2160
2161         if ( events == HCF_INT_PENDING ) {
2162                 /* Schedule the ISR handler as a bottom-half task in the
2163                    tq_immediate queue */
2164                 tasklet_schedule(&lp->task);
2165         } else {
2166                 //DBG_PRINT( "NOT OUR INTERRUPT\n" );
2167                 hcf_action( &lp->hcfCtx, HCF_ACT_INT_ON );
2168         }
2169
2170         return IRQ_RETVAL(events == HCF_INT_PENDING);
2171 } // wl_isr
2172 /*============================================================================*/
2173
2174
2175 /*******************************************************************************
2176  *      wl_isr_handler()
2177  *******************************************************************************
2178  *
2179  *  DESCRIPTION:
2180  *
2181  *      The ISR handler, scheduled to run in a deferred context by the ISR. This
2182  *      is where the ISR's work actually gets done.
2183  *
2184  *  PARAMETERS:
2185  *
2186  *      lp  - a pointer to the device's private adapter structure
2187  *
2188  *  RETURNS:
2189  *
2190  *      N/A
2191  *
2192  ******************************************************************************/
2193 #define WVLAN_MAX_INT_SERVICES  50
2194
2195 void wl_isr_handler( unsigned long p )
2196 {
2197         struct net_device       *dev;
2198         unsigned long           flags;
2199         bool_t                  stop = TRUE;
2200         int                     count;
2201         int                     result;
2202         struct wl_private       *lp = (struct wl_private *)p;
2203         /*------------------------------------------------------------------------*/
2204
2205         if ( lp == NULL ) {
2206                 DBG_PRINT( "wl_isr_handler  lp adapter pointer is NULL!!!\n" );
2207         } else {
2208                 wl_lock( lp, &flags );
2209
2210                 dev = (struct net_device *)lp->dev;
2211                 if ( dev != NULL && netif_device_present( dev ) ) stop = FALSE;
2212                 for( count = 0; stop == FALSE && count < WVLAN_MAX_INT_SERVICES; count++ ) {
2213                         stop = TRUE;
2214                         result = hcf_service_nic( &lp->hcfCtx,
2215                                                                           (wci_bufp)lp->lookAheadBuf,
2216                                                                           sizeof( lp->lookAheadBuf ));
2217                         if ( result == HCF_ERR_MIC ) {
2218                                 wl_wext_event_mic_failed( dev );        /* Send an event that MIC failed */
2219                                 //;?this seems wrong if HCF_ERR_MIC coincides with another event, stop gets FALSE
2220                                 //so why not do it always ;?
2221                         }
2222
2223 #ifndef USE_MBOX_SYNC
2224                         if ( lp->hcfCtx.IFB_MBInfoLen != 0 ) {  /* anything in the mailbox */
2225                                 wl_mbx( lp );
2226                                 stop = FALSE;
2227                         }
2228 #endif
2229                         /* Check for a Link status event */
2230                         if ( ( lp->hcfCtx.IFB_LinkStat & CFG_LINK_STAT_FW ) != 0 ) {
2231                                 wl_process_link_status( lp );
2232                                 stop = FALSE;
2233                         }
2234                         /* Check for probe response events */
2235                         if ( lp->ProbeResp.infoType != 0 &&
2236                                 lp->ProbeResp.infoType != 0xFFFF ) {
2237                                 wl_process_probe_response( lp );
2238                                 memset( &lp->ProbeResp, 0, sizeof( lp->ProbeResp ));
2239                                 lp->ProbeResp.infoType = 0xFFFF;
2240                                 stop = FALSE;
2241                         }
2242                         /* Check for updated record events */
2243                         if ( lp->updatedRecord.len != 0xFFFF ) {
2244                                 wl_process_updated_record( lp );
2245                                 lp->updatedRecord.len = 0xFFFF;
2246                                 stop = FALSE;
2247                         }
2248                         /* Check for association status events */
2249                         if ( lp->assoc_stat.len != 0xFFFF ) {
2250                                 wl_process_assoc_status( lp );
2251                                 lp->assoc_stat.len = 0xFFFF;
2252                                 stop = FALSE;
2253                         }
2254                         /* Check for security status events */
2255                         if ( lp->sec_stat.len != 0xFFFF ) {
2256                                 wl_process_security_status( lp );
2257                                 lp->sec_stat.len = 0xFFFF;
2258                                 stop = FALSE;
2259                         }
2260
2261 #ifdef ENABLE_DMA
2262                         if ( lp->use_dma ) {
2263                                 /* Check for DMA Rx packets */
2264                                 if ( lp->hcfCtx.IFB_DmaPackets & HREG_EV_RDMAD ) {
2265                                         wl_rx_dma( dev );
2266                                         stop = FALSE;
2267                                 }
2268                                 /* Return Tx DMA descriptors to host */
2269                                 if ( lp->hcfCtx.IFB_DmaPackets & HREG_EV_TDMAD ) {
2270                                         wl_pci_dma_hcf_reclaim_tx( lp );
2271                                         stop = FALSE;
2272                                 }
2273                         }
2274                         else
2275 #endif // ENABLE_DMA
2276                         {
2277                                 /* Check for Rx packets */
2278                                 if ( lp->hcfCtx.IFB_RxLen != 0 ) {
2279                                         wl_rx( dev );
2280                                         stop = FALSE;
2281                                 }
2282                                 /* Make sure that queued frames get sent */
2283                                 if ( wl_send( lp )) {
2284                                         stop = FALSE;
2285                                 }
2286                         }
2287                 }
2288                 /* We're done, so turn interrupts which were turned off in wl_isr, back on */
2289                 hcf_action( &lp->hcfCtx, HCF_ACT_INT_ON );
2290                 wl_unlock( lp, &flags );
2291         }
2292         return;
2293 } // wl_isr_handler
2294 /*============================================================================*/
2295
2296
2297 /*******************************************************************************
2298  *      wl_remove()
2299  *******************************************************************************
2300  *
2301  *  DESCRIPTION:
2302  *
2303  *      Notify the adapter that it has been removed. Since the adapter is gone,
2304  *  we should no longer try to talk to it.
2305  *
2306  *  PARAMETERS:
2307  *
2308  *      dev - a pointer to the device's net_device structure
2309  *
2310  *  RETURNS:
2311  *
2312  *      N/A
2313  *
2314  ******************************************************************************/
2315 void wl_remove( struct net_device *dev )
2316 {
2317         struct wl_private   *lp = wl_priv(dev);
2318         unsigned long   flags;
2319         /*------------------------------------------------------------------------*/
2320         DBG_FUNC( "wl_remove" );
2321         DBG_ENTER( DbgInfo );
2322
2323         DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
2324
2325         wl_lock( lp, &flags );
2326
2327         /* stop handling interrupts */
2328         wl_act_int_off( lp );
2329         lp->is_handling_int = WL_NOT_HANDLING_INT;
2330
2331         /*
2332          * Disable the ports: just change state: since the
2333          * card is gone it is useless to talk to it and at
2334          * disconnect all state information is lost anyway.
2335          */
2336         /* Reset portState */
2337         lp->portState = WVLAN_PORT_STATE_DISABLED;
2338
2339 #if 0 //;? (HCF_TYPE) & HCF_TYPE_AP
2340 #ifdef USE_WDS
2341         //wl_disable_wds_ports( lp );
2342 #endif // USE_WDS
2343 #endif  /* (HCF_TYPE) & HCF_TYPE_AP */
2344
2345         /* Mark the device as unregistered */
2346         lp->is_registered = FALSE;
2347
2348         /* Deregister the WDS ports as well */
2349         WL_WDS_NETDEV_DEREGISTER( lp );
2350 #ifdef USE_RTS
2351         if ( lp->useRTS == 1 ) {
2352                 wl_unlock( lp, &flags );
2353
2354                 DBG_LEAVE( DbgInfo );
2355                 return;
2356         }
2357 #endif  /* USE_RTS */
2358
2359         /* Inform the HCF that the card has been removed */
2360         hcf_connect( &lp->hcfCtx, HCF_DISCONNECT );
2361
2362         wl_unlock( lp, &flags );
2363
2364         DBG_LEAVE( DbgInfo );
2365         return;
2366 } // wl_remove
2367 /*============================================================================*/
2368
2369
2370 /*******************************************************************************
2371  *      wl_suspend()
2372  *******************************************************************************
2373  *
2374  *  DESCRIPTION:
2375  *
2376  *      Power-down and halt the adapter.
2377  *
2378  *  PARAMETERS:
2379  *
2380  *      dev - a pointer to the device's net_device structure
2381  *
2382  *  RETURNS:
2383  *
2384  *      N/A
2385  *
2386  ******************************************************************************/
2387 void wl_suspend( struct net_device *dev )
2388 {
2389         struct wl_private  *lp = wl_priv(dev);
2390         unsigned long   flags;
2391         /*------------------------------------------------------------------------*/
2392         DBG_FUNC( "wl_suspend" );
2393         DBG_ENTER( DbgInfo );
2394
2395         DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
2396
2397         /* The adapter is suspended:
2398                         Stop the adapter
2399                         Power down
2400         */
2401         wl_lock( lp, &flags );
2402
2403         /* Disable interrupt handling */
2404         wl_act_int_off( lp );
2405
2406         /* Disconnect */
2407         wl_disconnect( lp );
2408
2409         /* Disable */
2410         wl_disable( lp );
2411
2412         /* Disconnect from the adapter */
2413         hcf_connect( &lp->hcfCtx, HCF_DISCONNECT );
2414
2415         /* Reset portState to be sure (should have been done by wl_disable */
2416         lp->portState = WVLAN_PORT_STATE_DISABLED;
2417
2418         wl_unlock( lp, &flags );
2419
2420         DBG_LEAVE( DbgInfo );
2421         return;
2422 } // wl_suspend
2423 /*============================================================================*/
2424
2425
2426 /*******************************************************************************
2427  *      wl_resume()
2428  *******************************************************************************
2429  *
2430  *  DESCRIPTION:
2431  *
2432  *      Resume a previously suspended adapter.
2433  *
2434  *  PARAMETERS:
2435  *
2436  *      dev - a pointer to the device's net_device structure
2437  *
2438  *  RETURNS:
2439  *
2440  *      N/A
2441  *
2442  ******************************************************************************/
2443 void wl_resume(struct net_device *dev)
2444 {
2445         struct wl_private  *lp = wl_priv(dev);
2446         unsigned long   flags;
2447         /*------------------------------------------------------------------------*/
2448         DBG_FUNC( "wl_resume" );
2449         DBG_ENTER( DbgInfo );
2450
2451         DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
2452
2453         wl_lock( lp, &flags );
2454
2455         /* Connect to the adapter */
2456         hcf_connect( &lp->hcfCtx, dev->base_addr );
2457
2458         /* Reset portState */
2459         lp->portState = WVLAN_PORT_STATE_DISABLED;
2460
2461         /* Power might have been off, assume the card lost the firmware*/
2462         lp->firmware_present = WL_FRIMWARE_NOT_PRESENT;
2463
2464         /* Reload the firmware and restart */
2465         wl_reset( dev );
2466
2467         /* Resume interrupt handling */
2468         wl_act_int_on( lp );
2469
2470         wl_unlock( lp, &flags );
2471
2472         DBG_LEAVE( DbgInfo );
2473         return;
2474 } // wl_resume
2475 /*============================================================================*/
2476
2477
2478 /*******************************************************************************
2479  *      wl_release()
2480  *******************************************************************************
2481  *
2482  *  DESCRIPTION:
2483  *
2484  *      This function perfroms a check on the device and calls wl_remove() if
2485  *  necessary. This function can be used for all bus types, but exists mostly
2486  *  for the benefit of the Card Services driver, as there are times when
2487  *  wl_remove() does not get called.
2488  *
2489  *  PARAMETERS:
2490  *
2491  *      dev - a pointer to the device's net_device structure
2492  *
2493  *  RETURNS:
2494  *
2495  *      N/A
2496  *
2497  ******************************************************************************/
2498 void wl_release( struct net_device *dev )
2499 {
2500         struct wl_private  *lp = wl_priv(dev);
2501         /*------------------------------------------------------------------------*/
2502         DBG_FUNC( "wl_release" );
2503         DBG_ENTER( DbgInfo );
2504
2505         DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
2506         /* If wl_remove() hasn't been called (i.e. when Card Services is shut
2507            down with the card in the slot), then call it */
2508         if ( lp->is_registered == TRUE ) {
2509                 DBG_TRACE( DbgInfo, "Calling unregister_netdev(), as it wasn't called yet\n" );
2510                 wl_remove( dev );
2511
2512                 lp->is_registered = FALSE;
2513         }
2514
2515         DBG_LEAVE( DbgInfo );
2516         return;
2517 } // wl_release
2518 /*============================================================================*/
2519
2520
2521 /*******************************************************************************
2522  *      wl_get_irq_mask()
2523  *******************************************************************************
2524  *
2525  *  DESCRIPTION:
2526  *
2527  *      Accessor function to retrieve the irq_mask module parameter
2528  *
2529  *  PARAMETERS:
2530  *
2531  *      N/A
2532  *
2533  *  RETURNS:
2534  *
2535  *      The irq_mask module parameter
2536  *
2537  ******************************************************************************/
2538 p_u16 wl_get_irq_mask( void )
2539 {
2540         return irq_mask;
2541 } // wl_get_irq_mask
2542 /*============================================================================*/
2543
2544
2545 /*******************************************************************************
2546  *      wl_get_irq_list()
2547  *******************************************************************************
2548  *
2549  *  DESCRIPTION:
2550  *
2551  *      Accessor function to retrieve the irq_list module parameter
2552  *
2553  *  PARAMETERS:
2554  *
2555  *      N/A
2556  *
2557  *  RETURNS:
2558  *
2559  *      The irq_list module parameter
2560  *
2561  ******************************************************************************/
2562 p_s8 * wl_get_irq_list( void )
2563 {
2564         return irq_list;
2565 } // wl_get_irq_list
2566 /*============================================================================*/
2567
2568
2569
2570 /*******************************************************************************
2571  *      wl_enable()
2572  *******************************************************************************
2573  *
2574  *  DESCRIPTION:
2575  *
2576  *      Used to enable MAC ports
2577  *
2578  *  PARAMETERS:
2579  *
2580  *      lp      - pointer to the device's private adapter structure
2581  *
2582  *  RETURNS:
2583  *
2584  *      N/A
2585  *
2586  ******************************************************************************/
2587 int wl_enable( struct wl_private *lp )
2588 {
2589         int hcf_status = HCF_SUCCESS;
2590         /*------------------------------------------------------------------------*/
2591         DBG_FUNC( "wl_enable" );
2592         DBG_ENTER( DbgInfo );
2593
2594         if ( lp->portState == WVLAN_PORT_STATE_ENABLED ) {
2595                 DBG_TRACE( DbgInfo, "No action: Card already enabled\n" );
2596         } else if ( lp->portState == WVLAN_PORT_STATE_CONNECTED ) {
2597                 //;?suspicuous logic, how can you be connected without being enabled so this is probably dead code
2598                 DBG_TRACE( DbgInfo, "No action: Card already connected\n" );
2599         } else {
2600                 hcf_status = hcf_cntl( &lp->hcfCtx, HCF_CNTL_ENABLE );
2601                 if ( hcf_status == HCF_SUCCESS ) {
2602                         /* Set the status of the NIC to enabled */
2603                         lp->portState = WVLAN_PORT_STATE_ENABLED;   //;?bad mnemonic, NIC iso PORT
2604 #ifdef ENABLE_DMA
2605                         if ( lp->use_dma ) {
2606                                 wl_pci_dma_hcf_supply( lp );  //;?always succes?
2607                         }
2608 #endif
2609                 }
2610         }
2611         if ( hcf_status != HCF_SUCCESS ) {  //;?make this an assert
2612                 DBG_TRACE( DbgInfo, "failed: 0x%x\n", hcf_status );
2613         }
2614         DBG_LEAVE( DbgInfo );
2615         return hcf_status;
2616 } // wl_enable
2617 /*============================================================================*/
2618
2619
2620 #ifdef USE_WDS
2621 /*******************************************************************************
2622  *      wl_enable_wds_ports()
2623  *******************************************************************************
2624  *
2625  *  DESCRIPTION:
2626  *
2627  *      Used to enable the WDS MAC ports 1-6
2628  *
2629  *  PARAMETERS:
2630  *
2631  *      lp      - pointer to the device's private adapter structure
2632  *
2633  *  RETURNS:
2634  *
2635  *      N/A
2636  *
2637  ******************************************************************************/
2638 void wl_enable_wds_ports( struct wl_private * lp )
2639 {
2640
2641         DBG_FUNC( "wl_enable_wds_ports" );
2642         DBG_ENTER( DbgInfo );
2643         if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP  ){
2644                 DBG_ERROR( DbgInfo, "!!!!;? someone misunderstood something !!!!!\n" );
2645         }
2646         DBG_LEAVE( DbgInfo );
2647         return;
2648 } // wl_enable_wds_ports
2649 #endif  /* USE_WDS */
2650 /*============================================================================*/
2651
2652
2653 /*******************************************************************************
2654  *      wl_connect()
2655  *******************************************************************************
2656  *
2657  *  DESCRIPTION:
2658  *
2659  *      Used to connect a MAC port
2660  *
2661  *  PARAMETERS:
2662  *
2663  *      lp      - pointer to the device's private adapter structure
2664  *
2665  *  RETURNS:
2666  *
2667  *      N/A
2668  *
2669  ******************************************************************************/
2670 int wl_connect( struct wl_private *lp )
2671 {
2672         int hcf_status;
2673         /*------------------------------------------------------------------------*/
2674
2675         DBG_FUNC( "wl_connect" );
2676         DBG_ENTER( DbgInfo );
2677
2678         if ( lp->portState != WVLAN_PORT_STATE_ENABLED ) {
2679                 DBG_TRACE( DbgInfo, "No action: Not in enabled state\n" );
2680                 DBG_LEAVE( DbgInfo );
2681                 return HCF_SUCCESS;
2682         }
2683         hcf_status = hcf_cntl( &lp->hcfCtx, HCF_CNTL_CONNECT );
2684         if ( hcf_status == HCF_SUCCESS ) {
2685                 lp->portState = WVLAN_PORT_STATE_CONNECTED;
2686         }
2687         DBG_LEAVE( DbgInfo );
2688         return hcf_status;
2689 } // wl_connect
2690 /*============================================================================*/
2691
2692
2693 /*******************************************************************************
2694  *      wl_disconnect()
2695  *******************************************************************************
2696  *
2697  *  DESCRIPTION:
2698  *
2699  *      Used to disconnect a MAC port
2700  *
2701  *  PARAMETERS:
2702  *
2703  *      lp      - pointer to the device's private adapter structure
2704  *
2705  *  RETURNS:
2706  *
2707  *      N/A
2708  *
2709  ******************************************************************************/
2710 int wl_disconnect( struct wl_private *lp )
2711 {
2712         int hcf_status;
2713         /*------------------------------------------------------------------------*/
2714
2715         DBG_FUNC( "wl_disconnect" );
2716         DBG_ENTER( DbgInfo );
2717
2718         if ( lp->portState != WVLAN_PORT_STATE_CONNECTED ) {
2719                 DBG_TRACE( DbgInfo, "No action: Not in connected state\n" );
2720                 DBG_LEAVE( DbgInfo );
2721                 return HCF_SUCCESS;
2722         }
2723         hcf_status = hcf_cntl( &lp->hcfCtx, HCF_CNTL_DISCONNECT );
2724         if ( hcf_status == HCF_SUCCESS ) {
2725                 lp->portState = WVLAN_PORT_STATE_ENABLED;
2726         }
2727         DBG_LEAVE( DbgInfo );
2728         return hcf_status;
2729 } // wl_disconnect
2730 /*============================================================================*/
2731
2732
2733 /*******************************************************************************
2734  *      wl_disable()
2735  *******************************************************************************
2736  *
2737  *  DESCRIPTION:
2738  *
2739  *      Used to disable MAC ports
2740  *
2741  *  PARAMETERS:
2742  *
2743  *      lp      - pointer to the device's private adapter structure
2744  *      port    - the MAC port to disable
2745  *
2746  *  RETURNS:
2747  *
2748  *      N/A
2749  *
2750  ******************************************************************************/
2751 int wl_disable( struct wl_private *lp )
2752 {
2753         int hcf_status = HCF_SUCCESS;
2754         /*------------------------------------------------------------------------*/
2755         DBG_FUNC( "wl_disable" );
2756         DBG_ENTER( DbgInfo );
2757
2758         if ( lp->portState == WVLAN_PORT_STATE_DISABLED ) {
2759                 DBG_TRACE( DbgInfo, "No action: Port state is disabled\n" );
2760         } else {
2761                 hcf_status = hcf_cntl( &lp->hcfCtx, HCF_CNTL_DISABLE );
2762                 if ( hcf_status == HCF_SUCCESS ) {
2763                         /* Set the status of the port to disabled */ //;?bad mnemonic use NIC iso PORT
2764                         lp->portState = WVLAN_PORT_STATE_DISABLED;
2765
2766 #ifdef ENABLE_DMA
2767                         if ( lp->use_dma ) {
2768                                 wl_pci_dma_hcf_reclaim( lp );
2769                         }
2770 #endif
2771                 }
2772         }
2773         if ( hcf_status != HCF_SUCCESS ) {
2774                 DBG_TRACE( DbgInfo, "failed: 0x%x\n", hcf_status );
2775         }
2776         DBG_LEAVE( DbgInfo );
2777         return hcf_status;
2778 } // wl_disable
2779 /*============================================================================*/
2780
2781
2782 #ifdef USE_WDS
2783 /*******************************************************************************
2784  *      wl_disable_wds_ports()
2785  *******************************************************************************
2786  *
2787  *  DESCRIPTION:
2788  *
2789  *      Used to disable the WDS MAC ports 1-6
2790  *
2791  *  PARAMETERS:
2792  *
2793  *      lp      - pointer to the device's private adapter structure
2794  *
2795  *  RETURNS:
2796  *
2797  *      N/A
2798  *
2799  ******************************************************************************/
2800 void wl_disable_wds_ports( struct wl_private * lp )
2801 {
2802
2803         DBG_FUNC( "wl_disable_wds_ports" );
2804         DBG_ENTER( DbgInfo );
2805
2806         if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP  ){
2807                 DBG_ERROR( DbgInfo, "!!!!;? someone misunderstood something !!!!!\n" );
2808         }
2809 //      if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP  ) {
2810 //              wl_disable( lp, HCF_PORT_1 );
2811 //              wl_disable( lp, HCF_PORT_2 );
2812 //              wl_disable( lp, HCF_PORT_3 );
2813 //              wl_disable( lp, HCF_PORT_4 );
2814 //              wl_disable( lp, HCF_PORT_5 );
2815 //              wl_disable( lp, HCF_PORT_6 );
2816 //      }
2817         DBG_LEAVE( DbgInfo );
2818         return;
2819 } // wl_disable_wds_ports
2820 #endif // USE_WDS
2821 /*============================================================================*/
2822
2823
2824 #ifndef USE_MBOX_SYNC
2825 /*******************************************************************************
2826  *      wl_mbx()
2827  *******************************************************************************
2828  *
2829  *  DESCRIPTION:
2830  *      This function is used to read and process a mailbox message.
2831  *
2832  *
2833  *  PARAMETERS:
2834  *
2835  *      lp      - pointer to the device's private adapter structure
2836  *
2837  *  RETURNS:
2838  *
2839  *      an HCF status code
2840  *
2841  ******************************************************************************/
2842 int wl_mbx( struct wl_private *lp )
2843 {
2844         int hcf_status = HCF_SUCCESS;
2845         /*------------------------------------------------------------------------*/
2846         DBG_FUNC( "wl_mbx" );
2847         DBG_ENTER( DbgInfo );
2848         DBG_TRACE( DbgInfo, "Mailbox Info: IFB_MBInfoLen: %d\n",
2849                            lp->hcfCtx.IFB_MBInfoLen );
2850
2851         memset( &( lp->ltvRecord ), 0, sizeof( ltv_t ));
2852
2853         lp->ltvRecord.len = MB_SIZE;
2854         lp->ltvRecord.typ = CFG_MB_INFO;
2855         hcf_status = hcf_get_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
2856
2857         if ( hcf_status != HCF_SUCCESS ) {
2858                 DBG_ERROR( DbgInfo, "hcf_get_info returned 0x%x\n", hcf_status );
2859
2860                 DBG_LEAVE( DbgInfo );
2861                 return hcf_status;
2862         }
2863
2864         if ( lp->ltvRecord.typ == CFG_MB_INFO ) {
2865                 DBG_LEAVE( DbgInfo );
2866                 return hcf_status;
2867         }
2868         /* Endian translate the mailbox data, then process the message */
2869         wl_endian_translate_mailbox( &( lp->ltvRecord ));
2870         wl_process_mailbox( lp );
2871         DBG_LEAVE( DbgInfo );
2872         return hcf_status;
2873 } // wl_mbx
2874 /*============================================================================*/
2875
2876
2877 /*******************************************************************************
2878  *      wl_endian_translate_mailbox()
2879  *******************************************************************************
2880  *
2881  *  DESCRIPTION:
2882  *
2883  *      This function will perform the tedious task of endian translating all
2884  *  fields withtin a mailbox message which need translating.
2885  *
2886  *  PARAMETERS:
2887  *
2888  *      ltv - pointer to the LTV to endian translate
2889  *
2890  *  RETURNS:
2891  *
2892  *      none
2893  *
2894  ******************************************************************************/
2895 void wl_endian_translate_mailbox( ltv_t *ltv )
2896 {
2897
2898         DBG_FUNC( "wl_endian_translate_mailbox" );
2899         DBG_ENTER( DbgInfo );
2900         switch( ltv->typ ) {
2901           case CFG_TALLIES:
2902                 break;
2903
2904           case CFG_SCAN:
2905                 {
2906                         int num_aps;
2907                         SCAN_RS_STRCT *aps = (SCAN_RS_STRCT *)&ltv->u.u8[0];
2908
2909                         num_aps = (hcf_16)(( (size_t)(ltv->len - 1 ) * 2 ) /
2910                                                                  ( sizeof( SCAN_RS_STRCT )));
2911
2912                         while( num_aps >= 1 ) {
2913                                 num_aps--;
2914
2915                                 aps[num_aps].channel_id =
2916                                         CNV_LITTLE_TO_INT( aps[num_aps].channel_id );
2917
2918                                 aps[num_aps].noise_level =
2919                                         CNV_LITTLE_TO_INT( aps[num_aps].noise_level );
2920
2921                                 aps[num_aps].signal_level =
2922                                         CNV_LITTLE_TO_INT( aps[num_aps].signal_level );
2923
2924                                 aps[num_aps].beacon_interval_time =
2925                                         CNV_LITTLE_TO_INT( aps[num_aps].beacon_interval_time );
2926
2927                                 aps[num_aps].capability =
2928                                         CNV_LITTLE_TO_INT( aps[num_aps].capability );
2929
2930                                 aps[num_aps].ssid_len =
2931                                         CNV_LITTLE_TO_INT( aps[num_aps].ssid_len );
2932
2933                                 aps[num_aps].ssid_val[aps[num_aps].ssid_len] = 0;
2934                         }
2935                 }
2936                 break;
2937
2938           case CFG_ACS_SCAN:
2939                 {
2940                         PROBE_RESP *probe_resp = (PROBE_RESP *)ltv;
2941
2942                         probe_resp->frameControl   = CNV_LITTLE_TO_INT( probe_resp->frameControl );
2943                         probe_resp->durID          = CNV_LITTLE_TO_INT( probe_resp->durID );
2944                         probe_resp->sequence       = CNV_LITTLE_TO_INT( probe_resp->sequence );
2945                         probe_resp->dataLength     = CNV_LITTLE_TO_INT( probe_resp->dataLength );
2946 #ifndef WARP
2947                         probe_resp->lenType        = CNV_LITTLE_TO_INT( probe_resp->lenType );
2948 #endif // WARP
2949                         probe_resp->beaconInterval = CNV_LITTLE_TO_INT( probe_resp->beaconInterval );
2950                         probe_resp->capability     = CNV_LITTLE_TO_INT( probe_resp->capability );
2951                         probe_resp->flags          = CNV_LITTLE_TO_INT( probe_resp->flags );
2952                 }
2953                 break;
2954
2955           case CFG_LINK_STAT:
2956 #define ls ((LINK_STATUS_STRCT *)ltv)
2957                         ls->linkStatus = CNV_LITTLE_TO_INT( ls->linkStatus );
2958                 break;
2959 #undef ls
2960
2961           case CFG_ASSOC_STAT:
2962                 {
2963                         ASSOC_STATUS_STRCT *as = (ASSOC_STATUS_STRCT *)ltv;
2964
2965                         as->assocStatus = CNV_LITTLE_TO_INT( as->assocStatus );
2966                 }
2967                 break;
2968
2969           case CFG_SECURITY_STAT:
2970                 {
2971                         SECURITY_STATUS_STRCT *ss = (SECURITY_STATUS_STRCT *)ltv;
2972
2973                         ss->securityStatus  = CNV_LITTLE_TO_INT( ss->securityStatus );
2974                         ss->reason          = CNV_LITTLE_TO_INT( ss->reason );
2975                 }
2976                 break;
2977
2978           case CFG_WMP:
2979                 break;
2980
2981           case CFG_NULL:
2982                 break;
2983
2984         default:
2985                 break;
2986         }
2987
2988         DBG_LEAVE( DbgInfo );
2989         return;
2990 } // wl_endian_translate_mailbox
2991 /*============================================================================*/
2992
2993 /*******************************************************************************
2994  *      wl_process_mailbox()
2995  *******************************************************************************
2996  *
2997  *  DESCRIPTION:
2998  *
2999  *      This function will process the mailbox data.
3000  *
3001  *  PARAMETERS:
3002  *
3003  *      ltv - pointer to the LTV to be processed.
3004  *
3005  *  RETURNS:
3006  *
3007  *      none
3008  *
3009  ******************************************************************************/
3010 void wl_process_mailbox( struct wl_private *lp )
3011 {
3012         ltv_t   *ltv;
3013         hcf_16  ltv_val = 0xFFFF;
3014         /*------------------------------------------------------------------------*/
3015         DBG_FUNC( "wl_process_mailbox" );
3016         DBG_ENTER( DbgInfo );
3017         ltv = &( lp->ltvRecord );
3018
3019         switch( ltv->typ ) {
3020
3021           case CFG_TALLIES:
3022                 DBG_TRACE( DbgInfo, "CFG_TALLIES\n" );
3023                 break;
3024           case CFG_SCAN:
3025                 DBG_TRACE( DbgInfo, "CFG_SCAN\n" );
3026
3027                 {
3028                         int num_aps;
3029                         SCAN_RS_STRCT *aps = (SCAN_RS_STRCT *)&ltv->u.u8[0];
3030
3031                         num_aps = (hcf_16)(( (size_t)(ltv->len - 1 ) * 2 ) /
3032                                                                  ( sizeof( SCAN_RS_STRCT )));
3033
3034                         lp->scan_results.num_aps = num_aps;
3035
3036                         DBG_TRACE( DbgInfo, "Number of APs: %d\n", num_aps );
3037
3038                         while( num_aps >= 1 ) {
3039                                 num_aps--;
3040
3041                                 DBG_TRACE( DbgInfo, "AP              : %d\n", num_aps );
3042                                 DBG_TRACE( DbgInfo, "=========================\n" );
3043                                 DBG_TRACE( DbgInfo, "Channel ID      : 0x%04x\n",
3044                                                    aps[num_aps].channel_id );
3045                                 DBG_TRACE( DbgInfo, "Noise Level     : 0x%04x\n",
3046                                                    aps[num_aps].noise_level );
3047                                 DBG_TRACE( DbgInfo, "Signal Level    : 0x%04x\n",
3048                                                    aps[num_aps].signal_level );
3049                                 DBG_TRACE( DbgInfo, "Beacon Interval : 0x%04x\n",
3050                                                    aps[num_aps].beacon_interval_time );
3051                                 DBG_TRACE( DbgInfo, "Capability      : 0x%04x\n",
3052                                                    aps[num_aps].capability );
3053                                 DBG_TRACE( DbgInfo, "SSID Length     : 0x%04x\n",
3054                                                    aps[num_aps].ssid_len );
3055                                 DBG_TRACE( DbgInfo, "BSSID           : %s\n",
3056                                                    DbgHwAddr( aps[num_aps].bssid ));
3057
3058                                 if ( aps[num_aps].ssid_len != 0 ) {
3059                                         DBG_TRACE( DbgInfo, "SSID            : %s.\n",
3060                                                            aps[num_aps].ssid_val );
3061                                 } else {
3062                                         DBG_TRACE( DbgInfo, "SSID            : %s.\n", "ANY" );
3063                                 }
3064
3065                                 DBG_TRACE( DbgInfo, "\n" );
3066
3067                                 /* Copy the info to the ScanResult structure in the private
3068                                    adapter struct */
3069                                 memcpy( &( lp->scan_results.APTable[num_aps]), &( aps[num_aps] ),
3070                                                 sizeof( SCAN_RS_STRCT ));
3071                         }
3072
3073                         /* Set scan result to true so that any scan requests will
3074                            complete */
3075                         lp->scan_results.scan_complete = TRUE;
3076                 }
3077
3078                 break;
3079           case CFG_ACS_SCAN:
3080                 DBG_TRACE( DbgInfo, "CFG_ACS_SCAN\n" );
3081
3082                 {
3083                         PROBE_RESP  *probe_rsp = (PROBE_RESP *)ltv;
3084                         hcf_8       *wpa_ie = NULL;
3085                         hcf_16      wpa_ie_len = 0;
3086
3087                         DBG_TRACE( DbgInfo, "(%s) =========================\n",
3088                                            lp->dev->name );
3089
3090                         DBG_TRACE( DbgInfo, "(%s) length      : 0x%04x.\n",
3091                                            lp->dev->name, probe_rsp->length );
3092
3093                         if ( probe_rsp->length > 1 ) {
3094                                 DBG_TRACE( DbgInfo, "(%s) infoType    : 0x%04x.\n",
3095                                                    lp->dev->name, probe_rsp->infoType );
3096
3097                                 DBG_TRACE( DbgInfo, "(%s) signal      : 0x%02x.\n",
3098                                                    lp->dev->name, probe_rsp->signal );
3099
3100                                 DBG_TRACE( DbgInfo, "(%s) silence     : 0x%02x.\n",
3101                                                    lp->dev->name, probe_rsp->silence );
3102
3103                                 DBG_TRACE( DbgInfo, "(%s) rxFlow      : 0x%02x.\n",
3104                                                    lp->dev->name, probe_rsp->rxFlow );
3105
3106                                 DBG_TRACE( DbgInfo, "(%s) rate        : 0x%02x.\n",
3107                                                    lp->dev->name, probe_rsp->rate );
3108
3109                                 DBG_TRACE( DbgInfo, "(%s) frame cntl  : 0x%04x.\n",
3110                                                    lp->dev->name, probe_rsp->frameControl );
3111
3112                                 DBG_TRACE( DbgInfo, "(%s) durID       : 0x%04x.\n",
3113                                                    lp->dev->name, probe_rsp->durID );
3114
3115                                 DBG_TRACE( DbgInfo, "(%s) address1    : %s\n",
3116                                                    lp->dev->name, DbgHwAddr( probe_rsp->address1 ));
3117
3118                                 DBG_TRACE( DbgInfo, "(%s) address2    : %s\n",
3119                                                    lp->dev->name, DbgHwAddr( probe_rsp->address2 ));
3120
3121                                 DBG_TRACE( DbgInfo, "(%s) BSSID       : %s\n",
3122                                                    lp->dev->name, DbgHwAddr( probe_rsp->BSSID ));
3123
3124                                 DBG_TRACE( DbgInfo, "(%s) sequence    : 0x%04x.\n",
3125                                                    lp->dev->name, probe_rsp->sequence );
3126
3127                                 DBG_TRACE( DbgInfo, "(%s) address4    : %s\n",
3128                                                    lp->dev->name, DbgHwAddr( probe_rsp->address4 ));
3129
3130                                 DBG_TRACE( DbgInfo, "(%s) datalength  : 0x%04x.\n",
3131                                                    lp->dev->name, probe_rsp->dataLength );
3132
3133                                 DBG_TRACE( DbgInfo, "(%s) DA          : %s\n",
3134                                                    lp->dev->name, DbgHwAddr( probe_rsp->DA ));
3135
3136                                 DBG_TRACE( DbgInfo, "(%s) SA          : %s\n",
3137                                                    lp->dev->name, DbgHwAddr( probe_rsp->SA ));
3138
3139                                 //DBG_TRACE( DbgInfo, "(%s) lenType     : 0x%04x.\n",
3140                                 //           lp->dev->name, probe_rsp->lenType );
3141
3142                                 DBG_TRACE( DbgInfo, "(%s) timeStamp   : %s\n",
3143                                                    lp->dev->name, DbgHwAddr( probe_rsp->timeStamp ));
3144
3145                                 DBG_TRACE( DbgInfo, "(%s) beaconInt   : 0x%04x.\n",
3146                                                    lp->dev->name, probe_rsp->beaconInterval );
3147
3148                                 DBG_TRACE( DbgInfo, "(%s) capability  : 0x%04x.\n",
3149                                                    lp->dev->name, probe_rsp->capability );
3150
3151                                 DBG_TRACE( DbgInfo, "(%s) SSID len    : 0x%04x.\n",
3152                                                    lp->dev->name, probe_rsp->rawData[1] );
3153
3154                                 if ( probe_rsp->rawData[1] > 0 ) {
3155                                         char ssid[HCF_MAX_NAME_LEN];
3156
3157                                         memset( ssid, 0, sizeof( ssid ));
3158                                         strncpy( ssid, &probe_rsp->rawData[2],
3159                                                          probe_rsp->rawData[1] );
3160
3161                                         DBG_TRACE( DbgInfo, "(%s) SSID        : %s\n",
3162                                                            lp->dev->name, ssid );
3163                                 }
3164
3165                                 /* Parse out the WPA-IE, if one exists */
3166                                 wpa_ie = wl_parse_wpa_ie( probe_rsp, &wpa_ie_len );
3167                                 if ( wpa_ie != NULL ) {
3168                                         DBG_TRACE( DbgInfo, "(%s) WPA-IE      : %s\n",
3169                                         lp->dev->name, wl_print_wpa_ie( wpa_ie, wpa_ie_len ));
3170                                 }
3171
3172                                 DBG_TRACE( DbgInfo, "(%s) flags       : 0x%04x.\n",
3173                                                    lp->dev->name, probe_rsp->flags );
3174                         }
3175
3176                         DBG_TRACE( DbgInfo, "\n\n" );
3177                         /* If probe response length is 1, then the scan is complete */
3178                         if ( probe_rsp->length == 1 ) {
3179                                 DBG_TRACE( DbgInfo, "SCAN COMPLETE\n" );
3180                                 lp->probe_results.num_aps = lp->probe_num_aps;
3181                                 lp->probe_results.scan_complete = TRUE;
3182
3183                                 /* Reset the counter for the next scan request */
3184                                 lp->probe_num_aps = 0;
3185
3186                                 /* Send a wireless extensions event that the scan completed */
3187                                 wl_wext_event_scan_complete( lp->dev );
3188                         } else {
3189                                 /* Only copy to the table if the entry is unique; APs sometimes
3190                                    respond more than once to a probe */
3191                                 if ( lp->probe_num_aps == 0 ) {
3192                                         /* Copy the info to the ScanResult structure in the private
3193                                         adapter struct */
3194                                         memcpy( &( lp->probe_results.ProbeTable[lp->probe_num_aps] ),
3195                                                         probe_rsp, sizeof( PROBE_RESP ));
3196
3197                                         /* Increment the number of APs detected */
3198                                         lp->probe_num_aps++;
3199                                 } else {
3200                                         int count;
3201                                         int unique = 1;
3202
3203                                         for( count = 0; count < lp->probe_num_aps; count++ ) {
3204                                                 if ( memcmp( &( probe_rsp->BSSID ),
3205                                                         lp->probe_results.ProbeTable[count].BSSID,
3206                                                         ETH_ALEN ) == 0 ) {
3207                                                         unique = 0;
3208                                                 }
3209                                         }
3210
3211                                         if ( unique ) {
3212                                                 /* Copy the info to the ScanResult structure in the
3213                                                 private adapter struct. Only copy if there's room in the
3214                                                 table */
3215                                                 if ( lp->probe_num_aps < MAX_NAPS )
3216                                                 {
3217                                                         memcpy( &( lp->probe_results.ProbeTable[lp->probe_num_aps] ),
3218                                                                         probe_rsp, sizeof( PROBE_RESP ));
3219                                                 }
3220                                                 else
3221                                                 {
3222                                                         DBG_WARNING( DbgInfo, "Num of scan results exceeds storage, truncating\n" );
3223                                                 }
3224
3225                                                 /* Increment the number of APs detected. Note I do this
3226                                                    here even when I don't copy the probe response to the
3227                                                    buffer in order to detect the overflow condition */
3228                                                 lp->probe_num_aps++;
3229                                         }
3230                                 }
3231                         }
3232                 }
3233
3234                 break;
3235
3236           case CFG_LINK_STAT:
3237 #define ls ((LINK_STATUS_STRCT *)ltv)
3238                 DBG_TRACE( DbgInfo, "CFG_LINK_STAT\n" );
3239
3240                 switch( ls->linkStatus ) {
3241                   case 1:
3242                         DBG_TRACE( DbgInfo, "Link Status : Connected\n" );
3243                         wl_wext_event_ap( lp->dev );
3244                         break;
3245
3246                   case 2:
3247                         DBG_TRACE( DbgInfo, "Link Status : Disconnected\n"  );
3248                         break;
3249
3250                   case 3:
3251                         DBG_TRACE( DbgInfo, "Link Status : Access Point Change\n" );
3252                         break;
3253
3254                   case 4:
3255                         DBG_TRACE( DbgInfo, "Link Status : Access Point Out of Range\n" );
3256                         break;
3257
3258                   case 5:
3259                         DBG_TRACE( DbgInfo, "Link Status : Access Point In Range\n" );
3260                         break;
3261
3262                 default:
3263                         DBG_TRACE( DbgInfo, "Link Status : UNKNOWN (0x%04x)\n",
3264                                            ls->linkStatus );
3265                         break;
3266                 }
3267
3268                 break;
3269 #undef ls
3270
3271           case CFG_ASSOC_STAT:
3272                 DBG_TRACE( DbgInfo, "CFG_ASSOC_STAT\n" );
3273
3274                 {
3275                         ASSOC_STATUS_STRCT *as = (ASSOC_STATUS_STRCT *)ltv;
3276
3277                         switch( as->assocStatus ) {
3278                           case 1:
3279                                 DBG_TRACE( DbgInfo, "Association Status : STA Associated\n" );
3280                                 break;
3281
3282                           case 2:
3283                                 DBG_TRACE( DbgInfo, "Association Status : STA Reassociated\n" );
3284                                 break;
3285
3286                           case 3:
3287                                 DBG_TRACE( DbgInfo, "Association Status : STA Disassociated\n" );
3288                                 break;
3289
3290                         default:
3291                                 DBG_TRACE( DbgInfo, "Association Status : UNKNOWN (0x%04x)\n",
3292                                                    as->assocStatus );
3293                                 break;
3294                         }
3295
3296                         DBG_TRACE( DbgInfo, "STA Address        : %s\n",
3297                                            DbgHwAddr( as->staAddr ));
3298
3299                         if (( as->assocStatus == 2 )  && ( as->len == 8 )) {
3300                                 DBG_TRACE( DbgInfo, "Old AP Address     : %s\n",
3301                                                    DbgHwAddr( as->oldApAddr ));
3302                         }
3303                 }
3304
3305                 break;
3306
3307           case CFG_SECURITY_STAT:
3308                 DBG_TRACE( DbgInfo, "CFG_SECURITY_STAT\n" );
3309
3310                 {
3311                         SECURITY_STATUS_STRCT *ss = (SECURITY_STATUS_STRCT *)ltv;
3312
3313                         switch( ss->securityStatus ) {
3314                           case 1:
3315                                 DBG_TRACE( DbgInfo, "Security Status : Dissassociate [AP]\n" );
3316                                 break;
3317
3318                           case 2:
3319                                 DBG_TRACE( DbgInfo, "Security Status : Deauthenticate [AP]\n" );
3320                                 break;
3321
3322                           case 3:
3323                                 DBG_TRACE( DbgInfo, "Security Status : Authenticate Fail [STA] or [AP]\n" );
3324                                 break;
3325
3326                           case 4:
3327                                 DBG_TRACE( DbgInfo, "Security Status : MIC Fail\n" );
3328                                 break;
3329
3330                           case 5:
3331                                 DBG_TRACE( DbgInfo, "Security Status : Associate Fail\n" );
3332                                 break;
3333
3334                         default:
3335                                 DBG_TRACE( DbgInfo, "Security Status : UNKNOWN %d\n",
3336                                                    ss->securityStatus );
3337                                 break;
3338                         }
3339
3340                         DBG_TRACE( DbgInfo, "STA Address     : %s\n", DbgHwAddr( ss->staAddr ));
3341
3342                         DBG_TRACE( DbgInfo, "Reason          : 0x%04x \n", ss->reason );
3343                 }
3344
3345                 break;
3346
3347           case CFG_WMP:
3348                 DBG_TRACE( DbgInfo, "CFG_WMP, size is %d bytes\n", ltv->len );
3349                 {
3350                         WMP_RSP_STRCT *wmp_rsp = (WMP_RSP_STRCT *)ltv;
3351
3352                         DBG_TRACE( DbgInfo, "CFG_WMP, pdu type is 0x%x\n",
3353                                            wmp_rsp->wmpRsp.wmpHdr.type );
3354
3355                         switch( wmp_rsp->wmpRsp.wmpHdr.type ) {
3356                           case WVLAN_WMP_PDU_TYPE_LT_RSP:
3357                                 {
3358 #if DBG
3359                                         LINKTEST_RSP_STRCT  *lt_rsp = (LINKTEST_RSP_STRCT *)ltv;
3360 #endif // DBG
3361                                         DBG_TRACE( DbgInfo, "LINK TEST RESULT\n" );
3362                                         DBG_TRACE( DbgInfo, "================\n" );
3363                                         DBG_TRACE( DbgInfo, "Length        : %d.\n",     lt_rsp->len );
3364
3365                                         DBG_TRACE( DbgInfo, "Name          : %s.\n",     lt_rsp->ltRsp.ltRsp.name );
3366                                         DBG_TRACE( DbgInfo, "Signal Level  : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.signal );
3367                                         DBG_TRACE( DbgInfo, "Noise  Level  : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.noise );
3368                                         DBG_TRACE( DbgInfo, "Receive Flow  : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.rxFlow );
3369                                         DBG_TRACE( DbgInfo, "Data Rate     : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.dataRate );
3370                                         DBG_TRACE( DbgInfo, "Protocol      : 0x%04x.\n", lt_rsp->ltRsp.ltRsp.protocol );
3371                                         DBG_TRACE( DbgInfo, "Station       : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.station );
3372                                         DBG_TRACE( DbgInfo, "Data Rate Cap : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.dataRateCap );
3373
3374                                         DBG_TRACE( DbgInfo, "Power Mgmt    : 0x%02x 0x%02x 0x%02x 0x%02x.\n",
3375                                                                 lt_rsp->ltRsp.ltRsp.powerMgmt[0],
3376                                                                 lt_rsp->ltRsp.ltRsp.powerMgmt[1],
3377                                                                 lt_rsp->ltRsp.ltRsp.powerMgmt[2],
3378                                                                 lt_rsp->ltRsp.ltRsp.powerMgmt[3] );
3379
3380                                         DBG_TRACE( DbgInfo, "Robustness    : 0x%02x 0x%02x 0x%02x 0x%02x.\n",
3381                                                                 lt_rsp->ltRsp.ltRsp.robustness[0],
3382                                                                 lt_rsp->ltRsp.ltRsp.robustness[1],
3383                                                                 lt_rsp->ltRsp.ltRsp.robustness[2],
3384                                                                 lt_rsp->ltRsp.ltRsp.robustness[3] );
3385
3386                                         DBG_TRACE( DbgInfo, "Scaling       : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.scaling );
3387                                 }
3388
3389                                 break;
3390
3391                         default:
3392                                 break;
3393                         }
3394                 }
3395
3396                 break;
3397
3398           case CFG_NULL:
3399                 DBG_TRACE( DbgInfo, "CFG_NULL\n" );
3400                 break;
3401
3402           case CFG_UPDATED_INFO_RECORD:        // Updated Information Record
3403                 DBG_TRACE( DbgInfo, "UPDATED INFORMATION RECORD\n" );
3404
3405                 ltv_val = CNV_INT_TO_LITTLE( ltv->u.u16[0] );
3406
3407                 /* Check and see which RID was updated */
3408                 switch( ltv_val ) {
3409                   case CFG_CUR_COUNTRY_INFO:  // Indicate Passive Scan Completion
3410                         DBG_TRACE( DbgInfo, "Updated country info\n" );
3411
3412                         /* Do I need to hold off on updating RIDs until the process is
3413                            complete? */
3414                         wl_connect( lp );
3415                         break;
3416
3417                   case CFG_PORT_STAT:    // Wait for Connect Event
3418                         //wl_connect( lp );
3419
3420                         break;
3421
3422                 default:
3423                         DBG_WARNING( DbgInfo, "Unknown RID: 0x%04x\n", ltv_val );
3424                 }
3425
3426                 break;
3427
3428         default:
3429                 DBG_TRACE( DbgInfo, "UNKNOWN MESSAGE: 0x%04x\n", ltv->typ );
3430                 break;
3431         }
3432         DBG_LEAVE( DbgInfo );
3433         return;
3434 } // wl_process_mailbox
3435 /*============================================================================*/
3436 #endif  /* ifndef USE_MBOX_SYNC */
3437
3438 #ifdef USE_WDS
3439 /*******************************************************************************
3440  *      wl_wds_netdev_register()
3441  *******************************************************************************
3442  *
3443  *  DESCRIPTION:
3444  *
3445  *      This function registers net_device structures with the system's network
3446  *      layer for use with the WDS ports.
3447  *
3448  *
3449  *  PARAMETERS:
3450  *
3451  *      lp      - pointer to the device's private adapter structure
3452  *
3453  *  RETURNS:
3454  *
3455  *      N/A
3456  *
3457  ******************************************************************************/
3458 void wl_wds_netdev_register( struct wl_private *lp )
3459 {
3460         int count;
3461         /*------------------------------------------------------------------------*/
3462         DBG_FUNC( "wl_wds_netdev_register" );
3463         DBG_ENTER( DbgInfo );
3464         //;?why is there no USE_WDS clause like in wl_enable_wds_ports
3465         if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP  ) {
3466                 for( count = 0; count < NUM_WDS_PORTS; count++ ) {
3467                         if ( WVLAN_VALID_MAC_ADDRESS( lp->wds_port[count].wdsAddress )) {
3468                                 if ( register_netdev( lp->wds_port[count].dev ) != 0 ) {
3469                                         DBG_WARNING( DbgInfo, "net device for WDS port %d could not be registered\n",
3470                                                                 ( count + 1 ));
3471                                 }
3472                                 lp->wds_port[count].is_registered = TRUE;
3473
3474                                 /* Fill out the net_device structs with the MAC addr */
3475                                 memcpy( lp->wds_port[count].dev->dev_addr, lp->MACAddress, ETH_ALEN );
3476                                 lp->wds_port[count].dev->addr_len = ETH_ALEN;
3477                         }
3478                 }
3479         }
3480         DBG_LEAVE( DbgInfo );
3481         return;
3482 } // wl_wds_netdev_register
3483 /*============================================================================*/
3484
3485
3486 /*******************************************************************************
3487  *      wl_wds_netdev_deregister()
3488  *******************************************************************************
3489  *
3490  *  DESCRIPTION:
3491  *
3492  *      This function deregisters the WDS net_device structures used by the
3493  *      system's network layer.
3494  *
3495  *
3496  *  PARAMETERS:
3497  *
3498  *      lp      - pointer to the device's private adapter structure
3499  *
3500  *  RETURNS:
3501  *
3502  *      N/A
3503  *
3504  ******************************************************************************/
3505 void wl_wds_netdev_deregister( struct wl_private *lp )
3506 {
3507         int count;
3508         /*------------------------------------------------------------------------*/
3509         DBG_FUNC( "wl_wds_netdev_deregister" );
3510         DBG_ENTER( DbgInfo );
3511         if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP  ) {
3512                 for( count = 0; count < NUM_WDS_PORTS; count++ ) {
3513                         if ( WVLAN_VALID_MAC_ADDRESS( lp->wds_port[count].wdsAddress )) {
3514                                 unregister_netdev( lp->wds_port[count].dev );
3515                         }
3516                         lp->wds_port[count].is_registered = FALSE;
3517                 }
3518         }
3519         DBG_LEAVE( DbgInfo );
3520         return;
3521 } // wl_wds_netdev_deregister
3522 /*============================================================================*/
3523 #endif  /* USE_WDS */
3524
3525
3526 #if 0 //SCULL_USE_PROC /* don't waste space if unused */
3527 /*
3528  * The proc filesystem: function to read and entry
3529  */
3530 int printf_hcf_16( char *s, char *buf, hcf_16* p, int n );
3531 int printf_hcf_16( char *s, char *buf, hcf_16* p, int n ) {
3532
3533 int i, len;
3534
3535         len = sprintf(buf, "%s", s );
3536         while ( len < 20 ) len += sprintf(buf+len, " " );
3537         len += sprintf(buf+len,": " );
3538         for ( i = 0; i < n; i++ ) {
3539                 if ( len % 80 > 75 ) {
3540                         len += sprintf(buf+len,"\n" );
3541                 }
3542                 len += sprintf(buf+len,"%04X ", p[i] );
3543         }
3544         len += sprintf(buf+len,"\n" );
3545         return len;
3546 } // printf_hcf_16
3547
3548 int printf_hcf_8( char *s, char *buf, hcf_8* p, int n );
3549 int printf_hcf_8( char *s, char *buf, hcf_8* p, int n ) {
3550
3551 int i, len;
3552
3553         len = sprintf(buf, "%s", s );
3554         while ( len < 20 ) len += sprintf(buf+len, " " );
3555         len += sprintf(buf+len,": " );
3556         for ( i = 0; i <= n; i++ ) {
3557                 if ( len % 80 > 77 ) {
3558                         len += sprintf(buf+len,"\n" );
3559                 }
3560                 len += sprintf(buf+len,"%02X ", p[i] );
3561         }
3562         len += sprintf(buf+len,"\n" );
3563         return len;
3564 } // printf_hcf8
3565
3566 int printf_strct( char *s, char *buf, hcf_16* p );
3567 int printf_strct( char *s, char *buf, hcf_16* p ) {
3568
3569 int i, len;
3570
3571         len = sprintf(buf, "%s", s );
3572         while ( len < 20 ) len += sprintf(buf+len, " " );
3573         len += sprintf(buf+len,": " );
3574         for ( i = 0; i <= *p; i++ ) {
3575                 if ( len % 80 > 75 ) {
3576                         len += sprintf(buf+len,"\n" );
3577                 }
3578                 len += sprintf(buf+len,"%04X ", p[i] );
3579         }
3580         len += sprintf(buf+len,"\n" );
3581         return len;
3582 } // printf_strct
3583
3584 int scull_read_procmem(char *buf, char **start, off_t offset, int len, int *eof, void *data )
3585 {
3586         struct wl_private       *lp = NULL;
3587         IFBP                            ifbp;
3588         CFG_HERMES_TALLIES_STRCT *p;
3589
3590     #define LIMIT (PAGE_SIZE-80) /* don't print any more after this size */
3591
3592     len=0;
3593
3594         lp = ((struct net_device *)data)->priv;
3595         if (lp == NULL) {
3596         len += sprintf(buf+len,"No wl_private in scull_read_procmem\n" );
3597         } else if ( lp->wlags49_type == 0 ){
3598             ifbp = &lp->hcfCtx;
3599             len += sprintf(buf+len,"Magic:               0x%04X\n", ifbp->IFB_Magic );
3600             len += sprintf(buf+len,"IOBase:              0x%04X\n", ifbp->IFB_IOBase );
3601             len += sprintf(buf+len,"LinkStat:            0x%04X\n", ifbp->IFB_LinkStat );
3602             len += sprintf(buf+len,"DSLinkStat:          0x%04X\n", ifbp->IFB_DSLinkStat );
3603             len += sprintf(buf+len,"TickIni:         0x%08lX\n", ifbp->IFB_TickIni );
3604             len += sprintf(buf+len,"TickCnt:             0x%04X\n", ifbp->IFB_TickCnt );
3605             len += sprintf(buf+len,"IntOffCnt:           0x%04X\n", ifbp->IFB_IntOffCnt );
3606                 len += printf_hcf_16( "IFB_FWIdentity", &buf[len],
3607                                                           &ifbp->IFB_FWIdentity.len, ifbp->IFB_FWIdentity.len + 1 );
3608         } else if ( lp->wlags49_type == 1 ) {
3609             len += sprintf(buf+len,"Channel:              0x%04X\n", lp->Channel );
3610 /****** len += sprintf(buf+len,"slock:                  %d\n", lp->slock );             */
3611 //x             struct tq_struct            "task:               0x%04X\n", lp->task );
3612 //x             struct net_device_stats     "stats:              0x%04X\n", lp->stats );
3613 #ifdef WIRELESS_EXT
3614 //x             struct iw_statistics        "wstats:             0x%04X\n", lp->wstats );
3615 //x         len += sprintf(buf+len,"spy_number:           0x%04X\n", lp->spy_number );
3616 //x             u_char                      spy_address[IW_MAX_SPY][ETH_ALEN];
3617 //x             struct iw_quality           spy_stat[IW_MAX_SPY];
3618 #endif // WIRELESS_EXT
3619             len += sprintf(buf+len,"IFB:                  0x%p\n", &lp->hcfCtx );
3620             len += sprintf(buf+len,"flags:                %#.8lX\n", lp->flags );  //;?use this format from now on
3621             len += sprintf(buf+len,"DebugFlag(wl_private) 0x%04X\n", lp->DebugFlag );
3622 #if DBG
3623             len += sprintf(buf+len,"DebugFlag (DbgInfo):   0x%08lX\n", DbgInfo->DebugFlag );
3624 #endif // DBG
3625             len += sprintf(buf+len,"is_registered:        0x%04X\n", lp->is_registered );
3626 //x             CFG_DRV_INFO_STRCT          "driverInfo:         0x%04X\n", lp->driverInfo );
3627                 len += printf_strct( "driverInfo", &buf[len], (hcf_16*)&lp->driverInfo );
3628 //x             CFG_IDENTITY_STRCT          "driverIdentity:     0x%04X\n", lp->driverIdentity );
3629                 len += printf_strct( "driverIdentity", &buf[len], (hcf_16*)&lp->driverIdentity );
3630 //x             CFG_FW_IDENTITY_STRCT       "StationIdentity:    0x%04X\n", lp->StationIdentity );
3631                 len += printf_strct( "StationIdentity", &buf[len], (hcf_16*)&lp->StationIdentity );
3632 //x             CFG_PRI_IDENTITY_STRCT      "PrimaryIdentity:    0x%04X\n", lp->PrimaryIdentity );
3633                 len += printf_strct( "PrimaryIdentity", &buf[len], (hcf_16*)&lp->hcfCtx.IFB_PRIIdentity );
3634                 len += printf_strct( "PrimarySupplier", &buf[len], (hcf_16*)&lp->hcfCtx.IFB_PRISup );
3635 //x             CFG_PRI_IDENTITY_STRCT      "NICIdentity:        0x%04X\n", lp->NICIdentity );
3636                 len += printf_strct( "NICIdentity", &buf[len], (hcf_16*)&lp->NICIdentity );
3637 //x             ltv_t                       "ltvRecord:          0x%04X\n", lp->ltvRecord );
3638             len += sprintf(buf+len,"txBytes:              0x%08lX\n", lp->txBytes );
3639             len += sprintf(buf+len,"maxPort:              0x%04X\n", lp->maxPort );        /* 0 for STA, 6 for AP */
3640         /* Elements used for async notification from hardware */
3641 //x             RID_LOG_STRCT                           RidList[10];
3642 //x             ltv_t                       "updatedRecord:      0x%04X\n", lp->updatedRecord );
3643 //x             PROBE_RESP                                  "ProbeResp:                    0x%04X\n", lp->ProbeResp );
3644 //x             ASSOC_STATUS_STRCT          "assoc_stat:         0x%04X\n", lp->assoc_stat );
3645 //x             SECURITY_STATUS_STRCT       "sec_stat:           0x%04X\n", lp->sec_stat );
3646 //x             u_char                      lookAheadBuf[WVLAN_MAX_LOOKAHEAD];
3647             len += sprintf(buf+len,"PortType:             0x%04X\n", lp->PortType );           // 1 - 3 (1 [Normal] | 3 [AdHoc])
3648             len += sprintf(buf+len,"Channel:              0x%04X\n", lp->Channel );            // 0 - 14 (0)
3649 //x             hcf_16                      TxRateControl[2];
3650             len += sprintf(buf+len,"TxRateControl[2]:     0x%04X 0x%04X\n",
3651                                                 lp->TxRateControl[0], lp->TxRateControl[1] );
3652             len += sprintf(buf+len,"DistanceBetweenAPs:   0x%04X\n", lp->DistanceBetweenAPs ); // 1 - 3 (1)
3653             len += sprintf(buf+len,"RTSThreshold:         0x%04X\n", lp->RTSThreshold );       // 0 - 2347 (2347)
3654             len += sprintf(buf+len,"PMEnabled:            0x%04X\n", lp->PMEnabled );          // 0 - 2, 8001 - 8002 (0)
3655             len += sprintf(buf+len,"MicrowaveRobustness:  0x%04X\n", lp->MicrowaveRobustness );// 0 - 1 (0)
3656             len += sprintf(buf+len,"CreateIBSS:           0x%04X\n", lp->CreateIBSS );         // 0 - 1 (0)
3657             len += sprintf(buf+len,"MulticastReceive:     0x%04X\n", lp->MulticastReceive );   // 0 - 1 (1)
3658             len += sprintf(buf+len,"MaxSleepDuration:     0x%04X\n", lp->MaxSleepDuration );   // 0 - 65535 (100)
3659 //x             hcf_8                       MACAddress[ETH_ALEN];
3660                 len += printf_hcf_8( "MACAddress", &buf[len], lp->MACAddress, ETH_ALEN );
3661 //x             char                        NetworkName[HCF_MAX_NAME_LEN+1];
3662             len += sprintf(buf+len,"NetworkName:          %.32s\n", lp->NetworkName );
3663 //x             char                        StationName[HCF_MAX_NAME_LEN+1];
3664             len += sprintf(buf+len,"EnableEncryption:     0x%04X\n", lp->EnableEncryption );   // 0 - 1 (0)
3665 //x             char                        Key1[MAX_KEY_LEN+1];
3666                 len += printf_hcf_8( "Key1", &buf[len], lp->Key1, MAX_KEY_LEN );
3667 //x             char                        Key2[MAX_KEY_LEN+1];
3668 //x             char                        Key3[MAX_KEY_LEN+1];
3669 //x             char                        Key4[MAX_KEY_LEN+1];
3670             len += sprintf(buf+len,"TransmitKeyID:        0x%04X\n", lp->TransmitKeyID );      // 1 - 4 (1)
3671 //x             CFG_DEFAULT_KEYS_STRCT      "DefaultKeys:         0x%04X\n", lp->DefaultKeys );
3672 //x             u_char                      mailbox[MB_SIZE];
3673 //x             char                        szEncryption[MAX_ENC_LEN];
3674             len += sprintf(buf+len,"driverEnable:         0x%04X\n", lp->driverEnable );
3675             len += sprintf(buf+len,"wolasEnable:          0x%04X\n", lp->wolasEnable );
3676             len += sprintf(buf+len,"atimWindow:           0x%04X\n", lp->atimWindow );
3677             len += sprintf(buf+len,"holdoverDuration:     0x%04X\n", lp->holdoverDuration );
3678 //x             hcf_16                      MulticastRate[2];
3679             len += sprintf(buf+len,"authentication:       0x%04X\n", lp->authentication ); // is this AP specific?
3680             len += sprintf(buf+len,"promiscuousMode:      0x%04X\n", lp->promiscuousMode );
3681             len += sprintf(buf+len,"DownloadFirmware:     0x%04X\n", lp->DownloadFirmware );   // 0 - 2 (0 [None] | 1 [STA] | 2 [AP])
3682             len += sprintf(buf+len,"AuthKeyMgmtSuite:     0x%04X\n", lp->AuthKeyMgmtSuite );
3683             len += sprintf(buf+len,"loadBalancing:        0x%04X\n", lp->loadBalancing );
3684             len += sprintf(buf+len,"mediumDistribution:   0x%04X\n", lp->mediumDistribution );
3685             len += sprintf(buf+len,"txPowLevel:           0x%04X\n", lp->txPowLevel );
3686 //          len += sprintf(buf+len,"shortRetryLimit:    0x%04X\n", lp->shortRetryLimit );
3687 //          len += sprintf(buf+len,"longRetryLimit:     0x%04X\n", lp->longRetryLimit );
3688 //x             hcf_16                      srsc[2];
3689 //x             hcf_16                      brsc[2];
3690             len += sprintf(buf+len,"connectionControl:    0x%04X\n", lp->connectionControl );
3691 //x             //hcf_16                      probeDataRates[2];
3692             len += sprintf(buf+len,"ownBeaconInterval:    0x%04X\n", lp->ownBeaconInterval );
3693             len += sprintf(buf+len,"coexistence:          0x%04X\n", lp->coexistence );
3694 //x             WVLAN_FRAME                 "txF:                0x%04X\n", lp->txF );
3695 //x             WVLAN_LFRAME                txList[DEFAULT_NUM_TX_FRAMES];
3696 //x             struct list_head            "txFree:             0x%04X\n", lp->txFree );
3697 //x             struct list_head            txQ[WVLAN_MAX_TX_QUEUES];
3698             len += sprintf(buf+len,"netif_queue_on:       0x%04X\n", lp->netif_queue_on );
3699             len += sprintf(buf+len,"txQ_count:            0x%04X\n", lp->txQ_count );
3700 //x             DESC_STRCT                  "desc_rx:            0x%04X\n", lp->desc_rx );
3701 //x             DESC_STRCT                  "desc_tx:            0x%04X\n", lp->desc_tx );
3702 //x             WVLAN_PORT_STATE            "portState:          0x%04X\n", lp->portState );
3703 //x             ScanResult                  "scan_results:       0x%04X\n", lp->scan_results );
3704 //x             ProbeResult                 "probe_results:      0x%04X\n", lp->probe_results );
3705             len += sprintf(buf+len,"probe_num_aps:        0x%04X\n", lp->probe_num_aps );
3706             len += sprintf(buf+len,"use_dma:              0x%04X\n", lp->use_dma );
3707 //x             DMA_STRCT                   "dma:                0x%04X\n", lp->dma );
3708 #ifdef USE_RTS
3709             len += sprintf(buf+len,"useRTS:               0x%04X\n", lp->useRTS );
3710 #endif  // USE_RTS
3711 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
3712                 //;?should we restore this to allow smaller memory footprint
3713                 //;?I guess not. This should be brought under Debug mode only
3714             len += sprintf(buf+len,"DTIMPeriod:           0x%04X\n", lp->DTIMPeriod );         // 1 - 255 (1)
3715             len += sprintf(buf+len,"multicastPMBuffering: 0x%04X\n", lp->multicastPMBuffering );
3716             len += sprintf(buf+len,"RejectAny:            0x%04X\n", lp->RejectAny );          // 0 - 1 (0)
3717             len += sprintf(buf+len,"ExcludeUnencrypted:   0x%04X\n", lp->ExcludeUnencrypted ); // 0 - 1 (1)
3718             len += sprintf(buf+len,"intraBSSRelay:        0x%04X\n", lp->intraBSSRelay );
3719             len += sprintf(buf+len,"wlags49_type:             0x%08lX\n", lp->wlags49_type );
3720 #ifdef USE_WDS
3721 //x             WVLAN_WDS_IF                wds_port[NUM_WDS_PORTS];
3722 #endif // USE_WDS
3723 #endif // HCF_AP
3724         } else if ( lp->wlags49_type == 2 ){
3725         len += sprintf(buf+len,"tallies to be added\n" );
3726 //Hermes Tallies (IFB substructure) {
3727             p = &lp->hcfCtx.IFB_NIC_Tallies;
3728         len += sprintf(buf+len,"TxUnicastFrames:          %08lX\n", p->TxUnicastFrames );
3729         len += sprintf(buf+len,"TxMulticastFrames:        %08lX\n", p->TxMulticastFrames );
3730         len += sprintf(buf+len,"TxFragments:              %08lX\n", p->TxFragments );
3731         len += sprintf(buf+len,"TxUnicastOctets:          %08lX\n", p->TxUnicastOctets );
3732         len += sprintf(buf+len,"TxMulticastOctets:        %08lX\n", p->TxMulticastOctets );
3733         len += sprintf(buf+len,"TxDeferredTransmissions:  %08lX\n", p->TxDeferredTransmissions );
3734         len += sprintf(buf+len,"TxSingleRetryFrames:      %08lX\n", p->TxSingleRetryFrames );
3735         len += sprintf(buf+len,"TxMultipleRetryFrames:    %08lX\n", p->TxMultipleRetryFrames );
3736         len += sprintf(buf+len,"TxRetryLimitExceeded:     %08lX\n", p->TxRetryLimitExceeded );
3737         len += sprintf(buf+len,"TxDiscards:               %08lX\n", p->TxDiscards );
3738         len += sprintf(buf+len,"RxUnicastFrames:          %08lX\n", p->RxUnicastFrames );
3739         len += sprintf(buf+len,"RxMulticastFrames:        %08lX\n", p->RxMulticastFrames );
3740         len += sprintf(buf+len,"RxFragments:              %08lX\n", p->RxFragments );
3741         len += sprintf(buf+len,"RxUnicastOctets:          %08lX\n", p->RxUnicastOctets );
3742         len += sprintf(buf+len,"RxMulticastOctets:        %08lX\n", p->RxMulticastOctets );
3743         len += sprintf(buf+len,"RxFCSErrors:              %08lX\n", p->RxFCSErrors );
3744         len += sprintf(buf+len,"RxDiscardsNoBuffer:       %08lX\n", p->RxDiscardsNoBuffer );
3745         len += sprintf(buf+len,"TxDiscardsWrongSA:        %08lX\n", p->TxDiscardsWrongSA );
3746         len += sprintf(buf+len,"RxWEPUndecryptable:       %08lX\n", p->RxWEPUndecryptable );
3747         len += sprintf(buf+len,"RxMsgInMsgFragments:      %08lX\n", p->RxMsgInMsgFragments );
3748         len += sprintf(buf+len,"RxMsgInBadMsgFragments:   %08lX\n", p->RxMsgInBadMsgFragments );
3749         len += sprintf(buf+len,"RxDiscardsWEPICVError:    %08lX\n", p->RxDiscardsWEPICVError );
3750         len += sprintf(buf+len,"RxDiscardsWEPExcluded:    %08lX\n", p->RxDiscardsWEPExcluded );
3751 #if (HCF_EXT) & HCF_EXT_TALLIES_FW
3752         //to be added ;?
3753 #endif // HCF_EXT_TALLIES_FW
3754         } else if ( lp->wlags49_type & 0x8000 ) {       //;?kludgy but it is unclear to me were else to place this
3755 #if DBG
3756                 DbgInfo->DebugFlag = lp->wlags49_type & 0x7FFF;
3757 #endif // DBG
3758                 lp->wlags49_type = 0;                           //default to IFB again ;?
3759         } else {
3760         len += sprintf(buf+len,"unknown value for wlags49_type: 0x%08lX\n", lp->wlags49_type );
3761         len += sprintf(buf+len,"0x0000 - IFB\n" );
3762         len += sprintf(buf+len,"0x0001 - wl_private\n" );
3763         len += sprintf(buf+len,"0x0002 - Tallies\n" );
3764         len += sprintf(buf+len,"0x8xxx - Change debufflag\n" );
3765         len += sprintf(buf+len,"ERROR    0001\nWARNING  0002\nNOTICE   0004\nTRACE    0008\n" );
3766         len += sprintf(buf+len,"VERBOSE  0010\nPARAM    0020\nBREAK    0040\nRX       0100\n" );
3767         len += sprintf(buf+len,"TX       0200\nDS       0400\n" );
3768         }
3769     return len;
3770 } // scull_read_procmem
3771
3772 static void proc_write(const char *name, write_proc_t *w, void *data)
3773 {
3774         struct proc_dir_entry * entry = create_proc_entry(name, S_IFREG | S_IWUSR, NULL);
3775         if (entry) {
3776                 entry->write_proc = w;
3777                 entry->data = data;
3778         }
3779 } // proc_write
3780
3781 static int write_int(struct file *file, const char *buffer, unsigned long count, void *data)
3782 {
3783         static char             proc_number[11];
3784         unsigned int    nr = 0;
3785
3786         DBG_FUNC( "write_int" );
3787         DBG_ENTER( DbgInfo );
3788
3789         if (count > 9) {
3790                 count = -EINVAL;
3791         } else if ( copy_from_user(proc_number, buffer, count) ) {
3792                 count = -EFAULT;
3793         }
3794         if  (count > 0 ) {
3795                 proc_number[count] = 0;
3796                 nr = simple_strtoul(proc_number , NULL, 0);
3797                 *(unsigned int *)data = nr;
3798                 if ( nr & 0x8000 ) {    //;?kludgy but it is unclear to me were else to place this
3799 #if DBG
3800                         DbgInfo->DebugFlag = nr & 0x7FFF;
3801 #endif // DBG
3802                 }
3803         }
3804         DBG_PRINT( "value: %08X\n", nr );
3805         DBG_LEAVE( DbgInfo );
3806         return count;
3807 } // write_int
3808
3809 #endif /* SCULL_USE_PROC */
3810
3811 #ifdef DN554
3812 #define RUN_AT(x)               (jiffies+(x))           //"borrowed" from include/pcmcia/k_compat.h
3813 #define DS_OOR  0x8000          //Deepsleep OutOfRange Status
3814
3815                 lp->timer_oor_cnt = DS_OOR;
3816                 init_timer( &lp->timer_oor );
3817                 lp->timer_oor.function = timer_oor;
3818                 lp->timer_oor.data = (unsigned long)lp;
3819                 lp->timer_oor.expires = RUN_AT( 3 * HZ );
3820                 add_timer( &lp->timer_oor );
3821                 printk( "<5>wl_enable: %ld\n", jiffies );               //;?remove me 1 day
3822 #endif //DN554
3823 #ifdef DN554
3824 /*******************************************************************************
3825  *      timer_oor()
3826  *******************************************************************************
3827  *
3828  *  DESCRIPTION:
3829  *
3830  *
3831  *  PARAMETERS:
3832  *
3833  *      arg - a u_long representing a pointer to a dev_link_t structure for the
3834  *            device to be released.
3835  *
3836  *  RETURNS:
3837  *
3838  *      N/A
3839  *
3840  ******************************************************************************/
3841 void timer_oor( u_long arg )
3842 {
3843         struct wl_private       *lp = (struct wl_private *)arg;
3844
3845     /*------------------------------------------------------------------------*/
3846
3847     DBG_FUNC( "timer_oor" );
3848     DBG_ENTER( DbgInfo );
3849     DBG_PARAM( DbgInfo, "arg", "0x%08lx", arg );
3850
3851         printk( "<5>timer_oor: %ld 0x%04X\n", jiffies, lp->timer_oor_cnt );             //;?remove me 1 day
3852         lp->timer_oor_cnt += 10;
3853     if ( (lp->timer_oor_cnt & ~DS_OOR) > 300 ) {
3854                 lp->timer_oor_cnt = 300;
3855         }
3856         lp->timer_oor_cnt |= DS_OOR;
3857         init_timer( &lp->timer_oor );
3858         lp->timer_oor.function = timer_oor;
3859         lp->timer_oor.data = (unsigned long)lp;
3860         lp->timer_oor.expires = RUN_AT( (lp->timer_oor_cnt & ~DS_OOR) * HZ );
3861         add_timer( &lp->timer_oor );
3862
3863     DBG_LEAVE( DbgInfo );
3864 } // timer_oor
3865 #endif //DN554
3866
3867 MODULE_LICENSE("Dual BSD/GPL");