drivers/staging/brcm80211/brcmfmac/dhd_common.c

   1 /*
   2  * Copyright (c) 2010 Broadcom Corporation
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16 #include <linux/kernel.h>
  17 #include <linux/string.h>
  18 #include <linux/sched.h>
  19 #include <linux/netdevice.h>
  20 #include <asm/unaligned.h>
  21 #include <defs.h>
  22 #include <brcmu_wifi.h>
  23 #include <brcmu_utils.h>
  24 #include "dhd.h"
  25 #include "dhd_bus.h"
  26 #include "dhd_proto.h"
  27 #include "dhd_dbg.h"
  28
  29 #define BRCM_OUI                        "\x00\x10\x18"
  30 #define DOT11_OUI_LEN                   3
  31 #define BCMILCP_BCM_SUBTYPE_EVENT       1
  32 #define PKTFILTER_BUF_SIZE              2048
  33
  34 int brcmf_msg_level;
  35
  36 #define MSGTRACE_VERSION        1
  37
  38 #ifdef BCMDBG
  39 static const char brcmf_version[] =
  40         "Dongle Host Driver, version " BRCMF_VERSION_STR "\nCompiled on "
  41         __DATE__ " at " __TIME__;
  42 #else
  43 static const char brcmf_version[] =
  44         "Dongle Host Driver, version " BRCMF_VERSION_STR;
  45 #endif
  46
  47 /* IOVar table */
  48 enum {
  49         IOV_VERSION = 1,
  50         IOV_MSGLEVEL,
  51         IOV_BCMERRORSTR,
  52         IOV_BCMERROR,
  53         IOV_DUMP,
  54         IOV_CLEARCOUNTS,
  55         IOV_LOGDUMP,
  56         IOV_LOGCAL,
  57         IOV_LOGSTAMP,
  58         IOV_GPIOOB,
  59         IOV_LAST
  60 };
  61
  62 static const struct brcmu_iovar brcmf_iovars[] = {
  63         {"version", IOV_VERSION, 0, IOVT_BUFFER, sizeof(brcmf_version)}
  64         ,
  65 #ifdef BCMDBG
  66         {"msglevel", IOV_MSGLEVEL, 0, IOVT_UINT32, 0}
  67         ,
  68 #endif                          /* BCMDBG */
  69         {"bcmerrorstr", IOV_BCMERRORSTR, 0, IOVT_BUFFER, BCME_STRLEN}
  70         ,
  71         {"bcmerror", IOV_BCMERROR, 0, IOVT_INT8, 0}
  72         ,
  73         {"dump", IOV_DUMP, 0, IOVT_BUFFER, BRCMF_IOCTL_MAXLEN}
  74         ,
  75         {"clearcounts", IOV_CLEARCOUNTS, 0, IOVT_VOID, 0}
  76         ,
  77         {"gpioob", IOV_GPIOOB, 0, IOVT_UINT32, 0}
  78         ,
  79         {NULL, 0, 0, 0, 0}
  80 };
  81
  82 /* Message trace header */
  83 struct msgtrace_hdr {
  84         u8 version;
  85         u8 spare;
  86         u16 len;                /* Len of the trace */
  87         u32 seqnum;             /* Sequence number of message. Useful
  88                                  * if the messsage has been lost
  89                                  * because of DMA error or a bus reset
  90                                  * (ex: SDIO Func2)
  91                                  */
  92         u32 discarded_bytes;    /* Number of discarded bytes because of
  93                                  trace overflow  */
  94         u32 discarded_printf;   /* Number of discarded printf
  95                                  because of trace overflow */
  96 } __packed;
  97
  98 void brcmf_c_init(void)
  99 {
 100         /* Init global variables at run-time, not as part of the declaration.
 101          * This is required to support init/de-init of the driver.
 102          * Initialization
 103          * of globals as part of the declaration results in non-deterministic
 104          * behaviour since the value of the globals may be different on the
 105          * first time that the driver is initialized vs subsequent
 106          * initializations.
 107          */
 108         brcmf_msg_level = BRCMF_ERROR_VAL;
 109 }
 110
 111 static int brcmf_c_dump(struct brcmf_pub *drvr, char *buf, int buflen)
 112 {
 113         struct brcmu_strbuf b;
 114         struct brcmu_strbuf *strbuf = &b;
 115
 116         brcmu_binit(strbuf, buf, buflen);
 117
 118         /* Base info */
 119         brcmu_bprintf(strbuf, "%s\n", brcmf_version);
 120         brcmu_bprintf(strbuf, "\n");
 121         brcmu_bprintf(strbuf, "pub.up %d pub.txoff %d pub.busstate %d\n",
 122                     drvr->up, drvr->txoff, drvr->busstate);
 123         brcmu_bprintf(strbuf, "pub.hdrlen %d pub.maxctl %d pub.rxsz %d\n",
 124                     drvr->hdrlen, drvr->maxctl, drvr->rxsz);
 125         brcmu_bprintf(strbuf, "pub.iswl %d pub.drv_version %ld pub.mac %pM\n",
 126                     drvr->iswl, drvr->drv_version, &drvr->mac);
 127         brcmu_bprintf(strbuf, "pub.bcmerror %d tickcnt %d\n", drvr->bcmerror,
 128                     drvr->tickcnt);
 129
 130         brcmu_bprintf(strbuf, "dongle stats:\n");
 131         brcmu_bprintf(strbuf,
 132                     "tx_packets %ld tx_bytes %ld tx_errors %ld tx_dropped %ld\n",
 133                     drvr->dstats.tx_packets, drvr->dstats.tx_bytes,
 134                     drvr->dstats.tx_errors, drvr->dstats.tx_dropped);
 135         brcmu_bprintf(strbuf,
 136                     "rx_packets %ld rx_bytes %ld rx_errors %ld rx_dropped %ld\n",
 137                     drvr->dstats.rx_packets, drvr->dstats.rx_bytes,
 138                     drvr->dstats.rx_errors, drvr->dstats.rx_dropped);
 139         brcmu_bprintf(strbuf, "multicast %ld\n", drvr->dstats.multicast);
 140
 141         brcmu_bprintf(strbuf, "bus stats:\n");
 142         brcmu_bprintf(strbuf, "tx_packets %ld tx_multicast %ld tx_errors %ld\n",
 143                     drvr->tx_packets, drvr->tx_multicast, drvr->tx_errors);
 144         brcmu_bprintf(strbuf, "tx_ctlpkts %ld tx_ctlerrs %ld\n",
 145                     drvr->tx_ctlpkts, drvr->tx_ctlerrs);
 146         brcmu_bprintf(strbuf, "rx_packets %ld rx_multicast %ld rx_errors %ld\n",
 147                     drvr->rx_packets, drvr->rx_multicast, drvr->rx_errors);
 148         brcmu_bprintf(strbuf,
 149                     "rx_ctlpkts %ld rx_ctlerrs %ld rx_dropped %ld rx_flushed %ld\n",
 150                     drvr->rx_ctlpkts, drvr->rx_ctlerrs, drvr->rx_dropped,
 151                     drvr->rx_flushed);
 152         brcmu_bprintf(strbuf,
 153                     "rx_readahead_cnt %ld tx_realloc %ld fc_packets %ld\n",
 154                     drvr->rx_readahead_cnt, drvr->tx_realloc, drvr->fc_packets);
 155         brcmu_bprintf(strbuf, "wd_dpc_sched %ld\n", drvr->wd_dpc_sched);
 156         brcmu_bprintf(strbuf, "\n");
 157
 158         /* Add any prot info */
 159         brcmf_proto_dump(drvr, strbuf);
 160         brcmu_bprintf(strbuf, "\n");
 161
 162         /* Add any bus info */
 163         brcmf_sdbrcm_bus_dump(drvr, strbuf);
 164
 165         return !strbuf->size ? -EOVERFLOW : 0;
 166 }
 167
 168 static int
 169 brcmf_c_doiovar(struct brcmf_pub *drvr, const struct brcmu_iovar *vi,
 170                 u32 actionid, const char *name, void *params, int plen,
 171                 void *arg, int len, int val_size)
 172 {
 173         int bcmerror = 0;
 174         s32 int_val = 0;
 175
 176         brcmf_dbg(TRACE, "Enter\n");
 177
 178         bcmerror = brcmu_iovar_lencheck(vi, arg, len, IOV_ISSET(actionid));
 179         if (bcmerror != 0)
 180                 goto exit;
 181
 182         if (plen >= (int)sizeof(int_val))
 183                 memcpy(&int_val, params, sizeof(int_val));
 184
 185         switch (actionid) {
 186         case IOV_GVAL(IOV_VERSION):
 187                 /* Need to have checked buffer length */
 188                 strncpy((char *)arg, brcmf_version, len);
 189                 break;
 190
 191         case IOV_GVAL(IOV_MSGLEVEL):
 192                 int_val = (s32) brcmf_msg_level;
 193                 memcpy(arg, &int_val, val_size);
 194                 break;
 195
 196         case IOV_SVAL(IOV_MSGLEVEL):
 197                 brcmf_msg_level = int_val;
 198                 break;
 199
 200         case IOV_GVAL(IOV_BCMERRORSTR):
 201                 strncpy((char *)arg, "bcm_error",
 202                         BCME_STRLEN);
 203                 ((char *)arg)[BCME_STRLEN - 1] = 0x00;
 204                 break;
 205
 206         case IOV_GVAL(IOV_BCMERROR):
 207                 int_val = (s32) drvr->bcmerror;
 208                 memcpy(arg, &int_val, val_size);
 209                 break;
 210
 211         case IOV_GVAL(IOV_DUMP):
 212                 bcmerror = brcmf_c_dump(drvr, arg, len);
 213                 break;
 214
 215         case IOV_SVAL(IOV_CLEARCOUNTS):
 216                 drvr->tx_packets = drvr->rx_packets = 0;
 217                 drvr->tx_errors = drvr->rx_errors = 0;
 218                 drvr->tx_ctlpkts = drvr->rx_ctlpkts = 0;
 219                 drvr->tx_ctlerrs = drvr->rx_ctlerrs = 0;
 220                 drvr->rx_dropped = 0;
 221                 drvr->rx_readahead_cnt = 0;
 222                 drvr->tx_realloc = 0;
 223                 drvr->wd_dpc_sched = 0;
 224                 memset(&drvr->dstats, 0, sizeof(drvr->dstats));
 225                 brcmf_bus_clearcounts(drvr);
 226                 break;
 227
 228         default:
 229                 bcmerror = -ENOTSUPP;
 230                 break;
 231         }
 232
 233 exit:
 234         return bcmerror;
 235 }
 236
 237 bool brcmf_c_prec_enq(struct brcmf_pub *drvr, struct pktq *q,
 238                       struct sk_buff *pkt, int prec)
 239 {
 240         struct sk_buff *p;
 241         int eprec = -1;         /* precedence to evict from */
 242         bool discard_oldest;
 243
 244         /* Fast case, precedence queue is not full and we are also not
 245          * exceeding total queue length
 246          */
 247         if (!pktq_pfull(q, prec) && !pktq_full(q)) {
 248                 brcmu_pktq_penq(q, prec, pkt);
 249                 return true;
 250         }
 251
 252         /* Determine precedence from which to evict packet, if any */
 253         if (pktq_pfull(q, prec))
 254                 eprec = prec;
 255         else if (pktq_full(q)) {
 256                 p = brcmu_pktq_peek_tail(q, &eprec);
 257                 if (eprec > prec)
 258                         return false;
 259         }
 260
 261         /* Evict if needed */
 262         if (eprec >= 0) {
 263                 /* Detect queueing to unconfigured precedence */
 264                 discard_oldest = AC_BITMAP_TST(drvr->wme_dp, eprec);
 265                 if (eprec == prec && !discard_oldest)
 266                         return false;   /* refuse newer (incoming) packet */
 267                 /* Evict packet according to discard policy */
 268                 p = discard_oldest ? brcmu_pktq_pdeq(q, eprec) :
 269                         brcmu_pktq_pdeq_tail(q, eprec);
 270                 if (p == NULL)
 271                         brcmf_dbg(ERROR, "brcmu_pktq_penq() failed, oldest %d\n",
 272                                   discard_oldest);
 273
 274                 brcmu_pkt_buf_free_skb(p);
 275         }
 276
 277         /* Enqueue */
 278         p = brcmu_pktq_penq(q, prec, pkt);
 279         if (p == NULL)
 280                 brcmf_dbg(ERROR, "brcmu_pktq_penq() failed\n");
 281
 282         return p != NULL;
 283 }
 284
 285 static int
 286 brcmf_c_iovar_op(struct brcmf_pub *drvr, const char *name,
 287              void *params, int plen, void *arg, int len, bool set)
 288 {
 289         int bcmerror = 0;
 290         int val_size;
 291         const struct brcmu_iovar *vi = NULL;
 292         u32 actionid;
 293
 294         brcmf_dbg(TRACE, "Enter\n");
 295
 296         if (name == NULL || len < 0)
 297                 return -EINVAL;
 298
 299         /* Set does not take qualifiers */
 300         if (set && (params || plen))
 301                 return -EINVAL;
 302
 303         /* Get must have return space;*/
 304         if (!set && !(arg && len))
 305                 return -EINVAL;
 306
 307         vi = brcmu_iovar_lookup(brcmf_iovars, name);
 308         if (vi == NULL) {
 309                 bcmerror = -ENOTSUPP;
 310                 goto exit;
 311         }
 312
 313         brcmf_dbg(CTL, "%s %s, len %d plen %d\n",
 314                   name, set ? "set" : "get", len, plen);
 315
 316         /* set up 'params' pointer in case this is a set command so that
 317          * the convenience int and bool code can be common to set and get
 318          */
 319         if (params == NULL) {
 320                 params = arg;
 321                 plen = len;
 322         }
 323
 324         if (vi->type == IOVT_VOID)
 325                 val_size = 0;
 326         else if (vi->type == IOVT_BUFFER)
 327                 val_size = len;
 328         else
 329                 /* all other types are integer sized */
 330                 val_size = sizeof(int);
 331
 332         actionid = set ? IOV_SVAL(vi->varid) : IOV_GVAL(vi->varid);
 333         bcmerror =
 334             brcmf_c_doiovar(drvr, vi, actionid, name, params, plen, arg, len,
 335                         val_size);
 336
 337 exit:
 338         return bcmerror;
 339 }
 340
 341 int brcmf_c_ioctl(struct brcmf_pub *drvr, struct brcmf_c_ioctl *ioc, void *buf,
 342                   uint buflen)
 343 {
 344         int bcmerror = 0;
 345
 346         brcmf_dbg(TRACE, "Enter\n");
 347
 348         if (!buf)
 349                 return -EINVAL;
 350
 351         switch (ioc->cmd) {
 352         case BRCMF_GET_MAGIC:
 353                 if (buflen < sizeof(int))
 354                         bcmerror = -EOVERFLOW;
 355                 else
 356                         *(int *)buf = BRCMF_IOCTL_MAGIC;
 357                 break;
 358
 359         case BRCMF_GET_VERSION:
 360                 if (buflen < sizeof(int))
 361                         bcmerror = -EOVERFLOW;
 362                 else
 363                         *(int *)buf = BRCMF_IOCTL_VERSION;
 364                 break;
 365
 366         case BRCMF_GET_VAR:
 367         case BRCMF_SET_VAR:{
 368                         char *arg;
 369                         uint arglen;
 370
 371                         /* scan past the name to any arguments */
 372                         for (arg = buf, arglen = buflen; *arg && arglen;
 373                              arg++, arglen--)
 374                                 ;
 375
 376                         if (*arg) {
 377                                 bcmerror = -EOVERFLOW;
 378                                 break;
 379                         }
 380
 381                         /* account for the NUL terminator */
 382                         arg++, arglen--;
 383
 384                         /* call with the appropriate arguments */
 385                         if (ioc->cmd == BRCMF_GET_VAR)
 386                                 bcmerror = brcmf_c_iovar_op(drvr, buf, arg,
 387                                                 arglen, buf, buflen, IOV_GET);
 388                         else
 389                                 bcmerror =
 390                                     brcmf_c_iovar_op(drvr, buf, NULL, 0, arg,
 391                                                      arglen, IOV_SET);
 392                         if (bcmerror != -ENOTSUPP)
 393                                 break;
 394
 395                         /* if still not found, try bus module */
 396                         if (ioc->cmd == BRCMF_GET_VAR)
 397                                 bcmerror = brcmf_sdbrcm_bus_iovar_op(drvr,
 398                                                 buf, arg, arglen, buf, buflen,
 399                                                 IOV_GET);
 400                         else
 401                                 bcmerror = brcmf_sdbrcm_bus_iovar_op(drvr,
 402                                                 buf, NULL, 0, arg, arglen,
 403                                                 IOV_SET);
 404
 405                         break;
 406                 }
 407
 408         default:
 409                 bcmerror = -ENOTSUPP;
 410         }
 411
 412         return bcmerror;
 413 }
 414
 415 #ifdef BCMDBG
 416 static void
 417 brcmf_c_show_host_event(struct brcmf_event_msg *event, void *event_data)
 418 {
 419         uint i, status, reason;
 420         bool group = false, flush_txq = false, link = false;
 421         char *auth_str, *event_name;
 422         unsigned char *buf;
 423         char err_msg[256], eabuf[ETHER_ADDR_STR_LEN];
 424         static struct {
 425                 uint event;
 426                 char *event_name;
 427         } event_names[] = {
 428                 {
 429                 BRCMF_E_SET_SSID, "SET_SSID"}, {
 430                 BRCMF_E_JOIN, "JOIN"}, {
 431                 BRCMF_E_START, "START"}, {
 432                 BRCMF_E_AUTH, "AUTH"}, {
 433                 BRCMF_E_AUTH_IND, "AUTH_IND"}, {
 434                 BRCMF_E_DEAUTH, "DEAUTH"}, {
 435                 BRCMF_E_DEAUTH_IND, "DEAUTH_IND"}, {
 436                 BRCMF_E_ASSOC, "ASSOC"}, {
 437                 BRCMF_E_ASSOC_IND, "ASSOC_IND"}, {
 438                 BRCMF_E_REASSOC, "REASSOC"}, {
 439                 BRCMF_E_REASSOC_IND, "REASSOC_IND"}, {
 440                 BRCMF_E_DISASSOC, "DISASSOC"}, {
 441                 BRCMF_E_DISASSOC_IND, "DISASSOC_IND"}, {
 442                 BRCMF_E_QUIET_START, "START_QUIET"}, {
 443                 BRCMF_E_QUIET_END, "END_QUIET"}, {
 444                 BRCMF_E_BEACON_RX, "BEACON_RX"}, {
 445                 BRCMF_E_LINK, "LINK"}, {
 446                 BRCMF_E_MIC_ERROR, "MIC_ERROR"}, {
 447                 BRCMF_E_NDIS_LINK, "NDIS_LINK"}, {
 448                 BRCMF_E_ROAM, "ROAM"}, {
 449                 BRCMF_E_TXFAIL, "TXFAIL"}, {
 450                 BRCMF_E_PMKID_CACHE, "PMKID_CACHE"}, {
 451                 BRCMF_E_RETROGRADE_TSF, "RETROGRADE_TSF"}, {
 452                 BRCMF_E_PRUNE, "PRUNE"}, {
 453                 BRCMF_E_AUTOAUTH, "AUTOAUTH"}, {
 454                 BRCMF_E_EAPOL_MSG, "EAPOL_MSG"}, {
 455                 BRCMF_E_SCAN_COMPLETE, "SCAN_COMPLETE"}, {
 456                 BRCMF_E_ADDTS_IND, "ADDTS_IND"}, {
 457                 BRCMF_E_DELTS_IND, "DELTS_IND"}, {
 458                 BRCMF_E_BCNSENT_IND, "BCNSENT_IND"}, {
 459                 BRCMF_E_BCNRX_MSG, "BCNRX_MSG"}, {
 460                 BRCMF_E_BCNLOST_MSG, "BCNLOST_MSG"}, {
 461                 BRCMF_E_ROAM_PREP, "ROAM_PREP"}, {
 462                 BRCMF_E_PFN_NET_FOUND, "PNO_NET_FOUND"}, {
 463                 BRCMF_E_PFN_NET_LOST, "PNO_NET_LOST"}, {
 464                 BRCMF_E_RESET_COMPLETE, "RESET_COMPLETE"}, {
 465                 BRCMF_E_JOIN_START, "JOIN_START"}, {
 466                 BRCMF_E_ROAM_START, "ROAM_START"}, {
 467                 BRCMF_E_ASSOC_START, "ASSOC_START"}, {
 468                 BRCMF_E_IBSS_ASSOC, "IBSS_ASSOC"}, {
 469                 BRCMF_E_RADIO, "RADIO"}, {
 470                 BRCMF_E_PSM_WATCHDOG, "PSM_WATCHDOG"}, {
 471                 BRCMF_E_PROBREQ_MSG, "PROBREQ_MSG"}, {
 472                 BRCMF_E_SCAN_CONFIRM_IND, "SCAN_CONFIRM_IND"}, {
 473                 BRCMF_E_PSK_SUP, "PSK_SUP"}, {
 474                 BRCMF_E_COUNTRY_CODE_CHANGED, "COUNTRY_CODE_CHANGED"}, {
 475                 BRCMF_E_EXCEEDED_MEDIUM_TIME, "EXCEEDED_MEDIUM_TIME"}, {
 476                 BRCMF_E_ICV_ERROR, "ICV_ERROR"}, {
 477                 BRCMF_E_UNICAST_DECODE_ERROR, "UNICAST_DECODE_ERROR"}, {
 478                 BRCMF_E_MULTICAST_DECODE_ERROR, "MULTICAST_DECODE_ERROR"}, {
 479                 BRCMF_E_TRACE, "TRACE"}, {
 480                 BRCMF_E_ACTION_FRAME, "ACTION FRAME"}, {
 481                 BRCMF_E_ACTION_FRAME_COMPLETE, "ACTION FRAME TX COMPLETE"}, {
 482                 BRCMF_E_IF, "IF"}, {
 483                 BRCMF_E_RSSI, "RSSI"}, {
 484                 BRCMF_E_PFN_SCAN_COMPLETE, "SCAN_COMPLETE"}
 485         };
 486         uint event_type, flags, auth_type, datalen;
 487         event_type = be32_to_cpu(event->event_type);
 488         flags = be16_to_cpu(event->flags);
 489         status = be32_to_cpu(event->status);
 490         reason = be32_to_cpu(event->reason);
 491         auth_type = be32_to_cpu(event->auth_type);
 492         datalen = be32_to_cpu(event->datalen);
 493         /* debug dump of event messages */
 494         sprintf(eabuf, "%pM", event->addr);
 495
 496         event_name = "UNKNOWN";
 497         for (i = 0; i < ARRAY_SIZE(event_names); i++) {
 498                 if (event_names[i].event == event_type)
 499                         event_name = event_names[i].event_name;
 500         }
 501
 502         brcmf_dbg(EVENT, "EVENT: %s, event ID = %d\n", event_name, event_type);
 503         brcmf_dbg(EVENT, "flags 0x%04x, status %d, reason %d, auth_type %d MAC %s\n",
 504                   flags, status, reason, auth_type, eabuf);
 505
 506         if (flags & BRCMF_EVENT_MSG_LINK)
 507                 link = true;
 508         if (flags & BRCMF_EVENT_MSG_GROUP)
 509                 group = true;
 510         if (flags & BRCMF_EVENT_MSG_FLUSHTXQ)
 511                 flush_txq = true;
 512
 513         switch (event_type) {
 514         case BRCMF_E_START:
 515         case BRCMF_E_DEAUTH:
 516         case BRCMF_E_DISASSOC:
 517                 brcmf_dbg(EVENT, "MACEVENT: %s, MAC %s\n", event_name, eabuf);
 518                 break;
 519
 520         case BRCMF_E_ASSOC_IND:
 521         case BRCMF_E_REASSOC_IND:
 522                 brcmf_dbg(EVENT, "MACEVENT: %s, MAC %s\n", event_name, eabuf);
 523                 break;
 524
 525         case BRCMF_E_ASSOC:
 526         case BRCMF_E_REASSOC:
 527                 if (status == BRCMF_E_STATUS_SUCCESS)
 528                         brcmf_dbg(EVENT, "MACEVENT: %s, MAC %s, SUCCESS\n",
 529                                   event_name, eabuf);
 530                 else if (status == BRCMF_E_STATUS_TIMEOUT)
 531                         brcmf_dbg(EVENT, "MACEVENT: %s, MAC %s, TIMEOUT\n",
 532                                   event_name, eabuf);
 533                 else if (status == BRCMF_E_STATUS_FAIL)
 534                         brcmf_dbg(EVENT, "MACEVENT: %s, MAC %s, FAILURE, reason %d\n",
 535                                   event_name, eabuf, (int)reason);
 536                 else
 537                         brcmf_dbg(EVENT, "MACEVENT: %s, MAC %s, unexpected status %d\n",
 538                                   event_name, eabuf, (int)status);
 539                 break;
 540
 541         case BRCMF_E_DEAUTH_IND:
 542         case BRCMF_E_DISASSOC_IND:
 543                 brcmf_dbg(EVENT, "MACEVENT: %s, MAC %s, reason %d\n",
 544                           event_name, eabuf, (int)reason);
 545                 break;
 546
 547         case BRCMF_E_AUTH:
 548         case BRCMF_E_AUTH_IND:
 549                 if (auth_type == WLAN_AUTH_OPEN)
 550                         auth_str = "Open System";
 551                 else if (auth_type == WLAN_AUTH_SHARED_KEY)
 552                         auth_str = "Shared Key";
 553                 else {
 554                         sprintf(err_msg, "AUTH unknown: %d", (int)auth_type);
 555                         auth_str = err_msg;
 556                 }
 557                 if (event_type == BRCMF_E_AUTH_IND)
 558                         brcmf_dbg(EVENT, "MACEVENT: %s, MAC %s, %s\n",
 559                                   event_name, eabuf, auth_str);
 560                 else if (status == BRCMF_E_STATUS_SUCCESS)
 561                         brcmf_dbg(EVENT, "MACEVENT: %s, MAC %s, %s, SUCCESS\n",
 562                                   event_name, eabuf, auth_str);
 563                 else if (status == BRCMF_E_STATUS_TIMEOUT)
 564                         brcmf_dbg(EVENT, "MACEVENT: %s, MAC %s, %s, TIMEOUT\n",
 565                                   event_name, eabuf, auth_str);
 566                 else if (status == BRCMF_E_STATUS_FAIL) {
 567                         brcmf_dbg(EVENT, "MACEVENT: %s, MAC %s, %s, FAILURE, reason %d\n",
 568                                   event_name, eabuf, auth_str, (int)reason);
 569                 }
 570
 571                 break;
 572
 573         case BRCMF_E_JOIN:
 574         case BRCMF_E_ROAM:
 575         case BRCMF_E_SET_SSID:
 576                 if (status == BRCMF_E_STATUS_SUCCESS)
 577                         brcmf_dbg(EVENT, "MACEVENT: %s, MAC %s\n",
 578                                   event_name, eabuf);
 579                 else if (status == BRCMF_E_STATUS_FAIL)
 580                         brcmf_dbg(EVENT, "MACEVENT: %s, failed\n", event_name);
 581                 else if (status == BRCMF_E_STATUS_NO_NETWORKS)
 582                         brcmf_dbg(EVENT, "MACEVENT: %s, no networks found\n",
 583                                   event_name);
 584                 else
 585                         brcmf_dbg(EVENT, "MACEVENT: %s, unexpected status %d\n",
 586                                   event_name, (int)status);
 587                 break;
 588
 589         case BRCMF_E_BEACON_RX:
 590                 if (status == BRCMF_E_STATUS_SUCCESS)
 591                         brcmf_dbg(EVENT, "MACEVENT: %s, SUCCESS\n", event_name);
 592                 else if (status == BRCMF_E_STATUS_FAIL)
 593                         brcmf_dbg(EVENT, "MACEVENT: %s, FAIL\n", event_name);
 594                 else
 595                         brcmf_dbg(EVENT, "MACEVENT: %s, status %d\n",
 596                                   event_name, status);
 597                 break;
 598
 599         case BRCMF_E_LINK:
 600                 brcmf_dbg(EVENT, "MACEVENT: %s %s\n",
 601                           event_name, link ? "UP" : "DOWN");
 602                 break;
 603
 604         case BRCMF_E_MIC_ERROR:
 605                 brcmf_dbg(EVENT, "MACEVENT: %s, MAC %s, Group %d, Flush %d\n",
 606                           event_name, eabuf, group, flush_txq);
 607                 break;
 608
 609         case BRCMF_E_ICV_ERROR:
 610         case BRCMF_E_UNICAST_DECODE_ERROR:
 611         case BRCMF_E_MULTICAST_DECODE_ERROR:
 612                 brcmf_dbg(EVENT, "MACEVENT: %s, MAC %s\n", event_name, eabuf);
 613                 break;
 614
 615         case BRCMF_E_TXFAIL:
 616                 brcmf_dbg(EVENT, "MACEVENT: %s, RA %s\n", event_name, eabuf);
 617                 break;
 618
 619         case BRCMF_E_SCAN_COMPLETE:
 620         case BRCMF_E_PMKID_CACHE:
 621                 brcmf_dbg(EVENT, "MACEVENT: %s\n", event_name);
 622                 break;
 623
 624         case BRCMF_E_PFN_NET_FOUND:
 625         case BRCMF_E_PFN_NET_LOST:
 626         case BRCMF_E_PFN_SCAN_COMPLETE:
 627                 brcmf_dbg(EVENT, "PNOEVENT: %s\n", event_name);
 628                 break;
 629
 630         case BRCMF_E_PSK_SUP:
 631         case BRCMF_E_PRUNE:
 632                 brcmf_dbg(EVENT, "MACEVENT: %s, status %d, reason %d\n",
 633                           event_name, (int)status, (int)reason);
 634                 break;
 635
 636         case BRCMF_E_TRACE:
 637                 {
 638                         static u32 seqnum_prev;
 639                         struct msgtrace_hdr hdr;
 640                         u32 nblost;
 641                         char *s, *p;
 642
 643                         buf = (unsigned char *) event_data;
 644                         memcpy(&hdr, buf, sizeof(struct msgtrace_hdr));
 645
 646                         if (hdr.version != MSGTRACE_VERSION) {
 647                                 brcmf_dbg(ERROR, "MACEVENT: %s [unsupported version --> brcmf version:%d dongle version:%d]\n",
 648                                           event_name,
 649                                           MSGTRACE_VERSION, hdr.version);
 650                                 /* Reset datalen to avoid display below */
 651                                 datalen = 0;
 652                                 break;
 653                         }
 654
 655                         /* There are 2 bytes available at the end of data */
 656                         *(buf + sizeof(struct msgtrace_hdr)
 657                                  + be16_to_cpu(hdr.len)) = '\0';
 658
 659                         if (be32_to_cpu(hdr.discarded_bytes)
 660                             || be32_to_cpu(hdr.discarded_printf))
 661                                 brcmf_dbg(ERROR, "WLC_E_TRACE: [Discarded traces in dongle --> discarded_bytes %d discarded_printf %d]\n",
 662                                           be32_to_cpu(hdr.discarded_bytes),
 663                                           be32_to_cpu(hdr.discarded_printf));
 664
 665                         nblost = be32_to_cpu(hdr.seqnum) - seqnum_prev - 1;
 666                         if (nblost > 0)
 667                                 brcmf_dbg(ERROR, "WLC_E_TRACE: [Event lost --> seqnum %d nblost %d\n",
 668                                           be32_to_cpu(hdr.seqnum), nblost);
 669                         seqnum_prev = be32_to_cpu(hdr.seqnum);
 670
 671                         /* Display the trace buffer. Advance from \n to \n to
 672                          * avoid display big
 673                          * printf (issue with Linux printk )
 674                          */
 675                         p = (char *)&buf[sizeof(struct msgtrace_hdr)];
 676                         while ((s = strstr(p, "\n")) != NULL) {
 677                                 *s = '\0';
 678                                 printk(KERN_DEBUG"%s\n", p);
 679                                 p = s + 1;
 680                         }
 681                         printk(KERN_DEBUG "%s\n", p);
 682
 683                         /* Reset datalen to avoid display below */
 684                         datalen = 0;
 685                 }
 686                 break;
 687
 688         case BRCMF_E_RSSI:
 689                 brcmf_dbg(EVENT, "MACEVENT: %s %d\n",
 690                           event_name, be32_to_cpu(*((int *)event_data)));
 691                 break;
 692
 693         default:
 694                 brcmf_dbg(EVENT, "MACEVENT: %s %d, MAC %s, status %d, reason %d, auth %d\n",
 695                           event_name, event_type, eabuf,
 696                           (int)status, (int)reason, (int)auth_type);
 697                 break;
 698         }
 699
 700         /* show any appended data */
 701         if (datalen) {
 702                 buf = (unsigned char *) event_data;
 703                 brcmf_dbg(EVENT, " data (%d) : ", datalen);
 704                 for (i = 0; i < datalen; i++)
 705                         brcmf_dbg(EVENT, " 0x%02x ", *buf++);
 706                 brcmf_dbg(EVENT, "\n");
 707         }
 708 }
 709 #endif                          /* BCMDBG */
 710
 711 int
 712 brcmf_c_host_event(struct brcmf_info *drvr_priv, int *ifidx, void *pktdata,
 713                    struct brcmf_event_msg *event, void **data_ptr)
 714 {
 715         /* check whether packet is a BRCM event pkt */
 716         struct brcmf_event *pvt_data = (struct brcmf_event *) pktdata;
 717         char *event_data;
 718         u32 type, status;
 719         u16 flags;
 720         int evlen;
 721
 722         if (memcmp(BRCM_OUI, &pvt_data->hdr.oui[0], DOT11_OUI_LEN)) {
 723                 brcmf_dbg(ERROR, "mismatched OUI, bailing\n");
 724                 return -EBADE;
 725         }
 726
 727         /* BRCM event pkt may be unaligned - use xxx_ua to load user_subtype. */
 728         if (get_unaligned_be16(&pvt_data->hdr.usr_subtype) !=
 729             BCMILCP_BCM_SUBTYPE_EVENT) {
 730                 brcmf_dbg(ERROR, "mismatched subtype, bailing\n");
 731                 return -EBADE;
 732         }
 733
 734         *data_ptr = &pvt_data[1];
 735         event_data = *data_ptr;
 736
 737         /* memcpy since BRCM event pkt may be unaligned. */
 738         memcpy(event, &pvt_data->msg, sizeof(struct brcmf_event_msg));
 739
 740         type = get_unaligned_be32(&event->event_type);
 741         flags = get_unaligned_be16(&event->flags);
 742         status = get_unaligned_be32(&event->status);
 743         evlen = get_unaligned_be32(&event->datalen) +
 744                 sizeof(struct brcmf_event);
 745
 746         switch (type) {
 747         case BRCMF_E_IF:
 748                 {
 749                         struct brcmf_if_event *ifevent =
 750                                         (struct brcmf_if_event *) event_data;
 751                         brcmf_dbg(TRACE, "if event\n");
 752
 753                         if (ifevent->ifidx > 0 &&
 754                                  ifevent->ifidx < BRCMF_MAX_IFS) {
 755                                 if (ifevent->action == BRCMF_E_IF_ADD)
 756                                         brcmf_add_if(drvr_priv, ifevent->ifidx,
 757                                                    NULL, event->ifname,
 758                                                    pvt_data->eth.h_dest,
 759                                                    ifevent->flags,
 760                                                    ifevent->bssidx);
 761                                 else
 762                                         brcmf_del_if(drvr_priv, ifevent->ifidx);
 763                         } else {
 764                                 brcmf_dbg(ERROR, "Invalid ifidx %d for %s\n",
 765                                           ifevent->ifidx, event->ifname);
 766                         }
 767                 }
 768                 /* send up the if event: btamp user needs it */
 769                 *ifidx = brcmf_ifname2idx(drvr_priv, event->ifname);
 770                 break;
 771
 772                 /* These are what external supplicant/authenticator wants */
 773         case BRCMF_E_LINK:
 774         case BRCMF_E_ASSOC_IND:
 775         case BRCMF_E_REASSOC_IND:
 776         case BRCMF_E_DISASSOC_IND:
 777         case BRCMF_E_MIC_ERROR:
 778         default:
 779                 /* Fall through: this should get _everything_  */
 780
 781                 *ifidx = brcmf_ifname2idx(drvr_priv, event->ifname);
 782                 brcmf_dbg(TRACE, "MAC event %d, flags %x, status %x\n",
 783                           type, flags, status);
 784
 785                 /* put it back to BRCMF_E_NDIS_LINK */
 786                 if (type == BRCMF_E_NDIS_LINK) {
 787                         u32 temp;
 788
 789                         temp = get_unaligned_be32(&event->event_type);
 790                         brcmf_dbg(TRACE, "Converted to WLC_E_LINK type %d\n",
 791                                   temp);
 792
 793                         temp = be32_to_cpu(BRCMF_E_NDIS_LINK);
 794                         memcpy((void *)(&pvt_data->msg.event_type), &temp,
 795                                sizeof(pvt_data->msg.event_type));
 796                 }
 797                 break;
 798         }
 799
 800 #ifdef BCMDBG
 801         brcmf_c_show_host_event(event, event_data);
 802 #endif                          /* BCMDBG */
 803
 804         return 0;
 805 }
 806
 807 /* Convert user's input in hex pattern to byte-size mask */
 808 static int brcmf_c_pattern_atoh(char *src, char *dst)
 809 {
 810         int i;
 811         if (strncmp(src, "0x", 2) != 0 && strncmp(src, "0X", 2) != 0) {
 812                 brcmf_dbg(ERROR, "Mask invalid format. Needs to start with 0x\n");
 813                 return -EINVAL;
 814         }
 815         src = src + 2;          /* Skip past 0x */
 816         if (strlen(src) % 2 != 0) {
 817                 brcmf_dbg(ERROR, "Mask invalid format. Length must be even.\n");
 818                 return -EINVAL;
 819         }
 820         for (i = 0; *src != '\0'; i++) {
 821                 unsigned long res;
 822                 char num[3];
 823                 strncpy(num, src, 2);
 824                 num[2] = '\0';
 825                 if (kstrtoul(num, 16, &res))
 826                         return -EINVAL;
 827                 dst[i] = (u8)res;
 828                 src += 2;
 829         }
 830         return i;
 831 }
 832
 833 void
 834 brcmf_c_pktfilter_offload_enable(struct brcmf_pub *drvr, char *arg, int enable,
 835                              int master_mode)
 836 {
 837         unsigned long res;
 838         char *argv[8];
 839         int i = 0;
 840         const char *str;
 841         int buf_len;
 842         int str_len;
 843         char *arg_save = 0, *arg_org = 0;
 844         int rc;
 845         char buf[128];
 846         struct brcmf_pkt_filter_enable enable_parm;
 847         struct brcmf_pkt_filter_enable *pkt_filterp;
 848
 849         arg_save = kmalloc(strlen(arg) + 1, GFP_ATOMIC);
 850         if (!arg_save) {
 851                 brcmf_dbg(ERROR, "kmalloc failed\n");
 852                 goto fail;
 853         }
 854         arg_org = arg_save;
 855         memcpy(arg_save, arg, strlen(arg) + 1);
 856
 857         argv[i] = strsep(&arg_save, " ");
 858
 859         i = 0;
 860         if (NULL == argv[i]) {
 861                 brcmf_dbg(ERROR, "No args provided\n");
 862                 goto fail;
 863         }
 864
 865         str = "pkt_filter_enable";
 866         str_len = strlen(str);
 867         strncpy(buf, str, str_len);
 868         buf[str_len] = '\0';
 869         buf_len = str_len + 1;
 870
 871         pkt_filterp = (struct brcmf_pkt_filter_enable *) (buf + str_len + 1);
 872
 873         /* Parse packet filter id. */
 874         enable_parm.id = 0;
 875         if (!kstrtoul(argv[i], 0, &res))
 876                 enable_parm.id = (u32)res;
 877
 878         /* Parse enable/disable value. */
 879         enable_parm.enable = enable;
 880
 881         buf_len += sizeof(enable_parm);
 882         memcpy((char *)pkt_filterp, &enable_parm, sizeof(enable_parm));
 883
 884         /* Enable/disable the specified filter. */
 885         rc = brcmf_proto_cdc_set_ioctl(drvr, 0, BRCMF_C_SET_VAR, buf, buf_len);
 886         rc = rc >= 0 ? 0 : rc;
 887         if (rc)
 888                 brcmf_dbg(TRACE, "failed to add pktfilter %s, retcode = %d\n",
 889                           arg, rc);
 890         else
 891                 brcmf_dbg(TRACE, "successfully added pktfilter %s\n", arg);
 892
 893         /* Contorl the master mode */
 894         brcmu_mkiovar("pkt_filter_mode", (char *)&master_mode, 4, buf,
 895                     sizeof(buf));
 896         rc = brcmf_proto_cdc_set_ioctl(drvr, 0, BRCMF_C_SET_VAR, buf,
 897                                        sizeof(buf));
 898         rc = rc >= 0 ? 0 : rc;
 899         if (rc)
 900                 brcmf_dbg(TRACE, "failed to add pktfilter %s, retcode = %d\n",
 901                           arg, rc);
 902
 903 fail:
 904         kfree(arg_org);
 905 }
 906
 907 void brcmf_c_pktfilter_offload_set(struct brcmf_pub *drvr, char *arg)
 908 {
 909         const char *str;
 910         struct brcmf_pkt_filter pkt_filter;
 911         struct brcmf_pkt_filter *pkt_filterp;
 912         unsigned long res;
 913         int buf_len;
 914         int str_len;
 915         int rc;
 916         u32 mask_size;
 917         u32 pattern_size;
 918         char *argv[8], *buf = 0;
 919         int i = 0;
 920         char *arg_save = 0, *arg_org = 0;
 921
 922         arg_save = kstrdup(arg, GFP_ATOMIC);
 923         if (!arg_save) {
 924                 brcmf_dbg(ERROR, "kmalloc failed\n");
 925                 goto fail;
 926         }
 927
 928         arg_org = arg_save;
 929
 930         buf = kmalloc(PKTFILTER_BUF_SIZE, GFP_ATOMIC);
 931         if (!buf) {
 932                 brcmf_dbg(ERROR, "kmalloc failed\n");
 933                 goto fail;
 934         }
 935
 936         argv[i] = strsep(&arg_save, " ");
 937         while (argv[i++])
 938                 argv[i] = strsep(&arg_save, " ");
 939
 940         i = 0;
 941         if (NULL == argv[i]) {
 942                 brcmf_dbg(ERROR, "No args provided\n");
 943                 goto fail;
 944         }
 945
 946         str = "pkt_filter_add";
 947         strcpy(buf, str);
 948         str_len = strlen(str);
 949         buf_len = str_len + 1;
 950
 951         pkt_filterp = (struct brcmf_pkt_filter *) (buf + str_len + 1);
 952
 953         /* Parse packet filter id. */
 954         pkt_filter.id = 0;
 955         if (!kstrtoul(argv[i], 0, &res))
 956                 pkt_filter.id = (u32)res;
 957
 958         if (NULL == argv[++i]) {
 959                 brcmf_dbg(ERROR, "Polarity not provided\n");
 960                 goto fail;
 961         }
 962
 963         /* Parse filter polarity. */
 964         pkt_filter.negate_match = 0;
 965         if (!kstrtoul(argv[i], 0, &res))
 966                 pkt_filter.negate_match = (u32)res;
 967
 968         if (NULL == argv[++i]) {
 969                 brcmf_dbg(ERROR, "Filter type not provided\n");
 970                 goto fail;
 971         }
 972
 973         /* Parse filter type. */
 974         pkt_filter.type = 0;
 975         if (!kstrtoul(argv[i], 0, &res))
 976                 pkt_filter.type = (u32)res;
 977
 978         if (NULL == argv[++i]) {
 979                 brcmf_dbg(ERROR, "Offset not provided\n");
 980                 goto fail;
 981         }
 982
 983         /* Parse pattern filter offset. */
 984         pkt_filter.u.pattern.offset = 0;
 985         if (!kstrtoul(argv[i], 0, &res))
 986                 pkt_filter.u.pattern.offset = (u32)res;
 987
 988         if (NULL == argv[++i]) {
 989                 brcmf_dbg(ERROR, "Bitmask not provided\n");
 990                 goto fail;
 991         }
 992
 993         /* Parse pattern filter mask. */
 994         mask_size =
 995             brcmf_c_pattern_atoh
 996                    (argv[i], (char *)pkt_filterp->u.pattern.mask_and_pattern);
 997
 998         if (NULL == argv[++i]) {
 999                 brcmf_dbg(ERROR, "Pattern not provided\n");
1000                 goto fail;
1001         }
1002
1003         /* Parse pattern filter pattern. */
1004         pattern_size =
1005             brcmf_c_pattern_atoh(argv[i],
1006                                    (char *)&pkt_filterp->u.pattern.
1007                                    mask_and_pattern[mask_size]);
1008
1009         if (mask_size != pattern_size) {
1010                 brcmf_dbg(ERROR, "Mask and pattern not the same size\n");
1011                 goto fail;
1012         }
1013
1014         pkt_filter.u.pattern.size_bytes = mask_size;
1015         buf_len += BRCMF_PKT_FILTER_FIXED_LEN;
1016         buf_len += (BRCMF_PKT_FILTER_PATTERN_FIXED_LEN + 2 * mask_size);
1017
1018         /* Keep-alive attributes are set in local
1019          * variable (keep_alive_pkt), and
1020          ** then memcpy'ed into buffer (keep_alive_pktp) since there is no
1021          ** guarantee that the buffer is properly aligned.
1022          */
1023         memcpy((char *)pkt_filterp,
1024                &pkt_filter,
1025                BRCMF_PKT_FILTER_FIXED_LEN + BRCMF_PKT_FILTER_PATTERN_FIXED_LEN);
1026
1027         rc = brcmf_proto_cdc_set_ioctl(drvr, 0, BRCMF_C_SET_VAR, buf, buf_len);
1028         rc = rc >= 0 ? 0 : rc;
1029
1030         if (rc)
1031                 brcmf_dbg(TRACE, "failed to add pktfilter %s, retcode = %d\n",
1032                           arg, rc);
1033         else
1034                 brcmf_dbg(TRACE, "successfully added pktfilter %s\n", arg);
1035
1036 fail:
1037         kfree(arg_org);
1038
1039         kfree(buf);
1040 }
1041
1042 static void brcmf_c_arp_offload_set(struct brcmf_pub *drvr, int arp_mode)
1043 {
1044         char iovbuf[32];
1045         int retcode;
1046
1047         brcmu_mkiovar("arp_ol", (char *)&arp_mode, 4, iovbuf, sizeof(iovbuf));
1048         retcode = brcmf_proto_cdc_set_ioctl(drvr, 0, BRCMF_C_SET_VAR,
1049                                    iovbuf, sizeof(iovbuf));
1050         retcode = retcode >= 0 ? 0 : retcode;
1051         if (retcode)
1052                 brcmf_dbg(TRACE, "failed to set ARP offload mode to 0x%x, retcode = %d\n",
1053                           arp_mode, retcode);
1054         else
1055                 brcmf_dbg(TRACE, "successfully set ARP offload mode to 0x%x\n",
1056                           arp_mode);
1057 }
1058
1059 static void brcmf_c_arp_offload_enable(struct brcmf_pub *drvr, int arp_enable)
1060 {
1061         char iovbuf[32];
1062         int retcode;
1063
1064         brcmu_mkiovar("arpoe", (char *)&arp_enable, 4, iovbuf, sizeof(iovbuf));
1065         retcode = brcmf_proto_cdc_set_ioctl(drvr, 0, BRCMF_C_SET_VAR,
1066                                    iovbuf, sizeof(iovbuf));
1067         retcode = retcode >= 0 ? 0 : retcode;
1068         if (retcode)
1069                 brcmf_dbg(TRACE, "failed to enable ARP offload to %d, retcode = %d\n",
1070                           arp_enable, retcode);
1071         else
1072                 brcmf_dbg(TRACE, "successfully enabled ARP offload to %d\n",
1073                           arp_enable);
1074 }
1075
1076 int brcmf_c_preinit_ioctls(struct brcmf_pub *drvr)
1077 {
1078         char iovbuf[BRCMF_EVENTING_MASK_LEN + 12];      /*  Room for
1079                                  "event_msgs" + '\0' + bitvec  */
1080         uint up = 0;
1081         char buf[128], *ptr;
1082         u32 dongle_align = BRCMF_SDALIGN;
1083         u32 glom = 0;
1084         uint bcn_timeout = 3;
1085         int scan_assoc_time = 40;
1086         int scan_unassoc_time = 40;
1087         int i;
1088
1089         brcmf_os_proto_block(drvr);
1090
1091         /* Set Country code */
1092         if (drvr->country_code[0] != 0) {
1093                 if (brcmf_proto_cdc_set_ioctl(drvr, 0, BRCMF_C_SET_COUNTRY,
1094                                               drvr->country_code,
1095                                               sizeof(drvr->country_code)) < 0)
1096                         brcmf_dbg(ERROR, "country code setting failed\n");
1097         }
1098
1099         /* query for 'ver' to get version info from firmware */
1100         memset(buf, 0, sizeof(buf));
1101         ptr = buf;
1102         brcmu_mkiovar("ver", 0, 0, buf, sizeof(buf));
1103         brcmf_proto_cdc_query_ioctl(drvr, 0, BRCMF_C_GET_VAR, buf, sizeof(buf));
1104         strsep(&ptr, "\n");
1105         /* Print fw version info */
1106         brcmf_dbg(ERROR, "Firmware version = %s\n", buf);
1107
1108         /* Match Host and Dongle rx alignment */
1109         brcmu_mkiovar("bus:txglomalign", (char *)&dongle_align, 4, iovbuf,
1110                     sizeof(iovbuf));
1111         brcmf_proto_cdc_set_ioctl(drvr, 0, BRCMF_C_SET_VAR, iovbuf,
1112                                   sizeof(iovbuf));
1113
1114         /* disable glom option per default */
1115         brcmu_mkiovar("bus:txglom", (char *)&glom, 4, iovbuf, sizeof(iovbuf));
1116         brcmf_proto_cdc_set_ioctl(drvr, 0, BRCMF_C_SET_VAR, iovbuf,
1117                                   sizeof(iovbuf));
1118
1119         /* Setup timeout if Beacons are lost and roam is off to report
1120                  link down */
1121         brcmu_mkiovar("bcn_timeout", (char *)&bcn_timeout, 4, iovbuf,
1122                     sizeof(iovbuf));
1123         brcmf_proto_cdc_set_ioctl(drvr, 0, BRCMF_C_SET_VAR, iovbuf,
1124                                   sizeof(iovbuf));
1125
1126         /* Enable/Disable build-in roaming to allowed ext supplicant to take
1127                  of romaing */
1128         brcmu_mkiovar("roam_off", (char *)&brcmf_roam, 4,
1129                       iovbuf, sizeof(iovbuf));
1130         brcmf_proto_cdc_set_ioctl(drvr, 0, BRCMF_C_SET_VAR, iovbuf,
1131                                   sizeof(iovbuf));
1132
1133         /* Force STA UP */
1134         if (brcmf_radio_up)
1135                 brcmf_proto_cdc_set_ioctl(drvr, 0, BRCMF_C_UP, (char *)&up,
1136                                           sizeof(up));
1137
1138         /* Setup event_msgs */
1139         brcmu_mkiovar("event_msgs", drvr->eventmask, BRCMF_EVENTING_MASK_LEN,
1140                       iovbuf, sizeof(iovbuf));
1141         brcmf_proto_cdc_set_ioctl(drvr, 0, BRCMF_C_SET_VAR, iovbuf,
1142                                   sizeof(iovbuf));
1143
1144         brcmf_proto_cdc_set_ioctl(drvr, 0, BRCMF_C_SET_SCAN_CHANNEL_TIME,
1145                          (char *)&scan_assoc_time, sizeof(scan_assoc_time));
1146         brcmf_proto_cdc_set_ioctl(drvr, 0, BRCMF_C_SET_SCAN_UNASSOC_TIME,
1147                          (char *)&scan_unassoc_time, sizeof(scan_unassoc_time));
1148
1149         /* Set and enable ARP offload feature */
1150         if (brcmf_arp_enable)
1151                 brcmf_c_arp_offload_set(drvr, brcmf_arp_mode);
1152         brcmf_c_arp_offload_enable(drvr, brcmf_arp_enable);
1153
1154         /* Set up pkt filter */
1155         if (brcmf_pkt_filter_enable) {
1156                 for (i = 0; i < drvr->pktfilter_count; i++) {
1157                         brcmf_c_pktfilter_offload_set(drvr,
1158                                                   drvr->pktfilter[i]);
1159                         brcmf_c_pktfilter_offload_enable(drvr,
1160                              drvr->pktfilter[i],
1161                              brcmf_pkt_filter_init,
1162                              brcmf_master_mode);
1163                 }
1164         }
1165
1166         brcmf_os_proto_unblock(drvr);
1167
1168         return 0;
1169 }