recipes/pandora-system/pandora-wifi/0002-Add-in-the-start-of-wireless-extensions-support-ioct.patch

   1 From ff10751bd182684f71ac7f572c06fb1fc662e5e0 Mon Sep 17 00:00:00 2001
   2 From: David-John Willis <John.Willis@Distant-earth.com>
   3 Date: Tue, 3 Mar 2009 20:36:24 +0000
   4 Subject: [PATCH 2/5] Add in the start of wireless extensions support (ioctl stuff).
   5
   6 ---
   7  sta_dk_4_0_4_32/Makefile                   |    1 +
   8  sta_dk_4_0_4_32/pform/linux/src/iw_ioctl.c | 1906 ++++++++++++++++++++++++++++
   9  sta_dk_4_0_4_32/pform/linux/src/osapi.c    |    7 +-
  10  3 files changed, 1913 insertions(+), 1 deletions(-)
  11  mode change 100644 => 100755 sta_dk_4_0_4_32/Makefile
  12  create mode 100755 sta_dk_4_0_4_32/pform/linux/src/iw_ioctl.c
  13  mode change 100644 => 100755 sta_dk_4_0_4_32/pform/linux/src/osapi.c
  14
  15 diff --git a/sta_dk_4_0_4_32/Makefile b/sta_dk_4_0_4_32/Makefile
  16 old mode 100644
  17 new mode 100755
  18 index 76fbe48..339cfd5
  19 --- a/sta_dk_4_0_4_32/Makefile
  20 +++ b/sta_dk_4_0_4_32/Makefile
  21 @@ -61,6 +61,7 @@ OS_SRCS = \
  22      $(DK_ROOT)/pform/linux/src/ioctl_utils.c \
  23      $(DK_ROOT)/pform/linux/src/osRgstry_parser.c \
  24      $(DK_ROOT)/pform/linux/src/ipc_k.c \
  25 +    $(DK_ROOT)/pform/linux/src/iw_ioctl.c \
  26      $(DK_ROOT)/pform/linux/src/proc_stat.c
  27
  28  ifeq ($(DRIVER_PROFILING),y)
  29 diff --git a/sta_dk_4_0_4_32/pform/linux/src/iw_ioctl.c b/sta_dk_4_0_4_32/pform/linux/src/iw_ioctl.c
  30 new file mode 100755
  31 index 0000000..3b02424
  32 --- /dev/null
  33 +++ b/sta_dk_4_0_4_32/pform/linux/src/iw_ioctl.c
  34 @@ -0,0 +1,1906 @@
  35 +/* ioctl() (mostly Linux Wireless Extensions) routines for TI 1251 driver */
  36 +
  37 +#include <linux/if_arp.h>
  38 +#include <linux/wireless.h>
  39 +#include <net/iw_handler.h>
  40 +#include <net/ieee80211.h>
  41 +#include "osAdapter.h"
  42 +#include "tiioctl.h"
  43 +#include "paramOut.h"
  44 +#include "osUtil.h"
  45 +#include "srcApi.h"
  46 +#include "configMgr.h"
  47 +#include "esta_drv.h"
  48 +#include "osUtil.h"
  49 +#include "scanMngrTypes.h"
  50 +#include "scanMngrTypes.h"
  51 +
  52 +#define IOCTL_DBG 1
  53 +
  54 +static const long freq_list[] = { 2412, 2417, 2422, 2427, 2432, 2437, 2442,
  55 +                                 2447, 2452, 2457, 2462, 2467, 2472, 2484 };
  56 +#define FREQ_COUNT (sizeof(freq_list) / sizeof(freq_list[0]))
  57 +#define MAX_SSID_LEN 32
  58 +#define MAX_NAME_LEN 32 /* this is assumed to be equal to MAX_SSID_LEN */
  59 +#define VAL_DEFAULT_KEY_ID                     110
  60 +#define WEP_KEYS       4
  61 +//#define MEGA 1e6
  62 +
  63 +scan_Params_t iw_appScanParams;
  64 +scan_Policy_t iw_scanPolicy;
  65 +
  66 +void init_scan_params(void)
  67 +{
  68 +    int i,j;
  69 +
  70 +    /* init application scan default params */
  71 +    iw_appScanParams.desiredSsid.len = 0;
  72 +    iw_appScanParams.scanType = SCAN_TYPE_NORMAL_ACTIVE;
  73 +    iw_appScanParams.band = RADIO_BAND_2_4_GHZ;
  74 +    iw_appScanParams.probeReqNumber = 3;
  75 +    iw_appScanParams.probeRequestRate = DRV_RATE_MASK_2_BARKER;
  76 +    iw_appScanParams.numOfChannels = 11;
  77 +    for ( i = 0; i < 11; i++ )
  78 +    {
  79 +        for ( j = 0; j < 6; j++ )
  80 +        {
  81 +            iw_appScanParams.channelEntry[ i ].normalChannelEntry.bssId.addr[ j ] = 0xff;
  82 +        }
  83 +        iw_appScanParams.channelEntry[ i ].normalChannelEntry.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
  84 +        iw_appScanParams.channelEntry[ i ].normalChannelEntry.ETMaxNumOfAPframes = 0;
  85 +        iw_appScanParams.channelEntry[ i ].normalChannelEntry.maxChannelDwellTime = 60000;
  86 +        iw_appScanParams.channelEntry[ i ].normalChannelEntry.minChannelDwellTime = 30000;
  87 +        iw_appScanParams.channelEntry[ i ].normalChannelEntry.txPowerDbm = MAX_POWER_LEVEL;
  88 +        iw_appScanParams.channelEntry[ i ].normalChannelEntry.channel = i + 1;
  89 +    }
  90 +
  91 +    /* init default scan policy */
  92 +    iw_scanPolicy.normalScanInterval = 10000;
  93 +    iw_scanPolicy.deterioratingScanInterval = 5000;
  94 +    iw_scanPolicy.maxTrackFailures = 3;
  95 +    iw_scanPolicy.BSSListSize = 4;
  96 +    iw_scanPolicy.BSSNumberToStartDiscovery = 1;
  97 +    iw_scanPolicy.numOfBands = 1;
  98 +    iw_scanPolicy.bandScanPolicy[ 0 ].band = RADIO_BAND_2_4_GHZ;
  99 +    iw_scanPolicy.bandScanPolicy[ 0 ].rxRSSIThreshold = -80;
 100 +    iw_scanPolicy.bandScanPolicy[ 0 ].numOfChannles = 11;
 101 +    iw_scanPolicy.bandScanPolicy[ 0 ].numOfChannlesForDiscovery = 3;
 102 +    for ( i = 0; i < 11; i++ )
 103 +    {
 104 +        iw_scanPolicy.bandScanPolicy[ 0 ].channelList[ i ] = i + 1;
 105 +    }
 106 +    iw_scanPolicy.bandScanPolicy[ 0 ].trackingMethod.scanType = SCAN_TYPE_NORMAL_ACTIVE;
 107 +    iw_scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
 108 +    iw_scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.ETMaxNumberOfApFrames = 0;
 109 +    iw_scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.maxChannelDwellTime = 30000;
 110 +    iw_scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.minChannelDwellTime = 15000;
 111 +    iw_scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.probReqParams.bitrate = DRV_RATE_MASK_1_BARKER;
 112 +    iw_scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = 3;
 113 +    iw_scanPolicy.bandScanPolicy[ 0 ].trackingMethod.method.basicMethodParams.probReqParams.txPowerDbm = 1;
 114 +    iw_scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.scanType = SCAN_TYPE_NORMAL_ACTIVE;
 115 +    iw_scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
 116 +    iw_scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.ETMaxNumberOfApFrames = 0;
 117 +    iw_scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.maxChannelDwellTime = 30000;
 118 +    iw_scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.minChannelDwellTime = 15000;
 119 +    iw_scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.probReqParams.bitrate = DRV_RATE_MASK_2_BARKER;
 120 +    iw_scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = 3;
 121 +    iw_scanPolicy.bandScanPolicy[ 0 ].discoveryMethod.method.basicMethodParams.probReqParams.txPowerDbm = 1;
 122 +    iw_scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.scanType = SCAN_TYPE_NORMAL_ACTIVE;
 123 +    iw_scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
 124 +    iw_scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.ETMaxNumberOfApFrames = 0;
 125 +    iw_scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.maxChannelDwellTime = 30000;
 126 +    iw_scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.minChannelDwellTime = 15000;
 127 +    iw_scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.probReqParams.bitrate = DRV_RATE_MASK_5_5_CCK;
 128 +    iw_scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.probReqParams.numOfProbeReqs = 3;
 129 +    iw_scanPolicy.bandScanPolicy[ 0 ].immediateScanMethod.method.basicMethodParams.probReqParams.txPowerDbm = 1;
 130 +}
 131 +
 132 +static int iw_get_name(struct net_device *dev,
 133 +                          struct iw_request_info *info,
 134 +                          char *name, char *extra)
 135 +{
 136 +#if IOCTL_DBG
 137 +       printk("%s Call\n", __FUNCTION__);
 138 +#endif
 139 +/*
 140 +       u8 rates[10];
 141 +       int len, i, over2 = 0;
 142 +
 143 +       len = iw_get_datarates(dev, rates);
 144 +
 145 +       for (i = 0; i < len; i++) {
 146 +               if (rates[i] == 0x0b || rates[i] == 0x16) {
 147 +                       over2 = 1;
 148 +                       break;
 149 +               }
 150 +       }
 151 +*/
 152 +       strcpy(name, "IEEE 802.11g");
 153 +
 154 +       return 0;
 155 +}
 156 +
 157 +static int iw_ioctl_siwencode(struct net_device *dev,
 158 +                                 struct iw_request_info *info,
 159 +                                 struct iw_point *erq, char *keybuf)
 160 +{
 161 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 162 +       cipherSuite_e   cipher;
 163 +       int i;
 164 +       ULONG len;
 165 +
 166 +#if IOCTL_DBG
 167 +       printk("%s Call\n", __FUNCTION__);
 168 +#endif
 169 +       i = erq->flags & IW_ENCODE_INDEX;
 170 +       if (i < 1 || i > 4)
 171 +       {
 172 +               UINT32 ID = VAL_DEFAULT_KEY_ID;
 173 +               ULONG ID_size = 4;
 174 +               UtilInfoCodeQueryInformation(pAdapter, (UINT8 *)&ID, &ID_size);
 175 +               i = *((UINT8 *)&ID);
 176 +       }
 177 +       else
 178 +               i--;
 179 +       if (i < 0 || i >= WEP_KEYS)
 180 +               return -EINVAL;
 181 +
 182 +       UtilWepStatusGet(pAdapter, (UINT8 *)&cipher, &len);
 183 +
 184 +       if (erq->flags & IW_ENCODE_DISABLED) {
 185 +               cipherSuite_e val=RSN_CIPHER_NONE;
 186 +               UtilWepStatusSet(pAdapter, (UINT8 *)&val, sizeof(val));
 187 +               goto done;
 188 +       }
 189 +       else
 190 +       {
 191 +               if (erq->length > 0) {
 192 +                       OS_802_11_WEP wep;
 193 +                       int len = erq->length <= 5 ? 5 : 13;
 194 +
 195 +                       cipherSuite_e val=RSN_CIPHER_WEP;
 196 +                       UtilWepStatusSet(pAdapter, (UINT8 *)&val, sizeof(val));
 197 +
 198 +                       if (len > erq->length)
 199 +                               memset(keybuf + erq->length, 0, len - erq->length);
 200 +                       memcpy(wep.KeyMaterial, keybuf, len);
 201 +                       wep.Length = sizeof(wep);
 202 +                       wep.KeyIndex = i;
 203 +                       wep.KeyLength = len;
 204 +                       UtilAddWep(pAdapter, (UINT8 *)&wep, wep.Length, true);
 205 +               } else {
 206 +                       /* No key data - just set the default TX key index */
 207 +                       securityKeys_t key;
 208 +                       UINT8 data[5];
 209 +
 210 +                       memset(&key, 0, sizeof(securityKeys_t));
 211 +                       key.keyIndex = i;
 212 +                       if (!UtilWepKeyGet(pAdapter, (UINT8 *)&key, sizeof(securityKeys_t)))
 213 +                       {
 214 +                               if (key.encLen > 0)
 215 +                               {
 216 +                                       *(UINT32 *)data = VAL_DEFAULT_KEY_ID;
 217 +                                       data[4] = i;
 218 +                                       UtilInfoCodeSetInformation(pAdapter, data, 5);
 219 +                                       if (cipher == RSN_CIPHER_NONE)
 220 +                                       {
 221 +                                               cipherSuite_e val=RSN_CIPHER_WEP;
 222 +                                               UtilWepStatusSet(pAdapter, (UINT8 *)&val, sizeof(val));
 223 +                                       }
 224 +                               }
 225 +                               else
 226 +                                       return -EINVAL;
 227 +                       }
 228 +                       else
 229 +                               return -EINVAL;
 230 +               }
 231 +       }
 232 +done:
 233 +       if (erq->flags & IW_ENCODE_OPEN)
 234 +       {
 235 +               UINT8 MixedMode = true;
 236 +               UtilSetMixedMode(pAdapter, &MixedMode, 1);
 237 +       }
 238 +       else
 239 +       {
 240 +               UINT8 MixedMode = false;
 241 +               UtilSetMixedMode(pAdapter, &MixedMode, 1);
 242 +       }
 243 +       return 0;
 244 +}
 245 +
 246 +
 247 +static int iw_ioctl_giwencode(struct net_device *dev,
 248 +                                 struct iw_request_info *info,
 249 +                                 struct iw_point *erq, char *key)
 250 +{
 251 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 252 +       cipherSuite_e   cipher;
 253 +       ULONG                   len, i;
 254 +       UINT8                   MixedMode;
 255 +
 256 +#if IOCTL_DBG
 257 +       printk("%s Call\n", __FUNCTION__);
 258 +#endif
 259 +       i = erq->flags & IW_ENCODE_INDEX;
 260 +       if (i < 1 || i > 4)
 261 +       {
 262 +               UINT32 ID = VAL_DEFAULT_KEY_ID;
 263 +               ULONG ID_size = 4;
 264 +               UtilInfoCodeQueryInformation(pAdapter, (UINT8 *)&ID, &ID_size);
 265 +               i = *((UINT8 *)&ID);
 266 +       }
 267 +       else
 268 +               i--;
 269 +       if (i < 0 || i >= WEP_KEYS)
 270 +               return -EINVAL;
 271 +
 272 +       UtilWepStatusGet(pAdapter, (UINT8 *)&cipher, &len);
 273 +       erq->flags = i + 1;
 274 +
 275 +#if IOCTL_DBG
 276 +       printk("%s Call cipher=%d\n", __FUNCTION__, cipher);
 277 +#endif
 278 +
 279 +       if (cipher == RSN_CIPHER_NONE) {
 280 +               erq->length = 0;
 281 +               erq->flags |= IW_ENCODE_DISABLED;
 282 +       }
 283 +       else
 284 +       {
 285 +               securityKeys_t wkey;
 286 +               /* only WEP is supported with wireless extensions, so just
 287 +                * report that encryption is used */
 288 +               memset(&wkey, 0, sizeof(securityKeys_t));
 289 +               wkey.keyIndex = i;
 290 +               if (!UtilWepKeyGet(pAdapter, (PUCHAR)&wkey, sizeof(securityKeys_t)))
 291 +               {
 292 +               printk("iw_ioctl_giwencode KeyIndex  %x , keyLength=%d\n",
 293 +                      wkey.keyIndex, wkey.encLen);
 294 +                       if (wkey.encLen > 0)
 295 +                       {
 296 +                               int j;
 297 +                               erq->length = wkey.encLen;
 298 +                               memcpy(key, wkey.encKey, erq->length);
 299 +                               printk("key = ");
 300 +                               for (j=0;j<erq->length;j++)
 301 +                                       printk("%02x ", *(key+j));
 302 +                               printk("\n");
 303 +                               erq->flags |= IW_ENCODE_ENABLED;
 304 +                       }
 305 +                       else
 306 +                       {
 307 +                               erq->length = 0;
 308 +                               erq->flags |= IW_ENCODE_DISABLED;
 309 +                       }
 310 +               }
 311 +               else
 312 +               {
 313 +                       erq->length = 0;
 314 +                       erq->flags |= IW_ENCODE_DISABLED;
 315 +               }
 316 +       }
 317 +
 318 +       UtilGetMixedMode(pAdapter, RSN_MIXED_MODE, &MixedMode, &len);
 319 +       if (MixedMode)
 320 +               erq->flags |= IW_ENCODE_OPEN;
 321 +       else
 322 +               erq->flags |= IW_ENCODE_RESTRICTED;
 323 +
 324 +
 325 +       return 0;
 326 +}
 327 +
 328 +static int iw_ioctl_siwrate(struct net_device *dev,
 329 +                               struct iw_request_info *info,
 330 +                               struct iw_param *rrq, char *extra)
 331 +{
 332 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 333 +       u32 val;
 334 +
 335 +#if IOCTL_DBG
 336 +       printk("%s Call\n", __FUNCTION__);
 337 +#endif
 338 +       if (!rrq->fixed)
 339 +               val = 0;
 340 +       else
 341 +               val = (rrq->value*2/1000000);
 342 +
 343 +       return UtilDesiredRatesSet(pAdapter, (UINT8 *)&val, 4);
 344 +}
 345 +
 346 +
 347 +static int iw_ioctl_giwrate(struct net_device *dev,
 348 +                               struct iw_request_info *info,
 349 +                               struct iw_param *rrq, char *extra)
 350 +{
 351 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 352 +       ULONG val=0, len;
 353 +
 354 +#if IOCTL_DBG
 355 +       printk("%s Call\n", __FUNCTION__);
 356 +#endif
 357 +       if (UtilCurrentRatesGet(pAdapter, (UINT8 *)&val, &len))
 358 +               return -EINVAL;
 359 +
 360 +       if (val > 0)
 361 +       {
 362 +               rrq->fixed = 1;
 363 +               rrq->value = (val*1000000/2);
 364 +       }
 365 +       else
 366 +       {
 367 +               rrq->fixed = 1;
 368 +               rrq->value = 54*1000000;
 369 +       }
 370 +
 371 +       return 0;
 372 +}
 373 +
 374 +static UINT8  list_buf[10000];
 375 +/* Deprecated in new wireless extension API */
 376 +static int iw_ioctl_giwaplist(struct net_device *dev,
 377 +                                 struct iw_request_info *info,
 378 +                                 struct iw_point *data, char *extra)
 379 +{
 380 +
 381 +#if 1
 382 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 383 +       struct sockaddr addr[IW_MAX_AP];
 384 +       struct iw_quality qual[IW_MAX_AP];
 385 +       UINT32 number_items;
 386 +       ULONG len=10000;
 387 +       OS_802_11_BSSID_EX *bssid;
 388 +       OS_802_11_BSSID_LIST_EX *list;
 389 +       int i;
 390 +
 391 +#if IOCTL_DBG
 392 +       printk("%s Call\n", __FUNCTION__);
 393 +#endif
 394 +       printk("iw_ioctl_giwaplist\n");
 395 +       memset(list_buf, 0, 10000);
 396 +    UtilBssidListGet(pAdapter, list_buf, &len, TRUE, FALSE);
 397 +
 398 +    list = (OS_802_11_BSSID_LIST_EX *) list_buf;
 399 +    bssid = &list->Bssid[0];
 400 +    printk("bssid 0x%x\n",bssid);
 401 +    number_items = list->NumberOfItems;
 402 +    printk("number_items 0x%x\n",number_items);
 403 +
 404 +       data->length = number_items;
 405 +
 406 +       for (i=0;i<number_items;i++)
 407 +       {
 408 +               addr[i].sa_family = ARPHRD_ETHER;
 409 +               memcpy(addr[i].sa_data, bssid->MacAddress, 6);
 410 +               //memset((UINT8 *)qual[i], 0, size(struct iw_quality));
 411 +               qual[i].qual = bssid->Rssi;
 412 +               qual[i].level = 0;
 413 +               qual[i].noise = 0;
 414 +               qual[i].updated = 7;
 415 +        bssid = (OS_802_11_BSSID_EX *) (((char *) bssid) + bssid->Length);
 416 +       }
 417 +
 418 +       memcpy(extra, &addr, sizeof(addr[0]) * data->length);
 419 +       data->flags = 1; /* has quality information */
 420 +       memcpy(extra + sizeof(addr[0]) * data->length, &qual,
 421 +              sizeof(qual[0]) * data->length);
 422 +
 423 +       return 0;
 424 +#endif
 425 +}
 426 +
 427 +
 428 +static int iw_ioctl_siwrts(struct net_device *dev,
 429 +                              struct iw_request_info *info,
 430 +                              struct iw_param *rts, char *extra)
 431 +{
 432 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 433 +       u32 val;
 434 +
 435 +#if IOCTL_DBG
 436 +       printk("%s Call\n", __FUNCTION__);
 437 +#endif
 438 +       if (rts->disabled)
 439 +               val = 2347;
 440 +       else if (rts->value < 0 || rts->value > 2347)
 441 +               return -EINVAL;
 442 +       else
 443 +               val = rts->value;
 444 +
 445 +       UtilRtsThresholdSet(pAdapter, (UINT8 *)&val, 4);
 446 +
 447 +       return 0;
 448 +}
 449 +
 450 +static int iw_ioctl_giwrts(struct net_device *dev,
 451 +                              struct iw_request_info *info,
 452 +                              struct iw_param *rts, char *extra)
 453 +{
 454 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 455 +       ULONG val, len;
 456 +
 457 +#if IOCTL_DBG
 458 +       printk("%s Call\n", __FUNCTION__);
 459 +#endif
 460 +       if (UtilRtsThresholdGet(pAdapter, (UINT8 *)&val, &len))
 461 +               return -EINVAL;
 462 +       if (val >= 2347) val = 2347;
 463 +       rts->value = val;
 464 +       rts->disabled = (rts->value == 2347);
 465 +       rts->fixed = 1;
 466 +
 467 +       return 0;
 468 +}
 469 +
 470 +
 471 +static int iw_ioctl_siwfrag(struct net_device *dev,
 472 +                               struct iw_request_info *info,
 473 +                               struct iw_param *rts, char *extra)
 474 +{
 475 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 476 +       u32 val;
 477 +
 478 +#if IOCTL_DBG
 479 +       printk("%s Call\n", __FUNCTION__);
 480 +#endif
 481 +       if (rts->disabled)
 482 +               val = 2346;
 483 +       else if (rts->value < 256 || rts->value > 2346)
 484 +               return -EINVAL;
 485 +       else
 486 +               val = rts->value & ~0x1; /* even numbers only */
 487 +
 488 +       if (UtilFragmentationThresholdSet(pAdapter, (UINT8 *)&val, 4))
 489 +               return -EINVAL;
 490 +
 491 +       return 0;
 492 +}
 493 +
 494 +static int iw_ioctl_giwfrag(struct net_device *dev,
 495 +                               struct iw_request_info *info,
 496 +                               struct iw_param *rts, char *extra)
 497 +{
 498 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 499 +       ULONG val, len;
 500 +
 501 +#if IOCTL_DBG
 502 +       printk("%s Call\n", __FUNCTION__);
 503 +#endif
 504 +       if (UtilFragmentationThresholdGet(pAdapter, (UINT8 *)&val, &len))
 505 +               return -EINVAL;
 506 +
 507 +       if (val >= 2346) val = 2346;
 508 +       rts->value = val;
 509 +       rts->disabled = (rts->value == 2346);
 510 +       rts->fixed = 1;
 511 +
 512 +       return 0;
 513 +}
 514 +
 515 +
 516 +static int iw_ioctl_siwap(struct net_device *dev,
 517 +                             struct iw_request_info *info,
 518 +                             struct sockaddr *ap_addr, char *extra)
 519 +{
 520 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 521 +
 522 +#if IOCTL_DBG
 523 +       printk("%s Call\n", __FUNCTION__);
 524 +#endif
 525 +       return UtilSetBSSID(pAdapter, (UINT8 *)&ap_addr->sa_data, ETH_ALEN);
 526 +}
 527 +
 528 +static int iw_ioctl_giwap(struct net_device *dev,
 529 +                             struct iw_request_info *info,
 530 +                             struct sockaddr *ap_addr, char *extra)
 531 +{
 532 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 533 +       ULONG len;
 534 +
 535 +#if IOCTL_DBG
 536 +       printk("%s Call\n", __FUNCTION__);
 537 +#endif
 538 +       ap_addr->sa_family = ARPHRD_ETHER;
 539 +       return UtilGetBSSID(pAdapter, (UINT8 *)&ap_addr->sa_data, &len);
 540 +}
 541 +
 542 +static int iw_ioctl_giwnickn(struct net_device *dev,
 543 +                                struct iw_request_info *info,
 544 +                                struct iw_point *data, char *nickname)
 545 +{
 546 +#if IOCTL_DBG
 547 +       printk("%s Call\n", __FUNCTION__);
 548 +#endif
 549 +       data->length = 7;
 550 +       memcpy(nickname, "ti 1250", 7);
 551 +
 552 +       return 0;
 553 +}
 554 +
 555 +
 556 +static int iw_ioctl_siwfreq(struct net_device *dev,
 557 +                               struct iw_request_info *info,
 558 +                               struct iw_freq *freq, char *extra)
 559 +{
 560 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 561 +
 562 +#if IOCTL_DBG
 563 +       printk("%s Call\n", __FUNCTION__);
 564 +#endif
 565 +       if (freq->m == -1)
 566 +               return -EOPNOTSUPP;
 567 +
 568 +       /* freq => chan. */
 569 +       if (freq->e == 1 &&
 570 +           freq->m / 100000 >= freq_list[0] &&
 571 +           freq->m / 100000 <= freq_list[FREQ_COUNT - 1]) {
 572 +               int ch;
 573 +               int fr = freq->m / 100000;
 574 +               for (ch = 0; ch < FREQ_COUNT; ch++) {
 575 +                       if (fr == freq_list[ch]) {
 576 +                               freq->e = 0;
 577 +                               freq->m = ch + 1;
 578 +                               break;
 579 +                       }
 580 +               }
 581 +       }
 582 +
 583 +       if (freq->e != 0 || freq->m < 1 || freq->m > FREQ_COUNT)
 584 +               return -EINVAL;
 585 +
 586 +       UtilDesiredChannelSet(pAdapter, (UINT8 *)&freq->m, 1);
 587 +
 588 +       return 0;
 589 +}
 590 +
 591 +static int iw_ioctl_giwfreq(struct net_device *dev,
 592 +                               struct iw_request_info *info,
 593 +                               struct iw_freq *freq, char *extra)
 594 +{
 595 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 596 +       ULONG val, len;
 597 +
 598 +#if IOCTL_DBG
 599 +       printk("%s Call\n", __FUNCTION__);
 600 +#endif
 601 +       UtilDesiredChannelGet(pAdapter, (UINT8 *)&val, &len);
 602 +       if (val < 1 || val > FREQ_COUNT)
 603 +               return -EINVAL;
 604 +
 605 +       freq->m = freq_list[val - 1] * 100000;
 606 +       freq->e = 1;
 607 +
 608 +       return 0;
 609 +}
 610 +
 611 +
 612 +static int iw_ioctl_siwessid(struct net_device *dev,
 613 +                                struct iw_request_info *info,
 614 +                                struct iw_point *data, char *ssid)
 615 +{
 616 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 617 +       OS_802_11_SSID essid;
 618 +       OS_802_11_MAC_ADDRESS bssid = { 0xff,0xff,0xff,0xff,0xff,0xff };
 619 +
 620 +#if IOCTL_DBG
 621 +       printk("%s Call\n", __FUNCTION__);
 622 +#endif
 623 +
 624 +    UtilSetBSSID(pAdapter, (UINT8 *)&bssid, sizeof(OS_802_11_MAC_ADDRESS));
 625 +
 626 +       memset(&essid, 0, sizeof(OS_802_11_SSID));
 627 +       memcpy(essid.Ssid, ssid, data->length);
 628 +       essid.SsidLength = data->length;
 629 +
 630 +       if (UtilSetSSID(pAdapter, (UINT8 *)&essid, sizeof(OS_802_11_SSID))){
 631 +               return -EINVAL;
 632 +       }
 633 +
 634 +       return 0;
 635 +}
 636 +
 637 +static int iw_ioctl_giwessid(struct net_device *dev,
 638 +                                struct iw_request_info *info,
 639 +                                struct iw_point *data, char *essid)
 640 +{
 641 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 642 +       ULONG len=36;
 643 +       OS_802_11_SSID ssid;
 644 +
 645 +#if IOCTL_DBG
 646 +       printk("%s Call\n", __FUNCTION__);
 647 +#endif
 648 +       memset(&ssid, 0, sizeof(OS_802_11_SSID));
 649 +       data->flags = 1; /* active */
 650 +       UtilGetSSID(pAdapter, (UINT8 *)&ssid, &len);
 651 +       data->length = ssid.SsidLength;
 652 +       memcpy(essid, ssid.Ssid, ssid.SsidLength);
 653 +
 654 +       return 0;
 655 +}
 656 +
 657 +static int iw_ioctl_siwmode(struct net_device *dev,
 658 +                               struct iw_request_info *info,
 659 +                               __u32 *mode, char *extra)
 660 +{
 661 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 662 +       u32 val;
 663 +
 664 +#if IOCTL_DBG
 665 +       printk("%s Call\n", __FUNCTION__);
 666 +#endif
 667 +       if (*mode > IW_MODE_INFRA)
 668 +               return -EOPNOTSUPP;
 669 +
 670 +       switch (*mode)
 671 +       {
 672 +       case IW_MODE_AUTO:
 673 +               val = 2;
 674 +               break;
 675 +       case IW_MODE_ADHOC:
 676 +               val = 0;
 677 +               break;
 678 +       case IW_MODE_INFRA:
 679 +               val = 1;
 680 +               break;
 681 +       default:
 682 +               val = 1;
 683 +       }
 684 +
 685 +    UtilInfrastructureModeSet(pAdapter, (UINT8 *)&val, 4);
 686 +
 687 +       return 0;
 688 +}
 689 +
 690 +
 691 +static int iw_ioctl_giwmode(struct net_device *dev,
 692 +                               struct iw_request_info *info,
 693 +                               __u32 *mode, char *extra)
 694 +{
 695 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 696 +       ULONG val, len;
 697 +
 698 +#if IOCTL_DBG
 699 +       printk("%s Call\n", __FUNCTION__);
 700 +#endif
 701 +    UtilInfrastructureModeGet(pAdapter, (UINT8 *)&val, &len);
 702 +       switch (val) {
 703 +       case 0:
 704 +               *mode = IW_MODE_ADHOC;
 705 +               break;
 706 +       case 1:
 707 +               *mode = IW_MODE_INFRA;
 708 +               break;
 709 +       case 2:
 710 +               *mode = IW_MODE_AUTO;
 711 +               break;
 712 +       default:
 713 +               *mode = IW_MODE_INFRA;
 714 +               break;
 715 +       }
 716 +       return 0;
 717 +}
 718 +
 719 +int
 720 +iw_ioctl_siwsens(struct ieee80211com *ic,
 721 +                       struct iw_request_info *info,
 722 +                       struct iw_param *sens, char *extra)
 723 +{
 724 +       return 0;
 725 +}
 726 +
 727 +int
 728 +iw_ioctl_giwsens(struct ieee80211com *ic,
 729 +                       struct iw_request_info *info,
 730 +                       struct iw_param *sens, char *extra)
 731 +{
 732 +       sens->value = 3;
 733 +       sens->fixed = 1;
 734 +
 735 +       return 0;
 736 +}
 737 +
 738 +int
 739 +iw_ioctl_giwrange(struct net_device *dev,
 740 +                        struct iw_request_info *info,
 741 +                        struct iw_point *data, char *extra)
 742 +{
 743 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 744 +       struct iw_range *range = (struct iw_range *) extra;
 745 +       ULONG val, len, i;
 746 +       rates_t rateSet;
 747 +
 748 +       data->length = sizeof(struct iw_range);
 749 +       memset(range, 0, sizeof(struct iw_range));
 750 +
 751 +       /* TODO: could fill num_txpower and txpower array with
 752 +        * something; however, there are 128 different values.. */
 753 +
 754 +       range->txpower_capa = IW_TXPOW_DBM;
 755 +
 756 +    UtilInfrastructureModeGet(pAdapter, (UINT8 *)&val, &len);
 757 +       range->min_pmp = 1 * 1024;
 758 +       range->max_pmp = 65535 * 1024;
 759 +       range->min_pmt = 1 * 1024;
 760 +       range->max_pmt = 1000 * 1024;
 761 +       range->pmp_flags = IW_POWER_PERIOD;
 762 +       range->pmt_flags = IW_POWER_TIMEOUT;
 763 +       range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT |
 764 +                       IW_POWER_UNICAST_R | IW_POWER_ALL_R;
 765 +
 766 +       range->we_version_compiled = WIRELESS_EXT;
 767 +       range->we_version_source = 18;
 768 +
 769 +       range->retry_capa = IW_RETRY_LIMIT;
 770 +       range->retry_flags = IW_RETRY_LIMIT;
 771 +       range->min_retry = 0;
 772 +       range->max_retry = 255;
 773 +
 774 +       range->num_channels = FREQ_COUNT;       /* XXX */
 775 +
 776 +       val = 0;
 777 +       for (i = 0; i < FREQ_COUNT; i++) {
 778 +               range->freq[val].i = i + 1;
 779 +               range->freq[val].m = freq_list[i] * 100000;
 780 +               range->freq[val].e = 1;
 781 +               val++;
 782 +               if (val == IW_MAX_FREQUENCIES)
 783 +                       break;
 784 +       }
 785 +       range->num_frequency = val;
 786 +
 787 +       /* Max quality is max field value minus noise floor */
 788 +       range->max_qual.qual  = 0xff - 161;
 789 +
 790 +       /*
 791 +        * In order to use dBm measurements, 'level' must be lower
 792 +        * than any possible measurement (see iw_print_stats() in
 793 +        * wireless tools).  It's unclear how this is meant to be
 794 +        * done, but setting zero in these values forces dBm and
 795 +        * the actual numbers are not used.
 796 +        */
 797 +       range->max_qual.level = 0;
 798 +       range->max_qual.noise = 0;
 799 +
 800 +       range->sensitivity = 3;
 801 +
 802 +       range->max_encoding_tokens = WEP_KEYS;
 803 +       /* XXX query driver to find out supported key sizes */
 804 +       range->num_encoding_sizes = 2;
 805 +       range->encoding_size[0] = 5;            /* 40-bit */
 806 +       range->encoding_size[1] = 13;           /* 104-bit */
 807 +
 808 +       /* XXX this only works for station mode */
 809 +       UtilGetParam(pAdapter, SITE_MGR_DESIRED_SUPPORTED_RATE_SET_PARAM, (PUCHAR)&rateSet, sizeof(rates_t));
 810 +       range->num_bitrates = 0;
 811 +       for (i = 0; i < rateSet.len; i++) {
 812 +               if (range->num_bitrates < IW_MAX_BITRATES) {
 813 +                       range->bitrate[range->num_bitrates] =
 814 +                               rateSet.ratesString[i] * 2 / 1000000;
 815 +                       range->num_bitrates++;
 816 +               }
 817 +       }
 818 +
 819 +       /* estimated maximum TCP throughput values (bps) */
 820 +       range->throughput = 5500000;
 821 +
 822 +       range->min_rts = 0;
 823 +       range->max_rts = 2347;
 824 +       range->min_frag = 256;
 825 +       range->max_frag = 2346;
 826 +
 827 +#if WIRELESS_EXT > 16
 828 +       /* Event capability (kernel + driver) */
 829 +       range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
 830 +                               IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
 831 +                               IW_EVENT_CAPA_MASK(SIOCGIWAP) |
 832 +                               IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
 833 +       range->event_capa[1] = IW_EVENT_CAPA_K_1;
 834 +       range->event_capa[4] = (IW_EVENT_CAPA_MASK(IWEVTXDROP) |
 835 +                               IW_EVENT_CAPA_MASK(IWEVCUSTOM) |
 836 +                               IW_EVENT_CAPA_MASK(IWEVREGISTERED) |
 837 +                               IW_EVENT_CAPA_MASK(IWEVEXPIRED));
 838 +#endif /* WIRELESS_EXT > 16 */
 839 +
 840 +#if WIRELESS_EXT > 17
 841 +       range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
 842 +               IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
 843 +#endif /* WIRELESS_EXT > 17 */
 844 +
 845 +       return 0;}
 846 +
 847 +static int iw_ioctl_siwpower(struct net_device *dev,
 848 +                                struct iw_request_info *info,
 849 +                                struct iw_param *wrq, char *extra)
 850 +{
 851 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 852 +       UINT32 val=POWER_MODE_ACTIVE;
 853 +
 854 +#if IOCTL_DBG
 855 +       printk("%s Call\n", __FUNCTION__);
 856 +#endif
 857 +
 858 +       if (wrq->disabled)
 859 +       {
 860 +               UtilPowerModeSet(pAdapter, (UINT8 *)&val, sizeof(PowerMgr_PowerMode_e));
 861 +               return 0;
 862 +       }
 863 +
 864 +       switch (wrq->flags & IW_POWER_MODE) {
 865 +       case IW_POWER_UNICAST_R:
 866 +       case IW_POWER_ALL_R:
 867 +       case IW_POWER_ON:
 868 +               val = POWER_MODE_AUTO;
 869 +               UtilPowerModeSet(pAdapter, &val, sizeof(PowerMgr_PowerMode_e));
 870 +               break;
 871 +       default:
 872 +               return -EINVAL;
 873 +       }
 874 +
 875 +       if (wrq->flags & IW_POWER_TIMEOUT) {
 876 +               return -EOPNOTSUPP;
 877 +       }
 878 +       if (wrq->flags & IW_POWER_PERIOD) {
 879 +               return -EOPNOTSUPP;
 880 +       }
 881 +
 882 +       return 0;
 883 +}
 884 +
 885 +
 886 +static int iw_ioctl_giwpower(struct net_device *dev,
 887 +                                struct iw_request_info *info,
 888 +                                struct iw_param *rrq, char *extra)
 889 +{
 890 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 891 +       UINT32 val=POWER_MODE_ACTIVE, len;
 892 +
 893 +#if IOCTL_DBG
 894 +       printk("%s Call\n", __FUNCTION__);
 895 +#endif
 896 +       UtilPowerModeGet(pAdapter, (UINT8 *)&val, &len);
 897 +
 898 +       if (val==POWER_MODE_ACTIVE) {
 899 +               rrq->disabled = 1;
 900 +               return 0;
 901 +       }
 902 +
 903 +       rrq->disabled = 0;
 904 +
 905 +       return 0;
 906 +}
 907 +
 908 +
 909 +static int iw_ioctl_siwretry(struct net_device *dev,
 910 +                                struct iw_request_info *info,
 911 +                                struct iw_param *rrq, char *extra)
 912 +{
 913 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 914 +
 915 +#if IOCTL_DBG
 916 +       printk("%s Call\n", __FUNCTION__);
 917 +#endif
 918 +       if (rrq->disabled)
 919 +               return -EINVAL;
 920 +
 921 +       if (rrq->flags & IW_RETRY_LIMIT) {
 922 +               if (rrq->flags & IW_RETRY_MAX)
 923 +                       UtilLongRetrySet(pAdapter, (UINT8 *)&(rrq->value), sizeof(rrq->value));
 924 +               else if (rrq->flags & IW_RETRY_MIN)
 925 +                       UtilShortRetrySet(pAdapter, (UINT8 *)&(rrq->value), sizeof(rrq->value));
 926 +               else {
 927 +                       UtilLongRetrySet(pAdapter, (UINT8 *)&(rrq->value), sizeof(rrq->value));
 928 +                       UtilShortRetrySet(pAdapter, (UINT8 *)&(rrq->value), sizeof(rrq->value));
 929 +               }
 930 +               return 0;
 931 +       }
 932 +
 933 +       return -EOPNOTSUPP;
 934 +}
 935 +
 936 +static int iw_ioctl_giwretry(struct net_device *dev,
 937 +                                struct iw_request_info *info,
 938 +                                struct iw_param *rrq, char *extra)
 939 +{
 940 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 941 +       u16 shortretry, longretry;
 942 +       ULONG len;
 943 +
 944 +#if IOCTL_DBG
 945 +       printk("%s Call\n", __FUNCTION__);
 946 +#endif
 947 +       if (UtilShortRetryGet(pAdapter, (UINT8 *)&shortretry, &len)!=0 ||
 948 +               UtilLongRetryGet(pAdapter, (UINT8 *)&longretry, &len)!=0)
 949 +               return -EINVAL;
 950 +
 951 +       rrq->disabled = 0;
 952 +
 953 +       if ((rrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
 954 +               return -EOPNOTSUPP;
 955 +       } else {
 956 +               if ((rrq->flags & IW_RETRY_MAX)) {
 957 +                       rrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
 958 +                       rrq->value = longretry;
 959 +               } else {
 960 +                       rrq->flags = IW_RETRY_LIMIT;
 961 +                       rrq->value = shortretry;
 962 +                       if (shortretry != longretry)
 963 +                               rrq->flags |= IW_RETRY_MIN;
 964 +               }
 965 +       }
 966 +       return 0;
 967 +}
 968 +
 969 +
 970 +static int iw_ioctl_siwtxpow(struct net_device *dev,
 971 +                                struct iw_request_info *info,
 972 +                                struct iw_param *rrq, char *extra)
 973 +{
 974 +       return -EOPNOTSUPP;
 975 +}
 976 +
 977 +static int iw_ioctl_giwtxpow(struct net_device *dev,
 978 +                                struct iw_request_info *info,
 979 +                                struct iw_param *rrq, char *extra)
 980 +{
 981 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
 982 +       INT8 val;
 983 +       ULONG len;
 984 +
 985 +#if IOCTL_DBG
 986 +       printk("%s Call\n", __FUNCTION__);
 987 +#endif
 988 +
 989 +       UtilTxPowerLevelDbmGet(pAdapter, &val, &len);
 990 +       rrq->flags = IW_TXPOW_DBM;
 991 +       rrq->value = val;
 992 +       rrq->disabled = 0;
 993 +       rrq->fixed = 0;
 994 +
 995 +       return 0;
 996 +}
 997 +
 998 +u32    scan_TimeStamp;
 999 +
1000 +static int iw_ioctl_siwscan(struct net_device *dev,
1001 +                               struct iw_request_info *info,
1002 +                               struct iw_point *data, char *extra)
1003 +{
1004 +#if IOCTL_DBG
1005 +       printk("%s Call\n", __FUNCTION__);
1006 +#endif
1007 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
1008 +       int ret;
1009 +
1010 +       scan_TimeStamp = jiffies;
1011 +       init_scan_params();
1012 +
1013 +       ret = UtilStartAppScanSet(pAdapter, (PCHAR)&iw_appScanParams, sizeof(iw_appScanParams));
1014 +
1015 +       return ret;
1016 +}
1017 +
1018 +static inline int iw_scan_list(struct net_device *dev,
1019 +                                 struct iw_request_info *info,
1020 +                                 struct iw_point *data, char *extra)
1021 +{
1022 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
1023 +       UINT32 number_items;
1024 +       ULONG len=10000;
1025 +       OS_802_11_BSSID_EX *bssid;
1026 +       OS_802_11_BSSID_LIST_EX *list;
1027 +       int i, j;
1028 +       struct iw_event iwe;
1029 +       char *current_ev = extra;
1030 +       char *end_buf = extra + data->length;
1031 +       u16 capabilities;
1032 +       char *current_val;
1033 +       char buf[64 * 2 + 30];
1034 +    OS_802_11_VARIABLE_IEs  *pVarIes;
1035 +    int IELen;
1036 +       int chan;
1037 +       u8 *pos;
1038 +       spinlock_t lock;
1039 +
1040 +#if IOCTL_DBG
1041 +       printk("%s Call\n", __FUNCTION__);
1042 +#endif
1043 +       memset(list_buf, 0, 10000);
1044 +    UtilBssidListGet(pAdapter, list_buf, &len, TRUE, FALSE);
1045 +
1046 +    list = (OS_802_11_BSSID_LIST_EX *) list_buf;
1047 +    bssid = &list->Bssid[0];
1048 +    number_items = list->NumberOfItems;
1049 +
1050 +       spin_lock_bh(&lock);
1051 +       for (i=0;i<number_items;i++)
1052 +       {
1053 +               memset(&iwe, 0, sizeof(iwe));
1054 +               iwe.cmd = SIOCGIWAP;
1055 +               iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1056 +               memcpy(iwe.u.ap_addr.sa_data, bssid->MacAddress, ETH_ALEN);
1057 +               iwe.len = IW_EV_ADDR_LEN;
1058 +               current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
1059 +                                                 IW_EV_ADDR_LEN);
1060 +
1061 +               memset(&iwe, 0, sizeof(iwe));
1062 +               iwe.cmd = SIOCGIWESSID;
1063 +               iwe.u.data.length = bssid->Ssid.SsidLength;
1064 +               iwe.u.data.flags = 1;
1065 +               iwe.len = IW_EV_POINT_LEN + iwe.u.data.length;
1066 +//             printk("essid=%s len=%d\n", bssid->Ssid.Ssid, bssid->Ssid.SsidLength);
1067 +               current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, (char *)bssid->Ssid.Ssid);
1068 +
1069 +               memset(&iwe, 0, sizeof(iwe));
1070 +               iwe.cmd = SIOCGIWMODE;
1071 +               capabilities = bssid->Union.Capabilities;
1072 +               if (capabilities & (WLAN_CAPABILITY_BSS |
1073 +                                   WLAN_CAPABILITY_IBSS)) {
1074 +                       if (capabilities & WLAN_CAPABILITY_BSS)
1075 +                               iwe.u.mode = IW_MODE_MASTER;
1076 +                       else
1077 +                               iwe.u.mode = IW_MODE_ADHOC;
1078 +                       iwe.len = IW_EV_UINT_LEN;
1079 +                       current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
1080 +                                                         IW_EV_UINT_LEN);
1081 +               }
1082 +
1083 +               memset(&iwe, 0, sizeof(iwe));
1084 +               iwe.cmd = SIOCGIWFREQ;
1085 +               chan = bssid->Configuration.Union.channel;
1086 +               if (chan > 0) {
1087 +                       iwe.u.freq.m = chan;
1088 +                       iwe.u.freq.e = 1;
1089 +                       iwe.len = IW_EV_FREQ_LEN;
1090 +                       current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
1091 +                                                         IW_EV_FREQ_LEN);
1092 +               }
1093 +
1094 +               memset(&iwe, 0, sizeof(iwe));
1095 +               iwe.cmd = IWEVQUAL;
1096 +               iwe.u.qual.qual = bssid->Rssi;
1097 +               iwe.u.qual.level = 0;
1098 +               iwe.u.qual.noise = 0;
1099 +               iwe.u.qual.updated = IW_QUAL_LEVEL_UPDATED
1100 +                               | IW_QUAL_NOISE_UPDATED
1101 +                               | IW_QUAL_QUAL_INVALID;
1102 +               iwe.len = IW_EV_QUAL_LEN;
1103 +               current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe,
1104 +                                                 IW_EV_QUAL_LEN);
1105 +
1106 +               memset(&iwe, 0, sizeof(iwe));
1107 +               iwe.cmd = SIOCGIWENCODE;
1108 +               if (capabilities & WLAN_CAPABILITY_PRIVACY)
1109 +                       iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1110 +               else
1111 +                       iwe.u.data.flags = IW_ENCODE_DISABLED;
1112 +               iwe.u.data.length = 0;
1113 +               iwe.len = IW_EV_POINT_LEN + iwe.u.data.length;
1114 +               current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, "");
1115 +
1116 +               /* TODO: add SuppRates into BSS table */
1117 +               memset(&iwe, 0, sizeof(iwe));
1118 +               iwe.cmd = SIOCGIWRATE;
1119 +               current_val = current_ev + IW_EV_LCP_LEN;
1120 +               pos = bssid->SupportedRates;
1121 +               for (j = 0; j < sizeof(bssid->SupportedRates); j++) {
1122 +                       if (pos[j] == 0)
1123 +                               break;
1124 +                       /* Bit rate given in 500 kb/s units (+ 0x80) */
1125 +                       iwe.u.bitrate.value = ((pos[j] & 0x7f) * 500000);
1126 +                       current_val = iwe_stream_add_value(
1127 +                               current_ev, current_val, end_buf, &iwe,
1128 +                               IW_EV_PARAM_LEN);
1129 +               }
1130 +               /* Check if we added any event */
1131 +               if ((current_val - current_ev) > IW_EV_LCP_LEN)
1132 +                       current_ev = current_val;
1133 +
1134 +               /* TODO: add BeaconInt,resp_rate,atim into BSS table */
1135 +               memset(&iwe, 0, sizeof(iwe));
1136 +               iwe.cmd = IWEVCUSTOM;
1137 +               sprintf(buf, "bcn_int=%d",
1138 +                       bssid->Configuration.BeaconPeriod);
1139 +               iwe.u.data.length = strlen(buf);
1140 +               current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe,
1141 +                                                 buf);
1142 +
1143 +               if (capabilities & WLAN_CAPABILITY_IBSS) {
1144 +                       memset(&iwe, 0, sizeof(iwe));
1145 +                       iwe.cmd = IWEVCUSTOM;
1146 +                       sprintf(buf, "atim=%d", bssid->Configuration.ATIMWindow);
1147 +                       iwe.u.data.length = strlen(buf);
1148 +                       current_ev = iwe_stream_add_point(current_ev, end_buf,
1149 +                                                         &iwe, buf);
1150 +               }
1151 +
1152 +#if 1
1153 +               IELen = 0;
1154 +        IELen += sizeof(OS_802_11_FIXED_IEs);
1155 +        pVarIes = (OS_802_11_VARIABLE_IEs*)&bssid->IEs[IELen];
1156 +               while (IELen < bssid->IELength)
1157 +               {
1158 +//                     printk("IELen=%d pVarIes->ElementID=%d\n", IELen, pVarIes->ElementID);
1159 +                       if (pVarIes->ElementID == MFIE_TYPE_RSN || pVarIes->ElementID == MFIE_TYPE_GENERIC) {
1160 +                               memset(&iwe, 0, sizeof(iwe));
1161 +                               iwe.cmd = IWEVGENIE;
1162 +                               iwe.u.data.length = pVarIes->Length;
1163 +                               current_ev = iwe_stream_add_point(
1164 +                                       current_ev, end_buf, &iwe, (char *)pVarIes);
1165 +                       }
1166 +
1167 +            IELen += (pVarIes->Length + 2);
1168 +               pVarIes = (OS_802_11_VARIABLE_IEs*)&bssid->IEs[IELen];
1169 +               }
1170 +#endif
1171 +               if ((end_buf - current_ev) <= IW_EV_ADDR_LEN) {
1172 +                       /* Ask user space to try again with a bigger buffer */
1173 +                       spin_unlock_bh(&lock);
1174 +                       return -E2BIG;
1175 +               }
1176 +//             printk("current_ev=%x\n", current_ev);
1177 +        bssid = (OS_802_11_BSSID_EX *) (((char *) bssid) + bssid->Length);
1178 +       }
1179 +
1180 +       spin_unlock_bh(&lock);
1181 +       return current_ev - extra;
1182 +}
1183 +
1184 +static int iw_ioctl_giwscan(struct net_device *dev,
1185 +                               struct iw_request_info *info,
1186 +                               struct iw_point *data, char *extra)
1187 +{
1188 +       PTIWLN_ADAPTER_T                pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
1189 +       u32                                     val, len;
1190 +       int                                     res;
1191 +
1192 +#if IOCTL_DBG
1193 +       printk("%s Call\n", __FUNCTION__);
1194 +#endif
1195 +#if 0
1196 +       if (scan_TimeStamp &&
1197 +           time_before(jiffies, scan_TimeStamp + 30 * HZ)) {
1198 +               printk("iw_ioctl_giwscan time: 0x%x   0x%x\n",scan_TimeStamp,time_before(jiffies, scan_TimeStamp + 30 * HZ));
1199 +               return -EAGAIN;
1200 +       }
1201 +#endif
1202 +       if((jiffies - scan_TimeStamp) <= 4 * HZ){
1203 +               return -EAGAIN;
1204 +       }
1205 +
1206 +       res = iw_scan_list(dev, info, data, extra);
1207 +//     printk("iw_ioctl_giwscan end res=%d\n", res);
1208 +       if (res >= 0) {
1209 +               data->length = res;
1210 +               return 0;
1211 +       } else {
1212 +               data->length = 0;
1213 +               return res;
1214 +       }
1215 +}
1216 +
1217 +#if 0
1218 +static const struct iw_priv_args prism2_priv[] = {
1219 +       { iw_ioctl_MONITOR,
1220 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "monitor" },
1221 +       { iw_ioctl_READMIF,
1222 +         IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
1223 +         IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "readmif" },
1224 +       { iw_ioctl_WRITEMIF,
1225 +         IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 2, 0, "writemif" },
1226 +       { iw_ioctl_RESET,
1227 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "reset" },
1228 +       { iw_ioctl_INQUIRE,
1229 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "inquire" },
1230 +       { iw_ioctl_SET_RID_WORD,
1231 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "set_rid_word" },
1232 +       { iw_ioctl_MACCMD,
1233 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "maccmd" },
1234 +#ifdef PRISM2_USE_WE_TYPE_ADDR
1235 +       { iw_ioctl_WDS_ADD,
1236 +         IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "wds_add" },
1237 +       { iw_ioctl_WDS_DEL,
1238 +         IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "wds_del" },
1239 +       { iw_ioctl_ADDMAC,
1240 +         IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "addmac" },
1241 +       { iw_ioctl_DELMAC,
1242 +         IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "delmac" },
1243 +       { iw_ioctl_KICKMAC,
1244 +         IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "kickmac" },
1245 +#else /* PRISM2_USE_WE_TYPE_ADDR */
1246 +       { iw_ioctl_WDS_ADD,
1247 +         IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | 18, 0, "wds_add" },
1248 +       { iw_ioctl_WDS_DEL,
1249 +         IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | 18, 0, "wds_del" },
1250 +       { iw_ioctl_ADDMAC,
1251 +         IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | 18, 0, "addmac" },
1252 +       { iw_ioctl_DELMAC,
1253 +         IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | 18, 0, "delmac" },
1254 +       { iw_ioctl_KICKMAC,
1255 +         IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | 18, 0, "kickmac" },
1256 +#endif /* PRISM2_USE_WE_TYPE_ADDR */
1257 +       /* --- raw access to sub-ioctls --- */
1258 +       { iw_ioctl_PRISM2_PARAM,
1259 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "prism2_param" },
1260 +       { iw_ioctl_GET_PRISM2_PARAM,
1261 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1262 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getprism2_param" },
1263 +#ifdef PRISM2_USE_WE_SUB_IOCTLS
1264 +       /* --- sub-ioctls handlers --- */
1265 +       { iw_ioctl_PRISM2_PARAM,
1266 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "" },
1267 +       { iw_ioctl_GET_PRISM2_PARAM,
1268 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "" },
1269 +       /* --- sub-ioctls definitions --- */
1270 +       { PRISM2_PARAM_TXRATECTRL,
1271 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "txratectrl" },
1272 +       { PRISM2_PARAM_TXRATECTRL,
1273 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gettxratectrl" },
1274 +       { PRISM2_PARAM_BEACON_INT,
1275 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "beacon_int" },
1276 +       { PRISM2_PARAM_BEACON_INT,
1277 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbeacon_int" },
1278 +#ifndef PRISM2_NO_STATION_MODES
1279 +       { PRISM2_PARAM_PSEUDO_IBSS,
1280 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "pseudo_ibss" },
1281 +       { PRISM2_PARAM_PSEUDO_IBSS,
1282 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getpseudo_ibss" },
1283 +#endif /* PRISM2_NO_STATION_MODES */
1284 +       { PRISM2_PARAM_ALC,
1285 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "alc" },
1286 +       { PRISM2_PARAM_ALC,
1287 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getalc" },
1288 +       { PRISM2_PARAM_DUMP,
1289 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "dump" },
1290 +       { PRISM2_PARAM_DUMP,
1291 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getdump" },
1292 +       { PRISM2_PARAM_OTHER_AP_POLICY,
1293 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "other_ap_policy" },
1294 +       { PRISM2_PARAM_OTHER_AP_POLICY,
1295 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getother_ap_pol" },
1296 +       { PRISM2_PARAM_AP_MAX_INACTIVITY,
1297 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "max_inactivity" },
1298 +       { PRISM2_PARAM_AP_MAX_INACTIVITY,
1299 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmax_inactivi" },
1300 +       { PRISM2_PARAM_AP_BRIDGE_PACKETS,
1301 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "bridge_packets" },
1302 +       { PRISM2_PARAM_AP_BRIDGE_PACKETS,
1303 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbridge_packe" },
1304 +       { PRISM2_PARAM_DTIM_PERIOD,
1305 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "dtim_period" },
1306 +       { PRISM2_PARAM_DTIM_PERIOD,
1307 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getdtim_period" },
1308 +       { PRISM2_PARAM_AP_NULLFUNC_ACK,
1309 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "nullfunc_ack" },
1310 +       { PRISM2_PARAM_AP_NULLFUNC_ACK,
1311 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getnullfunc_ack" },
1312 +       { PRISM2_PARAM_MAX_WDS,
1313 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "max_wds" },
1314 +       { PRISM2_PARAM_MAX_WDS,
1315 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmax_wds" },
1316 +       { PRISM2_PARAM_AP_AUTOM_AP_WDS,
1317 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "autom_ap_wds" },
1318 +       { PRISM2_PARAM_AP_AUTOM_AP_WDS,
1319 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getautom_ap_wds" },
1320 +       { PRISM2_PARAM_AP_AUTH_ALGS,
1321 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "ap_auth_algs" },
1322 +       { PRISM2_PARAM_AP_AUTH_ALGS,
1323 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getap_auth_algs" },
1324 +       { PRISM2_PARAM_MONITOR_ALLOW_FCSERR,
1325 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "allow_fcserr" },
1326 +       { PRISM2_PARAM_MONITOR_ALLOW_FCSERR,
1327 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getallow_fcserr" },
1328 +       { PRISM2_PARAM_HOST_ENCRYPT,
1329 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "host_encrypt" },
1330 +       { PRISM2_PARAM_HOST_ENCRYPT,
1331 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethost_encrypt" },
1332 +       { PRISM2_PARAM_HOST_DECRYPT,
1333 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "host_decrypt" },
1334 +       { PRISM2_PARAM_HOST_DECRYPT,
1335 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethost_decrypt" },
1336 +       { PRISM2_PARAM_BUS_MASTER_THRESHOLD_RX,
1337 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "busmaster_rx" },
1338 +       { PRISM2_PARAM_BUS_MASTER_THRESHOLD_RX,
1339 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbusmaster_rx" },
1340 +       { PRISM2_PARAM_BUS_MASTER_THRESHOLD_TX,
1341 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "busmaster_tx" },
1342 +       { PRISM2_PARAM_BUS_MASTER_THRESHOLD_TX,
1343 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbusmaster_tx" },
1344 +#ifndef PRISM2_NO_STATION_MODES
1345 +       { PRISM2_PARAM_HOST_ROAMING,
1346 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "host_roaming" },
1347 +       { PRISM2_PARAM_HOST_ROAMING,
1348 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethost_roaming" },
1349 +#endif /* PRISM2_NO_STATION_MODES */
1350 +       { PRISM2_PARAM_BCRX_STA_KEY,
1351 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "bcrx_sta_key" },
1352 +       { PRISM2_PARAM_BCRX_STA_KEY,
1353 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbcrx_sta_key" },
1354 +       { PRISM2_PARAM_IEEE_802_1X,
1355 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "ieee_802_1x" },
1356 +       { PRISM2_PARAM_IEEE_802_1X,
1357 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getieee_802_1x" },
1358 +       { PRISM2_PARAM_ANTSEL_TX,
1359 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "antsel_tx" },
1360 +       { PRISM2_PARAM_ANTSEL_TX,
1361 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getantsel_tx" },
1362 +       { PRISM2_PARAM_ANTSEL_RX,
1363 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "antsel_rx" },
1364 +       { PRISM2_PARAM_ANTSEL_RX,
1365 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getantsel_rx" },
1366 +       { PRISM2_PARAM_MONITOR_TYPE,
1367 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "monitor_type" },
1368 +       { PRISM2_PARAM_MONITOR_TYPE,
1369 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmonitor_type" },
1370 +       { PRISM2_PARAM_WDS_TYPE,
1371 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wds_type" },
1372 +       { PRISM2_PARAM_WDS_TYPE,
1373 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getwds_type" },
1374 +       { PRISM2_PARAM_HOSTSCAN,
1375 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "hostscan" },
1376 +       { PRISM2_PARAM_HOSTSCAN,
1377 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostscan" },
1378 +       { PRISM2_PARAM_AP_SCAN,
1379 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "ap_scan" },
1380 +       { PRISM2_PARAM_AP_SCAN,
1381 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getap_scan" },
1382 +       { PRISM2_PARAM_ENH_SEC,
1383 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "enh_sec" },
1384 +       { PRISM2_PARAM_ENH_SEC,
1385 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getenh_sec" },
1386 +#ifdef PRISM2_IO_DEBUG
1387 +       { PRISM2_PARAM_IO_DEBUG,
1388 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "io_debug" },
1389 +       { PRISM2_PARAM_IO_DEBUG,
1390 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getio_debug" },
1391 +#endif /* PRISM2_IO_DEBUG */
1392 +       { PRISM2_PARAM_BASIC_RATES,
1393 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "basic_rates" },
1394 +       { PRISM2_PARAM_BASIC_RATES,
1395 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbasic_rates" },
1396 +       { PRISM2_PARAM_OPER_RATES,
1397 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "oper_rates" },
1398 +       { PRISM2_PARAM_OPER_RATES,
1399 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getoper_rates" },
1400 +       { PRISM2_PARAM_HOSTAPD,
1401 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "hostapd" },
1402 +       { PRISM2_PARAM_HOSTAPD,
1403 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostapd" },
1404 +       { PRISM2_PARAM_HOSTAPD_STA,
1405 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "hostapd_sta" },
1406 +       { PRISM2_PARAM_HOSTAPD_STA,
1407 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostapd_sta" },
1408 +       { PRISM2_PARAM_WPA,
1409 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wpa" },
1410 +       { PRISM2_PARAM_WPA,
1411 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getwpa" },
1412 +       { PRISM2_PARAM_PRIVACY_INVOKED,
1413 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "privacy_invoked" },
1414 +       { PRISM2_PARAM_PRIVACY_INVOKED,
1415 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getprivacy_invo" },
1416 +       { PRISM2_PARAM_TKIP_COUNTERMEASURES,
1417 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "tkip_countermea" },
1418 +       { PRISM2_PARAM_TKIP_COUNTERMEASURES,
1419 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gettkip_counter" },
1420 +       { PRISM2_PARAM_DROP_UNENCRYPTED,
1421 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "drop_unencrypte" },
1422 +       { PRISM2_PARAM_DROP_UNENCRYPTED,
1423 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getdrop_unencry" },
1424 +       { PRISM2_PARAM_SCAN_CHANNEL_MASK,
1425 +         IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "scan_channels" },
1426 +       { PRISM2_PARAM_SCAN_CHANNEL_MASK,
1427 +         0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getscan_channel" },
1428 +#endif /* PRISM2_USE_WE_SUB_IOCTLS */
1429 +};
1430 +#endif
1431 +
1432 +#if WIRELESS_EXT > 17
1433 +static int iw_ioctl_siwauth(struct net_device *dev,
1434 +                               struct iw_request_info *info,
1435 +                               struct iw_param *data, char *extra)
1436 +{
1437 +#if 0
1438 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
1439 +       u32 val, len;
1440 +
1441 +#if IOCTL_DBG
1442 +       printk("%s Call\n", __FUNCTION__);
1443 +#endif
1444 +       switch (data->flags & IW_AUTH_INDEX) {
1445 +       case IW_AUTH_WPA_VERSION:
1446 +       case IW_AUTH_CIPHER_PAIRWISE:
1447 +       case IW_AUTH_CIPHER_GROUP:
1448 +       case IW_AUTH_KEY_MGMT:
1449 +               /* Host AP driver does not use these parameters and allows
1450 +                * wpa_supplicant to control them internally. */
1451 +               break;
1452 +       case IW_AUTH_TKIP_COUNTERMEASURES:
1453 +               local->tkip_countermeasures = data->value;
1454 +               break;
1455 +       case IW_AUTH_DROP_UNENCRYPTED:
1456 +               local->drop_unencrypted = data->value;
1457 +               break;
1458 +       case IW_AUTH_80211_AUTH_ALG:
1459 +               local->auth_algs = data->value;
1460 +               break;
1461 +       case IW_AUTH_WPA_ENABLED:
1462 +               if (data->value == 0) {
1463 +                       local->wpa = 0;
1464 +                       if (local->sta_fw_ver < PRISM2_FW_VER(1,7,0))
1465 +                               break;
1466 +                       prism2_set_genericelement(dev, "", 0);
1467 +                       local->host_roaming = 0;
1468 +                       local->privacy_invoked = 0;
1469 +                       if (hostap_set_word(dev, HFA384X_RID_SSNHANDLINGMODE,
1470 +                                           0) ||
1471 +                           hostap_set_roaming(local) ||
1472 +                           hostap_set_encryption(local) ||
1473 +                           local->func->reset_port(dev))
1474 +                               return -EINVAL;
1475 +                       break;
1476 +               }
1477 +               if (local->sta_fw_ver < PRISM2_FW_VER(1,7,0))
1478 +                       return -EOPNOTSUPP;
1479 +               local->host_roaming = 2;
1480 +               local->privacy_invoked = 1;
1481 +               local->wpa = 1;
1482 +               if (hostap_set_word(dev, HFA384X_RID_SSNHANDLINGMODE, 1) ||
1483 +                   hostap_set_roaming(local) ||
1484 +                   hostap_set_encryption(local) ||
1485 +                   local->func->reset_port(dev))
1486 +                       return -EINVAL;
1487 +               break;
1488 +       case IW_AUTH_RX_UNENCRYPTED_EAPOL:
1489 +               local->ieee_802_1x = data->value;
1490 +               break;
1491 +       case IW_AUTH_PRIVACY_INVOKED:
1492 +               local->privacy_invoked = data->value;
1493 +               break;
1494 +       default:
1495 +               return -EOPNOTSUPP;
1496 +       }
1497 +       return 0;
1498 +#endif
1499 +       return -EOPNOTSUPP;
1500 +}
1501 +
1502 +
1503 +static int iw_ioctl_giwauth(struct net_device *dev,
1504 +                               struct iw_request_info *info,
1505 +                               struct iw_param *data, char *extra)
1506 +{
1507 +#if 0
1508 +       PTIWLN_ADAPTER_T pAdapter = &(((tiwlan_net_dev_t *)(dev->priv))->adapter);
1509 +       u32 val, len;
1510 +
1511 +#if IOCTL_DBG
1512 +       printk("%s Call\n", __FUNCTION__);
1513 +#endif
1514 +       switch (data->flags & IW_AUTH_INDEX) {
1515 +       case IW_AUTH_WPA_VERSION:
1516 +       case IW_AUTH_CIPHER_PAIRWISE:
1517 +       case IW_AUTH_CIPHER_GROUP:
1518 +       case IW_AUTH_KEY_MGMT:
1519 +               /* Host AP driver does not use these parameters and allows
1520 +                * wpa_supplicant to control them internally. */
1521 +               return -EOPNOTSUPP;
1522 +       case IW_AUTH_TKIP_COUNTERMEASURES:
1523 +               data->value = local->tkip_countermeasures;
1524 +               break;
1525 +       case IW_AUTH_DROP_UNENCRYPTED:
1526 +               data->value = local->drop_unencrypted;
1527 +               break;
1528 +       case IW_AUTH_80211_AUTH_ALG:
1529 +               data->value = local->auth_algs;
1530 +               break;
1531 +       case IW_AUTH_WPA_ENABLED:
1532 +               data->value = local->wpa;
1533 +               break;
1534 +       case IW_AUTH_RX_UNENCRYPTED_EAPOL:
1535 +               data->value = local->ieee_802_1x;
1536 +               break;
1537 +       default:
1538 +               return -EOPNOTSUPP;
1539 +       }
1540 +       return 0;
1541 +#endif
1542 +       return -EOPNOTSUPP;
1543 +}
1544 +
1545 +
1546 +static int iw_ioctl_siwencodeext(struct net_device *dev,
1547 +                                    struct iw_request_info *info,
1548 +                                    struct iw_point *erq, char *extra)
1549 +{
1550 +
1551 +#if IOCTL_DBG
1552 +       printk("%s Call\n", __FUNCTION__);
1553 +#endif
1554 +#if 0
1555 +       struct hostap_interface *iface = dev->priv;
1556 +       local_info_t *local = iface->local;
1557 +       struct iw_encode_ext *ext = (struct iw_encode_ext *) extra;
1558 +       int i, ret = 0;
1559 +       struct hostap_crypto_ops *ops;
1560 +       struct prism2_crypt_data **crypt;
1561 +       void *sta_ptr;
1562 +       u8 *addr;
1563 +       const char *alg, *module;
1564 +
1565 +       i = erq->flags & IW_ENCODE_INDEX;
1566 +       if (i > WEP_KEYS)
1567 +               return -EINVAL;
1568 +       if (i < 1 || i > WEP_KEYS)
1569 +               i = local->tx_keyidx;
1570 +       else
1571 +               i--;
1572 +       if (i < 0 || i >= WEP_KEYS)
1573 +               return -EINVAL;
1574 +
1575 +       addr = ext->addr.sa_data;
1576 +       if (addr[0] == 0xff && addr[1] == 0xff && addr[2] == 0xff &&
1577 +           addr[3] == 0xff && addr[4] == 0xff && addr[5] == 0xff) {
1578 +               sta_ptr = NULL;
1579 +               crypt = &local->crypt[i];
1580 +       } else {
1581 +               if (i != 0)
1582 +                       return -EINVAL;
1583 +               sta_ptr = ap_crypt_get_ptrs(local->ap, addr, 0, &crypt);
1584 +               if (sta_ptr == NULL) {
1585 +                       if (local->iw_mode == IW_MODE_INFRA) {
1586 +                               /* TODO: add STA entry for the current AP so
1587 +                                * that unicast key can be used. For now, this
1588 +                                * is emulated by using default key idx 0. */
1589 +                               i = 0;
1590 +                               crypt = &local->crypt[i];
1591 +                       } else
1592 +                               return -EINVAL;
1593 +               }
1594 +       }
1595 +
1596 +       if ((erq->flags & IW_ENCODE_DISABLED) ||
1597 +           ext->alg == IW_ENCODE_ALG_NONE) {
1598 +               if (*crypt)
1599 +                       prism2_crypt_delayed_deinit(local, crypt);
1600 +               goto done;
1601 +       }
1602 +
1603 +       switch (ext->alg) {
1604 +       case IW_ENCODE_ALG_WEP:
1605 +               alg = "WEP";
1606 +               module = "hostap_crypt_wep";
1607 +               break;
1608 +       case IW_ENCODE_ALG_TKIP:
1609 +               alg = "TKIP";
1610 +               module = "hostap_crypt_tkip";
1611 +               break;
1612 +       case IW_ENCODE_ALG_CCMP:
1613 +               alg = "CCMP";
1614 +               module = "hostap_crypt_ccmp";
1615 +               break;
1616 +       default:
1617 +               printk(KERN_DEBUG "%s: unsupported algorithm %d\n",
1618 +                      local->dev->name, ext->alg);
1619 +               ret = -EOPNOTSUPP;
1620 +               goto done;
1621 +       }
1622 +
1623 +       ops = hostap_get_crypto_ops(alg);
1624 +       if (ops == NULL) {
1625 +               request_module(module);
1626 +               ops = hostap_get_crypto_ops(alg);
1627 +       }
1628 +       if (ops == NULL) {
1629 +               printk(KERN_DEBUG "%s: unknown crypto alg '%s'\n",
1630 +                      local->dev->name, alg);
1631 +               ret = -EOPNOTSUPP;
1632 +               goto done;
1633 +       }
1634 +
1635 +       if (sta_ptr || ext->alg != IW_ENCODE_ALG_WEP) {
1636 +               /* station based encryption and other than WEP algorithms
1637 +                * require host-based encryption, so force them on
1638 +                * automatically */
1639 +               local->host_decrypt = local->host_encrypt = 1;
1640 +       }
1641 +
1642 +       if (*crypt == NULL || (*crypt)->ops != ops) {
1643 +               struct prism2_crypt_data *new_crypt;
1644 +
1645 +               prism2_crypt_delayed_deinit(local, crypt);
1646 +
1647 +               new_crypt = (struct prism2_crypt_data *)
1648 +                       kmalloc(sizeof(struct prism2_crypt_data), GFP_KERNEL);
1649 +               if (new_crypt == NULL) {
1650 +                       ret = -ENOMEM;
1651 +                       goto done;
1652 +               }
1653 +               memset(new_crypt, 0, sizeof(struct prism2_crypt_data));
1654 +               new_crypt->ops = ops;
1655 +               new_crypt->priv = new_crypt->ops->init(i);
1656 +               if (new_crypt->priv == NULL) {
1657 +                       kfree(new_crypt);
1658 +                       ret = -EINVAL;
1659 +                       goto done;
1660 +               }
1661 +
1662 +               *crypt = new_crypt;
1663 +       }
1664 +
1665 +       /* TODO: if ext_flags does not have IW_ENCODE_EXT_RX_SEQ_VALID, the
1666 +        * existing seq# should not be changed. */
1667 +       /* TODO: if ext_flags has IW_ENCODE_EXT_TX_SEQ_VALID, next TX seq#
1668 +        * should be changed to something else than zero. */
1669 +       if ((!(ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) || ext->key_len > 0)
1670 +           && (*crypt)->ops->set_key &&
1671 +           (*crypt)->ops->set_key(ext->key, ext->key_len, ext->rx_seq,
1672 +                                  (*crypt)->priv) < 0) {
1673 +               printk(KERN_DEBUG "%s: key setting failed\n",
1674 +                      local->dev->name);
1675 +               ret = -EINVAL;
1676 +               goto done;
1677 +       }
1678 +
1679 +       if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
1680 +               if (!sta_ptr)
1681 +                       local->tx_keyidx = i;
1682 +               else if (i) {
1683 +                       ret = -EINVAL;
1684 +                       goto done;
1685 +               }
1686 +       }
1687 +
1688 +
1689 +       if (sta_ptr == NULL && ext->key_len > 0) {
1690 +               int first = 1, j;
1691 +               for (j = 0; j < WEP_KEYS; j++) {
1692 +                       if (j != i && local->crypt[j]) {
1693 +                               first = 0;
1694 +                               break;
1695 +                       }
1696 +               }
1697 +               if (first)
1698 +                       local->tx_keyidx = i;
1699 +       }
1700 +
1701 + done:
1702 +       if (sta_ptr)
1703 +               hostap_handle_sta_release(sta_ptr);
1704 +
1705 +       local->open_wep = erq->flags & IW_ENCODE_OPEN;
1706 +
1707 +       /* Do not reset port0 if card is in Managed mode since resetting will
1708 +        * generate new IEEE 802.11 authentication which may end up in looping
1709 +        * with IEEE 802.1X. Prism2 documentation seem to require port reset
1710 +        * after WEP configuration. However, keys are apparently changed at
1711 +        * least in Managed mode. */
1712 +       if (ret == 0 &&
1713 +           (hostap_set_encryption(local) ||
1714 +            (local->iw_mode != IW_MODE_INFRA &&
1715 +             local->func->reset_port(local->dev))))
1716 +               ret = -EINVAL;
1717 +
1718 +       return ret;
1719 +#endif
1720 +       return -EOPNOTSUPP;
1721 +}
1722 +
1723 +
1724 +static int iw_ioctl_giwencodeext(struct net_device *dev,
1725 +                                    struct iw_request_info *info,
1726 +                                    struct iw_point *erq, char *extra)
1727 +{
1728 +#if IOCTL_DBG
1729 +       printk("%s Call\n", __FUNCTION__);
1730 +#endif
1731 +#if 0
1732 +       struct hostap_interface *iface = dev->priv;
1733 +       local_info_t *local = iface->local;
1734 +       struct prism2_crypt_data **crypt;
1735 +       void *sta_ptr;
1736 +       int max_key_len, i;
1737 +       struct iw_encode_ext *ext = (struct iw_encode_ext *) extra;
1738 +       u8 *addr;
1739 +
1740 +       max_key_len = erq->length - sizeof(*ext);
1741 +       if (max_key_len < 0)
1742 +               return -EINVAL;
1743 +
1744 +       i = erq->flags & IW_ENCODE_INDEX;
1745 +       if (i < 1 || i > WEP_KEYS)
1746 +               i = local->tx_keyidx;
1747 +       else
1748 +               i--;
1749 +
1750 +       addr = ext->addr.sa_data;
1751 +       if (addr[0] == 0xff && addr[1] == 0xff && addr[2] == 0xff &&
1752 +           addr[3] == 0xff && addr[4] == 0xff && addr[5] == 0xff) {
1753 +               sta_ptr = NULL;
1754 +               crypt = &local->crypt[i];
1755 +       } else {
1756 +               i = 0;
1757 +               sta_ptr = ap_crypt_get_ptrs(local->ap, addr, 0, &crypt);
1758 +               if (sta_ptr == NULL)
1759 +                       return -EINVAL;
1760 +       }
1761 +       erq->flags = i + 1;
1762 +       memset(ext, 0, sizeof(*ext));
1763 +
1764 +       if (*crypt == NULL || (*crypt)->ops == NULL) {
1765 +               ext->alg = IW_ENCODE_ALG_NONE;
1766 +               ext->key_len = 0;
1767 +               erq->flags |= IW_ENCODE_DISABLED;
1768 +       } else {
1769 +               if (strcmp((*crypt)->ops->name, "WEP") == 0)
1770 +                       ext->alg = IW_ENCODE_ALG_WEP;
1771 +               else if (strcmp((*crypt)->ops->name, "TKIP") == 0)
1772 +                       ext->alg = IW_ENCODE_ALG_TKIP;
1773 +               else if (strcmp((*crypt)->ops->name, "CCMP") == 0)
1774 +                       ext->alg = IW_ENCODE_ALG_CCMP;
1775 +               else
1776 +                       return -EINVAL;
1777 +
1778 +               if ((*crypt)->ops->get_key) {
1779 +                       ext->key_len =
1780 +                               (*crypt)->ops->get_key(ext->key,
1781 +                                                      max_key_len,
1782 +                                                      ext->tx_seq,
1783 +                                                      (*crypt)->priv);
1784 +                       if (ext->key_len &&
1785 +                           (ext->alg == IW_ENCODE_ALG_TKIP ||
1786 +                            ext->alg == IW_ENCODE_ALG_CCMP))
1787 +                               ext->ext_flags |= IW_ENCODE_EXT_TX_SEQ_VALID;
1788 +               }
1789 +       }
1790 +
1791 +       if (sta_ptr)
1792 +               hostap_handle_sta_release(sta_ptr);
1793 +
1794 +       return 0;
1795 +#endif
1796 +       return -EOPNOTSUPP;
1797 +}
1798 +#endif /* WIRELESS_EXT > 17 */
1799 +
1800 +
1801 +#if WIRELESS_EXT > 17
1802 +static int iw_ioctl_siwgenie(struct net_device *dev,
1803 +                                struct iw_request_info *info,
1804 +                                struct iw_point *data, char *extra)
1805 +{
1806 +#if IOCTL_DBG
1807 +       printk("%s Call\n", __FUNCTION__);
1808 +#endif
1809 +               return -EOPNOTSUPP;
1810 +}
1811 +#endif
1812 +
1813 +static int iw_ioctl_giwgenie(struct net_device *dev,
1814 +                                struct iw_request_info *info,
1815 +                                struct iw_point *data, char *extra)
1816 +{
1817 +#if IOCTL_DBG
1818 +       printk("%s Call\n", __FUNCTION__);
1819 +#endif
1820 +               return -EOPNOTSUPP;
1821 +}
1822 +
1823 +
1824 +#if WIRELESS_EXT > 17
1825 +static int iw_ioctl_siwmlme(struct net_device *dev,
1826 +                               struct iw_request_info *info,
1827 +                               struct iw_point *data, char *extra)
1828 +{
1829 +#if IOCTL_DBG
1830 +       printk("%s Call\n", __FUNCTION__);
1831 +#endif
1832 +               return -EOPNOTSUPP;
1833 +}
1834 +#endif
1835 +
1836 +/* Structures to export the Wireless Handlers */
1837 +
1838 +static const iw_handler ti_handler[] =
1839 +{
1840 +       (iw_handler) NULL,                                              /* SIOCSIWCOMMIT */
1841 +       (iw_handler) iw_get_name,                               /* SIOCGIWNAME */
1842 +       (iw_handler) NULL,                                              /* SIOCSIWNWID */
1843 +       (iw_handler) NULL,                                              /* SIOCGIWNWID */
1844 +       (iw_handler) iw_ioctl_siwfreq,                  /* SIOCSIWFREQ */
1845 +       (iw_handler) iw_ioctl_giwfreq,                  /* SIOCGIWFREQ */
1846 +       (iw_handler) iw_ioctl_siwmode,                  /* SIOCSIWMODE */
1847 +       (iw_handler) iw_ioctl_giwmode,                  /* SIOCGIWMODE */
1848 +       (iw_handler) iw_ioctl_siwsens,                  /* SIOCSIWSENS */
1849 +       (iw_handler) iw_ioctl_giwsens,                  /* SIOCGIWSENS */
1850 +       (iw_handler) NULL /* not used */,               /* SIOCSIWRANGE */
1851 +       (iw_handler) iw_ioctl_giwrange,                 /* SIOCGIWRANGE */
1852 +       (iw_handler) NULL /* not used */,               /* SIOCSIWPRIV */
1853 +       (iw_handler) NULL /* kernel code */,    /* SIOCGIWPRIV */
1854 +       (iw_handler) NULL /* not used */,               /* SIOCSIWSTATS */
1855 +       (iw_handler) NULL /* kernel code */,    /* SIOCGIWSTATS */
1856 +#if WIRELESS_EXT > 15
1857 +       (iw_handler) NULL,                                              /* SIOCSIWSPY */
1858 +       (iw_handler) NULL,                                              /* SIOCGIWSPY */
1859 +       (iw_handler) NULL,                                              /* SIOCSIWTHRSPY */
1860 +       (iw_handler) NULL,                                              /* SIOCGIWTHRSPY */
1861 +#else /* WIRELESS_EXT > 15 */
1862 +       (iw_handler) NULL,                                              /* SIOCSIWSPY */
1863 +       (iw_handler) NULL,                                              /* SIOCGIWSPY */
1864 +       (iw_handler) NULL,                                              /* -- hole -- */
1865 +       (iw_handler) NULL,                                              /* -- hole -- */
1866 +#endif /* WIRELESS_EXT > 15 */
1867 +       (iw_handler) iw_ioctl_siwap,                    /* SIOCSIWAP */
1868 +       (iw_handler) iw_ioctl_giwap,                    /* SIOCGIWAP */
1869 +#if WIRELESS_EXT > 17
1870 +       (iw_handler) iw_ioctl_siwmlme,                  /* SIOCSIWMLME */
1871 +#else /* WIRELESS_EXT > 17 */
1872 +       (iw_handler) NULL,                              /* -- hole -- */
1873 +#endif /* WIRELESS_EXT > 17 */
1874 +       (iw_handler) iw_ioctl_giwaplist,                /* SIOCGIWAPLIST */
1875 +       (iw_handler) iw_ioctl_siwscan,                  /* SIOCSIWSCAN */
1876 +       (iw_handler) iw_ioctl_giwscan,                  /* SIOCGIWSCAN */
1877 +       (iw_handler) iw_ioctl_siwessid,                 /* SIOCSIWESSID */
1878 +       (iw_handler) iw_ioctl_giwessid,                 /* SIOCGIWESSID */
1879 +       (iw_handler) NULL,                                              /* SIOCSIWNICKN */
1880 +       (iw_handler) iw_ioctl_giwnickn,                 /* SIOCGIWNICKN */
1881 +       (iw_handler) NULL,                                              /* -- hole -- */
1882 +       (iw_handler) NULL,                                              /* -- hole -- */
1883 +       (iw_handler) iw_ioctl_siwrate,                  /* SIOCSIWRATE */
1884 +       (iw_handler) iw_ioctl_giwrate,                  /* SIOCGIWRATE */
1885 +       (iw_handler) iw_ioctl_siwrts,                   /* SIOCSIWRTS */
1886 +       (iw_handler) iw_ioctl_giwrts,                   /* SIOCGIWRTS */
1887 +       (iw_handler) iw_ioctl_siwfrag,                  /* SIOCSIWFRAG */
1888 +       (iw_handler) iw_ioctl_giwfrag,                  /* SIOCGIWFRAG */
1889 +       (iw_handler) iw_ioctl_siwtxpow,                 /* SIOCSIWTXPOW */
1890 +       (iw_handler) iw_ioctl_giwtxpow,                 /* SIOCGIWTXPOW */
1891 +       (iw_handler) iw_ioctl_siwretry,                 /* SIOCSIWRETRY */
1892 +       (iw_handler) iw_ioctl_giwretry,                 /* SIOCGIWRETRY */
1893 +       (iw_handler) iw_ioctl_siwencode,                /* SIOCSIWENCODE */
1894 +       (iw_handler) iw_ioctl_giwencode,                /* SIOCGIWENCODE */
1895 +       (iw_handler) iw_ioctl_siwpower,                 /* SIOCSIWPOWER */
1896 +       (iw_handler) iw_ioctl_giwpower,                 /* SIOCGIWPOWER */
1897 +#if WIRELESS_EXT > 17
1898 +       (iw_handler) NULL,                                              /* -- hole -- */
1899 +       (iw_handler) NULL,                                              /* -- hole -- */
1900 +       (iw_handler) iw_ioctl_siwgenie,                 /* SIOCSIWGENIE */
1901 +       (iw_handler) iw_ioctl_giwgenie,                 /* SIOCGIWGENIE */
1902 +       (iw_handler) iw_ioctl_siwauth,                  /* SIOCSIWAUTH */
1903 +       (iw_handler) iw_ioctl_giwauth,                  /* SIOCGIWAUTH */
1904 +       (iw_handler) iw_ioctl_siwencodeext,             /* SIOCSIWENCODEEXT */
1905 +       (iw_handler) iw_ioctl_giwencodeext,             /* SIOCGIWENCODEEXT */
1906 +       (iw_handler) NULL,                                              /* SIOCSIWPMKSA */
1907 +       (iw_handler) NULL,                                              /* -- hole -- */
1908 +#endif /* WIRELESS_EXT > 17 */
1909 +};
1910 +
1911 +#if 0
1912 +static const iw_handler ti_private_handler[] =
1913 +{                                                      /* SIOCIWFIRSTPRIV + */
1914 +       (iw_handler) iw_ioctl_priv_prism2_param,        /* 0 */
1915 +       (iw_handler) iw_ioctl_priv_get_prism2_param, /* 1 */
1916 +       (iw_handler) iw_ioctl_priv_writemif,    /* 2 */
1917 +       (iw_handler) iw_ioctl_priv_readmif,             /* 3 */
1918 +};
1919 +#endif
1920 +
1921 +static const struct iw_handler_def ti_iw_handler_def =
1922 +{
1923 +       .num_standard   = sizeof(ti_handler) / sizeof(iw_handler),
1924 +//     .num_private    = sizeof(ti_private_handler) / sizeof(iw_handler),
1925 +//     .num_private_args = sizeof(ti_priv) / sizeof(struct iw_priv_args),
1926 +       .standard       = (iw_handler *) ti_handler,
1927 +//     .private        = (iw_handler *) ti_private_handler,
1928 +//     .private_args   = (struct iw_priv_args *) ti_priv,
1929 +#if WIRELESS_EXT == 16
1930 +//     .spy_offset     = offsetof(struct hostap_interface, spy_data),
1931 +#endif /* WIRELESS_EXT == 16 */
1932 +#if WIRELESS_EXT > 16
1933 +//     .get_wireless_stats = ti_get_wireless_stats,
1934 +#endif /* WIRELESS_EXT > 16 */
1935 +};
1936 +
1937 +void tiwlan_iwhandler_init(struct net_device *dev)
1938 +{
1939 +   dev->wireless_handlers = (struct iw_handler_def *) &ti_iw_handler_def;
1940 +}
1941 diff --git a/sta_dk_4_0_4_32/pform/linux/src/osapi.c b/sta_dk_4_0_4_32/pform/linux/src/osapi.c
1942 old mode 100644
1943 new mode 100755
1944 index a5a798c..002fd60
1945 --- a/sta_dk_4_0_4_32/pform/linux/src/osapi.c
1946 +++ b/sta_dk_4_0_4_32/pform/linux/src/osapi.c
1947 @@ -99,7 +99,12 @@ static int os_tl_timerHandlr(struct tiwlan_req *req);
1948  static void os_timerHandlr(unsigned long parm);
1949  static void send_frag(char* msg, int message_len, int level, int module);
1950
1951 -BOOL use_debug_module = FALSE;
1952 +/* linux/irq.h declerations */\r
1953 +extern void disable_irq(unsigned int);\r
1954 +extern void enable_irq(unsigned int);\r
1955 +\r
1956 +BOOL use_debug_module = FALSE;\r
1957 +#define debug_module_enqueue_message
1958
1959  /****************************************************************************************
1960   *                                                                                                                                                     *
1961 --
1962 1.6.3.1
1963