git.oblomov.eu Git - linux-2.6/blob - drivers/net/wireless/libertas/scan.c

   1 /* -*- mode: C; tab-width: 4; indent-tabs-mode: nil -*- */
   2 /* vi: set expandtab shiftwidth=4 tabstop=4 textwidth=78: */
   3
   4 /**
   5   * Functions implementing wlan scan IOCTL and firmware command APIs
   6   *
   7   * IOCTL handlers as well as command preperation and response routines
   8   *  for sending scan commands to the firmware.
   9   */
  10 #include <linux/ctype.h>
  11 #include <linux/if.h>
  12 #include <linux/netdevice.h>
  13 #include <linux/wireless.h>
  14
  15 #include <net/ieee80211.h>
  16 #include <net/iw_handler.h>
  17
  18 #include "host.h"
  19 #include "decl.h"
  20 #include "dev.h"
  21 #include "scan.h"
  22
  23 //! Approximate amount of data needed to pass a scan result back to iwlist
  24 #define MAX_SCAN_CELL_SIZE  (IW_EV_ADDR_LEN             \
  25                              + IW_ESSID_MAX_SIZE        \
  26                              + IW_EV_UINT_LEN           \
  27                              + IW_EV_FREQ_LEN           \
  28                              + IW_EV_QUAL_LEN           \
  29                              + IW_ESSID_MAX_SIZE        \
  30                              + IW_EV_PARAM_LEN          \
  31                              + 40)      /* 40 for WPAIE */
  32
  33 //! Memory needed to store a max sized channel List TLV for a firmware scan
  34 #define CHAN_TLV_MAX_SIZE  (sizeof(struct mrvlietypesheader)    \
  35                             + (MRVDRV_MAX_CHANNELS_PER_SCAN     \
  36                                * sizeof(struct chanscanparamset)))
  37
  38 //! Memory needed to store a max number/size SSID TLV for a firmware scan
  39 #define SSID_TLV_MAX_SIZE  (1 * sizeof(struct mrvlietypes_ssidparamset))
  40
  41 //! Maximum memory needed for a wlan_scan_cmd_config with all TLVs at max
  42 #define MAX_SCAN_CFG_ALLOC (sizeof(struct wlan_scan_cmd_config)  \
  43                             + sizeof(struct mrvlietypes_numprobes)   \
  44                             + CHAN_TLV_MAX_SIZE                 \
  45                             + SSID_TLV_MAX_SIZE)
  46
  47 //! The maximum number of channels the firmware can scan per command
  48 #define MRVDRV_MAX_CHANNELS_PER_SCAN   14
  49
  50 /**
  51  * @brief Number of channels to scan per firmware scan command issuance.
  52  *
  53  *  Number restricted to prevent hitting the limit on the amount of scan data
  54  *  returned in a single firmware scan command.
  55  */
  56 #define MRVDRV_CHANNELS_PER_SCAN_CMD   4
  57
  58 //! Scan time specified in the channel TLV for each channel for passive scans
  59 #define MRVDRV_PASSIVE_SCAN_CHAN_TIME  100
  60
  61 //! Scan time specified in the channel TLV for each channel for active scans
  62 #define MRVDRV_ACTIVE_SCAN_CHAN_TIME   100
  63
  64 //! Macro to enable/disable SSID checking before storing a scan table
  65 #ifdef DISCARD_BAD_SSID
  66 #define CHECK_SSID_IS_VALID(x) ssid_valid(&bssidEntry.ssid)
  67 #else
  68 #define CHECK_SSID_IS_VALID(x) 1
  69 #endif
  70
  71 /**
  72  *  @brief Check if a scanned network compatible with the driver settings
  73  *
  74  *   WEP     WPA     WPA2    ad-hoc  encrypt                      Network
  75  * enabled enabled  enabled   AES     mode   privacy  WPA  WPA2  Compatible
  76  *    0       0        0       0      NONE      0      0    0   yes No security
  77  *    1       0        0       0      NONE      1      0    0   yes Static WEP
  78  *    0       1        0       0       x        1x     1    x   yes WPA
  79  *    0       0        1       0       x        1x     x    1   yes WPA2
  80  *    0       0        0       1      NONE      1      0    0   yes Ad-hoc AES
  81  *    0       0        0       0     !=NONE     1      0    0   yes Dynamic WEP
  82  *
  83  *
  84  *  @param adapter A pointer to wlan_adapter
  85  *  @param index   Index in scantable to check against current driver settings
  86  *  @param mode    Network mode: Infrastructure or IBSS
  87  *
  88  *  @return        Index in scantable, or error code if negative
  89  */
  90 static int is_network_compatible(wlan_adapter * adapter, int index, int mode)
  91 {
  92         ENTER();
  93
  94         if (adapter->scantable[index].inframode == mode) {
  95                 if (adapter->secinfo.WEPstatus == wlan802_11WEPdisabled
  96                     && !adapter->secinfo.WPAenabled
  97                     && !adapter->secinfo.WPA2enabled
  98                     && adapter->scantable[index].wpa_supplicant.wpa_ie[0] !=
  99                     WPA_IE
 100                     && adapter->scantable[index].wpa2_supplicant.wpa_ie[0] !=
 101                     WPA2_IE && adapter->secinfo.Encryptionmode == CIPHER_NONE
 102                     && !adapter->scantable[index].privacy) {
 103                         /* no security */
 104                         LEAVE();
 105                         return index;
 106                 } else if (adapter->secinfo.WEPstatus == wlan802_11WEPenabled
 107                            && !adapter->secinfo.WPAenabled
 108                            && !adapter->secinfo.WPA2enabled
 109                            && adapter->scantable[index].privacy) {
 110                         /* static WEP enabled */
 111                         LEAVE();
 112                         return index;
 113                 } else if (adapter->secinfo.WEPstatus == wlan802_11WEPdisabled
 114                            && adapter->secinfo.WPAenabled
 115                            && !adapter->secinfo.WPA2enabled
 116                            && (adapter->scantable[index].wpa_supplicant.
 117                                wpa_ie[0]
 118                                == WPA_IE)
 119                            /* privacy bit may NOT be set in some APs like LinkSys WRT54G
 120                               && adapter->scantable[index].privacy */
 121                     ) {
 122                         /* WPA enabled */
 123             lbs_pr_debug(1,
 124                                "is_network_compatible() WPA: index=%d wpa_ie=%#x "
 125                                "wpa2_ie=%#x WEP=%s WPA=%s WPA2=%s Encmode=%#x "
 126                                "privacy=%#x\n", index,
 127                                adapter->scantable[index].wpa_supplicant.
 128                                wpa_ie[0],
 129                                adapter->scantable[index].wpa2_supplicant.
 130                                wpa_ie[0],
 131                                (adapter->secinfo.WEPstatus ==
 132                                 wlan802_11WEPenabled) ? "e" : "d",
 133                                (adapter->secinfo.WPAenabled) ? "e" : "d",
 134                                (adapter->secinfo.WPA2enabled) ? "e" : "d",
 135                                adapter->secinfo.Encryptionmode,
 136                                adapter->scantable[index].privacy);
 137                         LEAVE();
 138                         return index;
 139                 } else if (adapter->secinfo.WEPstatus == wlan802_11WEPdisabled
 140                            && !adapter->secinfo.WPAenabled
 141                            && adapter->secinfo.WPA2enabled
 142                            && (adapter->scantable[index].wpa2_supplicant.
 143                                wpa_ie[0]
 144                                == WPA2_IE)
 145                            /* privacy bit may NOT be set in some APs like LinkSys WRT54G
 146                               && adapter->scantable[index].privacy */
 147                     ) {
 148                         /* WPA2 enabled */
 149             lbs_pr_debug(1,
 150                                "is_network_compatible() WPA2: index=%d wpa_ie=%#x "
 151                                "wpa2_ie=%#x WEP=%s WPA=%s WPA2=%s Encmode=%#x "
 152                                "privacy=%#x\n", index,
 153                                adapter->scantable[index].wpa_supplicant.
 154                                wpa_ie[0],
 155                                adapter->scantable[index].wpa2_supplicant.
 156                                wpa_ie[0],
 157                                (adapter->secinfo.WEPstatus ==
 158                                 wlan802_11WEPenabled) ? "e" : "d",
 159                                (adapter->secinfo.WPAenabled) ? "e" : "d",
 160                                (adapter->secinfo.WPA2enabled) ? "e" : "d",
 161                                adapter->secinfo.Encryptionmode,
 162                                adapter->scantable[index].privacy);
 163                         LEAVE();
 164                         return index;
 165                 } else if (adapter->secinfo.WEPstatus == wlan802_11WEPdisabled
 166                            && !adapter->secinfo.WPAenabled
 167                            && !adapter->secinfo.WPA2enabled
 168                            && (adapter->scantable[index].wpa_supplicant.
 169                                wpa_ie[0]
 170                                != WPA_IE)
 171                            && (adapter->scantable[index].wpa2_supplicant.
 172                                wpa_ie[0]
 173                                != WPA2_IE)
 174                            && adapter->secinfo.Encryptionmode != CIPHER_NONE
 175                            && adapter->scantable[index].privacy) {
 176                         /* dynamic WEP enabled */
 177             lbs_pr_debug(1,
 178                                "is_network_compatible() dynamic WEP: index=%d "
 179                                "wpa_ie=%#x wpa2_ie=%#x Encmode=%#x privacy=%#x\n",
 180                                index,
 181                                adapter->scantable[index].wpa_supplicant.
 182                                wpa_ie[0],
 183                                adapter->scantable[index].wpa2_supplicant.
 184                                wpa_ie[0], adapter->secinfo.Encryptionmode,
 185                                adapter->scantable[index].privacy);
 186                         LEAVE();
 187                         return index;
 188                 }
 189
 190                 /* security doesn't match */
 191         lbs_pr_debug(1,
 192                        "is_network_compatible() FAILED: index=%d wpa_ie=%#x "
 193                        "wpa2_ie=%#x WEP=%s WPA=%s WPA2=%s Encmode=%#x privacy=%#x\n",
 194                        index,
 195                        adapter->scantable[index].wpa_supplicant.wpa_ie[0],
 196                        adapter->scantable[index].wpa2_supplicant.wpa_ie[0],
 197                        (adapter->secinfo.WEPstatus ==
 198                         wlan802_11WEPenabled) ? "e" : "d",
 199                        (adapter->secinfo.WPAenabled) ? "e" : "d",
 200                        (adapter->secinfo.WPA2enabled) ? "e" : "d",
 201                        adapter->secinfo.Encryptionmode,
 202                        adapter->scantable[index].privacy);
 203                 LEAVE();
 204                 return -ECONNREFUSED;
 205         }
 206
 207         /* mode doesn't match */
 208         LEAVE();
 209         return -ENETUNREACH;
 210 }
 211
 212 /**
 213  *  @brief This function validates a SSID as being able to be printed
 214  *
 215  *  @param pssid   SSID structure to validate
 216  *
 217  *  @return        TRUE or FALSE
 218  */
 219 static u8 ssid_valid(struct WLAN_802_11_SSID *pssid)
 220 {
 221         int ssididx;
 222
 223         for (ssididx = 0; ssididx < pssid->ssidlength; ssididx++) {
 224                 if (!isprint(pssid->ssid[ssididx])) {
 225                         return 0;
 226                 }
 227         }
 228
 229         return 1;
 230 }
 231
 232 /**
 233  *  @brief Post process the scan table after a new scan command has completed
 234  *
 235  *  Inspect each entry of the scan table and try to find an entry that
 236  *    matches our current associated/joined network from the scan.  If
 237  *    one is found, update the stored copy of the bssdescriptor for our
 238  *    current network.
 239  *
 240  *  Debug dump the current scan table contents if compiled accordingly.
 241  *
 242  *  @param priv   A pointer to wlan_private structure
 243  *
 244  *  @return       void
 245  */
 246 static void wlan_scan_process_results(wlan_private * priv)
 247 {
 248         wlan_adapter *adapter = priv->adapter;
 249         int foundcurrent;
 250         int i;
 251
 252         foundcurrent = 0;
 253
 254         if (adapter->connect_status == libertas_connected) {
 255                 /* try to find the current BSSID in the new scan list */
 256                 for (i = 0; i < adapter->numinscantable; i++) {
 257                         if (!libertas_SSID_cmp(&adapter->scantable[i].ssid,
 258                                      &adapter->curbssparams.ssid) &&
 259                             !memcmp(adapter->curbssparams.bssid,
 260                                     adapter->scantable[i].macaddress,
 261                                     ETH_ALEN)) {
 262                                 foundcurrent = 1;
 263                         }
 264                 }
 265
 266                 if (foundcurrent) {
 267                         /* Make a copy of current BSSID descriptor */
 268                         memcpy(&adapter->curbssparams.bssdescriptor,
 269                                &adapter->scantable[i],
 270                                sizeof(adapter->curbssparams.bssdescriptor));
 271                 }
 272         }
 273
 274         for (i = 0; i < adapter->numinscantable; i++) {
 275                 lbs_pr_debug(1, "Scan:(%02d) %02x:%02x:%02x:%02x:%02x:%02x, "
 276                        "RSSI[%03d], SSID[%s]\n",
 277                        i,
 278                        adapter->scantable[i].macaddress[0],
 279                        adapter->scantable[i].macaddress[1],
 280                        adapter->scantable[i].macaddress[2],
 281                        adapter->scantable[i].macaddress[3],
 282                        adapter->scantable[i].macaddress[4],
 283                        adapter->scantable[i].macaddress[5],
 284                        (s32) adapter->scantable[i].rssi,
 285                        adapter->scantable[i].ssid.ssid);
 286         }
 287 }
 288
 289 /**
 290  *  @brief Create a channel list for the driver to scan based on region info
 291  *
 292  *  Use the driver region/band information to construct a comprehensive list
 293  *    of channels to scan.  This routine is used for any scan that is not
 294  *    provided a specific channel list to scan.
 295  *
 296  *  @param priv          A pointer to wlan_private structure
 297  *  @param scanchanlist  Output parameter: resulting channel list to scan
 298  *  @param filteredscan  Flag indicating whether or not a BSSID or SSID filter
 299  *                       is being sent in the command to firmware.  Used to
 300  *                       increase the number of channels sent in a scan
 301  *                       command and to disable the firmware channel scan
 302  *                       filter.
 303  *
 304  *  @return              void
 305  */
 306 static void wlan_scan_create_channel_list(wlan_private * priv,
 307                                           struct chanscanparamset * scanchanlist,
 308                                           u8 filteredscan)
 309 {
 310
 311         wlan_adapter *adapter = priv->adapter;
 312         struct region_channel *scanregion;
 313         struct chan_freq_power *cfp;
 314         int rgnidx;
 315         int chanidx;
 316         int nextchan;
 317         u8 scantype;
 318
 319         chanidx = 0;
 320
 321         /* Set the default scan type to the user specified type, will later
 322          *   be changed to passive on a per channel basis if restricted by
 323          *   regulatory requirements (11d or 11h)
 324          */
 325         scantype = adapter->scantype;
 326
 327         for (rgnidx = 0; rgnidx < ARRAY_SIZE(adapter->region_channel); rgnidx++) {
 328                 if (priv->adapter->enable11d &&
 329                     adapter->connect_status != libertas_connected) {
 330                         /* Scan all the supported chan for the first scan */
 331                         if (!adapter->universal_channel[rgnidx].valid)
 332                                 continue;
 333                         scanregion = &adapter->universal_channel[rgnidx];
 334
 335                         /* clear the parsed_region_chan for the first scan */
 336                         memset(&adapter->parsed_region_chan, 0x00,
 337                                sizeof(adapter->parsed_region_chan));
 338                 } else {
 339                         if (!adapter->region_channel[rgnidx].valid)
 340                                 continue;
 341                         scanregion = &adapter->region_channel[rgnidx];
 342                 }
 343
 344                 for (nextchan = 0;
 345                      nextchan < scanregion->nrcfp; nextchan++, chanidx++) {
 346
 347                         cfp = scanregion->CFP + nextchan;
 348
 349                         if (priv->adapter->enable11d) {
 350                                 scantype =
 351                                     libertas_get_scan_type_11d(cfp->channel,
 352                                                            &adapter->
 353                                                            parsed_region_chan);
 354                         }
 355
 356                         switch (scanregion->band) {
 357                         case BAND_B:
 358                         case BAND_G:
 359                         default:
 360                                 scanchanlist[chanidx].radiotype =
 361                                     cmd_scan_radio_type_bg;
 362                                 break;
 363                         }
 364
 365                         if (scantype == cmd_scan_type_passive) {
 366                                 scanchanlist[chanidx].maxscantime =
 367                                     cpu_to_le16
 368                                     (MRVDRV_PASSIVE_SCAN_CHAN_TIME);
 369                                 scanchanlist[chanidx].chanscanmode.passivescan =
 370                                     1;
 371                         } else {
 372                                 scanchanlist[chanidx].maxscantime =
 373                                     cpu_to_le16
 374                                     (MRVDRV_ACTIVE_SCAN_CHAN_TIME);
 375                                 scanchanlist[chanidx].chanscanmode.passivescan =
 376                                     0;
 377                         }
 378
 379                         scanchanlist[chanidx].channumber = cfp->channel;
 380
 381                         if (filteredscan) {
 382                                 scanchanlist[chanidx].chanscanmode.
 383                                     disablechanfilt = 1;
 384                         }
 385                 }
 386         }
 387 }
 388
 389 /**
 390  *  @brief Construct a wlan_scan_cmd_config structure to use in issue scan cmds
 391  *
 392  *  Application layer or other functions can invoke wlan_scan_networks
 393  *    with a scan configuration supplied in a wlan_ioctl_user_scan_cfg struct.
 394  *    This structure is used as the basis of one or many wlan_scan_cmd_config
 395  *    commands that are sent to the command processing module and sent to
 396  *    firmware.
 397  *
 398  *  Create a wlan_scan_cmd_config based on the following user supplied
 399  *    parameters (if present):
 400  *             - SSID filter
 401  *             - BSSID filter
 402  *             - Number of Probes to be sent
 403  *             - channel list
 404  *
 405  *  If the SSID or BSSID filter is not present, disable/clear the filter.
 406  *  If the number of probes is not set, use the adapter default setting
 407  *  Qualify the channel
 408  *
 409  *  @param priv             A pointer to wlan_private structure
 410  *  @param puserscanin      NULL or pointer to scan configuration parameters
 411  *  @param ppchantlvout     Output parameter: Pointer to the start of the
 412  *                          channel TLV portion of the output scan config
 413  *  @param pscanchanlist    Output parameter: Pointer to the resulting channel
 414  *                          list to scan
 415  *  @param pmaxchanperscan  Output parameter: Number of channels to scan for
 416  *                          each issuance of the firmware scan command
 417  *  @param pfilteredscan    Output parameter: Flag indicating whether or not
 418  *                          a BSSID or SSID filter is being sent in the
 419  *                          command to firmware.  Used to increase the number
 420  *                          of channels sent in a scan command and to
 421  *                          disable the firmware channel scan filter.
 422  *  @param pscancurrentonly Output parameter: Flag indicating whether or not
 423  *                          we are only scanning our current active channel
 424  *
 425  *  @return                 resulting scan configuration
 426  */
 427 static struct wlan_scan_cmd_config *
 428 wlan_scan_setup_scan_config(wlan_private * priv,
 429                             const struct wlan_ioctl_user_scan_cfg * puserscanin,
 430                             struct mrvlietypes_chanlistparamset ** ppchantlvout,
 431                             struct chanscanparamset * pscanchanlist,
 432                             int *pmaxchanperscan,
 433                             u8 * pfilteredscan,
 434                             u8 * pscancurrentonly)
 435 {
 436         wlan_adapter *adapter = priv->adapter;
 437         const u8 zeromac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
 438         struct mrvlietypes_numprobes *pnumprobestlv;
 439         struct mrvlietypes_ssidparamset *pssidtlv;
 440         struct wlan_scan_cmd_config * pscancfgout = NULL;
 441         u8 *ptlvpos;
 442         u16 numprobes;
 443         u16 ssidlen;
 444         int chanidx;
 445         int scantype;
 446         int scandur;
 447         int channel;
 448         int radiotype;
 449
 450         pscancfgout = kzalloc(MAX_SCAN_CFG_ALLOC, GFP_KERNEL);
 451         if (pscancfgout == NULL)
 452                 goto out;
 453
 454         /* The tlvbufferlen is calculated for each scan command.  The TLVs added
 455          *   in this routine will be preserved since the routine that sends
 456          *   the command will append channelTLVs at *ppchantlvout.  The difference
 457          *   between the *ppchantlvout and the tlvbuffer start will be used
 458          *   to calculate the size of anything we add in this routine.
 459          */
 460         pscancfgout->tlvbufferlen = 0;
 461
 462         /* Running tlv pointer.  Assigned to ppchantlvout at end of function
 463          *  so later routines know where channels can be added to the command buf
 464          */
 465         ptlvpos = pscancfgout->tlvbuffer;
 466
 467         /*
 468          * Set the initial scan paramters for progressive scanning.  If a specific
 469          *   BSSID or SSID is used, the number of channels in the scan command
 470          *   will be increased to the absolute maximum
 471          */
 472         *pmaxchanperscan = MRVDRV_CHANNELS_PER_SCAN_CMD;
 473
 474         /* Initialize the scan as un-filtered by firmware, set to TRUE below if
 475          *   a SSID or BSSID filter is sent in the command
 476          */
 477         *pfilteredscan = 0;
 478
 479         /* Initialize the scan as not being only on the current channel.  If
 480          *   the channel list is customized, only contains one channel, and
 481          *   is the active channel, this is set true and data flow is not halted.
 482          */
 483         *pscancurrentonly = 0;
 484
 485         if (puserscanin) {
 486
 487                 /* Set the bss type scan filter, use adapter setting if unset */
 488                 pscancfgout->bsstype =
 489                     (puserscanin->bsstype ? puserscanin->bsstype : adapter->
 490                      scanmode);
 491
 492                 /* Set the number of probes to send, use adapter setting if unset */
 493                 numprobes = (puserscanin->numprobes ? puserscanin->numprobes :
 494                              adapter->scanprobes);
 495
 496                 /*
 497                  * Set the BSSID filter to the incoming configuration,
 498                  *   if non-zero.  If not set, it will remain disabled (all zeros).
 499                  */
 500                 memcpy(pscancfgout->specificBSSID,
 501                        puserscanin->specificBSSID,
 502                        sizeof(pscancfgout->specificBSSID));
 503
 504                 ssidlen = strlen(puserscanin->specificSSID);
 505
 506                 if (ssidlen) {
 507                         pssidtlv =
 508                             (struct mrvlietypes_ssidparamset *) pscancfgout->
 509                             tlvbuffer;
 510                         pssidtlv->header.type = cpu_to_le16(TLV_TYPE_SSID);
 511                         pssidtlv->header.len = cpu_to_le16(ssidlen);
 512                         memcpy(pssidtlv->ssid, puserscanin->specificSSID,
 513                                ssidlen);
 514                         ptlvpos += sizeof(pssidtlv->header) + ssidlen;
 515                 }
 516
 517                 /*
 518                  *  The default number of channels sent in the command is low to
 519                  *    ensure the response buffer from the firmware does not truncate
 520                  *    scan results.  That is not an issue with an SSID or BSSID
 521                  *    filter applied to the scan results in the firmware.
 522                  */
 523                 if (ssidlen || (memcmp(pscancfgout->specificBSSID,
 524                                        &zeromac, sizeof(zeromac)) != 0)) {
 525                         *pmaxchanperscan = MRVDRV_MAX_CHANNELS_PER_SCAN;
 526                         *pfilteredscan = 1;
 527                 }
 528         } else {
 529                 pscancfgout->bsstype = adapter->scanmode;
 530                 numprobes = adapter->scanprobes;
 531         }
 532
 533         /* If the input config or adapter has the number of Probes set, add tlv */
 534         if (numprobes) {
 535                 pnumprobestlv = (struct mrvlietypes_numprobes *) ptlvpos;
 536                 pnumprobestlv->header.type =
 537                     cpu_to_le16(TLV_TYPE_NUMPROBES);
 538                 pnumprobestlv->header.len = sizeof(pnumprobestlv->numprobes);
 539                 pnumprobestlv->numprobes = cpu_to_le16(numprobes);
 540
 541                 ptlvpos +=
 542                     sizeof(pnumprobestlv->header) + pnumprobestlv->header.len;
 543
 544                 pnumprobestlv->header.len =
 545                     cpu_to_le16(pnumprobestlv->header.len);
 546         }
 547
 548         /*
 549          * Set the output for the channel TLV to the address in the tlv buffer
 550          *   past any TLVs that were added in this fuction (SSID, numprobes).
 551          *   channel TLVs will be added past this for each scan command, preserving
 552          *   the TLVs that were previously added.
 553          */
 554         *ppchantlvout = (struct mrvlietypes_chanlistparamset *) ptlvpos;
 555
 556         if (puserscanin && puserscanin->chanlist[0].channumber) {
 557
 558                 lbs_pr_debug(1, "Scan: Using supplied channel list\n");
 559
 560                 for (chanidx = 0;
 561                      chanidx < WLAN_IOCTL_USER_SCAN_CHAN_MAX
 562                      && puserscanin->chanlist[chanidx].channumber; chanidx++) {
 563
 564                         channel = puserscanin->chanlist[chanidx].channumber;
 565                         (pscanchanlist + chanidx)->channumber = channel;
 566
 567                         radiotype = puserscanin->chanlist[chanidx].radiotype;
 568                         (pscanchanlist + chanidx)->radiotype = radiotype;
 569
 570                         scantype = puserscanin->chanlist[chanidx].scantype;
 571
 572                         if (scantype == cmd_scan_type_passive) {
 573                                 (pscanchanlist +
 574                                  chanidx)->chanscanmode.passivescan = 1;
 575                         } else {
 576                                 (pscanchanlist +
 577                                  chanidx)->chanscanmode.passivescan = 0;
 578                         }
 579
 580                         if (puserscanin->chanlist[chanidx].scantime) {
 581                                 scandur =
 582                                     puserscanin->chanlist[chanidx].scantime;
 583                         } else {
 584                                 if (scantype == cmd_scan_type_passive) {
 585                                         scandur = MRVDRV_PASSIVE_SCAN_CHAN_TIME;
 586                                 } else {
 587                                         scandur = MRVDRV_ACTIVE_SCAN_CHAN_TIME;
 588                                 }
 589                         }
 590
 591                         (pscanchanlist + chanidx)->minscantime =
 592                             cpu_to_le16(scandur);
 593                         (pscanchanlist + chanidx)->maxscantime =
 594                             cpu_to_le16(scandur);
 595                 }
 596
 597                 /* Check if we are only scanning the current channel */
 598                 if ((chanidx == 1) && (puserscanin->chanlist[0].channumber
 599                                        ==
 600                                        priv->adapter->curbssparams.channel)) {
 601                         *pscancurrentonly = 1;
 602                         lbs_pr_debug(1, "Scan: Scanning current channel only");
 603                 }
 604
 605         } else {
 606                 lbs_pr_debug(1, "Scan: Creating full region channel list\n");
 607                 wlan_scan_create_channel_list(priv, pscanchanlist,
 608                                               *pfilteredscan);
 609         }
 610
 611 out:
 612         return pscancfgout;
 613 }
 614
 615 /**
 616  *  @brief Construct and send multiple scan config commands to the firmware
 617  *
 618  *  Previous routines have created a wlan_scan_cmd_config with any requested
 619  *   TLVs.  This function splits the channel TLV into maxchanperscan lists
 620  *   and sends the portion of the channel TLV along with the other TLVs
 621  *   to the wlan_cmd routines for execution in the firmware.
 622  *
 623  *  @param priv            A pointer to wlan_private structure
 624  *  @param maxchanperscan  Maximum number channels to be included in each
 625  *                         scan command sent to firmware
 626  *  @param filteredscan    Flag indicating whether or not a BSSID or SSID
 627  *                         filter is being used for the firmware command
 628  *                         scan command sent to firmware
 629  *  @param pscancfgout     Scan configuration used for this scan.
 630  *  @param pchantlvout     Pointer in the pscancfgout where the channel TLV
 631  *                         should start.  This is past any other TLVs that
 632  *                         must be sent down in each firmware command.
 633  *  @param pscanchanlist   List of channels to scan in maxchanperscan segments
 634  *
 635  *  @return                0 or error return otherwise
 636  */
 637 static int wlan_scan_channel_list(wlan_private * priv,
 638                                   int maxchanperscan,
 639                                   u8 filteredscan,
 640                                   struct wlan_scan_cmd_config * pscancfgout,
 641                                   struct mrvlietypes_chanlistparamset * pchantlvout,
 642                                   struct chanscanparamset * pscanchanlist)
 643 {
 644         struct chanscanparamset *ptmpchan;
 645         struct chanscanparamset *pstartchan;
 646         u8 scanband;
 647         int doneearly;
 648         int tlvidx;
 649         int ret = 0;
 650
 651         ENTER();
 652
 653         if (pscancfgout == 0 || pchantlvout == 0 || pscanchanlist == 0) {
 654                 lbs_pr_debug(1, "Scan: Null detect: %p, %p, %p\n",
 655                        pscancfgout, pchantlvout, pscanchanlist);
 656                 return -1;
 657         }
 658
 659         pchantlvout->header.type = cpu_to_le16(TLV_TYPE_CHANLIST);
 660
 661         /* Set the temp channel struct pointer to the start of the desired list */
 662         ptmpchan = pscanchanlist;
 663
 664         /* Loop through the desired channel list, sending a new firmware scan
 665          *   commands for each maxchanperscan channels (or for 1,6,11 individually
 666          *   if configured accordingly)
 667          */
 668         while (ptmpchan->channumber) {
 669
 670                 tlvidx = 0;
 671                 pchantlvout->header.len = 0;
 672                 scanband = ptmpchan->radiotype;
 673                 pstartchan = ptmpchan;
 674                 doneearly = 0;
 675
 676                 /* Construct the channel TLV for the scan command.  Continue to
 677                  *  insert channel TLVs until:
 678                  *    - the tlvidx hits the maximum configured per scan command
 679                  *    - the next channel to insert is 0 (end of desired channel list)
 680                  *    - doneearly is set (controlling individual scanning of 1,6,11)
 681                  */
 682                 while (tlvidx < maxchanperscan && ptmpchan->channumber
 683                        && !doneearly) {
 684
 685             lbs_pr_debug(1,
 686                     "Scan: Chan(%3d), Radio(%d), mode(%d,%d), Dur(%d)\n",
 687                 ptmpchan->channumber, ptmpchan->radiotype,
 688                 ptmpchan->chanscanmode.passivescan,
 689                 ptmpchan->chanscanmode.disablechanfilt,
 690                 ptmpchan->maxscantime);
 691
 692                         /* Copy the current channel TLV to the command being prepared */
 693                         memcpy(pchantlvout->chanscanparam + tlvidx,
 694                                ptmpchan, sizeof(pchantlvout->chanscanparam));
 695
 696                         /* Increment the TLV header length by the size appended */
 697                         pchantlvout->header.len +=
 698                             sizeof(pchantlvout->chanscanparam);
 699
 700                         /*
 701                          *  The tlv buffer length is set to the number of bytes of the
 702                          *    between the channel tlv pointer and the start of the
 703                          *    tlv buffer.  This compensates for any TLVs that were appended
 704                          *    before the channel list.
 705                          */
 706                         pscancfgout->tlvbufferlen = ((u8 *) pchantlvout
 707                                                      - pscancfgout->tlvbuffer);
 708
 709                         /*  Add the size of the channel tlv header and the data length */
 710                         pscancfgout->tlvbufferlen +=
 711                             (sizeof(pchantlvout->header)
 712                              + pchantlvout->header.len);
 713
 714                         /* Increment the index to the channel tlv we are constructing */
 715                         tlvidx++;
 716
 717                         doneearly = 0;
 718
 719                         /* Stop the loop if the *current* channel is in the 1,6,11 set
 720                          *   and we are not filtering on a BSSID or SSID.
 721                          */
 722                         if (!filteredscan && (ptmpchan->channumber == 1
 723                                               || ptmpchan->channumber == 6
 724                                               || ptmpchan->channumber == 11)) {
 725                                 doneearly = 1;
 726                         }
 727
 728                         /* Increment the tmp pointer to the next channel to be scanned */
 729                         ptmpchan++;
 730
 731                         /* Stop the loop if the *next* channel is in the 1,6,11 set.
 732                          *  This will cause it to be the only channel scanned on the next
 733                          *  interation
 734                          */
 735                         if (!filteredscan && (ptmpchan->channumber == 1
 736                                               || ptmpchan->channumber == 6
 737                                               || ptmpchan->channumber == 11)) {
 738                                 doneearly = 1;
 739                         }
 740                 }
 741
 742                 /* Send the scan command to the firmware with the specified cfg */
 743                 ret = libertas_prepare_and_send_command(priv, cmd_802_11_scan, 0,
 744                                             0, 0, pscancfgout);
 745         }
 746
 747         LEAVE();
 748         return ret;
 749 }
 750
 751 /**
 752  *  @brief Internal function used to start a scan based on an input config
 753  *
 754  *  Use the input user scan configuration information when provided in
 755  *    order to send the appropriate scan commands to firmware to populate or
 756  *    update the internal driver scan table
 757  *
 758  *  @param priv          A pointer to wlan_private structure
 759  *  @param puserscanin   Pointer to the input configuration for the requested
 760  *                       scan.
 761  *
 762  *  @return              0 or < 0 if error
 763  */
 764 int wlan_scan_networks(wlan_private * priv,
 765                               const struct wlan_ioctl_user_scan_cfg * puserscanin)
 766 {
 767         wlan_adapter *adapter = priv->adapter;
 768         struct mrvlietypes_chanlistparamset *pchantlvout;
 769         struct chanscanparamset * scan_chan_list = NULL;
 770         struct wlan_scan_cmd_config * scan_cfg = NULL;
 771         u8 keeppreviousscan;
 772         u8 filteredscan;
 773         u8 scancurrentchanonly;
 774         int maxchanperscan;
 775         int ret;
 776
 777         ENTER();
 778
 779         scan_chan_list = kzalloc(sizeof(struct chanscanparamset) *
 780                                 WLAN_IOCTL_USER_SCAN_CHAN_MAX, GFP_KERNEL);
 781         if (scan_chan_list == NULL) {
 782                 ret = -ENOMEM;
 783                 goto out;
 784         }
 785
 786         scan_cfg = wlan_scan_setup_scan_config(priv,
 787                                                puserscanin,
 788                                                &pchantlvout,
 789                                                scan_chan_list,
 790                                                &maxchanperscan,
 791                                                &filteredscan,
 792                                                &scancurrentchanonly);
 793         if (scan_cfg == NULL) {
 794                 ret = -ENOMEM;
 795                 goto out;
 796         }
 797
 798         keeppreviousscan = 0;
 799
 800         if (puserscanin) {
 801                 keeppreviousscan = puserscanin->keeppreviousscan;
 802         }
 803
 804         if (!keeppreviousscan) {
 805                 memset(adapter->scantable, 0x00,
 806                        sizeof(struct bss_descriptor) * MRVDRV_MAX_BSSID_LIST);
 807                 adapter->numinscantable = 0;
 808         }
 809
 810         /* Keep the data path active if we are only scanning our current channel */
 811         if (!scancurrentchanonly) {
 812                 netif_stop_queue(priv->wlan_dev.netdev);
 813                 netif_carrier_off(priv->wlan_dev.netdev);
 814         }
 815
 816         ret = wlan_scan_channel_list(priv,
 817                                      maxchanperscan,
 818                                      filteredscan,
 819                                      scan_cfg,
 820                                      pchantlvout,
 821                                      scan_chan_list);
 822
 823         /*  Process the resulting scan table:
 824          *    - Remove any bad ssids
 825          *    - Update our current BSS information from scan data
 826          */
 827         wlan_scan_process_results(priv);
 828
 829         if (priv->adapter->connect_status == libertas_connected) {
 830                 netif_carrier_on(priv->wlan_dev.netdev);
 831                 netif_wake_queue(priv->wlan_dev.netdev);
 832         }
 833
 834 out:
 835         if (scan_cfg)
 836                 kfree(scan_cfg);
 837
 838         if (scan_chan_list)
 839                 kfree(scan_chan_list);
 840
 841         LEAVE();
 842         return ret;
 843 }
 844
 845 /**
 846  *  @brief Inspect the scan response buffer for pointers to expected TLVs
 847  *
 848  *  TLVs can be included at the end of the scan response BSS information.
 849  *    Parse the data in the buffer for pointers to TLVs that can potentially
 850  *    be passed back in the response
 851  *
 852  *  @param ptlv        Pointer to the start of the TLV buffer to parse
 853  *  @param tlvbufsize  size of the TLV buffer
 854  *  @param ptsftlv     Output parameter: Pointer to the TSF TLV if found
 855  *
 856  *  @return            void
 857  */
 858 static
 859 void wlan_ret_802_11_scan_get_tlv_ptrs(struct mrvlietypes_data * ptlv,
 860                                        int tlvbufsize,
 861                                        struct mrvlietypes_tsftimestamp ** ptsftlv)
 862 {
 863         struct mrvlietypes_data *pcurrenttlv;
 864         int tlvbufleft;
 865         u16 tlvtype;
 866         u16 tlvlen;
 867
 868         pcurrenttlv = ptlv;
 869         tlvbufleft = tlvbufsize;
 870         *ptsftlv = NULL;
 871
 872         lbs_pr_debug(1, "SCAN_RESP: tlvbufsize = %d\n", tlvbufsize);
 873         lbs_dbg_hex("SCAN_RESP: TLV Buf", (u8 *) ptlv, tlvbufsize);
 874
 875         while (tlvbufleft >= sizeof(struct mrvlietypesheader)) {
 876                 tlvtype = le16_to_cpu(pcurrenttlv->header.type);
 877                 tlvlen = le16_to_cpu(pcurrenttlv->header.len);
 878
 879                 switch (tlvtype) {
 880                 case TLV_TYPE_TSFTIMESTAMP:
 881                         *ptsftlv = (struct mrvlietypes_tsftimestamp *) pcurrenttlv;
 882                         break;
 883
 884                 default:
 885                         lbs_pr_debug(1, "SCAN_RESP: Unhandled TLV = %d\n",
 886                                tlvtype);
 887                         /* Give up, this seems corrupted */
 888                         return;
 889                 }               /* switch */
 890
 891                 tlvbufleft -= (sizeof(ptlv->header) + tlvlen);
 892                 pcurrenttlv =
 893                     (struct mrvlietypes_data *) (pcurrenttlv->Data + tlvlen);
 894         }                       /* while */
 895 }
 896
 897 /**
 898  *  @brief Interpret a BSS scan response returned from the firmware
 899  *
 900  *  Parse the various fixed fields and IEs passed back for a a BSS probe
 901  *   response or beacon from the scan command.  Record information as needed
 902  *   in the scan table struct bss_descriptor for that entry.
 903  *
 904  *  @param pBSSIDEntry  Output parameter: Pointer to the BSS Entry
 905  *
 906  *  @return             0 or -1
 907  */
 908 static int InterpretBSSDescriptionWithIE(struct bss_descriptor * pBSSEntry,
 909                                          u8 ** pbeaconinfo, int *bytesleft)
 910 {
 911         enum ieeetypes_elementid elemID;
 912         struct ieeetypes_fhparamset *pFH;
 913         struct ieeetypes_dsparamset *pDS;
 914         struct ieeetypes_cfparamset *pCF;
 915         struct ieeetypes_ibssparamset *pibss;
 916         struct ieeetypes_capinfo *pcap;
 917         struct WLAN_802_11_FIXED_IEs fixedie;
 918         u8 *pcurrentptr;
 919         u8 *pRate;
 920         u8 elemlen;
 921         u8 bytestocopy;
 922         u8 ratesize;
 923         u16 beaconsize;
 924         u8 founddatarateie;
 925         int bytesleftforcurrentbeacon;
 926
 927         struct WPA_SUPPLICANT *pwpa_supplicant;
 928         struct WPA_SUPPLICANT *pwpa2_supplicant;
 929         struct IE_WPA *pIe;
 930         const u8 oui01[4] = { 0x00, 0x50, 0xf2, 0x01 };
 931
 932         struct ieeetypes_countryinfoset *pcountryinfo;
 933
 934         ENTER();
 935
 936         founddatarateie = 0;
 937         ratesize = 0;
 938         beaconsize = 0;
 939
 940         if (*bytesleft >= sizeof(beaconsize)) {
 941                 /* Extract & convert beacon size from the command buffer */
 942                 memcpy(&beaconsize, *pbeaconinfo, sizeof(beaconsize));
 943                 beaconsize = le16_to_cpu(beaconsize);
 944                 *bytesleft -= sizeof(beaconsize);
 945                 *pbeaconinfo += sizeof(beaconsize);
 946         }
 947
 948         if (beaconsize == 0 || beaconsize > *bytesleft) {
 949
 950                 *pbeaconinfo += *bytesleft;
 951                 *bytesleft = 0;
 952
 953                 return -1;
 954         }
 955
 956         /* Initialize the current working beacon pointer for this BSS iteration */
 957         pcurrentptr = *pbeaconinfo;
 958
 959         /* Advance the return beacon pointer past the current beacon */
 960         *pbeaconinfo += beaconsize;
 961         *bytesleft -= beaconsize;
 962
 963         bytesleftforcurrentbeacon = beaconsize;
 964
 965         pwpa_supplicant = &pBSSEntry->wpa_supplicant;
 966         pwpa2_supplicant = &pBSSEntry->wpa2_supplicant;
 967
 968         memcpy(pBSSEntry->macaddress, pcurrentptr, ETH_ALEN);
 969         lbs_pr_debug(1, "InterpretIE: AP MAC Addr-%x:%x:%x:%x:%x:%x\n",
 970                pBSSEntry->macaddress[0], pBSSEntry->macaddress[1],
 971                pBSSEntry->macaddress[2], pBSSEntry->macaddress[3],
 972                pBSSEntry->macaddress[4], pBSSEntry->macaddress[5]);
 973
 974         pcurrentptr += ETH_ALEN;
 975         bytesleftforcurrentbeacon -= ETH_ALEN;
 976
 977         if (bytesleftforcurrentbeacon < 12) {
 978                 lbs_pr_debug(1, "InterpretIE: Not enough bytes left\n");
 979                 return -1;
 980         }
 981
 982         /*
 983          * next 4 fields are RSSI, time stamp, beacon interval,
 984          *   and capability information
 985          */
 986
 987         /* RSSI is 1 byte long */
 988         pBSSEntry->rssi = le32_to_cpu((long)(*pcurrentptr));
 989         lbs_pr_debug(1, "InterpretIE: RSSI=%02X\n", *pcurrentptr);
 990         pcurrentptr += 1;
 991         bytesleftforcurrentbeacon -= 1;
 992
 993         /* time stamp is 8 bytes long */
 994         memcpy(fixedie.timestamp, pcurrentptr, 8);
 995         memcpy(pBSSEntry->timestamp, pcurrentptr, 8);
 996         pcurrentptr += 8;
 997         bytesleftforcurrentbeacon -= 8;
 998
 999         /* beacon interval is 2 bytes long */
1000         memcpy(&fixedie.beaconinterval, pcurrentptr, 2);
1001         pBSSEntry->beaconperiod = le16_to_cpu(fixedie.beaconinterval);
1002         pcurrentptr += 2;
1003         bytesleftforcurrentbeacon -= 2;
1004
1005         /* capability information is 2 bytes long */
1006         memcpy(&fixedie.capabilities, pcurrentptr, 2);
1007         lbs_pr_debug(1, "InterpretIE: fixedie.capabilities=0x%X\n",
1008                fixedie.capabilities);
1009         fixedie.capabilities = le16_to_cpu(fixedie.capabilities);
1010         pcap = (struct ieeetypes_capinfo *) & fixedie.capabilities;
1011         memcpy(&pBSSEntry->cap, pcap, sizeof(struct ieeetypes_capinfo));
1012         pcurrentptr += 2;
1013         bytesleftforcurrentbeacon -= 2;
1014
1015         /* rest of the current buffer are IE's */
1016         lbs_pr_debug(1, "InterpretIE: IElength for this AP = %d\n",
1017                bytesleftforcurrentbeacon);
1018
1019         lbs_dbg_hex("InterpretIE: IE info", (u8 *) pcurrentptr,
1020                 bytesleftforcurrentbeacon);
1021
1022         if (pcap->privacy) {
1023                 lbs_pr_debug(1, "InterpretIE: AP WEP enabled\n");
1024                 pBSSEntry->privacy = wlan802_11privfilter8021xWEP;
1025         } else {
1026                 pBSSEntry->privacy = wlan802_11privfilteracceptall;
1027         }
1028
1029         if (pcap->ibss == 1) {
1030                 pBSSEntry->inframode = wlan802_11ibss;
1031         } else {
1032                 pBSSEntry->inframode = wlan802_11infrastructure;
1033         }
1034
1035         /* process variable IE */
1036         while (bytesleftforcurrentbeacon >= 2) {
1037                 elemID = (enum ieeetypes_elementid) (*((u8 *) pcurrentptr));
1038                 elemlen = *((u8 *) pcurrentptr + 1);
1039
1040                 if (bytesleftforcurrentbeacon < elemlen) {
1041                         lbs_pr_debug(1, "InterpretIE: error in processing IE, "
1042                                "bytes left < IE length\n");
1043                         bytesleftforcurrentbeacon = 0;
1044                         continue;
1045                 }
1046
1047                 switch (elemID) {
1048
1049                 case SSID:
1050                         pBSSEntry->ssid.ssidlength = elemlen;
1051                         memcpy(pBSSEntry->ssid.ssid, (pcurrentptr + 2),
1052                                elemlen);
1053                         lbs_pr_debug(1, "ssid: %32s", pBSSEntry->ssid.ssid);
1054                         break;
1055
1056                 case SUPPORTED_RATES:
1057                         memcpy(pBSSEntry->datarates, (pcurrentptr + 2),
1058                                elemlen);
1059                         memmove(pBSSEntry->libertas_supported_rates, (pcurrentptr + 2),
1060                                 elemlen);
1061                         ratesize = elemlen;
1062                         founddatarateie = 1;
1063                         break;
1064
1065                 case EXTRA_IE:
1066                         lbs_pr_debug(1, "InterpretIE: EXTRA_IE Found!\n");
1067                         pBSSEntry->extra_ie = 1;
1068                         break;
1069
1070                 case FH_PARAM_SET:
1071                         pFH = (struct ieeetypes_fhparamset *) pcurrentptr;
1072                         memmove(&pBSSEntry->phyparamset.fhparamset, pFH,
1073                                 sizeof(struct ieeetypes_fhparamset));
1074                         pBSSEntry->phyparamset.fhparamset.dwelltime
1075                             =
1076                             le16_to_cpu(pBSSEntry->phyparamset.fhparamset.
1077                                              dwelltime);
1078                         break;
1079
1080                 case DS_PARAM_SET:
1081                         pDS = (struct ieeetypes_dsparamset *) pcurrentptr;
1082
1083                         pBSSEntry->channel = pDS->currentchan;
1084
1085                         memcpy(&pBSSEntry->phyparamset.dsparamset, pDS,
1086                                sizeof(struct ieeetypes_dsparamset));
1087                         break;
1088
1089                 case CF_PARAM_SET:
1090                         pCF = (struct ieeetypes_cfparamset *) pcurrentptr;
1091
1092                         memcpy(&pBSSEntry->ssparamset.cfparamset, pCF,
1093                                sizeof(struct ieeetypes_cfparamset));
1094                         break;
1095
1096                 case IBSS_PARAM_SET:
1097                         pibss = (struct ieeetypes_ibssparamset *) pcurrentptr;
1098                         pBSSEntry->atimwindow =
1099                             le32_to_cpu(pibss->atimwindow);
1100
1101                         memmove(&pBSSEntry->ssparamset.ibssparamset, pibss,
1102                                 sizeof(struct ieeetypes_ibssparamset));
1103
1104                         pBSSEntry->ssparamset.ibssparamset.atimwindow
1105                             =
1106                             le16_to_cpu(pBSSEntry->ssparamset.ibssparamset.
1107                                              atimwindow);
1108                         break;
1109
1110                         /* Handle Country Info IE */
1111                 case COUNTRY_INFO:
1112                         pcountryinfo =
1113                             (struct ieeetypes_countryinfoset *) pcurrentptr;
1114
1115                         if (pcountryinfo->len <
1116                             sizeof(pcountryinfo->countrycode)
1117                             || pcountryinfo->len > 254) {
1118                                 lbs_pr_debug(1, "InterpretIE: 11D- Err "
1119                                        "CountryInfo len =%d min=%d max=254\n",
1120                                        pcountryinfo->len,
1121                                        sizeof(pcountryinfo->countrycode));
1122                                 LEAVE();
1123                                 return -1;
1124                         }
1125
1126                         memcpy(&pBSSEntry->countryinfo,
1127                                pcountryinfo, pcountryinfo->len + 2);
1128                         lbs_dbg_hex("InterpretIE: 11D- CountryInfo:",
1129                                 (u8 *) pcountryinfo,
1130                                 (u32) (pcountryinfo->len + 2));
1131                         break;
1132
1133                 case EXTENDED_SUPPORTED_RATES:
1134                         /*
1135                          * only process extended supported rate
1136                          * if data rate is already found.
1137                          * data rate IE should come before
1138                          * extended supported rate IE
1139                          */
1140                         if (founddatarateie) {
1141                                 if ((elemlen + ratesize) > WLAN_SUPPORTED_RATES) {
1142                                         bytestocopy =
1143                                             (WLAN_SUPPORTED_RATES - ratesize);
1144                                 } else {
1145                                         bytestocopy = elemlen;
1146                                 }
1147
1148                                 pRate = (u8 *) pBSSEntry->datarates;
1149                                 pRate += ratesize;
1150                                 memmove(pRate, (pcurrentptr + 2), bytestocopy);
1151
1152                                 pRate = (u8 *) pBSSEntry->libertas_supported_rates;
1153
1154                                 pRate += ratesize;
1155                                 memmove(pRate, (pcurrentptr + 2), bytestocopy);
1156                         }
1157                         break;
1158
1159                 case VENDOR_SPECIFIC_221:
1160 #define IE_ID_LEN_FIELDS_BYTES 2
1161                         pIe = (struct IE_WPA *)pcurrentptr;
1162
1163                         if (!memcmp(pIe->oui, oui01, sizeof(oui01))) {
1164                                 pwpa_supplicant->wpa_ie_len
1165                                     = min_t(size_t, elemlen + IE_ID_LEN_FIELDS_BYTES,
1166                                           sizeof(pwpa_supplicant->wpa_ie));
1167                                 memcpy(pwpa_supplicant->wpa_ie,
1168                                        pcurrentptr,
1169                                        pwpa_supplicant->wpa_ie_len);
1170                                 lbs_dbg_hex("InterpretIE: Resp WPA_IE",
1171                                         pwpa_supplicant->wpa_ie, elemlen);
1172                         }
1173                         break;
1174                 case WPA2_IE:
1175                         pIe = (struct IE_WPA *)pcurrentptr;
1176                         pwpa2_supplicant->wpa_ie_len
1177                             = min_t(size_t, elemlen + IE_ID_LEN_FIELDS_BYTES,
1178                                   sizeof(pwpa2_supplicant->wpa_ie));
1179                         memcpy(pwpa2_supplicant->wpa_ie,
1180                                pcurrentptr, pwpa2_supplicant->wpa_ie_len);
1181
1182                         lbs_dbg_hex("InterpretIE: Resp WPA2_IE",
1183                                 pwpa2_supplicant->wpa_ie, elemlen);
1184                         break;
1185                 case TIM:
1186                         break;
1187
1188                 case CHALLENGE_TEXT:
1189                         break;
1190                 }
1191
1192                 pcurrentptr += elemlen + 2;
1193
1194                 /* need to account for IE ID and IE len */
1195                 bytesleftforcurrentbeacon -= (elemlen + 2);
1196
1197         }                       /* while (bytesleftforcurrentbeacon > 2) */
1198
1199         return 0;
1200 }
1201
1202 /**
1203  *  @brief Compare two SSIDs
1204  *
1205  *  @param ssid1    A pointer to ssid to compare
1206  *  @param ssid2    A pointer to ssid to compare
1207  *
1208  *  @return         0--ssid is same, otherwise is different
1209  */
1210 int libertas_SSID_cmp(struct WLAN_802_11_SSID *ssid1, struct WLAN_802_11_SSID *ssid2)
1211 {
1212         if (!ssid1 || !ssid2)
1213                 return -1;
1214
1215         if (ssid1->ssidlength != ssid2->ssidlength)
1216                 return -1;
1217
1218         return memcmp(ssid1->ssid, ssid2->ssid, ssid1->ssidlength);
1219 }
1220
1221 /**
1222  *  @brief This function finds a specific compatible BSSID in the scan list
1223  *
1224  *  @param adapter  A pointer to wlan_adapter
1225  *  @param bssid    BSSID to find in the scan list
1226  *  @param mode     Network mode: Infrastructure or IBSS
1227  *
1228  *  @return         index in BSSID list, or error return code (< 0)
1229  */
1230 int libertas_find_BSSID_in_list(wlan_adapter * adapter, u8 * bssid, int mode)
1231 {
1232         int ret = -ENETUNREACH;
1233         int i;
1234
1235         if (!bssid)
1236                 return -EFAULT;
1237
1238         lbs_pr_debug(1, "FindBSSID: Num of BSSIDs = %d\n",
1239                adapter->numinscantable);
1240
1241         /* Look through the scan table for a compatible match. The ret return
1242          *   variable will be equal to the index in the scan table (greater
1243          *   than zero) if the network is compatible.  The loop will continue
1244          *   past a matched bssid that is not compatible in case there is an
1245          *   AP with multiple SSIDs assigned to the same BSSID
1246          */
1247         for (i = 0; ret < 0 && i < adapter->numinscantable; i++) {
1248                 if (!memcmp(adapter->scantable[i].macaddress, bssid, ETH_ALEN)) {
1249                         switch (mode) {
1250                         case wlan802_11infrastructure:
1251                         case wlan802_11ibss:
1252                                 ret = is_network_compatible(adapter, i, mode);
1253                                 break;
1254                         default:
1255                                 ret = i;
1256                                 break;
1257                         }
1258                 }
1259         }
1260
1261         return ret;
1262 }
1263
1264 /**
1265  *  @brief This function finds ssid in ssid list.
1266  *
1267  *  @param adapter  A pointer to wlan_adapter
1268  *  @param ssid     SSID to find in the list
1269  *  @param bssid    BSSID to qualify the SSID selection (if provided)
1270  *  @param mode     Network mode: Infrastructure or IBSS
1271  *
1272  *  @return         index in BSSID list
1273  */
1274 int libertas_find_SSID_in_list(wlan_adapter * adapter,
1275                    struct WLAN_802_11_SSID *ssid, u8 * bssid, int mode)
1276 {
1277         int net = -ENETUNREACH;
1278         u8 bestrssi = 0;
1279         int i;
1280         int j;
1281
1282         lbs_pr_debug(1, "Num of Entries in Table = %d\n", adapter->numinscantable);
1283
1284         for (i = 0; i < adapter->numinscantable; i++) {
1285                 if (!libertas_SSID_cmp(&adapter->scantable[i].ssid, ssid) &&
1286                     (!bssid ||
1287                      !memcmp(adapter->scantable[i].
1288                              macaddress, bssid, ETH_ALEN))) {
1289                         switch (mode) {
1290                         case wlan802_11infrastructure:
1291                         case wlan802_11ibss:
1292                                 j = is_network_compatible(adapter, i, mode);
1293
1294                                 if (j >= 0) {
1295                                         if (bssid) {
1296                                                 return i;
1297                                         }
1298
1299                                         if (SCAN_RSSI
1300                                             (adapter->scantable[i].rssi)
1301                                             > bestrssi) {
1302                                                 bestrssi =
1303                                                     SCAN_RSSI(adapter->
1304                                                               scantable[i].
1305                                                               rssi);
1306                                                 net = i;
1307                                         }
1308                                 } else {
1309                                         if (net == -ENETUNREACH) {
1310                                                 net = j;
1311                                         }
1312                                 }
1313                                 break;
1314                         case wlan802_11autounknown:
1315                         default:
1316                                 if (SCAN_RSSI(adapter->scantable[i].rssi)
1317                                     > bestrssi) {
1318                                         bestrssi =
1319                                             SCAN_RSSI(adapter->scantable[i].
1320                                                       rssi);
1321                                         net = i;
1322                                 }
1323                                 break;
1324                         }
1325                 }
1326         }
1327
1328         return net;
1329 }
1330
1331 /**
1332  *  @brief This function finds the best SSID in the Scan List
1333  *
1334  *  Search the scan table for the best SSID that also matches the current
1335  *   adapter network preference (infrastructure or adhoc)
1336  *
1337  *  @param adapter  A pointer to wlan_adapter
1338  *
1339  *  @return         index in BSSID list
1340  */
1341 int libertas_find_best_SSID_in_list(wlan_adapter * adapter,
1342                                     enum WLAN_802_11_NETWORK_INFRASTRUCTURE mode)
1343 {
1344         int bestnet = -ENETUNREACH;
1345         u8 bestrssi = 0;
1346         int i;
1347
1348         ENTER();
1349
1350         lbs_pr_debug(1, "Num of BSSIDs = %d\n", adapter->numinscantable);
1351
1352         for (i = 0; i < adapter->numinscantable; i++) {
1353                 switch (mode) {
1354                 case wlan802_11infrastructure:
1355                 case wlan802_11ibss:
1356                         if (is_network_compatible(adapter, i, mode) >= 0) {
1357                                 if (SCAN_RSSI(adapter->scantable[i].rssi) >
1358                                     bestrssi) {
1359                                         bestrssi =
1360                                             SCAN_RSSI(adapter->scantable[i].
1361                                                       rssi);
1362                                         bestnet = i;
1363                                 }
1364                         }
1365                         break;
1366                 case wlan802_11autounknown:
1367                 default:
1368                         if (SCAN_RSSI(adapter->scantable[i].rssi) > bestrssi) {
1369                                 bestrssi =
1370                                     SCAN_RSSI(adapter->scantable[i].rssi);
1371                                 bestnet = i;
1372                         }
1373                         break;
1374                 }
1375         }
1376
1377         LEAVE();
1378         return bestnet;
1379 }
1380
1381 /**
1382  *  @brief Find the AP with specific ssid in the scan list
1383  *
1384  *  @param priv         A pointer to wlan_private structure
1385  *  @param pSSID        A pointer to AP's ssid
1386  *
1387  *  @return             0--success, otherwise--fail
1388  */
1389 int libertas_find_best_network_SSID(wlan_private * priv,
1390                                     struct WLAN_802_11_SSID *pSSID,
1391                                     enum WLAN_802_11_NETWORK_INFRASTRUCTURE preferred_mode,
1392                                     enum WLAN_802_11_NETWORK_INFRASTRUCTURE *out_mode)
1393 {
1394         wlan_adapter *adapter = priv->adapter;
1395         int ret = 0;
1396         struct bss_descriptor *preqbssid;
1397         int i;
1398
1399         ENTER();
1400
1401         memset(pSSID, 0, sizeof(struct WLAN_802_11_SSID));
1402
1403         wlan_scan_networks(priv, NULL);
1404         if (adapter->surpriseremoved)
1405                 return -1;
1406         wait_event_interruptible(adapter->cmd_pending, !adapter->nr_cmd_pending);
1407
1408         i = libertas_find_best_SSID_in_list(adapter, preferred_mode);
1409         if (i < 0) {
1410                 ret = -1;
1411                 goto out;
1412         }
1413
1414         preqbssid = &adapter->scantable[i];
1415         memcpy(pSSID, &preqbssid->ssid,
1416                sizeof(struct WLAN_802_11_SSID));
1417         *out_mode = preqbssid->inframode;
1418
1419         if (!pSSID->ssidlength) {
1420                 ret = -1;
1421         }
1422
1423 out:
1424         LEAVE();
1425         return ret;
1426 }
1427
1428 /**
1429  *  @brief Scan Network
1430  *
1431  *  @param dev          A pointer to net_device structure
1432  *  @param info         A pointer to iw_request_info structure
1433  *  @param vwrq         A pointer to iw_param structure
1434  *  @param extra        A pointer to extra data buf
1435  *
1436  *  @return             0 --success, otherwise fail
1437  */
1438 int libertas_set_scan(struct net_device *dev, struct iw_request_info *info,
1439                   struct iw_param *vwrq, char *extra)
1440 {
1441         wlan_private *priv = dev->priv;
1442         wlan_adapter *adapter = priv->adapter;
1443         union iwreq_data wrqu;
1444
1445         ENTER();
1446
1447         if (!wlan_scan_networks(priv, NULL)) {
1448                 memset(&wrqu, 0, sizeof(union iwreq_data));
1449                 wireless_send_event(priv->wlan_dev.netdev, SIOCGIWSCAN, &wrqu,
1450                                     NULL);
1451         }
1452
1453         if (adapter->surpriseremoved)
1454                 return -1;
1455
1456         LEAVE();
1457         return 0;
1458 }
1459
1460 /**
1461  *  @brief Send a scan command for all available channels filtered on a spec
1462  *
1463  *  @param priv             A pointer to wlan_private structure
1464  *  @param prequestedssid   A pointer to AP's ssid
1465  *  @param keeppreviousscan Flag used to save/clear scan table before scan
1466  *
1467  *  @return                0-success, otherwise fail
1468  */
1469 int libertas_send_specific_SSID_scan(wlan_private * priv,
1470                          struct WLAN_802_11_SSID *prequestedssid,
1471                          u8 keeppreviousscan)
1472 {
1473         wlan_adapter *adapter = priv->adapter;
1474         struct wlan_ioctl_user_scan_cfg scancfg;
1475
1476         ENTER();
1477
1478         if (prequestedssid == NULL) {
1479                 return -1;
1480         }
1481
1482         memset(&scancfg, 0x00, sizeof(scancfg));
1483
1484         memcpy(scancfg.specificSSID, prequestedssid->ssid,
1485                prequestedssid->ssidlength);
1486         scancfg.keeppreviousscan = keeppreviousscan;
1487
1488         wlan_scan_networks(priv, &scancfg);
1489         if (adapter->surpriseremoved)
1490                 return -1;
1491         wait_event_interruptible(adapter->cmd_pending, !adapter->nr_cmd_pending);
1492
1493         LEAVE();
1494         return 0;
1495 }
1496
1497 /**
1498  *  @brief scan an AP with specific BSSID
1499  *
1500  *  @param priv             A pointer to wlan_private structure
1501  *  @param bssid            A pointer to AP's bssid
1502  *  @param keeppreviousscan Flag used to save/clear scan table before scan
1503  *
1504  *  @return          0-success, otherwise fail
1505  */
1506 int libertas_send_specific_BSSID_scan(wlan_private * priv, u8 * bssid, u8 keeppreviousscan)
1507 {
1508         struct wlan_ioctl_user_scan_cfg scancfg;
1509
1510         ENTER();
1511
1512         if (bssid == NULL) {
1513                 return -1;
1514         }
1515
1516         memset(&scancfg, 0x00, sizeof(scancfg));
1517         memcpy(scancfg.specificBSSID, bssid, sizeof(scancfg.specificBSSID));
1518         scancfg.keeppreviousscan = keeppreviousscan;
1519
1520         wlan_scan_networks(priv, &scancfg);
1521         if (priv->adapter->surpriseremoved)
1522                 return -1;
1523         wait_event_interruptible(priv->adapter->cmd_pending,
1524                 !priv->adapter->nr_cmd_pending);
1525
1526         LEAVE();
1527         return 0;
1528 }
1529
1530 /**
1531  *  @brief  Retrieve the scan table entries via wireless tools IOCTL call
1532  *
1533  *  @param dev          A pointer to net_device structure
1534  *  @param info         A pointer to iw_request_info structure
1535  *  @param dwrq         A pointer to iw_point structure
1536  *  @param extra        A pointer to extra data buf
1537  *
1538  *  @return             0 --success, otherwise fail
1539  */
1540 int libertas_get_scan(struct net_device *dev, struct iw_request_info *info,
1541                   struct iw_point *dwrq, char *extra)
1542 {
1543         wlan_private *priv = dev->priv;
1544         wlan_adapter *adapter = priv->adapter;
1545         int ret = 0;
1546         char *current_ev = extra;
1547         char *end_buf = extra + IW_SCAN_MAX_DATA;
1548         struct chan_freq_power *cfp;
1549         struct bss_descriptor *pscantable;
1550         char *current_val;      /* For rates */
1551         struct iw_event iwe;    /* Temporary buffer */
1552         int i;
1553         int j;
1554         int rate;
1555 #define PERFECT_RSSI ((u8)50)
1556 #define WORST_RSSI   ((u8)0)
1557 #define RSSI_DIFF    ((u8)(PERFECT_RSSI - WORST_RSSI))
1558         u8 rssi;
1559
1560         u8 buf[16 + 256 * 2];
1561         u8 *ptr;
1562
1563         ENTER();
1564
1565         /*
1566          * if there's either commands in the queue or one being
1567          * processed return -EAGAIN for iwlist to retry later.
1568          */
1569     if (adapter->nr_cmd_pending)
1570                 return -EAGAIN;
1571
1572         if (adapter->connect_status == libertas_connected)
1573                 lbs_pr_debug(1, "Current ssid: %32s\n",
1574                        adapter->curbssparams.ssid.ssid);
1575
1576         lbs_pr_debug(1, "Scan: Get: numinscantable = %d\n",
1577                adapter->numinscantable);
1578
1579         /* The old API using SIOCGIWAPLIST had a hard limit of IW_MAX_AP.
1580          * The new API using SIOCGIWSCAN is only limited by buffer size
1581          * WE-14 -> WE-16 the buffer is limited to IW_SCAN_MAX_DATA bytes
1582          * which is 4096.
1583          */
1584         for (i = 0; i < adapter->numinscantable; i++) {
1585                 if ((current_ev + MAX_SCAN_CELL_SIZE) >= end_buf) {
1586                         lbs_pr_debug(1, "i=%d break out: current_ev=%p end_buf=%p "
1587                                "MAX_SCAN_CELL_SIZE=%d\n",
1588                                i, current_ev, end_buf, MAX_SCAN_CELL_SIZE);
1589                         break;
1590                 }
1591
1592                 pscantable = &adapter->scantable[i];
1593
1594                 lbs_pr_debug(1, "i=%d  ssid: %32s\n", i, pscantable->ssid.ssid);
1595
1596                 cfp =
1597                     libertas_find_cfp_by_band_and_channel(adapter, 0,
1598                                                  pscantable->channel);
1599                 if (!cfp) {
1600                         lbs_pr_debug(1, "Invalid channel number %d\n",
1601                                pscantable->channel);
1602                         continue;
1603                 }
1604
1605                 if (!ssid_valid(&adapter->scantable[i].ssid)) {
1606                         continue;
1607                 }
1608
1609                 /* First entry *MUST* be the AP MAC address */
1610                 iwe.cmd = SIOCGIWAP;
1611                 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1612                 memcpy(iwe.u.ap_addr.sa_data,
1613                        &adapter->scantable[i].macaddress, ETH_ALEN);
1614
1615                 iwe.len = IW_EV_ADDR_LEN;
1616                 current_ev =
1617                     iwe_stream_add_event(current_ev, end_buf, &iwe, iwe.len);
1618
1619                 //Add the ESSID
1620                 iwe.u.data.length = adapter->scantable[i].ssid.ssidlength;
1621
1622                 if (iwe.u.data.length > 32) {
1623                         iwe.u.data.length = 32;
1624                 }
1625
1626                 iwe.cmd = SIOCGIWESSID;
1627                 iwe.u.data.flags = 1;
1628                 iwe.len = IW_EV_POINT_LEN + iwe.u.data.length;
1629                 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe,
1630                                                   adapter->scantable[i].ssid.
1631                                                   ssid);
1632
1633                 //Add mode
1634                 iwe.cmd = SIOCGIWMODE;
1635                 iwe.u.mode = adapter->scantable[i].inframode + 1;
1636                 iwe.len = IW_EV_UINT_LEN;
1637                 current_ev =
1638                     iwe_stream_add_event(current_ev, end_buf, &iwe, iwe.len);
1639
1640                 //frequency
1641                 iwe.cmd = SIOCGIWFREQ;
1642                 iwe.u.freq.m = (long)cfp->freq * 100000;
1643                 iwe.u.freq.e = 1;
1644                 iwe.len = IW_EV_FREQ_LEN;
1645                 current_ev =
1646                     iwe_stream_add_event(current_ev, end_buf, &iwe, iwe.len);
1647
1648                 /* Add quality statistics */
1649                 iwe.cmd = IWEVQUAL;
1650                 iwe.u.qual.updated = IW_QUAL_ALL_UPDATED;
1651                 iwe.u.qual.level = SCAN_RSSI(adapter->scantable[i].rssi);
1652
1653                 rssi = iwe.u.qual.level - MRVDRV_NF_DEFAULT_SCAN_VALUE;
1654                 iwe.u.qual.qual =
1655                     (100 * RSSI_DIFF * RSSI_DIFF - (PERFECT_RSSI - rssi) *
1656                      (15 * (RSSI_DIFF) + 62 * (PERFECT_RSSI - rssi))) /
1657                     (RSSI_DIFF * RSSI_DIFF);
1658                 if (iwe.u.qual.qual > 100)
1659                         iwe.u.qual.qual = 100;
1660                 else if (iwe.u.qual.qual < 1)
1661                         iwe.u.qual.qual = 0;
1662
1663                 if (adapter->NF[TYPE_BEACON][TYPE_NOAVG] == 0) {
1664                         iwe.u.qual.noise = MRVDRV_NF_DEFAULT_SCAN_VALUE;
1665                 } else {
1666                         iwe.u.qual.noise =
1667                             CAL_NF(adapter->NF[TYPE_BEACON][TYPE_NOAVG]);
1668                 }
1669                 if ((adapter->inframode == wlan802_11ibss) &&
1670                     !libertas_SSID_cmp(&adapter->curbssparams.ssid,
1671                              &adapter->scantable[i].ssid)
1672                     && adapter->adhoccreate) {
1673                         ret = libertas_prepare_and_send_command(priv,
1674                                                     cmd_802_11_rssi,
1675                                                     0,
1676                                                     cmd_option_waitforrsp,
1677                                                     0, NULL);
1678
1679                         if (!ret) {
1680                                 iwe.u.qual.level =
1681                                     CAL_RSSI(adapter->SNR[TYPE_RXPD][TYPE_AVG] /
1682                                              AVG_SCALE,
1683                                              adapter->NF[TYPE_RXPD][TYPE_AVG] /
1684                                              AVG_SCALE);
1685                         }
1686                 }
1687                 iwe.len = IW_EV_QUAL_LEN;
1688                 current_ev =
1689                     iwe_stream_add_event(current_ev, end_buf, &iwe, iwe.len);
1690
1691                 /* Add encryption capability */
1692                 iwe.cmd = SIOCGIWENCODE;
1693                 if (adapter->scantable[i].privacy) {
1694                         iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1695                 } else {
1696                         iwe.u.data.flags = IW_ENCODE_DISABLED;
1697                 }
1698                 iwe.u.data.length = 0;
1699                 iwe.len = IW_EV_POINT_LEN + iwe.u.data.length;
1700                 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe,
1701                                                   adapter->scantable->ssid.
1702                                                   ssid);
1703
1704                 current_val = current_ev + IW_EV_LCP_LEN;
1705
1706                 iwe.cmd = SIOCGIWRATE;
1707
1708                 iwe.u.bitrate.fixed = 0;
1709                 iwe.u.bitrate.disabled = 0;
1710                 iwe.u.bitrate.value = 0;
1711
1712                 /* Bit rate given in 500 kb/s units (+ 0x80) */
1713                 for (j = 0; j < sizeof(adapter->scantable[i].libertas_supported_rates);
1714                      j++) {
1715                         if (adapter->scantable[i].libertas_supported_rates[j] == 0) {
1716                                 break;
1717                         }
1718                         rate =
1719                             (adapter->scantable[i].libertas_supported_rates[j] & 0x7F) *
1720                             500000;
1721                         if (rate > iwe.u.bitrate.value) {
1722                                 iwe.u.bitrate.value = rate;
1723                         }
1724
1725                         iwe.u.bitrate.value =
1726                             (adapter->scantable[i].libertas_supported_rates[j]
1727                              & 0x7f) * 500000;
1728                         iwe.len = IW_EV_PARAM_LEN;
1729                         current_ev =
1730                             iwe_stream_add_value(current_ev, current_val,
1731                                                  end_buf, &iwe, iwe.len);
1732
1733                 }
1734                 if ((adapter->scantable[i].inframode == wlan802_11ibss)
1735                     && !libertas_SSID_cmp(&adapter->curbssparams.ssid,
1736                                 &adapter->scantable[i].ssid)
1737                     && adapter->adhoccreate) {
1738                         iwe.u.bitrate.value = 22 * 500000;
1739                 }
1740                 iwe.len = IW_EV_PARAM_LEN;
1741                 current_ev =
1742                     iwe_stream_add_value(current_ev, current_val, end_buf, &iwe,
1743                                          iwe.len);
1744
1745                 /* Add new value to event */
1746                 current_val = current_ev + IW_EV_LCP_LEN;
1747
1748                 if (adapter->scantable[i].wpa2_supplicant.wpa_ie[0] == WPA2_IE) {
1749                         memset(&iwe, 0, sizeof(iwe));
1750                         memset(buf, 0, sizeof(buf));
1751                         memcpy(buf, adapter->scantable[i].
1752                                                 wpa2_supplicant.wpa_ie,
1753                                         adapter->scantable[i].wpa2_supplicant.
1754                                                 wpa_ie_len);
1755                         iwe.cmd = IWEVGENIE;
1756                         iwe.u.data.length = adapter->scantable[i].
1757                                         wpa2_supplicant.wpa_ie_len;
1758                         iwe.len = IW_EV_POINT_LEN + iwe.u.data.length;
1759                         current_ev = iwe_stream_add_point(current_ev, end_buf,
1760                                         &iwe, buf);
1761                 }
1762                 if (adapter->scantable[i].wpa_supplicant.wpa_ie[0] == WPA_IE) {
1763                         memset(&iwe, 0, sizeof(iwe));
1764                         memset(buf, 0, sizeof(buf));
1765                         memcpy(buf, adapter->scantable[i].
1766                                                 wpa_supplicant.wpa_ie,
1767                                         adapter->scantable[i].wpa_supplicant.
1768                                                 wpa_ie_len);
1769                         iwe.cmd = IWEVGENIE;
1770                         iwe.u.data.length = adapter->scantable[i].
1771                                         wpa_supplicant.wpa_ie_len;
1772                         iwe.len = IW_EV_POINT_LEN + iwe.u.data.length;
1773                         current_ev = iwe_stream_add_point(current_ev, end_buf,
1774                                         &iwe, buf);
1775                 }
1776
1777
1778                 if (adapter->scantable[i].extra_ie != 0) {
1779                         memset(&iwe, 0, sizeof(iwe));
1780                         memset(buf, 0, sizeof(buf));
1781                         ptr = buf;
1782                         ptr += sprintf(ptr, "extra_ie");
1783                         iwe.u.data.length = strlen(buf);
1784
1785                         lbs_pr_debug(1, "iwe.u.data.length %d\n",
1786                                iwe.u.data.length);
1787                         lbs_pr_debug(1, "BUF: %s \n", buf);
1788
1789                         iwe.cmd = IWEVCUSTOM;
1790                         iwe.len = IW_EV_POINT_LEN + iwe.u.data.length;
1791                         current_ev =
1792                             iwe_stream_add_point(current_ev, end_buf, &iwe,
1793                                                  buf);
1794                 }
1795
1796                 current_val = current_ev + IW_EV_LCP_LEN;
1797
1798                 /*
1799                  * Check if we added any event
1800                  */
1801                 if ((current_val - current_ev) > IW_EV_LCP_LEN)
1802                         current_ev = current_val;
1803         }
1804
1805         dwrq->length = (current_ev - extra);
1806         dwrq->flags = 0;
1807
1808         LEAVE();
1809         return 0;
1810 }
1811
1812 /**
1813  *  @brief Prepare a scan command to be sent to the firmware
1814  *
1815  *  Use the wlan_scan_cmd_config sent to the command processing module in
1816  *   the libertas_prepare_and_send_command to configure a cmd_ds_802_11_scan command
1817  *   struct to send to firmware.
1818  *
1819  *  The fixed fields specifying the BSS type and BSSID filters as well as a
1820  *   variable number/length of TLVs are sent in the command to firmware.
1821  *
1822  *  @param priv       A pointer to wlan_private structure
1823  *  @param cmd        A pointer to cmd_ds_command structure to be sent to
1824  *                    firmware with the cmd_DS_801_11_SCAN structure
1825  *  @param pdata_buf  Void pointer cast of a wlan_scan_cmd_config struct used
1826  *                    to set the fields/TLVs for the command sent to firmware
1827  *
1828  *  @return           0 or -1
1829  *
1830  *  @sa wlan_scan_create_channel_list
1831  */
1832 int libertas_cmd_80211_scan(wlan_private * priv,
1833                          struct cmd_ds_command *cmd, void *pdata_buf)
1834 {
1835         struct cmd_ds_802_11_scan *pscan = &cmd->params.scan;
1836         struct wlan_scan_cmd_config *pscancfg;
1837
1838         ENTER();
1839
1840         pscancfg = pdata_buf;
1841
1842         /* Set fixed field variables in scan command */
1843         pscan->bsstype = pscancfg->bsstype;
1844         memcpy(pscan->BSSID, pscancfg->specificBSSID, sizeof(pscan->BSSID));
1845         memcpy(pscan->tlvbuffer, pscancfg->tlvbuffer, pscancfg->tlvbufferlen);
1846
1847         cmd->command = cpu_to_le16(cmd_802_11_scan);
1848
1849         /* size is equal to the sizeof(fixed portions) + the TLV len + header */
1850         cmd->size = cpu_to_le16(sizeof(pscan->bsstype)
1851                                      + sizeof(pscan->BSSID)
1852                                      + pscancfg->tlvbufferlen + S_DS_GEN);
1853
1854         lbs_pr_debug(1, "SCAN_CMD: command=%x, size=%x, seqnum=%x\n",
1855                cmd->command, cmd->size, cmd->seqnum);
1856         LEAVE();
1857         return 0;
1858 }
1859
1860 /**
1861  *  @brief This function handles the command response of scan
1862  *
1863  *   The response buffer for the scan command has the following
1864  *      memory layout:
1865  *
1866  *     .-----------------------------------------------------------.
1867  *     |  header (4 * sizeof(u16)):  Standard command response hdr |
1868  *     .-----------------------------------------------------------.
1869  *     |  bufsize (u16) : sizeof the BSS Description data          |
1870  *     .-----------------------------------------------------------.
1871  *     |  NumOfSet (u8) : Number of BSS Descs returned             |
1872  *     .-----------------------------------------------------------.
1873  *     |  BSSDescription data (variable, size given in bufsize)    |
1874  *     .-----------------------------------------------------------.
1875  *     |  TLV data (variable, size calculated using header->size,  |
1876  *     |            bufsize and sizeof the fixed fields above)     |
1877  *     .-----------------------------------------------------------.
1878  *
1879  *  @param priv    A pointer to wlan_private structure
1880  *  @param resp    A pointer to cmd_ds_command
1881  *
1882  *  @return        0 or -1
1883  */
1884 int libertas_ret_80211_scan(wlan_private * priv, struct cmd_ds_command *resp)
1885 {
1886         wlan_adapter *adapter = priv->adapter;
1887         struct cmd_ds_802_11_scan_rsp *pscan;
1888         struct bss_descriptor newbssentry;
1889         struct mrvlietypes_data *ptlv;
1890         struct mrvlietypes_tsftimestamp *ptsftlv;
1891         u8 *pbssinfo;
1892         u16 scanrespsize;
1893         int bytesleft;
1894         int numintable;
1895         int bssIdx;
1896         int idx;
1897         int tlvbufsize;
1898         u64 tsfval;
1899
1900         ENTER();
1901
1902         pscan = &resp->params.scanresp;
1903
1904         if (pscan->nr_sets > MRVDRV_MAX_BSSID_LIST) {
1905         lbs_pr_debug(1,
1906                        "SCAN_RESP: Invalid number of AP returned (%d)!!\n",
1907                        pscan->nr_sets);
1908                 LEAVE();
1909                 return -1;
1910         }
1911
1912         bytesleft = le16_to_cpu(pscan->bssdescriptsize);
1913         lbs_pr_debug(1, "SCAN_RESP: bssdescriptsize %d\n", bytesleft);
1914
1915         scanrespsize = le16_to_cpu(resp->size);
1916         lbs_pr_debug(1, "SCAN_RESP: returned %d AP before parsing\n",
1917                pscan->nr_sets);
1918
1919         numintable = adapter->numinscantable;
1920         pbssinfo = pscan->bssdesc_and_tlvbuffer;
1921
1922         /* The size of the TLV buffer is equal to the entire command response
1923          *   size (scanrespsize) minus the fixed fields (sizeof()'s), the
1924          *   BSS Descriptions (bssdescriptsize as bytesLef) and the command
1925          *   response header (S_DS_GEN)
1926          */
1927         tlvbufsize = scanrespsize - (bytesleft + sizeof(pscan->bssdescriptsize)
1928                                      + sizeof(pscan->nr_sets)
1929                                      + S_DS_GEN);
1930
1931         ptlv = (struct mrvlietypes_data *) (pscan->bssdesc_and_tlvbuffer + bytesleft);
1932
1933         /* Search the TLV buffer space in the scan response for any valid TLVs */
1934         wlan_ret_802_11_scan_get_tlv_ptrs(ptlv, tlvbufsize, &ptsftlv);
1935
1936         /*
1937          *  Process each scan response returned (pscan->nr_sets).  Save
1938          *    the information in the newbssentry and then insert into the
1939          *    driver scan table either as an update to an existing entry
1940          *    or as an addition at the end of the table
1941          */
1942         for (idx = 0; idx < pscan->nr_sets && bytesleft; idx++) {
1943                 /* Zero out the newbssentry we are about to store info in */
1944                 memset(&newbssentry, 0x00, sizeof(newbssentry));
1945
1946                 /* Process the data fields and IEs returned for this BSS */
1947                 if ((InterpretBSSDescriptionWithIE(&newbssentry,
1948                                                    &pbssinfo,
1949                                                    &bytesleft) ==
1950                      0)
1951                     && CHECK_SSID_IS_VALID(&newbssentry.ssid)) {
1952
1953             lbs_pr_debug(1,
1954                                "SCAN_RESP: BSSID = %02x:%02x:%02x:%02x:%02x:%02x\n",
1955                                newbssentry.macaddress[0],
1956                                newbssentry.macaddress[1],
1957                                newbssentry.macaddress[2],
1958                                newbssentry.macaddress[3],
1959                                newbssentry.macaddress[4],
1960                                newbssentry.macaddress[5]);
1961
1962                         /*
1963                          * Search the scan table for the same bssid
1964                          */
1965                         for (bssIdx = 0; bssIdx < numintable; bssIdx++) {
1966                                 if (memcmp(newbssentry.macaddress,
1967                                            adapter->scantable[bssIdx].
1968                                            macaddress,
1969                                            sizeof(newbssentry.macaddress)) ==
1970                                     0) {
1971                                         /*
1972                                          * If the SSID matches as well, it is a duplicate of
1973                                          *   this entry.  Keep the bssIdx set to this
1974                                          *   entry so we replace the old contents in the table
1975                                          */
1976                                         if ((newbssentry.ssid.ssidlength ==
1977                                              adapter->scantable[bssIdx].ssid.
1978                                              ssidlength)
1979                                             &&
1980                                             (memcmp
1981                                              (newbssentry.ssid.ssid,
1982                                               adapter->scantable[bssIdx].ssid.
1983                                               ssid,
1984                                               newbssentry.ssid.ssidlength) ==
1985                                              0)) {
1986                         lbs_pr_debug(1,
1987                                                        "SCAN_RESP: Duplicate of index: %d\n",
1988                                                        bssIdx);
1989                                                 break;
1990                                         }
1991                                 }
1992                         }
1993                         /*
1994                          * If the bssIdx is equal to the number of entries in the table,
1995                          *   the new entry was not a duplicate; append it to the scan
1996                          *   table
1997                          */
1998                         if (bssIdx == numintable) {
1999                                 /* Range check the bssIdx, keep it limited to the last entry */
2000                                 if (bssIdx == MRVDRV_MAX_BSSID_LIST) {
2001                                         bssIdx--;
2002                                 } else {
2003                                         numintable++;
2004                                 }
2005                         }
2006
2007                         /*
2008                          * If the TSF TLV was appended to the scan results, save the
2009                          *   this entries TSF value in the networktsf field.  The
2010                          *   networktsf is the firmware's TSF value at the time the
2011                          *   beacon or probe response was received.
2012                          */
2013                         if (ptsftlv) {
2014                                 memcpy(&tsfval, &ptsftlv->tsftable[idx],
2015                                        sizeof(tsfval));
2016                                 tsfval = le64_to_cpu(tsfval);
2017
2018                                 memcpy(&newbssentry.networktsf,
2019                                        &tsfval, sizeof(newbssentry.networktsf));
2020                         }
2021
2022                         /* Copy the locally created newbssentry to the scan table */
2023                         memcpy(&adapter->scantable[bssIdx],
2024                                &newbssentry,
2025                                sizeof(adapter->scantable[bssIdx]));
2026
2027                 } else {
2028
2029                         /* error parsing/interpreting the scan response, skipped */
2030                         lbs_pr_debug(1, "SCAN_RESP: "
2031                                "InterpretBSSDescriptionWithIE returned ERROR\n");
2032                 }
2033         }
2034
2035         lbs_pr_debug(1, "SCAN_RESP: Scanned %2d APs, %d valid, %d total\n",
2036                pscan->nr_sets, numintable - adapter->numinscantable,
2037                numintable);
2038
2039         /* Update the total number of BSSIDs in the scan table */
2040         adapter->numinscantable = numintable;
2041
2042         LEAVE();
2043         return 0;
2044 }