drivers/net/wireless/rkwifi/bcmdhd/dhd_common.c

   1 /*
   2  * Broadcom Dongle Host Driver (DHD), common DHD core.
   3  *
   4  * $Copyright Open Broadcom Corporation$
   5  *
   6  * $Id: dhd_common.c 419132 2013-08-19 21:33:05Z $
   7  */
   8 #include <typedefs.h>
   9 #include <osl.h>
  10
  11 #include <epivers.h>
  12 #include <bcmutils.h>
  13
  14 #include <bcmendian.h>
  15 #include <dngl_stats.h>
  16 #include <wlioctl.h>
  17 #include <dhd.h>
  18 #include <dhd_ip.h>
  19
  20 #include <proto/bcmevent.h>
  21 #include <proto/bcmip.h>
  22
  23 #include <dhd_bus.h>
  24 #include <dhd_proto.h>
  25 #include <dhd_config.h>
  26 #include <dhd_dbg.h>
  27 #include <msgtrace.h>
  28
  29 #ifdef WL_CFG80211
  30 #include <wl_cfg80211.h>
  31 #endif
  32 #ifdef WLBTAMP
  33 #include <proto/bt_amp_hci.h>
  34 #include <dhd_bta.h>
  35 #endif
  36 #ifdef PNO_SUPPORT
  37 #include <dhd_pno.h>
  38 #endif
  39 #ifdef SET_RANDOM_MAC_SOFTAP
  40 #include <linux/random.h>
  41 #include <linux/jiffies.h>
  42 #endif
  43
  44 #define htod32(i) i
  45 #define htod16(i) i
  46 #define dtoh32(i) i
  47 #define dtoh16(i) i
  48 #define htodchanspec(i) i
  49 #define dtohchanspec(i) i
  50
  51 #ifdef PROP_TXSTATUS
  52 #include <wlfc_proto.h>
  53 #include <dhd_wlfc.h>
  54 #endif
  55
  56 #ifdef WLMEDIA_HTSF
  57 extern void htsf_update(struct dhd_info *dhd, void *data);
  58 #endif
  59 int dhd_msg_level = DHD_ERROR_VAL;
  60
  61
  62 #include <wl_iw.h>
  63
  64 char fw_path[MOD_PARAM_PATHLEN];
  65 char nv_path[MOD_PARAM_PATHLEN];
  66 // terence 20130703: customer can add some parameters to configure driver
  67 char conf_path[MOD_PARAM_PATHLEN];
  68
  69 #ifdef SOFTAP
  70 char fw_path2[MOD_PARAM_PATHLEN];
  71 extern bool softap_enabled;
  72 #endif
  73
  74 /* Last connection success/failure status */
  75 uint32 dhd_conn_event;
  76 uint32 dhd_conn_status;
  77 uint32 dhd_conn_reason;
  78
  79 extern int dhd_iscan_request(void * dhdp, uint16 action);
  80 extern void dhd_ind_scan_confirm(void *h, bool status);
  81 extern int dhd_iscan_in_progress(void *h);
  82 void dhd_iscan_lock(void);
  83 void dhd_iscan_unlock(void);
  84 extern int dhd_change_mtu(dhd_pub_t *dhd, int new_mtu, int ifidx);
  85 #if !defined(AP) && defined(WLP2P)
  86 extern int dhd_get_concurrent_capabilites(dhd_pub_t *dhd);
  87 #endif
  88 bool ap_cfg_running = FALSE;
  89 bool ap_fw_loaded = FALSE;
  90
  91 //(gwl)
  92 #define CONFIG_BCMDHD_CONFIG_PATH "/system/etc/firmware/config.txt"
  93 extern char CONFIG_BCMDHD_FW_PATH[];
  94 extern char CONFIG_BCMDHD_NVRAM_PATH[];
  95
  96 #ifdef DHD_DEBUG
  97 const char dhd_version[] = "Dongle Host Driver, version " EPI_VERSION_STR "\nCompiled on "
  98         __DATE__ " at " __TIME__;
  99 #else
 100 const char dhd_version[] = "Dongle Host Driver, version " EPI_VERSION_STR;
 101 #endif
 102
 103 void dhd_set_timer(void *bus, uint wdtick);
 104
 105 /* IOVar table */
 106 enum {
 107         IOV_VERSION = 1,
 108         IOV_WLMSGLEVEL,
 109         IOV_MSGLEVEL,
 110         IOV_BCMERRORSTR,
 111         IOV_BCMERROR,
 112         IOV_WDTICK,
 113         IOV_DUMP,
 114         IOV_CLEARCOUNTS,
 115         IOV_LOGDUMP,
 116         IOV_LOGCAL,
 117         IOV_LOGSTAMP,
 118         IOV_GPIOOB,
 119         IOV_IOCTLTIMEOUT,
 120 #ifdef WLBTAMP
 121         IOV_HCI_CMD,            /* HCI command */
 122         IOV_HCI_ACL_DATA,       /* HCI data packet */
 123 #endif
 124 #if defined(DHD_DEBUG)
 125         IOV_CONS,
 126         IOV_DCONSOLE_POLL,
 127 #endif /* defined(DHD_DEBUG) */
 128 #ifdef PROP_TXSTATUS
 129         IOV_PROPTXSTATUS_ENABLE,
 130         IOV_PROPTXSTATUS_MODE,
 131         IOV_PROPTXSTATUS_OPT,
 132 #ifdef QMONITOR
 133         IOV_QMON_TIME_THRES,
 134         IOV_QMON_TIME_PERCENT,
 135 #endif /* QMONITOR */
 136 #endif /* PROP_TXSTATUS */
 137         IOV_BUS_TYPE,
 138 #ifdef WLMEDIA_HTSF
 139         IOV_WLPKTDLYSTAT_SZ,
 140 #endif
 141         IOV_CHANGEMTU,
 142         IOV_HOSTREORDER_FLOWS,
 143         IOV_LAST
 144 };
 145
 146 const bcm_iovar_t dhd_iovars[] = {
 147         {"version",     IOV_VERSION,    0,      IOVT_BUFFER,    sizeof(dhd_version) },
 148         {"wlmsglevel",  IOV_WLMSGLEVEL, 0,      IOVT_UINT32,    0 },
 149 #ifdef DHD_DEBUG
 150         {"msglevel",    IOV_MSGLEVEL,   0,      IOVT_UINT32,    0 },
 151 #endif /* DHD_DEBUG */
 152         {"bcmerrorstr", IOV_BCMERRORSTR, 0, IOVT_BUFFER,        BCME_STRLEN },
 153         {"bcmerror",    IOV_BCMERROR,   0,      IOVT_INT8,      0 },
 154         {"wdtick",      IOV_WDTICK, 0,  IOVT_UINT32,    0 },
 155         {"dump",        IOV_DUMP,       0,      IOVT_BUFFER,    DHD_IOCTL_MAXLEN },
 156 #ifdef DHD_DEBUG
 157         {"cons",        IOV_CONS,       0,      IOVT_BUFFER,    0 },
 158         {"dconpoll",    IOV_DCONSOLE_POLL, 0,   IOVT_UINT32,    0 },
 159 #endif
 160         {"clearcounts", IOV_CLEARCOUNTS, 0, IOVT_VOID,  0 },
 161         {"gpioob",      IOV_GPIOOB,     0,      IOVT_UINT32,    0 },
 162         {"ioctl_timeout",       IOV_IOCTLTIMEOUT,       0,      IOVT_UINT32,    0 },
 163 #ifdef WLBTAMP
 164         {"HCI_cmd",     IOV_HCI_CMD,    0,      IOVT_BUFFER,    0},
 165         {"HCI_ACL_data", IOV_HCI_ACL_DATA, 0,   IOVT_BUFFER,    0},
 166 #endif
 167 #ifdef PROP_TXSTATUS
 168         {"proptx",      IOV_PROPTXSTATUS_ENABLE,        0,      IOVT_UINT32,    0 },
 169         /*
 170         set the proptxtstatus operation mode:
 171         0 - Do not do any proptxtstatus flow control
 172         1 - Use implied credit from a packet status
 173         2 - Use explicit credit
 174         */
 175         {"ptxmode",     IOV_PROPTXSTATUS_MODE,  0,      IOVT_UINT32,    0 },
 176         {"proptx_opt", IOV_PROPTXSTATUS_OPT,    0,      IOVT_UINT32,    0 },
 177 #ifdef QMONITOR
 178         {"qtime_thres", IOV_QMON_TIME_THRES,    0,      IOVT_UINT32,    0 },
 179         {"qtime_percent", IOV_QMON_TIME_PERCENT, 0,     IOVT_UINT32,    0 },
 180 #endif /* QMONITOR */
 181 #endif /* PROP_TXSTATUS */
 182         {"bustype", IOV_BUS_TYPE, 0, IOVT_UINT32, 0},
 183 #ifdef WLMEDIA_HTSF
 184         {"pktdlystatsz", IOV_WLPKTDLYSTAT_SZ, 0, IOVT_UINT8, 0 },
 185 #endif
 186         {"changemtu", IOV_CHANGEMTU, 0, IOVT_UINT32, 0 },
 187         {"host_reorder_flows", IOV_HOSTREORDER_FLOWS, 0, IOVT_BUFFER,
 188         (WLHOST_REORDERDATA_MAXFLOWS + 1) },
 189         {NULL, 0, 0, 0, 0 }
 190 };
 191 #define DHD_IOVAR_BUF_SIZE      128
 192 //(gwl)
 193 extern int rkwifi_set_firmware(char *fw, char *nvram);
 194
 195 void
 196 dhd_common_init(osl_t *osh)
 197 {
 198 //#ifdef CONFIG_BCMDHD_FW_PATH
 199     if(strlen(CONFIG_BCMDHD_FW_PATH))
 200         bcm_strncpy_s(fw_path, sizeof(fw_path), CONFIG_BCMDHD_FW_PATH, MOD_PARAM_PATHLEN-1);
 201 //#else /* CONFIG_BCMDHD_FW_PATH */
 202     else
 203         fw_path[0] = '\0';
 204 //#endif /* CONFIG_BCMDHD_FW_PATH */
 205 //#ifdef CONFIG_BCMDHD_NVRAM_PATH
 206     if(strlen(CONFIG_BCMDHD_NVRAM_PATH))
 207         bcm_strncpy_s(nv_path, sizeof(nv_path), CONFIG_BCMDHD_NVRAM_PATH, MOD_PARAM_PATHLEN-1);
 208 //#else /* CONFIG_BCMDHD_NVRAM_PATH */
 209     else
 210         nv_path[0] = '\0';
 211 //#endif /* CONFIG_BCMDHD_NVRAM_PATH */
 212 #ifdef CONFIG_BCMDHD_CONFIG_PATH
 213         bcm_strncpy_s(conf_path, sizeof(conf_path), CONFIG_BCMDHD_CONFIG_PATH, MOD_PARAM_PATHLEN-1);
 214 #else /* CONFIG_BCMDHD_CONFIG_PATH */
 215         conf_path[0] = '\0';
 216 #endif /* CONFIG_BCMDHD_CONFIG_PATH */
 217     rkwifi_set_firmware(fw_path, nv_path);
 218     //bcm_strncpy_s(firmware_path, sizeof(firmware_path), fw_path, MOD_PARAM_PATHLEN-1);
 219     printk("FW_PATH = %s\nNVRAM_PATH = %s\n", fw_path, nv_path); //(gwl)
 220 #ifdef SOFTAP
 221         fw_path2[0] = '\0';
 222 #endif
 223 }
 224
 225 void
 226 dhd_common_deinit(dhd_pub_t *dhd_pub, dhd_cmn_t *sa_cmn)
 227 {
 228         osl_t *osh;
 229         dhd_cmn_t *cmn;
 230
 231         if (dhd_pub != NULL)
 232                 cmn = dhd_pub->cmn;
 233         else
 234                 cmn = sa_cmn;
 235
 236         if (!cmn)
 237                 return;
 238
 239         osh = cmn->osh;
 240
 241         if (dhd_pub != NULL)
 242                 dhd_pub->cmn = NULL;
 243
 244         MFREE(osh, cmn, sizeof(dhd_cmn_t));
 245 }
 246
 247 static int
 248 dhd_dump(dhd_pub_t *dhdp, char *buf, int buflen)
 249 {
 250         char eabuf[ETHER_ADDR_STR_LEN];
 251
 252         struct bcmstrbuf b;
 253         struct bcmstrbuf *strbuf = &b;
 254
 255         bcm_binit(strbuf, buf, buflen);
 256
 257         /* Base DHD info */
 258         bcm_bprintf(strbuf, "%s\n", dhd_version);
 259         bcm_bprintf(strbuf, "\n");
 260         bcm_bprintf(strbuf, "pub.up %d pub.txoff %d pub.busstate %d\n",
 261                     dhdp->up, dhdp->txoff, dhdp->busstate);
 262         bcm_bprintf(strbuf, "pub.hdrlen %u pub.maxctl %u pub.rxsz %u\n",
 263                     dhdp->hdrlen, dhdp->maxctl, dhdp->rxsz);
 264         bcm_bprintf(strbuf, "pub.iswl %d pub.drv_version %ld pub.mac %s\n",
 265                     dhdp->iswl, dhdp->drv_version, bcm_ether_ntoa(&dhdp->mac, eabuf));
 266         bcm_bprintf(strbuf, "pub.bcmerror %d tickcnt %u\n", dhdp->bcmerror, dhdp->tickcnt);
 267
 268         bcm_bprintf(strbuf, "dongle stats:\n");
 269         bcm_bprintf(strbuf, "tx_packets %lu tx_bytes %lu tx_errors %lu tx_dropped %lu\n",
 270                     dhdp->dstats.tx_packets, dhdp->dstats.tx_bytes,
 271                     dhdp->dstats.tx_errors, dhdp->dstats.tx_dropped);
 272         bcm_bprintf(strbuf, "rx_packets %lu rx_bytes %lu rx_errors %lu rx_dropped %lu\n",
 273                     dhdp->dstats.rx_packets, dhdp->dstats.rx_bytes,
 274                     dhdp->dstats.rx_errors, dhdp->dstats.rx_dropped);
 275         bcm_bprintf(strbuf, "multicast %lu\n", dhdp->dstats.multicast);
 276
 277         bcm_bprintf(strbuf, "bus stats:\n");
 278         bcm_bprintf(strbuf, "tx_packets %lu tx_multicast %lu tx_errors %lu\n",
 279                     dhdp->tx_packets, dhdp->tx_multicast, dhdp->tx_errors);
 280         bcm_bprintf(strbuf, "tx_ctlpkts %lu tx_ctlerrs %lu\n",
 281                     dhdp->tx_ctlpkts, dhdp->tx_ctlerrs);
 282         bcm_bprintf(strbuf, "rx_packets %lu rx_multicast %lu rx_errors %lu \n",
 283                     dhdp->rx_packets, dhdp->rx_multicast, dhdp->rx_errors);
 284         bcm_bprintf(strbuf, "rx_ctlpkts %lu rx_ctlerrs %lu rx_dropped %lu\n",
 285                     dhdp->rx_ctlpkts, dhdp->rx_ctlerrs, dhdp->rx_dropped);
 286         bcm_bprintf(strbuf, "rx_readahead_cnt %lu tx_realloc %lu\n",
 287                     dhdp->rx_readahead_cnt, dhdp->tx_realloc);
 288         bcm_bprintf(strbuf, "\n");
 289
 290         /* Add any prot info */
 291         dhd_prot_dump(dhdp, strbuf);
 292         bcm_bprintf(strbuf, "\n");
 293
 294         /* Add any bus info */
 295         dhd_bus_dump(dhdp, strbuf);
 296
 297         return (!strbuf->size ? BCME_BUFTOOSHORT : 0);
 298 }
 299
 300 int
 301 dhd_wl_ioctl_cmd(dhd_pub_t *dhd_pub, int cmd, void *arg, int len, uint8 set, int ifindex)
 302 {
 303         wl_ioctl_t ioc;
 304
 305         ioc.cmd = cmd;
 306         ioc.buf = arg;
 307         ioc.len = len;
 308         ioc.set = set;
 309
 310         return dhd_wl_ioctl(dhd_pub, ifindex, &ioc, arg, len);
 311 }
 312
 313
 314 int
 315 dhd_wl_ioctl(dhd_pub_t *dhd_pub, int ifindex, wl_ioctl_t *ioc, void *buf, int len)
 316 {
 317         int ret = 0;
 318
 319         if (dhd_os_proto_block(dhd_pub))
 320         {
 321                 ret = dhd_prot_ioctl(dhd_pub, ifindex, ioc, buf, len);
 322                 if ((ret) && (dhd_pub->up))
 323                         /* Send hang event only if dhd_open() was success */
 324                         dhd_os_check_hang(dhd_pub, ifindex, ret);
 325
 326                 if (ret == -ETIMEDOUT && !dhd_pub->up) {
 327                         DHD_ERROR(("%s: 'resumed on timeout' error is "
 328                                 "occurred before the interface does not"
 329                                 " bring up\n", __FUNCTION__));
 330                         dhd_pub->busstate = DHD_BUS_DOWN;
 331                 }
 332
 333                 dhd_os_proto_unblock(dhd_pub);
 334
 335         }
 336         return ret;
 337 }
 338
 339 static int
 340 dhd_doiovar(dhd_pub_t *dhd_pub, const bcm_iovar_t *vi, uint32 actionid, const char *name,
 341             void *params, int plen, void *arg, int len, int val_size)
 342 {
 343         int bcmerror = 0;
 344         int32 int_val = 0;
 345
 346         DHD_TRACE(("%s: Enter\n", __FUNCTION__));
 347         DHD_TRACE(("%s: actionid = %d; name %s\n", __FUNCTION__, actionid, name));
 348
 349         if ((bcmerror = bcm_iovar_lencheck(vi, arg, len, IOV_ISSET(actionid))) != 0)
 350                 goto exit;
 351
 352         if (plen >= (int)sizeof(int_val))
 353                 bcopy(params, &int_val, sizeof(int_val));
 354
 355         switch (actionid) {
 356         case IOV_GVAL(IOV_VERSION):
 357                 /* Need to have checked buffer length */
 358                 bcm_strncpy_s((char*)arg, len, dhd_version, len);
 359                 break;
 360
 361         case IOV_GVAL(IOV_WLMSGLEVEL):
 362                 printk("android_msg_level=0x%x\n", android_msg_level);
 363                 printk("config_msg_level=0x%x\n", config_msg_level);
 364 #if defined(WL_WIRELESS_EXT)
 365                 int_val = (int32)iw_msg_level;
 366                 bcopy(&int_val, arg, val_size);
 367                 printk("iw_msg_level=0x%x\n", iw_msg_level);
 368 #endif
 369 #ifdef WL_CFG80211
 370                 int_val = (int32)wl_dbg_level;
 371                 bcopy(&int_val, arg, val_size);
 372                 printk("cfg_msg_level=0x%x\n", wl_dbg_level);
 373 #endif
 374                 break;
 375
 376         case IOV_SVAL(IOV_WLMSGLEVEL):
 377                 if (int_val & DHD_ANDROID_VAL) {
 378                         android_msg_level = (uint)(int_val & 0xFFFF);
 379                         printk("android_msg_level=0x%x\n", android_msg_level);
 380                 }
 381                 if (int_val & DHD_CONFIG_VAL) {
 382                         config_msg_level = (uint)(int_val & 0xFFFF);
 383                         printk("config_msg_level=0x%x\n", config_msg_level);
 384                 }
 385 #if defined(WL_WIRELESS_EXT)
 386                 if (int_val & DHD_IW_VAL) {
 387                         iw_msg_level = (uint)(int_val & 0xFFFF);
 388                         printk("iw_msg_level=0x%x\n", iw_msg_level);
 389                 }
 390 #endif
 391 #ifdef WL_CFG80211
 392                 if (int_val & DHD_CFG_VAL) {
 393                         wl_cfg80211_enable_trace((u32)(int_val & 0xFFFF));
 394                 }
 395 #endif
 396                 break;
 397
 398         case IOV_GVAL(IOV_MSGLEVEL):
 399                 int_val = (int32)dhd_msg_level;
 400                 bcopy(&int_val, arg, val_size);
 401                 break;
 402
 403         case IOV_SVAL(IOV_MSGLEVEL):
 404                 dhd_msg_level = int_val;
 405                 break;
 406
 407         case IOV_GVAL(IOV_BCMERRORSTR):
 408                 bcm_strncpy_s((char *)arg, len, bcmerrorstr(dhd_pub->bcmerror), BCME_STRLEN);
 409                 ((char *)arg)[BCME_STRLEN - 1] = 0x00;
 410                 break;
 411
 412         case IOV_GVAL(IOV_BCMERROR):
 413                 int_val = (int32)dhd_pub->bcmerror;
 414                 bcopy(&int_val, arg, val_size);
 415                 break;
 416
 417         case IOV_GVAL(IOV_WDTICK):
 418                 int_val = (int32)dhd_watchdog_ms;
 419                 bcopy(&int_val, arg, val_size);
 420                 break;
 421
 422         case IOV_SVAL(IOV_WDTICK):
 423                 if (!dhd_pub->up) {
 424                         bcmerror = BCME_NOTUP;
 425                         break;
 426                 }
 427                 dhd_os_wd_timer(dhd_pub, (uint)int_val);
 428                 break;
 429
 430         case IOV_GVAL(IOV_DUMP):
 431                 bcmerror = dhd_dump(dhd_pub, arg, len);
 432                 break;
 433
 434 #ifdef DHD_DEBUG
 435         case IOV_GVAL(IOV_DCONSOLE_POLL):
 436                 int_val = (int32)dhd_console_ms;
 437                 bcopy(&int_val, arg, val_size);
 438                 break;
 439
 440         case IOV_SVAL(IOV_DCONSOLE_POLL):
 441                 dhd_console_ms = (uint)int_val;
 442                 break;
 443
 444         case IOV_SVAL(IOV_CONS):
 445                 if (len > 0)
 446                         bcmerror = dhd_bus_console_in(dhd_pub, arg, len - 1);
 447                 break;
 448 #endif /* DHD_DEBUG */
 449
 450         case IOV_SVAL(IOV_CLEARCOUNTS):
 451                 dhd_pub->tx_packets = dhd_pub->rx_packets = 0;
 452                 dhd_pub->tx_errors = dhd_pub->rx_errors = 0;
 453                 dhd_pub->tx_ctlpkts = dhd_pub->rx_ctlpkts = 0;
 454                 dhd_pub->tx_ctlerrs = dhd_pub->rx_ctlerrs = 0;
 455                 dhd_pub->rx_dropped = 0;
 456                 dhd_pub->rx_readahead_cnt = 0;
 457                 dhd_pub->tx_realloc = 0;
 458                 dhd_pub->wd_dpc_sched = 0;
 459                 memset(&dhd_pub->dstats, 0, sizeof(dhd_pub->dstats));
 460                 dhd_bus_clearcounts(dhd_pub);
 461 #ifdef PROP_TXSTATUS
 462                 /* clear proptxstatus related counters */
 463                 if (dhd_pub->wlfc_state) {
 464                         athost_wl_status_info_t *wlfc =
 465                                 (athost_wl_status_info_t*)dhd_pub->wlfc_state;
 466                         wlfc_hanger_t* hanger;
 467
 468                         memset(&wlfc->stats, 0, sizeof(athost_wl_stat_counters_t));
 469
 470                         hanger = (wlfc_hanger_t*)wlfc->hanger;
 471                         hanger->pushed = 0;
 472                         hanger->popped = 0;
 473                         hanger->failed_slotfind = 0;
 474                         hanger->failed_to_pop = 0;
 475                         hanger->failed_to_push = 0;
 476                 }
 477 #endif /* PROP_TXSTATUS */
 478                 break;
 479
 480         case IOV_GVAL(IOV_IOCTLTIMEOUT): {
 481                 int_val = (int32)dhd_os_get_ioctl_resp_timeout();
 482                 bcopy(&int_val, arg, sizeof(int_val));
 483                 break;
 484         }
 485
 486         case IOV_SVAL(IOV_IOCTLTIMEOUT): {
 487                 if (int_val <= 0)
 488                         bcmerror = BCME_BADARG;
 489                 else
 490                         dhd_os_set_ioctl_resp_timeout((unsigned int)int_val);
 491                 break;
 492         }
 493
 494 #ifdef WLBTAMP
 495         case IOV_SVAL(IOV_HCI_CMD): {
 496                 amp_hci_cmd_t *cmd = (amp_hci_cmd_t *)arg;
 497
 498                 /* sanity check: command preamble present */
 499                 if (len < HCI_CMD_PREAMBLE_SIZE)
 500                         return BCME_BUFTOOSHORT;
 501
 502                 /* sanity check: command parameters are present */
 503                 if (len < (int)(HCI_CMD_PREAMBLE_SIZE + cmd->plen))
 504                         return BCME_BUFTOOSHORT;
 505
 506                 dhd_bta_docmd(dhd_pub, cmd, len);
 507                 break;
 508         }
 509
 510         case IOV_SVAL(IOV_HCI_ACL_DATA): {
 511                 amp_hci_ACL_data_t *ACL_data = (amp_hci_ACL_data_t *)arg;
 512
 513                 /* sanity check: HCI header present */
 514                 if (len < HCI_ACL_DATA_PREAMBLE_SIZE)
 515                         return BCME_BUFTOOSHORT;
 516
 517                 /* sanity check: ACL data is present */
 518                 if (len < (int)(HCI_ACL_DATA_PREAMBLE_SIZE + ACL_data->dlen))
 519                         return BCME_BUFTOOSHORT;
 520
 521                 dhd_bta_tx_hcidata(dhd_pub, ACL_data, len);
 522                 break;
 523         }
 524 #endif /* WLBTAMP */
 525
 526 #ifdef PROP_TXSTATUS
 527         case IOV_GVAL(IOV_PROPTXSTATUS_ENABLE):
 528                 int_val = dhd_pub->wlfc_enabled? 1 : 0;
 529                 bcopy(&int_val, arg, val_size);
 530                 break;
 531
 532         case IOV_SVAL(IOV_PROPTXSTATUS_ENABLE):
 533                 dhd_pub->wlfc_enabled = int_val? 1 : 0;
 534                 break;
 535
 536         case IOV_GVAL(IOV_PROPTXSTATUS_MODE): {
 537                 athost_wl_status_info_t *wlfc =
 538                         (athost_wl_status_info_t*)dhd_pub->wlfc_state;
 539                 int_val = dhd_pub->wlfc_state ? (int32)wlfc->proptxstatus_mode : 0;
 540                 bcopy(&int_val, arg, val_size);
 541                 break;
 542         }
 543
 544         case IOV_SVAL(IOV_PROPTXSTATUS_MODE):
 545                 if (dhd_pub->wlfc_state) {
 546                         athost_wl_status_info_t *wlfc =
 547                                 (athost_wl_status_info_t*)dhd_pub->wlfc_state;
 548                         wlfc->proptxstatus_mode = int_val & 0xff;
 549                 }
 550                 break;
 551 #ifdef QMONITOR
 552         case IOV_GVAL(IOV_QMON_TIME_THRES): {
 553                 int_val = dhd_qmon_thres(dhd_pub, FALSE, 0);
 554                 bcopy(&int_val, arg, val_size);
 555                 break;
 556         }
 557
 558         case IOV_SVAL(IOV_QMON_TIME_THRES): {
 559                 dhd_qmon_thres(dhd_pub, TRUE, int_val);
 560                 break;
 561         }
 562
 563         case IOV_GVAL(IOV_QMON_TIME_PERCENT): {
 564                 int_val = dhd_qmon_getpercent(dhd_pub);
 565                 bcopy(&int_val, arg, val_size);
 566                 break;
 567         }
 568 #endif /* QMONITOR */
 569 #endif /* PROP_TXSTATUS */
 570
 571         case IOV_GVAL(IOV_BUS_TYPE):
 572                 /* The dhd application queries the driver to check if its usb or sdio.  */
 573 #ifdef BCMDHDUSB
 574                 int_val = BUS_TYPE_USB;
 575 #endif
 576                 int_val = BUS_TYPE_SDIO;
 577                 bcopy(&int_val, arg, val_size);
 578                 break;
 579
 580
 581 #ifdef WLMEDIA_HTSF
 582         case IOV_GVAL(IOV_WLPKTDLYSTAT_SZ):
 583                 int_val = dhd_pub->htsfdlystat_sz;
 584                 bcopy(&int_val, arg, val_size);
 585                 break;
 586
 587         case IOV_SVAL(IOV_WLPKTDLYSTAT_SZ):
 588                 dhd_pub->htsfdlystat_sz = int_val & 0xff;
 589                 printf("Setting tsfdlystat_sz:%d\n", dhd_pub->htsfdlystat_sz);
 590                 break;
 591 #endif
 592         case IOV_SVAL(IOV_CHANGEMTU):
 593                 int_val &= 0xffff;
 594                 bcmerror = dhd_change_mtu(dhd_pub, int_val, 0);
 595                 break;
 596
 597         case IOV_GVAL(IOV_HOSTREORDER_FLOWS):
 598         {
 599                 uint i = 0;
 600                 uint8 *ptr = (uint8 *)arg;
 601                 uint8 count = 0;
 602
 603                 ptr++;
 604                 for (i = 0; i < WLHOST_REORDERDATA_MAXFLOWS; i++) {
 605                         if (dhd_pub->reorder_bufs[i] != NULL) {
 606                                 *ptr = dhd_pub->reorder_bufs[i]->flow_id;
 607                                 ptr++;
 608                                 count++;
 609                         }
 610                 }
 611                 ptr = (uint8 *)arg;
 612                 *ptr = count;
 613                 break;
 614         }
 615
 616         default:
 617                 bcmerror = BCME_UNSUPPORTED;
 618                 break;
 619         }
 620
 621 exit:
 622         DHD_TRACE(("%s: actionid %d, bcmerror %d\n", __FUNCTION__, actionid, bcmerror));
 623         return bcmerror;
 624 }
 625
 626 /* Store the status of a connection attempt for later retrieval by an iovar */
 627 void
 628 dhd_store_conn_status(uint32 event, uint32 status, uint32 reason)
 629 {
 630         /* Do not overwrite a WLC_E_PRUNE with a WLC_E_SET_SSID
 631          * because an encryption/rsn mismatch results in both events, and
 632          * the important information is in the WLC_E_PRUNE.
 633          */
 634         if (!(event == WLC_E_SET_SSID && status == WLC_E_STATUS_FAIL &&
 635               dhd_conn_event == WLC_E_PRUNE)) {
 636                 dhd_conn_event = event;
 637                 dhd_conn_status = status;
 638                 dhd_conn_reason = reason;
 639         }
 640 }
 641
 642 bool
 643 dhd_prec_enq(dhd_pub_t *dhdp, struct pktq *q, void *pkt, int prec)
 644 {
 645         void *p;
 646         int eprec = -1;         /* precedence to evict from */
 647         bool discard_oldest;
 648
 649         /* Fast case, precedence queue is not full and we are also not
 650          * exceeding total queue length
 651          */
 652         if (!pktq_pfull(q, prec) && !pktq_full(q)) {
 653                 pktq_penq(q, prec, pkt);
 654                 return TRUE;
 655         }
 656
 657         /* Determine precedence from which to evict packet, if any */
 658         if (pktq_pfull(q, prec))
 659                 eprec = prec;
 660         else if (pktq_full(q)) {
 661                 p = pktq_peek_tail(q, &eprec);
 662                 ASSERT(p);
 663                 if (eprec > prec || eprec < 0)
 664                         return FALSE;
 665         }
 666
 667         /* Evict if needed */
 668         if (eprec >= 0) {
 669                 /* Detect queueing to unconfigured precedence */
 670                 ASSERT(!pktq_pempty(q, eprec));
 671                 discard_oldest = AC_BITMAP_TST(dhdp->wme_dp, eprec);
 672                 if (eprec == prec && !discard_oldest)
 673                         return FALSE;           /* refuse newer (incoming) packet */
 674                 /* Evict packet according to discard policy */
 675                 p = discard_oldest ? pktq_pdeq(q, eprec) : pktq_pdeq_tail(q, eprec);
 676                 ASSERT(p);
 677
 678                 PKTFREE(dhdp->osh, p, TRUE);
 679         }
 680
 681         /* Enqueue */
 682         p = pktq_penq(q, prec, pkt);
 683         ASSERT(p);
 684
 685         return TRUE;
 686 }
 687
 688 /*
 689  * Functions to drop proper pkts from queue:
 690  *      If one pkt in queue is non-fragmented, drop first non-fragmented pkt only
 691  *      If all pkts in queue are all fragmented, find and drop one whole set fragmented pkts
 692  *      If can't find pkts matching upper 2 cases, drop first pkt anyway
 693  */
 694 bool
 695 dhd_prec_drop_pkts(osl_t *osh, struct pktq *pq, int prec)
 696 {
 697         struct pktq_prec *q = NULL;
 698         void *p, *prev = NULL, *next = NULL, *first = NULL, *last = NULL, *prev_first = NULL;
 699         pkt_frag_t frag_info;
 700
 701         ASSERT(osh && pq);
 702         ASSERT(prec >= 0 && prec < pq->num_prec);
 703
 704         q = &pq->q[prec];
 705         p = q->head;
 706
 707         if (p == NULL)
 708                 return FALSE;
 709
 710         while (p) {
 711                 frag_info = pkt_frag_info(osh, p);
 712                 if (frag_info == DHD_PKT_FRAG_NONE) {
 713                         break;
 714                 } else if (frag_info == DHD_PKT_FRAG_FIRST) {
 715                         if (first) {
 716                                 /* No last frag pkt, use prev as last */
 717                                 last = prev;
 718                         } else {
 719                                 first = p;
 720                                 prev_first = prev;
 721                         }
 722                 } else if (frag_info == DHD_PKT_FRAG_LAST) {
 723                         if (first) {
 724                                 last = p;
 725                                 break;
 726                         }
 727                 }
 728
 729                 prev = p;
 730                 p = PKTLINK(p);
 731         }
 732
 733         if ((p == NULL) || ((frag_info != DHD_PKT_FRAG_NONE) && !(first && last))) {
 734                 /* Not found matching pkts, use oldest */
 735                 prev = NULL;
 736                 p = q->head;
 737                 frag_info = 0;
 738         }
 739
 740         if (frag_info == DHD_PKT_FRAG_NONE) {
 741                 first = last = p;
 742                 prev_first = prev;
 743         }
 744
 745         p = first;
 746         while (p) {
 747                 next = PKTLINK(p);
 748                 q->len--;
 749                 pq->len--;
 750
 751                 PKTSETLINK(p, NULL);
 752
 753                 PKTFREE(osh, p, TRUE);
 754
 755                 if (p == last)
 756                         break;
 757
 758                 p = next;
 759         }
 760
 761         if (prev_first == NULL) {
 762                 if ((q->head = next) == NULL)
 763                         q->tail = NULL;
 764         } else {
 765                 PKTSETLINK(prev_first, next);
 766         }
 767
 768         return TRUE;
 769 }
 770
 771 static int
 772 dhd_iovar_op(dhd_pub_t *dhd_pub, const char *name,
 773         void *params, int plen, void *arg, int len, bool set)
 774 {
 775         int bcmerror = 0;
 776         int val_size;
 777         const bcm_iovar_t *vi = NULL;
 778         uint32 actionid;
 779
 780         DHD_TRACE(("%s: Enter\n", __FUNCTION__));
 781
 782         ASSERT(name);
 783         ASSERT(len >= 0);
 784
 785         /* Get MUST have return space */
 786         ASSERT(set || (arg && len));
 787
 788         /* Set does NOT take qualifiers */
 789         ASSERT(!set || (!params && !plen));
 790
 791         if ((vi = bcm_iovar_lookup(dhd_iovars, name)) == NULL) {
 792                 bcmerror = BCME_UNSUPPORTED;
 793                 goto exit;
 794         }
 795
 796         DHD_CTL(("%s: %s %s, len %d plen %d\n", __FUNCTION__,
 797                 name, (set ? "set" : "get"), len, plen));
 798
 799         /* set up 'params' pointer in case this is a set command so that
 800          * the convenience int and bool code can be common to set and get
 801          */
 802         if (params == NULL) {
 803                 params = arg;
 804                 plen = len;
 805         }
 806
 807         if (vi->type == IOVT_VOID)
 808                 val_size = 0;
 809         else if (vi->type == IOVT_BUFFER)
 810                 val_size = len;
 811         else
 812                 /* all other types are integer sized */
 813                 val_size = sizeof(int);
 814
 815         actionid = set ? IOV_SVAL(vi->varid) : IOV_GVAL(vi->varid);
 816
 817         bcmerror = dhd_doiovar(dhd_pub, vi, actionid, name, params, plen, arg, len, val_size);
 818
 819 exit:
 820         return bcmerror;
 821 }
 822
 823 int
 824 dhd_ioctl(dhd_pub_t * dhd_pub, dhd_ioctl_t *ioc, void * buf, uint buflen)
 825 {
 826         int bcmerror = 0;
 827
 828         DHD_TRACE(("%s: Enter\n", __FUNCTION__));
 829
 830         if (!buf) {
 831                 return BCME_BADARG;
 832         }
 833
 834         switch (ioc->cmd) {
 835         case DHD_GET_MAGIC:
 836                 if (buflen < sizeof(int))
 837                         bcmerror = BCME_BUFTOOSHORT;
 838                 else
 839                         *(int*)buf = DHD_IOCTL_MAGIC;
 840                 break;
 841
 842         case DHD_GET_VERSION:
 843                 if (buflen < sizeof(int))
 844                         bcmerror = BCME_BUFTOOSHORT;
 845                 else
 846                         *(int*)buf = DHD_IOCTL_VERSION;
 847                 break;
 848
 849         case DHD_GET_VAR:
 850         case DHD_SET_VAR: {
 851                 char *arg;
 852                 uint arglen;
 853
 854                 /* scan past the name to any arguments */
 855                 for (arg = buf, arglen = buflen; *arg && arglen; arg++, arglen--)
 856                         ;
 857
 858                 if (*arg) {
 859                         bcmerror = BCME_BUFTOOSHORT;
 860                         break;
 861                 }
 862
 863                 /* account for the NUL terminator */
 864                 arg++, arglen--;
 865
 866                 /* call with the appropriate arguments */
 867                 if (ioc->cmd == DHD_GET_VAR)
 868                         bcmerror = dhd_iovar_op(dhd_pub, buf, arg, arglen,
 869                         buf, buflen, IOV_GET);
 870                 else
 871                         bcmerror = dhd_iovar_op(dhd_pub, buf, NULL, 0, arg, arglen, IOV_SET);
 872                 if (bcmerror != BCME_UNSUPPORTED)
 873                         break;
 874
 875                 /* not in generic table, try protocol module */
 876                 if (ioc->cmd == DHD_GET_VAR)
 877                         bcmerror = dhd_prot_iovar_op(dhd_pub, buf, arg,
 878                                 arglen, buf, buflen, IOV_GET);
 879                 else
 880                         bcmerror = dhd_prot_iovar_op(dhd_pub, buf,
 881                                 NULL, 0, arg, arglen, IOV_SET);
 882                 if (bcmerror != BCME_UNSUPPORTED)
 883                         break;
 884
 885                 /* if still not found, try bus module */
 886                 if (ioc->cmd == DHD_GET_VAR) {
 887                         bcmerror = dhd_bus_iovar_op(dhd_pub, buf,
 888                                 arg, arglen, buf, buflen, IOV_GET);
 889                 } else {
 890                         bcmerror = dhd_bus_iovar_op(dhd_pub, buf,
 891                                 NULL, 0, arg, arglen, IOV_SET);
 892                 }
 893
 894                 break;
 895         }
 896
 897         default:
 898                 bcmerror = BCME_UNSUPPORTED;
 899         }
 900
 901         return bcmerror;
 902 }
 903
 904 #ifdef SHOW_EVENTS
 905 static void
 906 wl_show_host_event(wl_event_msg_t *event, void *event_data)
 907 {
 908         uint i, status, reason;
 909         bool group = FALSE, flush_txq = FALSE, link = FALSE;
 910         const char *auth_str;
 911         const char *event_name;
 912         uchar *buf;
 913         char err_msg[256], eabuf[ETHER_ADDR_STR_LEN];
 914         uint event_type, flags, auth_type, datalen;
 915
 916         event_type = ntoh32(event->event_type);
 917         flags = ntoh16(event->flags);
 918         status = ntoh32(event->status);
 919         reason = ntoh32(event->reason);
 920         BCM_REFERENCE(reason);
 921         auth_type = ntoh32(event->auth_type);
 922         datalen = ntoh32(event->datalen);
 923
 924         /* debug dump of event messages */
 925         snprintf(eabuf, sizeof(eabuf), "%02x:%02x:%02x:%02x:%02x:%02x",
 926                 (uchar)event->addr.octet[0]&0xff,
 927                 (uchar)event->addr.octet[1]&0xff,
 928                 (uchar)event->addr.octet[2]&0xff,
 929                 (uchar)event->addr.octet[3]&0xff,
 930                 (uchar)event->addr.octet[4]&0xff,
 931                 (uchar)event->addr.octet[5]&0xff);
 932
 933         event_name = "UNKNOWN";
 934         for (i = 0; i < (uint)bcmevent_names_size; i++)
 935                 if (bcmevent_names[i].event == event_type)
 936                         event_name = bcmevent_names[i].name;
 937
 938         if (flags & WLC_EVENT_MSG_LINK)
 939                 link = TRUE;
 940         if (flags & WLC_EVENT_MSG_GROUP)
 941                 group = TRUE;
 942         if (flags & WLC_EVENT_MSG_FLUSHTXQ)
 943                 flush_txq = TRUE;
 944
 945         switch (event_type) {
 946         case WLC_E_START:
 947         case WLC_E_DEAUTH:
 948         case WLC_E_DISASSOC:
 949                 DHD_EVENT(("MACEVENT: %s, MAC %s\n", event_name, eabuf));
 950                 break;
 951
 952         case WLC_E_ASSOC_IND:
 953         case WLC_E_REASSOC_IND:
 954
 955                 DHD_EVENT(("MACEVENT: %s, MAC %s\n", event_name, eabuf));
 956                 break;
 957
 958         case WLC_E_ASSOC:
 959         case WLC_E_REASSOC:
 960                 if (status == WLC_E_STATUS_SUCCESS) {
 961                         DHD_EVENT(("MACEVENT: %s, MAC %s, SUCCESS\n", event_name, eabuf));
 962                 } else if (status == WLC_E_STATUS_TIMEOUT) {
 963                         DHD_EVENT(("MACEVENT: %s, MAC %s, TIMEOUT\n", event_name, eabuf));
 964                 } else if (status == WLC_E_STATUS_FAIL) {
 965                         DHD_EVENT(("MACEVENT: %s, MAC %s, FAILURE, reason %d\n",
 966                                event_name, eabuf, (int)reason));
 967                 } else {
 968                         DHD_EVENT(("MACEVENT: %s, MAC %s, unexpected status %d\n",
 969                                event_name, eabuf, (int)status));
 970                 }
 971                 break;
 972
 973         case WLC_E_DEAUTH_IND:
 974         case WLC_E_DISASSOC_IND:
 975                 DHD_EVENT(("MACEVENT: %s, MAC %s, reason %d\n", event_name, eabuf, (int)reason));
 976                 break;
 977
 978         case WLC_E_AUTH:
 979         case WLC_E_AUTH_IND:
 980                 if (auth_type == DOT11_OPEN_SYSTEM)
 981                         auth_str = "Open System";
 982                 else if (auth_type == DOT11_SHARED_KEY)
 983                         auth_str = "Shared Key";
 984                 else {
 985                         snprintf(err_msg, sizeof(err_msg), "AUTH unknown: %d", (int)auth_type);
 986                         auth_str = err_msg;
 987                 }
 988                 if (event_type == WLC_E_AUTH_IND) {
 989                         DHD_EVENT(("MACEVENT: %s, MAC %s, %s\n", event_name, eabuf, auth_str));
 990                 } else if (status == WLC_E_STATUS_SUCCESS) {
 991                         DHD_EVENT(("MACEVENT: %s, MAC %s, %s, SUCCESS\n",
 992                                 event_name, eabuf, auth_str));
 993                 } else if (status == WLC_E_STATUS_TIMEOUT) {
 994                         DHD_EVENT(("MACEVENT: %s, MAC %s, %s, TIMEOUT\n",
 995                                 event_name, eabuf, auth_str));
 996                 } else if (status == WLC_E_STATUS_FAIL) {
 997                         DHD_EVENT(("MACEVENT: %s, MAC %s, %s, FAILURE, reason %d\n",
 998                                event_name, eabuf, auth_str, (int)reason));
 999                 }
1000                 BCM_REFERENCE(auth_str);
1001
1002                 break;
1003
1004         case WLC_E_JOIN:
1005         case WLC_E_ROAM:
1006         case WLC_E_SET_SSID:
1007                 if (status == WLC_E_STATUS_SUCCESS) {
1008                         DHD_EVENT(("MACEVENT: %s, MAC %s\n", event_name, eabuf));
1009                 } else if (status == WLC_E_STATUS_FAIL) {
1010                         DHD_EVENT(("MACEVENT: %s, failed\n", event_name));
1011                 } else if (status == WLC_E_STATUS_NO_NETWORKS) {
1012                         DHD_EVENT(("MACEVENT: %s, no networks found\n", event_name));
1013                 } else {
1014                         DHD_EVENT(("MACEVENT: %s, unexpected status %d\n",
1015                                 event_name, (int)status));
1016                 }
1017                 break;
1018
1019         case WLC_E_BEACON_RX:
1020                 if (status == WLC_E_STATUS_SUCCESS) {
1021                         DHD_EVENT(("MACEVENT: %s, SUCCESS\n", event_name));
1022                 } else if (status == WLC_E_STATUS_FAIL) {
1023                         DHD_EVENT(("MACEVENT: %s, FAIL\n", event_name));
1024                 } else {
1025                         DHD_EVENT(("MACEVENT: %s, status %d\n", event_name, status));
1026                 }
1027                 break;
1028
1029         case WLC_E_LINK:
1030                 DHD_EVENT(("MACEVENT: %s %s\n", event_name, link?"UP":"DOWN"));
1031                 BCM_REFERENCE(link);
1032                 break;
1033
1034         case WLC_E_MIC_ERROR:
1035                 DHD_EVENT(("MACEVENT: %s, MAC %s, Group %d, Flush %d\n",
1036                        event_name, eabuf, group, flush_txq));
1037                 BCM_REFERENCE(group);
1038                 BCM_REFERENCE(flush_txq);
1039                 break;
1040
1041         case WLC_E_ICV_ERROR:
1042         case WLC_E_UNICAST_DECODE_ERROR:
1043         case WLC_E_MULTICAST_DECODE_ERROR:
1044                 DHD_EVENT(("MACEVENT: %s, MAC %s\n",
1045                        event_name, eabuf));
1046                 break;
1047
1048         case WLC_E_TXFAIL:
1049                 DHD_EVENT(("MACEVENT: %s, RA %s\n", event_name, eabuf));
1050                 break;
1051
1052         case WLC_E_SCAN_COMPLETE:
1053         case WLC_E_ASSOC_REQ_IE:
1054         case WLC_E_ASSOC_RESP_IE:
1055         case WLC_E_PMKID_CACHE:
1056                 DHD_EVENT(("MACEVENT: %s\n", event_name));
1057                 break;
1058
1059         case WLC_E_PFN_NET_FOUND:
1060         case WLC_E_PFN_NET_LOST:
1061         case WLC_E_PFN_SCAN_COMPLETE:
1062         case WLC_E_PFN_SCAN_NONE:
1063         case WLC_E_PFN_SCAN_ALLGONE:
1064                 DHD_EVENT(("PNOEVENT: %s\n", event_name));
1065                 break;
1066
1067         case WLC_E_PSK_SUP:
1068         case WLC_E_PRUNE:
1069                 DHD_EVENT(("MACEVENT: %s, status %d, reason %d\n",
1070                            event_name, (int)status, (int)reason));
1071                 break;
1072
1073 #ifdef WIFI_ACT_FRAME
1074         case WLC_E_ACTION_FRAME:
1075                 DHD_TRACE(("MACEVENT: %s Bssid %s\n", event_name, eabuf));
1076                 break;
1077 #endif /* WIFI_ACT_FRAME */
1078
1079         case WLC_E_TRACE: {
1080                 static uint32 seqnum_prev = 0;
1081                 static uint32 logtrace_seqnum_prev = 0;
1082                 msgtrace_hdr_t hdr;
1083                 uint32 nblost;
1084                 char *s, *p;
1085
1086                 buf = (uchar *) event_data;
1087                 memcpy(&hdr, buf, MSGTRACE_HDRLEN);
1088
1089                 if (hdr.version != MSGTRACE_VERSION) {
1090                         printf("\nMACEVENT: %s [unsupported version --> "
1091                                "dhd version:%d dongle version:%d]\n",
1092                                event_name, MSGTRACE_VERSION, hdr.version);
1093                         /* Reset datalen to avoid display below */
1094                         datalen = 0;
1095                         break;
1096                 }
1097
1098                 if (hdr.trace_type == MSGTRACE_HDR_TYPE_MSG) {
1099                         /* There are 2 bytes available at the end of data */
1100                         buf[MSGTRACE_HDRLEN + ntoh16(hdr.len)] = '\0';
1101
1102                         if (ntoh32(hdr.discarded_bytes) || ntoh32(hdr.discarded_printf)) {
1103                                 printf("\nWLC_E_TRACE: [Discarded traces in dongle -->"
1104                                        "discarded_bytes %d discarded_printf %d]\n",
1105                                        ntoh32(hdr.discarded_bytes), ntoh32(hdr.discarded_printf));
1106                         }
1107
1108                         nblost = ntoh32(hdr.seqnum) - seqnum_prev - 1;
1109                         if (nblost > 0) {
1110                                 printf("\nWLC_E_TRACE: [Event lost (msg) --> seqnum %d nblost %d\n",
1111                                        ntoh32(hdr.seqnum), nblost);
1112                         }
1113                         seqnum_prev = ntoh32(hdr.seqnum);
1114
1115                         /* Display the trace buffer. Advance from \n to \n to avoid display big
1116                          * printf (issue with Linux printk )
1117                          */
1118                         p = (char *)&buf[MSGTRACE_HDRLEN];
1119                 while (*p != '\0' && (s = strstr(p, "\n")) != NULL) {
1120                                 *s = '\0';
1121                                 printf("%s\n", p);
1122                                 p = s+1;
1123                         }
1124                         if (*p) printf("%s", p);
1125
1126                         /* Reset datalen to avoid display below */
1127                         datalen = 0;
1128
1129                 } else if (hdr.trace_type == MSGTRACE_HDR_TYPE_LOG) {
1130                         /* Let the standard event printing work for now */
1131                         uint32 timestamp, w;
1132                         if (ntoh32(hdr.seqnum) == logtrace_seqnum_prev) {
1133                                 printf("\nWLC_E_TRACE: [Event duplicate (log) %d",
1134                                        logtrace_seqnum_prev);
1135                         } else {
1136                                 nblost = ntoh32(hdr.seqnum) - logtrace_seqnum_prev - 1;
1137                                 if (nblost > 0) {
1138                                         printf("\nWLC_E_TRACE: [Event lost (log)"
1139                                                " --> seqnum %d nblost %d\n",
1140                                                ntoh32(hdr.seqnum), nblost);
1141                                 }
1142                                 logtrace_seqnum_prev = ntoh32(hdr.seqnum);
1143
1144                                 p = (char *)&buf[MSGTRACE_HDRLEN];
1145                                 datalen -= MSGTRACE_HDRLEN;
1146                                 w = ntoh32((uint32) *p);
1147                                 p += 4;
1148                                 datalen -= 4;
1149                                 timestamp = ntoh32((uint32) *p);
1150                                 printf("Logtrace %x timestamp %x %x",
1151                                        logtrace_seqnum_prev, timestamp, w);
1152
1153                                 while (datalen > 4) {
1154                                         p += 4;
1155                                         datalen -= 4;
1156                                         /* Print each word.  DO NOT ntoh it.  */
1157                                         printf(" %8.8x", *((uint32 *) p));
1158                                 }
1159                                 printf("\n");
1160                         }
1161                         datalen = 0;
1162                 }
1163
1164                 break;
1165         }
1166
1167
1168         case WLC_E_RSSI:
1169                 DHD_EVENT(("MACEVENT: %s %d\n", event_name, ntoh32(*((int *)event_data))));
1170                 break;
1171
1172         case WLC_E_SERVICE_FOUND:
1173         case WLC_E_P2PO_ADD_DEVICE:
1174         case WLC_E_P2PO_DEL_DEVICE:
1175                 DHD_EVENT(("MACEVENT: %s, MAC %s\n", event_name, eabuf));
1176                 break;
1177
1178         default:
1179                 DHD_EVENT(("MACEVENT: %s %d, MAC %s, status %d, reason %d, auth %d\n",
1180                        event_name, event_type, eabuf, (int)status, (int)reason,
1181                        (int)auth_type));
1182                 break;
1183         }
1184
1185         /* show any appended data */
1186         if (DHD_BYTES_ON() && DHD_EVENT_ON() && datalen) {
1187                 buf = (uchar *) event_data;
1188                 DHD_EVENT((" data (%d) : ", datalen));
1189                 for (i = 0; i < datalen; i++)
1190                         DHD_EVENT((" 0x%02x ", *buf++));
1191                 DHD_EVENT(("\n"));
1192         }
1193 }
1194 #endif /* SHOW_EVENTS */
1195
1196 int
1197 wl_host_event(dhd_pub_t *dhd_pub, int *ifidx, void *pktdata,
1198               wl_event_msg_t *event, void **data_ptr)
1199 {
1200         /* check whether packet is a BRCM event pkt */
1201         bcm_event_t *pvt_data = (bcm_event_t *)pktdata;
1202         uint8 *event_data;
1203         uint32 type, status, datalen;
1204         uint16 flags;
1205         int evlen;
1206
1207         if (bcmp(BRCM_OUI, &pvt_data->bcm_hdr.oui[0], DOT11_OUI_LEN)) {
1208                 DHD_ERROR(("%s: mismatched OUI, bailing\n", __FUNCTION__));
1209                 return (BCME_ERROR);
1210         }
1211
1212         /* BRCM event pkt may be unaligned - use xxx_ua to load user_subtype. */
1213         if (ntoh16_ua((void *)&pvt_data->bcm_hdr.usr_subtype) != BCMILCP_BCM_SUBTYPE_EVENT) {
1214                 DHD_ERROR(("%s: mismatched subtype, bailing\n", __FUNCTION__));
1215                 return (BCME_ERROR);
1216         }
1217
1218         *data_ptr = &pvt_data[1];
1219         event_data = *data_ptr;
1220
1221         /* memcpy since BRCM event pkt may be unaligned. */
1222         memcpy(event, &pvt_data->event, sizeof(wl_event_msg_t));
1223
1224         type = ntoh32_ua((void *)&event->event_type);
1225         flags = ntoh16_ua((void *)&event->flags);
1226         status = ntoh32_ua((void *)&event->status);
1227         datalen = ntoh32_ua((void *)&event->datalen);
1228         evlen = datalen + sizeof(bcm_event_t);
1229
1230         switch (type) {
1231 #ifdef PROP_TXSTATUS
1232         case WLC_E_FIFO_CREDIT_MAP:
1233                 dhd_os_wlfc_block(dhd_pub);
1234                 dhd_wlfc_event(dhd_pub->info);
1235                 dhd_wlfc_FIFOcreditmap_event(dhd_pub->info, event_data);
1236                 dhd_os_wlfc_unblock(dhd_pub);
1237                 WLFC_DBGMESG(("WLC_E_FIFO_CREDIT_MAP:(AC0,AC1,AC2,AC3),(BC_MC),(OTHER): "
1238                         "(%d,%d,%d,%d),(%d),(%d)\n", event_data[0], event_data[1],
1239                         event_data[2],
1240                         event_data[3], event_data[4], event_data[5]));
1241                 break;
1242 #endif
1243
1244         case WLC_E_IF:
1245                 {
1246                 dhd_if_event_t *ifevent = (dhd_if_event_t *)event_data;
1247
1248                 /* Ignore the event if NOIF is set */
1249                 if (ifevent->flags & WLC_E_IF_FLAGS_BSSCFG_NOIF) {
1250                         WLFC_DBGMESG(("WLC_E_IF: NO_IF set, event Ignored\r\n"));
1251                         return (BCME_OK);
1252                 }
1253
1254 #ifdef PROP_TXSTATUS
1255                         {
1256                 uint8* ea = pvt_data->eth.ether_dhost;
1257                 WLFC_DBGMESG(("WLC_E_IF: idx:%d, action:%s, iftype:%s, "
1258                               "[%02x:%02x:%02x:%02x:%02x:%02x]\n",
1259                               ifevent->ifidx,
1260                               ((ifevent->action == WLC_E_IF_ADD) ? "ADD":"DEL"),
1261                               ((ifevent->is_AP == 0) ? "STA":"AP "),
1262                               ea[0], ea[1], ea[2], ea[3], ea[4], ea[5]));
1263                 (void)ea;
1264
1265                 dhd_os_wlfc_block(dhd_pub);
1266                 if (ifevent->action == WLC_E_IF_CHANGE)
1267                         dhd_wlfc_interface_event(dhd_pub->info,
1268                                 eWLFC_MAC_ENTRY_ACTION_UPDATE,
1269                                 ifevent->ifidx, ifevent->is_AP, ea);
1270                 else
1271                         dhd_wlfc_interface_event(dhd_pub->info,
1272                                 ((ifevent->action == WLC_E_IF_ADD) ?
1273                                 eWLFC_MAC_ENTRY_ACTION_ADD : eWLFC_MAC_ENTRY_ACTION_DEL),
1274                                 ifevent->ifidx, ifevent->is_AP, ea);
1275                 dhd_os_wlfc_unblock(dhd_pub);
1276
1277                 /* dhd already has created an interface by default, for 0 */
1278                 if (ifevent->ifidx == 0)
1279                         break;
1280                         }
1281 #endif /* PROP_TXSTATUS */
1282
1283 #ifdef WL_CFG80211
1284                         if (wl_cfg80211_is_progress_ifchange()) {
1285                                 DHD_ERROR(("%s:  ifidx %d for %s action %d\n",
1286                                         __FUNCTION__, ifevent->ifidx,
1287                                         event->ifname, ifevent->action));
1288                                 if (ifevent->action == WLC_E_IF_ADD ||
1289                                         ifevent->action == WLC_E_IF_CHANGE)
1290                                         wl_cfg80211_notify_ifchange();
1291                                 return (BCME_OK);
1292                         }
1293 #endif /* WL_CFG80211 */
1294                 if (ifevent->ifidx > 0 && ifevent->ifidx < DHD_MAX_IFS) {
1295                                         if (ifevent->action == WLC_E_IF_ADD) {
1296                                                 if (dhd_add_if(dhd_pub->info, ifevent->ifidx,
1297                                                         NULL, event->ifname,
1298                                                         event->addr.octet,
1299                                                         ifevent->flags, ifevent->bssidx)) {
1300                                                         DHD_ERROR(("%s: dhd_add_if failed!!"
1301                                                                         " ifidx: %d for %s\n",
1302                                                                         __FUNCTION__,
1303                                                                         ifevent->ifidx,
1304                                                                         event->ifname));
1305                                                         return (BCME_ERROR);
1306                                                 }
1307                                         }
1308                                         else if (ifevent->action == WLC_E_IF_DEL)
1309                                                 dhd_del_if(dhd_pub->info, ifevent->ifidx);
1310                 } else {
1311 #ifndef PROP_TXSTATUS
1312                         DHD_ERROR(("%s: Invalid ifidx %d for %s\n",
1313                                    __FUNCTION__, ifevent->ifidx, event->ifname));
1314 #endif /* !PROP_TXSTATUS */
1315                 }
1316                         }
1317                         /* send up the if event: btamp user needs it */
1318                         *ifidx = dhd_ifname2idx(dhd_pub->info, event->ifname);
1319                         /* push up to external supp/auth */
1320                         dhd_event(dhd_pub->info, (char *)pvt_data, evlen, *ifidx);
1321                 break;
1322
1323
1324 #ifdef WLMEDIA_HTSF
1325         case WLC_E_HTSFSYNC:
1326                 htsf_update(dhd_pub->info, event_data);
1327                 break;
1328 #endif /* WLMEDIA_HTSF */
1329         case WLC_E_NDIS_LINK: {
1330                 uint32 temp = hton32(WLC_E_LINK);
1331
1332                 memcpy((void *)(&pvt_data->event.event_type), &temp,
1333                        sizeof(pvt_data->event.event_type));
1334         }
1335         case WLC_E_PFN_NET_FOUND:
1336         case WLC_E_PFN_NET_LOST:
1337                 break;
1338         case WLC_E_PFN_BSSID_NET_FOUND:
1339         case WLC_E_PFN_BSSID_NET_LOST:
1340         case WLC_E_PFN_BEST_BATCHING:
1341 #ifdef PNO_SUPPORT
1342                 dhd_pno_event_handler(dhd_pub, event, (void *)event_data);
1343 #endif
1344                 break;
1345                 /* These are what external supplicant/authenticator wants */
1346                 /* fall through */
1347         case WLC_E_LINK:
1348         case WLC_E_DEAUTH:
1349         case WLC_E_DEAUTH_IND:
1350         case WLC_E_DISASSOC:
1351         case WLC_E_DISASSOC_IND:
1352                 DHD_EVENT(("%s: Link event %d, flags %x, status %x\n",
1353                            __FUNCTION__, type, flags, status));
1354                 /* fall through */
1355         default:
1356                 *ifidx = dhd_ifname2idx(dhd_pub->info, event->ifname);
1357                 /* push up to external supp/auth */
1358                 dhd_event(dhd_pub->info, (char *)pvt_data, evlen, *ifidx);
1359                 DHD_TRACE(("%s: MAC event %d, flags %x, status %x\n",
1360                            __FUNCTION__, type, flags, status));
1361                 BCM_REFERENCE(flags);
1362                 BCM_REFERENCE(status);
1363
1364                 /* put it back to WLC_E_NDIS_LINK */
1365                 if (type == WLC_E_NDIS_LINK) {
1366                         uint32 temp;
1367
1368                         temp = ntoh32_ua((void *)&event->event_type);
1369                         DHD_TRACE(("Converted to WLC_E_LINK type %d\n", temp));
1370
1371                         temp = ntoh32(WLC_E_NDIS_LINK);
1372                         memcpy((void *)(&pvt_data->event.event_type), &temp,
1373                                sizeof(pvt_data->event.event_type));
1374                 }
1375                 break;
1376         }
1377
1378 #ifdef SHOW_EVENTS
1379         wl_show_host_event(event, (void *)event_data);
1380 #endif /* SHOW_EVENTS */
1381
1382         return (BCME_OK);
1383 }
1384
1385 void
1386 wl_event_to_host_order(wl_event_msg_t * evt)
1387 {
1388         /* Event struct members passed from dongle to host are stored in network
1389          * byte order. Convert all members to host-order.
1390          */
1391         evt->event_type = ntoh32(evt->event_type);
1392         evt->flags = ntoh16(evt->flags);
1393         evt->status = ntoh32(evt->status);
1394         evt->reason = ntoh32(evt->reason);
1395         evt->auth_type = ntoh32(evt->auth_type);
1396         evt->datalen = ntoh32(evt->datalen);
1397         evt->version = ntoh16(evt->version);
1398 }
1399
1400 void
1401 dhd_print_buf(void *pbuf, int len, int bytes_per_line)
1402 {
1403 #ifdef DHD_DEBUG
1404         int i, j = 0;
1405         unsigned char *buf = pbuf;
1406
1407         if (bytes_per_line == 0) {
1408                 bytes_per_line = len;
1409         }
1410
1411         for (i = 0; i < len; i++) {
1412                 printf("%2.2x", *buf++);
1413                 j++;
1414                 if (j == bytes_per_line) {
1415                         printf("\n");
1416                         j = 0;
1417                 } else {
1418                         printf(":");
1419                 }
1420         }
1421         printf("\n");
1422 #endif /* DHD_DEBUG */
1423 }
1424
1425 #ifndef strtoul
1426 #define strtoul(nptr, endptr, base) bcm_strtoul((nptr), (endptr), (base))
1427 #endif
1428
1429 #ifdef PKT_FILTER_SUPPORT
1430 /* Convert user's input in hex pattern to byte-size mask */
1431 static int
1432 wl_pattern_atoh(char *src, char *dst)
1433 {
1434         int i;
1435         if (strncmp(src, "0x", 2) != 0 &&
1436             strncmp(src, "0X", 2) != 0) {
1437                 DHD_ERROR(("Mask invalid format. Needs to start with 0x\n"));
1438                 return -1;
1439         }
1440         src = src + 2; /* Skip past 0x */
1441         if (strlen(src) % 2 != 0) {
1442                 DHD_ERROR(("Mask invalid format. Needs to be of even length\n"));
1443                 return -1;
1444         }
1445         for (i = 0; *src != '\0'; i++) {
1446                 char num[3];
1447                 bcm_strncpy_s(num, sizeof(num), src, 2);
1448                 num[2] = '\0';
1449                 dst[i] = (uint8)strtoul(num, NULL, 16);
1450                 src += 2;
1451         }
1452         return i;
1453 }
1454
1455 void
1456 dhd_pktfilter_offload_enable(dhd_pub_t * dhd, char *arg, int enable, int master_mode)
1457 {
1458         char                            *argv[8];
1459         int                                     i = 0;
1460         const char                      *str;
1461         int                                     buf_len;
1462         int                                     str_len;
1463         char                            *arg_save = 0, *arg_org = 0;
1464         int                                     rc;
1465         char                            buf[128];
1466         wl_pkt_filter_enable_t  enable_parm;
1467         wl_pkt_filter_enable_t  * pkt_filterp;
1468
1469         if (!arg)
1470                 return;
1471
1472         if (!(arg_save = MALLOC(dhd->osh, strlen(arg) + 1))) {
1473                 DHD_ERROR(("%s: kmalloc failed\n", __FUNCTION__));
1474                 goto fail;
1475         }
1476         arg_org = arg_save;
1477         memcpy(arg_save, arg, strlen(arg) + 1);
1478
1479         argv[i] = bcmstrtok(&arg_save, " ", 0);
1480
1481         i = 0;
1482         if (argv[i] == NULL) {
1483                 DHD_ERROR(("No args provided\n"));
1484                 goto fail;
1485         }
1486
1487         str = "pkt_filter_enable";
1488         str_len = strlen(str);
1489         bcm_strncpy_s(buf, sizeof(buf), str, str_len);
1490         buf[str_len] = '\0';
1491         buf_len = str_len + 1;
1492
1493         pkt_filterp = (wl_pkt_filter_enable_t *)(buf + str_len + 1);
1494
1495         /* Parse packet filter id. */
1496         enable_parm.id = htod32(strtoul(argv[i], NULL, 0));
1497
1498         /* Parse enable/disable value. */
1499         enable_parm.enable = htod32(enable);
1500
1501         buf_len += sizeof(enable_parm);
1502         memcpy((char *)pkt_filterp,
1503                &enable_parm,
1504                sizeof(enable_parm));
1505
1506         /* Enable/disable the specified filter. */
1507         rc = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, buf, buf_len, TRUE, 0);
1508         rc = rc >= 0 ? 0 : rc;
1509         if (rc)
1510                 DHD_TRACE(("%s: failed to add pktfilter %s, retcode = %d\n",
1511                 __FUNCTION__, arg, rc));
1512         else
1513                 DHD_TRACE(("%s: successfully added pktfilter %s\n",
1514                 __FUNCTION__, arg));
1515
1516         /* Contorl the master mode */
1517         bcm_mkiovar("pkt_filter_mode", (char *)&master_mode, 4, buf, sizeof(buf));
1518         rc = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, buf, sizeof(buf), TRUE, 0);
1519         rc = rc >= 0 ? 0 : rc;
1520         if (rc)
1521                 DHD_TRACE(("%s: failed to add pktfilter %s, retcode = %d\n",
1522                 __FUNCTION__, arg, rc));
1523
1524 fail:
1525         if (arg_org)
1526                 MFREE(dhd->osh, arg_org, strlen(arg) + 1);
1527 }
1528
1529 void
1530 dhd_pktfilter_offload_set(dhd_pub_t * dhd, char *arg)
1531 {
1532         const char                      *str;
1533         wl_pkt_filter_t         pkt_filter;
1534         wl_pkt_filter_t         *pkt_filterp;
1535         int                                     buf_len;
1536         int                                     str_len;
1537         int                             rc;
1538         uint32                          mask_size;
1539         uint32                          pattern_size;
1540         char                            *argv[8], * buf = 0;
1541         int                                     i = 0;
1542         char                            *arg_save = 0, *arg_org = 0;
1543 #define BUF_SIZE                2048
1544
1545         if (!arg)
1546                 return;
1547
1548         if (!(arg_save = MALLOC(dhd->osh, strlen(arg) + 1))) {
1549                 DHD_ERROR(("%s: kmalloc failed\n", __FUNCTION__));
1550                 goto fail;
1551         }
1552
1553         arg_org = arg_save;
1554
1555         if (!(buf = MALLOC(dhd->osh, BUF_SIZE))) {
1556                 DHD_ERROR(("%s: kmalloc failed\n", __FUNCTION__));
1557                 goto fail;
1558         }
1559
1560         memcpy(arg_save, arg, strlen(arg) + 1);
1561
1562         if (strlen(arg) > BUF_SIZE) {
1563                 DHD_ERROR(("Not enough buffer %d < %d\n", (int)strlen(arg), (int)sizeof(buf)));
1564                 goto fail;
1565         }
1566
1567         argv[i] = bcmstrtok(&arg_save, " ", 0);
1568         while (argv[i++])
1569                 argv[i] = bcmstrtok(&arg_save, " ", 0);
1570
1571         i = 0;
1572         if (argv[i] == NULL) {
1573                 DHD_ERROR(("No args provided\n"));
1574                 goto fail;
1575         }
1576
1577         str = "pkt_filter_add";
1578         str_len = strlen(str);
1579         bcm_strncpy_s(buf, BUF_SIZE, str, str_len);
1580         buf[ str_len ] = '\0';
1581         buf_len = str_len + 1;
1582
1583         pkt_filterp = (wl_pkt_filter_t *) (buf + str_len + 1);
1584
1585         /* Parse packet filter id. */
1586         pkt_filter.id = htod32(strtoul(argv[i], NULL, 0));
1587
1588         if (argv[++i] == NULL) {
1589                 DHD_ERROR(("Polarity not provided\n"));
1590                 goto fail;
1591         }
1592
1593         /* Parse filter polarity. */
1594         pkt_filter.negate_match = htod32(strtoul(argv[i], NULL, 0));
1595
1596         if (argv[++i] == NULL) {
1597                 DHD_ERROR(("Filter type not provided\n"));
1598                 goto fail;
1599         }
1600
1601         /* Parse filter type. */
1602         pkt_filter.type = htod32(strtoul(argv[i], NULL, 0));
1603
1604         if (argv[++i] == NULL) {
1605                 DHD_ERROR(("Offset not provided\n"));
1606                 goto fail;
1607         }
1608
1609         /* Parse pattern filter offset. */
1610         pkt_filter.u.pattern.offset = htod32(strtoul(argv[i], NULL, 0));
1611
1612         if (argv[++i] == NULL) {
1613                 DHD_ERROR(("Bitmask not provided\n"));
1614                 goto fail;
1615         }
1616
1617         /* Parse pattern filter mask. */
1618         mask_size =
1619                 htod32(wl_pattern_atoh(argv[i], (char *) pkt_filterp->u.pattern.mask_and_pattern));
1620
1621         if (argv[++i] == NULL) {
1622                 DHD_ERROR(("Pattern not provided\n"));
1623                 goto fail;
1624         }
1625
1626         /* Parse pattern filter pattern. */
1627         pattern_size =
1628                 htod32(wl_pattern_atoh(argv[i],
1629                  (char *) &pkt_filterp->u.pattern.mask_and_pattern[mask_size]));
1630
1631         if (mask_size != pattern_size) {
1632                 DHD_ERROR(("Mask and pattern not the same size\n"));
1633                 goto fail;
1634         }
1635
1636         pkt_filter.u.pattern.size_bytes = mask_size;
1637         buf_len += WL_PKT_FILTER_FIXED_LEN;
1638         buf_len += (WL_PKT_FILTER_PATTERN_FIXED_LEN + 2 * mask_size);
1639
1640         /* Keep-alive attributes are set in local       variable (keep_alive_pkt), and
1641         ** then memcpy'ed into buffer (keep_alive_pktp) since there is no
1642         ** guarantee that the buffer is properly aligned.
1643         */
1644         memcpy((char *)pkt_filterp,
1645                &pkt_filter,
1646                WL_PKT_FILTER_FIXED_LEN + WL_PKT_FILTER_PATTERN_FIXED_LEN);
1647
1648         rc = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, buf, buf_len, TRUE, 0);
1649         rc = rc >= 0 ? 0 : rc;
1650
1651         if (rc)
1652                 DHD_TRACE(("%s: failed to add pktfilter %s, retcode = %d\n",
1653                 __FUNCTION__, arg, rc));
1654         else
1655                 DHD_TRACE(("%s: successfully added pktfilter %s\n",
1656                 __FUNCTION__, arg));
1657
1658 fail:
1659         if (arg_org)
1660                 MFREE(dhd->osh, arg_org, strlen(arg) + 1);
1661
1662         if (buf)
1663                 MFREE(dhd->osh, buf, BUF_SIZE);
1664 }
1665
1666 void dhd_pktfilter_offload_delete(dhd_pub_t *dhd, int id)
1667 {
1668         char iovbuf[32];
1669         int ret;
1670
1671         bcm_mkiovar("pkt_filter_delete", (char *)&id, 4, iovbuf, sizeof(iovbuf));
1672         ret = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0);
1673         if (ret < 0) {
1674                 DHD_ERROR(("%s: Failed to delete filter ID:%d, ret=%d\n",
1675                         __FUNCTION__, id, ret));
1676         }
1677 }
1678 #endif /* PKT_FILTER_SUPPORT */
1679
1680 /* ========================== */
1681 /* ==== ARP OFFLOAD SUPPORT = */
1682 /* ========================== */
1683 #ifdef ARP_OFFLOAD_SUPPORT
1684 void
1685 dhd_arp_offload_set(dhd_pub_t * dhd, int arp_mode)
1686 {
1687         char iovbuf[32];
1688         int retcode;
1689
1690         bcm_mkiovar("arp_ol", (char *)&arp_mode, 4, iovbuf, sizeof(iovbuf));
1691         retcode = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0);
1692         retcode = retcode >= 0 ? 0 : retcode;
1693         if (retcode)
1694                 DHD_TRACE(("%s: failed to set ARP offload mode to 0x%x, retcode = %d\n",
1695                         __FUNCTION__, arp_mode, retcode));
1696         else
1697                 DHD_TRACE(("%s: successfully set ARP offload mode to 0x%x\n",
1698                         __FUNCTION__, arp_mode));
1699 }
1700
1701 void
1702 dhd_arp_offload_enable(dhd_pub_t * dhd, int arp_enable)
1703 {
1704         char iovbuf[32];
1705         int retcode;
1706
1707         bcm_mkiovar("arpoe", (char *)&arp_enable, 4, iovbuf, sizeof(iovbuf));
1708         retcode = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0);
1709         retcode = retcode >= 0 ? 0 : retcode;
1710         if (retcode)
1711                 DHD_TRACE(("%s: failed to enabe ARP offload to %d, retcode = %d\n",
1712                         __FUNCTION__, arp_enable, retcode));
1713         else
1714                 DHD_TRACE(("%s: successfully enabed ARP offload to %d\n",
1715                         __FUNCTION__, arp_enable));
1716         if (arp_enable) {
1717                 uint32 version;
1718                 bcm_mkiovar("arp_version", 0, 0, iovbuf, sizeof(iovbuf));
1719                 retcode = dhd_wl_ioctl_cmd(dhd, WLC_GET_VAR, iovbuf, sizeof(iovbuf), FALSE, 0);
1720                 if (retcode) {
1721                         DHD_INFO(("%s: fail to get version (maybe version 1:retcode = %d\n",
1722                                 __FUNCTION__, retcode));
1723                         dhd->arp_version = 1;
1724                 }
1725                 else {
1726                         memcpy(&version, iovbuf, sizeof(version));
1727                         DHD_INFO(("%s: ARP Version= %x\n", __FUNCTION__, version));
1728                         dhd->arp_version = version;
1729                 }
1730         }
1731 }
1732
1733 void
1734 dhd_aoe_arp_clr(dhd_pub_t *dhd, int idx)
1735 {
1736         int ret = 0;
1737         int iov_len = 0;
1738         char iovbuf[DHD_IOVAR_BUF_SIZE];
1739
1740         if (dhd == NULL) return;
1741         if (dhd->arp_version == 1)
1742                 idx = 0;
1743
1744         iov_len = bcm_mkiovar("arp_table_clear", 0, 0, iovbuf, sizeof(iovbuf));
1745         if ((ret  = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, iov_len, TRUE, idx)) < 0)
1746                 DHD_ERROR(("%s failed code %d\n", __FUNCTION__, ret));
1747 }
1748
1749 void
1750 dhd_aoe_hostip_clr(dhd_pub_t *dhd, int idx)
1751 {
1752         int ret = 0;
1753         int iov_len = 0;
1754         char iovbuf[DHD_IOVAR_BUF_SIZE];
1755
1756         if (dhd == NULL) return;
1757         if (dhd->arp_version == 1)
1758                 idx = 0;
1759
1760         iov_len = bcm_mkiovar("arp_hostip_clear", 0, 0, iovbuf, sizeof(iovbuf));
1761         if ((ret  = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, iov_len, TRUE, idx)) < 0)
1762                 DHD_ERROR(("%s failed code %d\n", __FUNCTION__, ret));
1763 }
1764
1765 void
1766 dhd_arp_offload_add_ip(dhd_pub_t *dhd, uint32 ipaddr, int idx)
1767 {
1768         int iov_len = 0;
1769         char iovbuf[DHD_IOVAR_BUF_SIZE];
1770         int retcode;
1771
1772
1773         if (dhd == NULL) return;
1774         if (dhd->arp_version == 1)
1775                 idx = 0;
1776         iov_len = bcm_mkiovar("arp_hostip", (char *)&ipaddr,
1777                 sizeof(ipaddr), iovbuf, sizeof(iovbuf));
1778         retcode = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, iov_len, TRUE, idx);
1779
1780         if (retcode)
1781                 DHD_TRACE(("%s: ARP ip addr add failed, retcode = %d\n",
1782                 __FUNCTION__, retcode));
1783         else
1784                 DHD_TRACE(("%s: sARP H ipaddr entry added \n",
1785                 __FUNCTION__));
1786 }
1787
1788 int
1789 dhd_arp_get_arp_hostip_table(dhd_pub_t *dhd, void *buf, int buflen, int idx)
1790 {
1791         int retcode, i;
1792         int iov_len;
1793         uint32 *ptr32 = buf;
1794         bool clr_bottom = FALSE;
1795
1796         if (!buf)
1797                 return -1;
1798         if (dhd == NULL) return -1;
1799         if (dhd->arp_version == 1)
1800                 idx = 0;
1801
1802         iov_len = bcm_mkiovar("arp_hostip", 0, 0, buf, buflen);
1803         BCM_REFERENCE(iov_len);
1804         retcode = dhd_wl_ioctl_cmd(dhd, WLC_GET_VAR, buf, buflen, FALSE, idx);
1805
1806         if (retcode) {
1807                 DHD_TRACE(("%s: ioctl WLC_GET_VAR error %d\n",
1808                 __FUNCTION__, retcode));
1809
1810                 return -1;
1811         }
1812
1813         /* clean up the buf, ascii reminder */
1814         for (i = 0; i < MAX_IPV4_ENTRIES; i++) {
1815                 if (!clr_bottom) {
1816                         if (*ptr32 == 0)
1817                                 clr_bottom = TRUE;
1818                 } else {
1819                         *ptr32 = 0;
1820                 }
1821                 ptr32++;
1822         }
1823
1824         return 0;
1825 }
1826 #endif /* ARP_OFFLOAD_SUPPORT  */
1827 /*
1828  * Neighbor Discovery Offload: enable NDO feature
1829  * Called  by ipv6 event handler when interface comes up/goes down
1830  */
1831 int
1832 dhd_ndo_enable(dhd_pub_t * dhd, int ndo_enable)
1833 {
1834         char iovbuf[DHD_IOVAR_BUF_SIZE];
1835         int retcode;
1836
1837         if (dhd == NULL)
1838                 return -1;
1839
1840         bcm_mkiovar("ndoe", (char *)&ndo_enable, 4, iovbuf, sizeof(iovbuf));
1841         retcode = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0);
1842         if (retcode)
1843                 DHD_ERROR(("%s: failed to enabe ndo to %d, retcode = %d\n",
1844                         __FUNCTION__, ndo_enable, retcode));
1845         else
1846                 DHD_TRACE(("%s: successfully enabed ndo offload to %d\n",
1847                         __FUNCTION__, ndo_enable));
1848
1849         return retcode;
1850 }
1851
1852 /*
1853  * Neighbor Discover Offload: add host ipv6 ip into firmware
1854  * Called  by ipv6 event handler when interface comes up
1855  */
1856 int
1857 dhd_ndo_add_ip(dhd_pub_t *dhd, char* ipv6addr, int idx)
1858 {
1859         int iov_len = 0;
1860         char iovbuf[DHD_IOVAR_BUF_SIZE];
1861         int retcode;
1862
1863         if (dhd == NULL || ipv6addr == NULL)
1864                 return -1;
1865
1866         iov_len = bcm_mkiovar("nd_hostip", ipv6addr,
1867                 IPV6_ADDR_LEN, iovbuf, sizeof(iovbuf));
1868         retcode = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, iov_len, TRUE, idx);
1869
1870         if (retcode)
1871                 DHD_ERROR(("%s: ndo ip addr add failed, retcode = %d\n",
1872                 __FUNCTION__, retcode));
1873         else
1874                 DHD_ERROR(("%s: ndo ipaddr entry added \n",
1875                 __FUNCTION__));
1876         return retcode;
1877 }
1878 /*
1879  * Neighbor Discover Offload: disable NDO feature
1880  * Called  by ipv6 event handler when interface goes down
1881  */
1882 int
1883 dhd_ndo_remove_ip(dhd_pub_t *dhd, int idx)
1884 {
1885         int iov_len = 0;
1886         char iovbuf[DHD_IOVAR_BUF_SIZE];
1887         int retcode;
1888
1889         if (dhd == NULL)
1890                 return -1;
1891
1892         iov_len = bcm_mkiovar("nd_hostip_clear", (char *)NULL,
1893                 0, iovbuf, sizeof(iovbuf));
1894         retcode = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, iov_len, TRUE, idx);
1895
1896         if (retcode)
1897                 DHD_ERROR(("%s: ndo ip addr remove failed, retcode = %d\n",
1898                 __FUNCTION__, retcode));
1899         else
1900                 DHD_TRACE(("%s: ndo ipaddr entry removed \n",
1901                 __FUNCTION__));
1902
1903         return retcode;
1904 }
1905
1906 /* send up locally generated event */
1907 void
1908 dhd_sendup_event_common(dhd_pub_t *dhdp, wl_event_msg_t *event, void *data)
1909 {
1910         switch (ntoh32(event->event_type)) {
1911 #ifdef WLBTAMP
1912         case WLC_E_BTA_HCI_EVENT:
1913                 break;
1914 #endif /* WLBTAMP */
1915         default:
1916                 break;
1917         }
1918
1919         /* Call per-port handler. */
1920         dhd_sendup_event(dhdp, event, data);
1921 }
1922
1923
1924 /*
1925  * returns = TRUE if associated, FALSE if not associated
1926  */
1927 bool dhd_is_associated(dhd_pub_t *dhd, void *bss_buf, int *retval)
1928 {
1929         char bssid[6], zbuf[6];
1930         int ret = -1;
1931
1932         bzero(bssid, 6);
1933         bzero(zbuf, 6);
1934
1935         ret  = dhd_wl_ioctl_cmd(dhd, WLC_GET_BSSID, (char *)&bssid, ETHER_ADDR_LEN, FALSE, 0);
1936         DHD_TRACE((" %s WLC_GET_BSSID ioctl res = %d\n", __FUNCTION__, ret));
1937
1938         if (ret == BCME_NOTASSOCIATED) {
1939                 DHD_TRACE(("%s: not associated! res:%d\n", __FUNCTION__, ret));
1940         }
1941
1942         if (retval)
1943                 *retval = ret;
1944
1945         if (ret < 0)
1946                 return FALSE;
1947
1948         if ((memcmp(bssid, zbuf, ETHER_ADDR_LEN) != 0)) {
1949                 /*  STA is assocoated BSSID is non zero */
1950
1951                 if (bss_buf) {
1952                         /* return bss if caller provided buf */
1953                         memcpy(bss_buf, bssid, ETHER_ADDR_LEN);
1954                 }
1955                 return TRUE;
1956         } else {
1957                 DHD_TRACE(("%s: WLC_GET_BSSID ioctl returned zero bssid\n", __FUNCTION__));
1958                 return FALSE;
1959         }
1960 }
1961
1962
1963 /* Function to estimate possible DTIM_SKIP value */
1964 int
1965 dhd_get_suspend_bcn_li_dtim(dhd_pub_t *dhd)
1966 {
1967         int bcn_li_dtim = 1; /* deafult no dtim skip setting */
1968         int ret = -1;
1969         int dtim_assoc = 0;
1970         int ap_beacon = 0;
1971
1972         /* Check if associated */
1973         if (dhd_is_associated(dhd, NULL, NULL) == FALSE) {
1974                 DHD_TRACE(("%s NOT assoc ret %d\n", __FUNCTION__, ret));
1975                 goto exit;
1976         }
1977
1978         /* read associated AP beacon interval */
1979         if ((ret = dhd_wl_ioctl_cmd(dhd, WLC_GET_BCNPRD,
1980                 &ap_beacon, sizeof(ap_beacon), FALSE, 0)) < 0) {
1981                 DHD_ERROR(("%s get beacon failed code %d\n", __FUNCTION__, ret));
1982                 goto exit;
1983         }
1984
1985         /* if associated APs Beacon more  that 100msec do no dtim skip */
1986         if (ap_beacon > MAX_DTIM_SKIP_BEACON_ITERVAL) {
1987                 DHD_ERROR(("%s NO dtim skip for AP with beacon %d ms\n", __FUNCTION__, ap_beacon));
1988                 goto exit;
1989         }
1990
1991         /* read associated ap's dtim setup */
1992         if ((ret = dhd_wl_ioctl_cmd(dhd, WLC_GET_DTIMPRD,
1993                 &dtim_assoc, sizeof(dtim_assoc), FALSE, 0)) < 0) {
1994                 DHD_ERROR(("%s failed code %d\n", __FUNCTION__, ret));
1995                 goto exit;
1996         }
1997
1998         /* if not assocated just eixt */
1999         if (dtim_assoc == 0) {
2000                 goto exit;
2001         }
2002
2003         /* attemp to use platform defined dtim skip interval */
2004         bcn_li_dtim = dhd->suspend_bcn_li_dtim;
2005
2006         /* check if sta listen interval fits into AP dtim */
2007         if (dtim_assoc > CUSTOM_LISTEN_INTERVAL) {
2008                 /* AP DTIM to big for our Listen Interval : no dtim skiping */
2009                 bcn_li_dtim = 1;
2010                 DHD_ERROR(("%s DTIM=%d > Listen=%d : too big ...\n",
2011                         __FUNCTION__, dtim_assoc, CUSTOM_LISTEN_INTERVAL));
2012                 goto exit;
2013         }
2014
2015         if ((bcn_li_dtim * dtim_assoc) > CUSTOM_LISTEN_INTERVAL) {
2016                 /* Round up dtim_skip to fit into STAs Listen Interval */
2017                 bcn_li_dtim = (int)(CUSTOM_LISTEN_INTERVAL / dtim_assoc);
2018                 DHD_TRACE(("%s agjust dtim_skip as %d\n", __FUNCTION__, bcn_li_dtim));
2019         }
2020
2021         DHD_ERROR(("%s beacon=%d bcn_li_dtim=%d DTIM=%d Listen=%d\n",
2022                 __FUNCTION__, ap_beacon, bcn_li_dtim, dtim_assoc, CUSTOM_LISTEN_INTERVAL));
2023
2024 exit:
2025         return bcn_li_dtim;
2026 }
2027
2028 /* Check if the mode supports STA MODE */
2029 bool dhd_support_sta_mode(dhd_pub_t *dhd)
2030 {
2031
2032 #ifdef  WL_CFG80211
2033         if (!(dhd->op_mode & DHD_FLAG_STA_MODE))
2034                 return FALSE;
2035         else
2036 #endif /* WL_CFG80211 */
2037                 return TRUE;
2038 }
2039
2040 #if defined(KEEP_ALIVE)
2041 int dhd_keep_alive_onoff(dhd_pub_t *dhd)
2042 {
2043         char                            buf[256];
2044         const char                      *str;
2045         wl_mkeep_alive_pkt_t    mkeep_alive_pkt = {0};
2046         wl_mkeep_alive_pkt_t    *mkeep_alive_pktp;
2047         int                                     buf_len;
2048         int                                     str_len;
2049         int res                                 = -1;
2050
2051         if (!dhd_support_sta_mode(dhd))
2052                 return res;
2053
2054         DHD_TRACE(("%s execution\n", __FUNCTION__));
2055
2056         str = "mkeep_alive";
2057         str_len = strlen(str);
2058         strncpy(buf, str, str_len);
2059         buf[ str_len ] = '\0';
2060         mkeep_alive_pktp = (wl_mkeep_alive_pkt_t *) (buf + str_len + 1);
2061         mkeep_alive_pkt.period_msec = dhd->conf->keep_alive_period;
2062         buf_len = str_len + 1;
2063         mkeep_alive_pkt.version = htod16(WL_MKEEP_ALIVE_VERSION);
2064         mkeep_alive_pkt.length = htod16(WL_MKEEP_ALIVE_FIXED_LEN);
2065         /* Setup keep alive zero for null packet generation */
2066         mkeep_alive_pkt.keep_alive_id = 0;
2067         mkeep_alive_pkt.len_bytes = 0;
2068         buf_len += WL_MKEEP_ALIVE_FIXED_LEN;
2069         bzero(mkeep_alive_pkt.data, sizeof(mkeep_alive_pkt.data));
2070         /* Keep-alive attributes are set in local       variable (mkeep_alive_pkt), and
2071          * then memcpy'ed into buffer (mkeep_alive_pktp) since there is no
2072          * guarantee that the buffer is properly aligned.
2073          */
2074         memcpy((char *)mkeep_alive_pktp, &mkeep_alive_pkt, WL_MKEEP_ALIVE_FIXED_LEN);
2075
2076         res = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, buf, buf_len, TRUE, 0);
2077
2078         return res;
2079 }
2080 #endif /* defined(KEEP_ALIVE) */
2081 /* Android ComboSCAN support */
2082
2083 /*
2084  *  data parsing from ComboScan tlv list
2085 */
2086 int
2087 wl_iw_parse_data_tlv(char** list_str, void *dst, int dst_size, const char token,
2088                      int input_size, int *bytes_left)
2089 {
2090         char* str;
2091         uint16 short_temp;
2092         uint32 int_temp;
2093
2094         if ((list_str == NULL) || (*list_str == NULL) ||(bytes_left == NULL) || (*bytes_left < 0)) {
2095                 DHD_ERROR(("%s error paramters\n", __FUNCTION__));
2096                 return -1;
2097         }
2098         str = *list_str;
2099
2100         /* Clean all dest bytes */
2101         memset(dst, 0, dst_size);
2102         while (*bytes_left > 0) {
2103
2104                 if (str[0] != token) {
2105                         DHD_TRACE(("%s NOT Type=%d get=%d left_parse=%d \n",
2106                                 __FUNCTION__, token, str[0], *bytes_left));
2107                         return -1;
2108                 }
2109
2110                 *bytes_left -= 1;
2111                 str += 1;
2112
2113                 if (input_size == 1) {
2114                         memcpy(dst, str, input_size);
2115                 }
2116                 else if (input_size == 2) {
2117                         memcpy(dst, (char *)htod16(memcpy(&short_temp, str, input_size)),
2118                                 input_size);
2119                 }
2120                 else if (input_size == 4) {
2121                         memcpy(dst, (char *)htod32(memcpy(&int_temp, str, input_size)),
2122                                 input_size);
2123                 }
2124
2125                 *bytes_left -= input_size;
2126                 str += input_size;
2127                 *list_str = str;
2128                 return 1;
2129         }
2130         return 1;
2131 }
2132
2133 /*
2134  *  channel list parsing from cscan tlv list
2135 */
2136 int
2137 wl_iw_parse_channel_list_tlv(char** list_str, uint16* channel_list,
2138                              int channel_num, int *bytes_left)
2139 {
2140         char* str;
2141         int idx = 0;
2142
2143         if ((list_str == NULL) || (*list_str == NULL) ||(bytes_left == NULL) || (*bytes_left < 0)) {
2144                 DHD_ERROR(("%s error paramters\n", __FUNCTION__));
2145                 return -1;
2146         }
2147         str = *list_str;
2148
2149         while (*bytes_left > 0) {
2150
2151                 if (str[0] != CSCAN_TLV_TYPE_CHANNEL_IE) {
2152                         *list_str = str;
2153                         DHD_TRACE(("End channel=%d left_parse=%d %d\n", idx, *bytes_left, str[0]));
2154                         return idx;
2155                 }
2156                 /* Get proper CSCAN_TLV_TYPE_CHANNEL_IE */
2157                 *bytes_left -= 1;
2158                 str += 1;
2159
2160                 if (str[0] == 0) {
2161                         /* All channels */
2162                         channel_list[idx] = 0x0;
2163                 }
2164                 else {
2165                         channel_list[idx] = (uint16)str[0];
2166                         DHD_TRACE(("%s channel=%d \n", __FUNCTION__,  channel_list[idx]));
2167                 }
2168                 *bytes_left -= 1;
2169                 str += 1;
2170
2171                 if (idx++ > 255) {
2172                         DHD_ERROR(("%s Too many channels \n", __FUNCTION__));
2173                         return -1;
2174                 }
2175         }
2176
2177         *list_str = str;
2178         return idx;
2179 }
2180
2181 /*
2182  *  SSIDs list parsing from cscan tlv list
2183  */
2184 int
2185 wl_iw_parse_ssid_list_tlv(char** list_str, wlc_ssid_t* ssid, int max, int *bytes_left)
2186 {
2187         char* str;
2188         int idx = 0;
2189
2190         if ((list_str == NULL) || (*list_str == NULL) || (*bytes_left < 0)) {
2191                 DHD_ERROR(("%s error paramters\n", __FUNCTION__));
2192                 return -1;
2193         }
2194         str = *list_str;
2195         while (*bytes_left > 0) {
2196
2197                 if (str[0] != CSCAN_TLV_TYPE_SSID_IE) {
2198                         *list_str = str;
2199                         DHD_TRACE(("nssid=%d left_parse=%d %d\n", idx, *bytes_left, str[0]));
2200                         return idx;
2201                 }
2202
2203                 /* Get proper CSCAN_TLV_TYPE_SSID_IE */
2204                 *bytes_left -= 1;
2205                 str += 1;
2206
2207                 if (str[0] == 0) {
2208                         /* Broadcast SSID */
2209                         ssid[idx].SSID_len = 0;
2210                         memset((char*)ssid[idx].SSID, 0x0, DOT11_MAX_SSID_LEN);
2211                         *bytes_left -= 1;
2212                         str += 1;
2213
2214                         DHD_TRACE(("BROADCAST SCAN  left=%d\n", *bytes_left));
2215                 }
2216                 else if (str[0] <= DOT11_MAX_SSID_LEN) {
2217                         /* Get proper SSID size */
2218                         ssid[idx].SSID_len = str[0];
2219                         *bytes_left -= 1;
2220                         str += 1;
2221
2222                         /* Get SSID */
2223                         if (ssid[idx].SSID_len > *bytes_left) {
2224                                 DHD_ERROR(("%s out of memory range len=%d but left=%d\n",
2225                                 __FUNCTION__, ssid[idx].SSID_len, *bytes_left));
2226                                 return -1;
2227                         }
2228
2229                         memcpy((char*)ssid[idx].SSID, str, ssid[idx].SSID_len);
2230
2231                         *bytes_left -= ssid[idx].SSID_len;
2232                         str += ssid[idx].SSID_len;
2233
2234                         DHD_TRACE(("%s :size=%d left=%d\n",
2235                                 (char*)ssid[idx].SSID, ssid[idx].SSID_len, *bytes_left));
2236                 }
2237                 else {
2238                         DHD_ERROR(("### SSID size more that %d\n", str[0]));
2239                         return -1;
2240                 }
2241
2242                 if (idx++ >  max) {
2243                         DHD_ERROR(("%s number of SSIDs more that %d\n", __FUNCTION__, idx));
2244                         return -1;
2245                 }
2246         }
2247
2248         *list_str = str;
2249         return idx;
2250 }
2251
2252 /* Parse a comma-separated list from list_str into ssid array, starting
2253  * at index idx.  Max specifies size of the ssid array.  Parses ssids
2254  * and returns updated idx; if idx >= max not all fit, the excess have
2255  * not been copied.  Returns -1 on empty string, or on ssid too long.
2256  */
2257 int
2258 wl_iw_parse_ssid_list(char** list_str, wlc_ssid_t* ssid, int idx, int max)
2259 {
2260         char* str, *ptr;
2261
2262         if ((list_str == NULL) || (*list_str == NULL))
2263                 return -1;
2264
2265         for (str = *list_str; str != NULL; str = ptr) {
2266
2267                 /* check for next TAG */
2268                 if (!strncmp(str, GET_CHANNEL, strlen(GET_CHANNEL))) {
2269                         *list_str        = str + strlen(GET_CHANNEL);
2270                         return idx;
2271                 }
2272
2273                 if ((ptr = strchr(str, ',')) != NULL) {
2274                         *ptr++ = '\0';
2275                 }
2276
2277                 if (strlen(str) > DOT11_MAX_SSID_LEN) {
2278                         DHD_ERROR(("ssid <%s> exceeds %d\n", str, DOT11_MAX_SSID_LEN));
2279                         return -1;
2280                 }
2281
2282                 if (strlen(str) == 0)
2283                         ssid[idx].SSID_len = 0;
2284
2285                 if (idx < max) {
2286                         bzero(ssid[idx].SSID, sizeof(ssid[idx].SSID));
2287                         strncpy((char*)ssid[idx].SSID, str, sizeof(ssid[idx].SSID) - 1);
2288                         ssid[idx].SSID_len = strlen(str);
2289                 }
2290                 idx++;
2291         }
2292         return idx;
2293 }
2294
2295 /*
2296  * Parse channel list from iwpriv CSCAN
2297  */
2298 int
2299 wl_iw_parse_channel_list(char** list_str, uint16* channel_list, int channel_num)
2300 {
2301         int num;
2302         int val;
2303         char* str;
2304         char* endptr = NULL;
2305
2306         if ((list_str == NULL)||(*list_str == NULL))
2307                 return -1;
2308
2309         str = *list_str;
2310         num = 0;
2311         while (strncmp(str, GET_NPROBE, strlen(GET_NPROBE))) {
2312                 val = (int)strtoul(str, &endptr, 0);
2313                 if (endptr == str) {
2314                         printf("could not parse channel number starting at"
2315                                 " substring \"%s\" in list:\n%s\n",
2316                                 str, *list_str);
2317                         return -1;
2318                 }
2319                 str = endptr + strspn(endptr, " ,");
2320
2321                 if (num == channel_num) {
2322                         DHD_ERROR(("too many channels (more than %d) in channel list:\n%s\n",
2323                                 channel_num, *list_str));
2324                         return -1;
2325                 }
2326
2327                 channel_list[num++] = (uint16)val;
2328         }
2329         *list_str = str;
2330         return num;
2331 }