drivers/net/wireless/brcm80211/brcmfmac/core.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
  17 #include <linux/kernel.h>
  18 #include <linux/etherdevice.h>
  19 #include <linux/module.h>
  20 #include <net/cfg80211.h>
  21 #include <net/rtnetlink.h>
  22 #include <brcmu_utils.h>
  23 #include <brcmu_wifi.h>
  24
  25 #include "core.h"
  26 #include "bus.h"
  27 #include "debug.h"
  28 #include "fwil_types.h"
  29 #include "p2p.h"
  30 #include "cfg80211.h"
  31 #include "fwil.h"
  32 #include "fwsignal.h"
  33 #include "feature.h"
  34 #include "proto.h"
  35 #include "pcie.h"
  36 #include "common.h"
  37
  38 MODULE_AUTHOR("Broadcom Corporation");
  39 MODULE_DESCRIPTION("Broadcom 802.11 wireless LAN fullmac driver.");
  40 MODULE_LICENSE("Dual BSD/GPL");
  41
  42 #define MAX_WAIT_FOR_8021X_TX           50      /* msecs */
  43
  44 /* AMPDU rx reordering definitions */
  45 #define BRCMF_RXREORDER_FLOWID_OFFSET           0
  46 #define BRCMF_RXREORDER_MAXIDX_OFFSET           2
  47 #define BRCMF_RXREORDER_FLAGS_OFFSET            4
  48 #define BRCMF_RXREORDER_CURIDX_OFFSET           6
  49 #define BRCMF_RXREORDER_EXPIDX_OFFSET           8
  50
  51 #define BRCMF_RXREORDER_DEL_FLOW                0x01
  52 #define BRCMF_RXREORDER_FLUSH_ALL               0x02
  53 #define BRCMF_RXREORDER_CURIDX_VALID            0x04
  54 #define BRCMF_RXREORDER_EXPIDX_VALID            0x08
  55 #define BRCMF_RXREORDER_NEW_HOLE                0x10
  56
  57 #define BRCMF_BSSIDX_INVALID                    -1
  58
  59 /* Error bits */
  60 int brcmf_msg_level;
  61 module_param_named(debug, brcmf_msg_level, int, S_IRUSR | S_IWUSR);
  62 MODULE_PARM_DESC(debug, "level of debug output");
  63
  64 /* P2P0 enable */
  65 static int brcmf_p2p_enable;
  66 module_param_named(p2pon, brcmf_p2p_enable, int, 0);
  67 MODULE_PARM_DESC(p2pon, "enable legacy p2p management functionality");
  68
  69 char *brcmf_ifname(struct brcmf_pub *drvr, int ifidx)
  70 {
  71         if (ifidx < 0 || ifidx >= BRCMF_MAX_IFS) {
  72                 brcmf_err("ifidx %d out of range\n", ifidx);
  73                 return "<if_bad>";
  74         }
  75
  76         if (drvr->iflist[ifidx] == NULL) {
  77                 brcmf_err("null i/f %d\n", ifidx);
  78                 return "<if_null>";
  79         }
  80
  81         if (drvr->iflist[ifidx]->ndev)
  82                 return drvr->iflist[ifidx]->ndev->name;
  83
  84         return "<if_none>";
  85 }
  86
  87 struct brcmf_if *brcmf_get_ifp(struct brcmf_pub *drvr, int ifidx)
  88 {
  89         struct brcmf_if *ifp;
  90         s32 bssidx;
  91
  92         if (ifidx < 0 || ifidx >= BRCMF_MAX_IFS) {
  93                 brcmf_err("ifidx %d out of range\n", ifidx);
  94                 return NULL;
  95         }
  96
  97         ifp = NULL;
  98         bssidx = drvr->if2bss[ifidx];
  99         if (bssidx >= 0)
 100                 ifp = drvr->iflist[bssidx];
 101
 102         return ifp;
 103 }
 104
 105 static void _brcmf_set_multicast_list(struct work_struct *work)
 106 {
 107         struct brcmf_if *ifp;
 108         struct net_device *ndev;
 109         struct netdev_hw_addr *ha;
 110         u32 cmd_value, cnt;
 111         __le32 cnt_le;
 112         char *buf, *bufp;
 113         u32 buflen;
 114         s32 err;
 115
 116         ifp = container_of(work, struct brcmf_if, multicast_work);
 117
 118         brcmf_dbg(TRACE, "Enter, idx=%d\n", ifp->bssidx);
 119
 120         ndev = ifp->ndev;
 121
 122         /* Determine initial value of allmulti flag */
 123         cmd_value = (ndev->flags & IFF_ALLMULTI) ? true : false;
 124
 125         /* Send down the multicast list first. */
 126         cnt = netdev_mc_count(ndev);
 127         buflen = sizeof(cnt) + (cnt * ETH_ALEN);
 128         buf = kmalloc(buflen, GFP_ATOMIC);
 129         if (!buf)
 130                 return;
 131         bufp = buf;
 132
 133         cnt_le = cpu_to_le32(cnt);
 134         memcpy(bufp, &cnt_le, sizeof(cnt_le));
 135         bufp += sizeof(cnt_le);
 136
 137         netdev_for_each_mc_addr(ha, ndev) {
 138                 if (!cnt)
 139                         break;
 140                 memcpy(bufp, ha->addr, ETH_ALEN);
 141                 bufp += ETH_ALEN;
 142                 cnt--;
 143         }
 144
 145         err = brcmf_fil_iovar_data_set(ifp, "mcast_list", buf, buflen);
 146         if (err < 0) {
 147                 brcmf_err("Setting mcast_list failed, %d\n", err);
 148                 cmd_value = cnt ? true : cmd_value;
 149         }
 150
 151         kfree(buf);
 152
 153         /*
 154          * Now send the allmulti setting.  This is based on the setting in the
 155          * net_device flags, but might be modified above to be turned on if we
 156          * were trying to set some addresses and dongle rejected it...
 157          */
 158         err = brcmf_fil_iovar_int_set(ifp, "allmulti", cmd_value);
 159         if (err < 0)
 160                 brcmf_err("Setting allmulti failed, %d\n", err);
 161
 162         /*Finally, pick up the PROMISC flag */
 163         cmd_value = (ndev->flags & IFF_PROMISC) ? true : false;
 164         err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PROMISC, cmd_value);
 165         if (err < 0)
 166                 brcmf_err("Setting BRCMF_C_SET_PROMISC failed, %d\n",
 167                           err);
 168 }
 169
 170 static void
 171 _brcmf_set_mac_address(struct work_struct *work)
 172 {
 173         struct brcmf_if *ifp;
 174         s32 err;
 175
 176         ifp = container_of(work, struct brcmf_if, setmacaddr_work);
 177
 178         brcmf_dbg(TRACE, "Enter, idx=%d\n", ifp->bssidx);
 179
 180         err = brcmf_fil_iovar_data_set(ifp, "cur_etheraddr", ifp->mac_addr,
 181                                        ETH_ALEN);
 182         if (err < 0) {
 183                 brcmf_err("Setting cur_etheraddr failed, %d\n", err);
 184         } else {
 185                 brcmf_dbg(TRACE, "MAC address updated to %pM\n",
 186                           ifp->mac_addr);
 187                 memcpy(ifp->ndev->dev_addr, ifp->mac_addr, ETH_ALEN);
 188         }
 189 }
 190
 191 static int brcmf_netdev_set_mac_address(struct net_device *ndev, void *addr)
 192 {
 193         struct brcmf_if *ifp = netdev_priv(ndev);
 194         struct sockaddr *sa = (struct sockaddr *)addr;
 195
 196         memcpy(&ifp->mac_addr, sa->sa_data, ETH_ALEN);
 197         schedule_work(&ifp->setmacaddr_work);
 198         return 0;
 199 }
 200
 201 static void brcmf_netdev_set_multicast_list(struct net_device *ndev)
 202 {
 203         struct brcmf_if *ifp = netdev_priv(ndev);
 204
 205         schedule_work(&ifp->multicast_work);
 206 }
 207
 208 static netdev_tx_t brcmf_netdev_start_xmit(struct sk_buff *skb,
 209                                            struct net_device *ndev)
 210 {
 211         int ret;
 212         struct brcmf_if *ifp = netdev_priv(ndev);
 213         struct brcmf_pub *drvr = ifp->drvr;
 214         struct ethhdr *eh = (struct ethhdr *)(skb->data);
 215
 216         brcmf_dbg(DATA, "Enter, idx=%d\n", ifp->bssidx);
 217
 218         /* Can the device send data? */
 219         if (drvr->bus_if->state != BRCMF_BUS_UP) {
 220                 brcmf_err("xmit rejected state=%d\n", drvr->bus_if->state);
 221                 netif_stop_queue(ndev);
 222                 dev_kfree_skb(skb);
 223                 ret = -ENODEV;
 224                 goto done;
 225         }
 226
 227         if (!drvr->iflist[ifp->bssidx]) {
 228                 brcmf_err("bad ifidx %d\n", ifp->bssidx);
 229                 netif_stop_queue(ndev);
 230                 dev_kfree_skb(skb);
 231                 ret = -ENODEV;
 232                 goto done;
 233         }
 234
 235         /* Make sure there's enough room for any header */
 236         if (skb_headroom(skb) < drvr->hdrlen) {
 237                 struct sk_buff *skb2;
 238
 239                 brcmf_dbg(INFO, "%s: insufficient headroom\n",
 240                           brcmf_ifname(drvr, ifp->bssidx));
 241                 drvr->bus_if->tx_realloc++;
 242                 skb2 = skb_realloc_headroom(skb, drvr->hdrlen);
 243                 dev_kfree_skb(skb);
 244                 skb = skb2;
 245                 if (skb == NULL) {
 246                         brcmf_err("%s: skb_realloc_headroom failed\n",
 247                                   brcmf_ifname(drvr, ifp->bssidx));
 248                         ret = -ENOMEM;
 249                         goto done;
 250                 }
 251         }
 252
 253         /* validate length for ether packet */
 254         if (skb->len < sizeof(*eh)) {
 255                 ret = -EINVAL;
 256                 dev_kfree_skb(skb);
 257                 goto done;
 258         }
 259
 260         if (eh->h_proto == htons(ETH_P_PAE))
 261                 atomic_inc(&ifp->pend_8021x_cnt);
 262
 263         ret = brcmf_fws_process_skb(ifp, skb);
 264
 265 done:
 266         if (ret) {
 267                 ifp->stats.tx_dropped++;
 268         } else {
 269                 ifp->stats.tx_packets++;
 270                 ifp->stats.tx_bytes += skb->len;
 271         }
 272
 273         /* Return ok: we always eat the packet */
 274         return NETDEV_TX_OK;
 275 }
 276
 277 void brcmf_txflowblock_if(struct brcmf_if *ifp,
 278                           enum brcmf_netif_stop_reason reason, bool state)
 279 {
 280         unsigned long flags;
 281
 282         if (!ifp || !ifp->ndev)
 283                 return;
 284
 285         brcmf_dbg(TRACE, "enter: idx=%d stop=0x%X reason=%d state=%d\n",
 286                   ifp->bssidx, ifp->netif_stop, reason, state);
 287
 288         spin_lock_irqsave(&ifp->netif_stop_lock, flags);
 289         if (state) {
 290                 if (!ifp->netif_stop)
 291                         netif_stop_queue(ifp->ndev);
 292                 ifp->netif_stop |= reason;
 293         } else {
 294                 ifp->netif_stop &= ~reason;
 295                 if (!ifp->netif_stop)
 296                         netif_wake_queue(ifp->ndev);
 297         }
 298         spin_unlock_irqrestore(&ifp->netif_stop_lock, flags);
 299 }
 300
 301 void brcmf_txflowblock(struct device *dev, bool state)
 302 {
 303         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
 304         struct brcmf_pub *drvr = bus_if->drvr;
 305
 306         brcmf_dbg(TRACE, "Enter\n");
 307
 308         brcmf_fws_bus_blocked(drvr, state);
 309 }
 310
 311 void brcmf_netif_rx(struct brcmf_if *ifp, struct sk_buff *skb)
 312 {
 313         skb->dev = ifp->ndev;
 314         skb->protocol = eth_type_trans(skb, skb->dev);
 315
 316         if (skb->pkt_type == PACKET_MULTICAST)
 317                 ifp->stats.multicast++;
 318
 319         /* Process special event packets */
 320         brcmf_fweh_process_skb(ifp->drvr, skb);
 321
 322         if (!(ifp->ndev->flags & IFF_UP)) {
 323                 brcmu_pkt_buf_free_skb(skb);
 324                 return;
 325         }
 326
 327         ifp->stats.rx_bytes += skb->len;
 328         ifp->stats.rx_packets++;
 329
 330         brcmf_dbg(DATA, "rx proto=0x%X\n", ntohs(skb->protocol));
 331         if (in_interrupt())
 332                 netif_rx(skb);
 333         else
 334                 /* If the receive is not processed inside an ISR,
 335                  * the softirqd must be woken explicitly to service
 336                  * the NET_RX_SOFTIRQ.  This is handled by netif_rx_ni().
 337                  */
 338                 netif_rx_ni(skb);
 339 }
 340
 341 static void brcmf_rxreorder_get_skb_list(struct brcmf_ampdu_rx_reorder *rfi,
 342                                          u8 start, u8 end,
 343                                          struct sk_buff_head *skb_list)
 344 {
 345         /* initialize return list */
 346         __skb_queue_head_init(skb_list);
 347
 348         if (rfi->pend_pkts == 0) {
 349                 brcmf_dbg(INFO, "no packets in reorder queue\n");
 350                 return;
 351         }
 352
 353         do {
 354                 if (rfi->pktslots[start]) {
 355                         __skb_queue_tail(skb_list, rfi->pktslots[start]);
 356                         rfi->pktslots[start] = NULL;
 357                 }
 358                 start++;
 359                 if (start > rfi->max_idx)
 360                         start = 0;
 361         } while (start != end);
 362         rfi->pend_pkts -= skb_queue_len(skb_list);
 363 }
 364
 365 static void brcmf_rxreorder_process_info(struct brcmf_if *ifp, u8 *reorder_data,
 366                                          struct sk_buff *pkt)
 367 {
 368         u8 flow_id, max_idx, cur_idx, exp_idx, end_idx;
 369         struct brcmf_ampdu_rx_reorder *rfi;
 370         struct sk_buff_head reorder_list;
 371         struct sk_buff *pnext;
 372         u8 flags;
 373         u32 buf_size;
 374
 375         flow_id = reorder_data[BRCMF_RXREORDER_FLOWID_OFFSET];
 376         flags = reorder_data[BRCMF_RXREORDER_FLAGS_OFFSET];
 377
 378         /* validate flags and flow id */
 379         if (flags == 0xFF) {
 380                 brcmf_err("invalid flags...so ignore this packet\n");
 381                 brcmf_netif_rx(ifp, pkt);
 382                 return;
 383         }
 384
 385         rfi = ifp->drvr->reorder_flows[flow_id];
 386         if (flags & BRCMF_RXREORDER_DEL_FLOW) {
 387                 brcmf_dbg(INFO, "flow-%d: delete\n",
 388                           flow_id);
 389
 390                 if (rfi == NULL) {
 391                         brcmf_dbg(INFO, "received flags to cleanup, but no flow (%d) yet\n",
 392                                   flow_id);
 393                         brcmf_netif_rx(ifp, pkt);
 394                         return;
 395                 }
 396
 397                 brcmf_rxreorder_get_skb_list(rfi, rfi->exp_idx, rfi->exp_idx,
 398                                              &reorder_list);
 399                 /* add the last packet */
 400                 __skb_queue_tail(&reorder_list, pkt);
 401                 kfree(rfi);
 402                 ifp->drvr->reorder_flows[flow_id] = NULL;
 403                 goto netif_rx;
 404         }
 405         /* from here on we need a flow reorder instance */
 406         if (rfi == NULL) {
 407                 buf_size = sizeof(*rfi);
 408                 max_idx = reorder_data[BRCMF_RXREORDER_MAXIDX_OFFSET];
 409
 410                 buf_size += (max_idx + 1) * sizeof(pkt);
 411
 412                 /* allocate space for flow reorder info */
 413                 brcmf_dbg(INFO, "flow-%d: start, maxidx %d\n",
 414                           flow_id, max_idx);
 415                 rfi = kzalloc(buf_size, GFP_ATOMIC);
 416                 if (rfi == NULL) {
 417                         brcmf_err("failed to alloc buffer\n");
 418                         brcmf_netif_rx(ifp, pkt);
 419                         return;
 420                 }
 421
 422                 ifp->drvr->reorder_flows[flow_id] = rfi;
 423                 rfi->pktslots = (struct sk_buff **)(rfi+1);
 424                 rfi->max_idx = max_idx;
 425         }
 426         if (flags & BRCMF_RXREORDER_NEW_HOLE)  {
 427                 if (rfi->pend_pkts) {
 428                         brcmf_rxreorder_get_skb_list(rfi, rfi->exp_idx,
 429                                                      rfi->exp_idx,
 430                                                      &reorder_list);
 431                         WARN_ON(rfi->pend_pkts);
 432                 } else {
 433                         __skb_queue_head_init(&reorder_list);
 434                 }
 435                 rfi->cur_idx = reorder_data[BRCMF_RXREORDER_CURIDX_OFFSET];
 436                 rfi->exp_idx = reorder_data[BRCMF_RXREORDER_EXPIDX_OFFSET];
 437                 rfi->max_idx = reorder_data[BRCMF_RXREORDER_MAXIDX_OFFSET];
 438                 rfi->pktslots[rfi->cur_idx] = pkt;
 439                 rfi->pend_pkts++;
 440                 brcmf_dbg(DATA, "flow-%d: new hole %d (%d), pending %d\n",
 441                           flow_id, rfi->cur_idx, rfi->exp_idx, rfi->pend_pkts);
 442         } else if (flags & BRCMF_RXREORDER_CURIDX_VALID) {
 443                 cur_idx = reorder_data[BRCMF_RXREORDER_CURIDX_OFFSET];
 444                 exp_idx = reorder_data[BRCMF_RXREORDER_EXPIDX_OFFSET];
 445
 446                 if ((exp_idx == rfi->exp_idx) && (cur_idx != rfi->exp_idx)) {
 447                         /* still in the current hole */
 448                         /* enqueue the current on the buffer chain */
 449                         if (rfi->pktslots[cur_idx] != NULL) {
 450                                 brcmf_dbg(INFO, "HOLE: ERROR buffer pending..free it\n");
 451                                 brcmu_pkt_buf_free_skb(rfi->pktslots[cur_idx]);
 452                                 rfi->pktslots[cur_idx] = NULL;
 453                         }
 454                         rfi->pktslots[cur_idx] = pkt;
 455                         rfi->pend_pkts++;
 456                         rfi->cur_idx = cur_idx;
 457                         brcmf_dbg(DATA, "flow-%d: store pkt %d (%d), pending %d\n",
 458                                   flow_id, cur_idx, exp_idx, rfi->pend_pkts);
 459
 460                         /* can return now as there is no reorder
 461                          * list to process.
 462                          */
 463                         return;
 464                 }
 465                 if (rfi->exp_idx == cur_idx) {
 466                         if (rfi->pktslots[cur_idx] != NULL) {
 467                                 brcmf_dbg(INFO, "error buffer pending..free it\n");
 468                                 brcmu_pkt_buf_free_skb(rfi->pktslots[cur_idx]);
 469                                 rfi->pktslots[cur_idx] = NULL;
 470                         }
 471                         rfi->pktslots[cur_idx] = pkt;
 472                         rfi->pend_pkts++;
 473
 474                         /* got the expected one. flush from current to expected
 475                          * and update expected
 476                          */
 477                         brcmf_dbg(DATA, "flow-%d: expected %d (%d), pending %d\n",
 478                                   flow_id, cur_idx, exp_idx, rfi->pend_pkts);
 479
 480                         rfi->cur_idx = cur_idx;
 481                         rfi->exp_idx = exp_idx;
 482
 483                         brcmf_rxreorder_get_skb_list(rfi, cur_idx, exp_idx,
 484                                                      &reorder_list);
 485                         brcmf_dbg(DATA, "flow-%d: freeing buffers %d, pending %d\n",
 486                                   flow_id, skb_queue_len(&reorder_list),
 487                                   rfi->pend_pkts);
 488                 } else {
 489                         u8 end_idx;
 490
 491                         brcmf_dbg(DATA, "flow-%d (0x%x): both moved, old %d/%d, new %d/%d\n",
 492                                   flow_id, flags, rfi->cur_idx, rfi->exp_idx,
 493                                   cur_idx, exp_idx);
 494                         if (flags & BRCMF_RXREORDER_FLUSH_ALL)
 495                                 end_idx = rfi->exp_idx;
 496                         else
 497                                 end_idx = exp_idx;
 498
 499                         /* flush pkts first */
 500                         brcmf_rxreorder_get_skb_list(rfi, rfi->exp_idx, end_idx,
 501                                                      &reorder_list);
 502
 503                         if (exp_idx == ((cur_idx + 1) % (rfi->max_idx + 1))) {
 504                                 __skb_queue_tail(&reorder_list, pkt);
 505                         } else {
 506                                 rfi->pktslots[cur_idx] = pkt;
 507                                 rfi->pend_pkts++;
 508                         }
 509                         rfi->exp_idx = exp_idx;
 510                         rfi->cur_idx = cur_idx;
 511                 }
 512         } else {
 513                 /* explicity window move updating the expected index */
 514                 exp_idx = reorder_data[BRCMF_RXREORDER_EXPIDX_OFFSET];
 515
 516                 brcmf_dbg(DATA, "flow-%d (0x%x): change expected: %d -> %d\n",
 517                           flow_id, flags, rfi->exp_idx, exp_idx);
 518                 if (flags & BRCMF_RXREORDER_FLUSH_ALL)
 519                         end_idx =  rfi->exp_idx;
 520                 else
 521                         end_idx =  exp_idx;
 522
 523                 brcmf_rxreorder_get_skb_list(rfi, rfi->exp_idx, end_idx,
 524                                              &reorder_list);
 525                 __skb_queue_tail(&reorder_list, pkt);
 526                 /* set the new expected idx */
 527                 rfi->exp_idx = exp_idx;
 528         }
 529 netif_rx:
 530         skb_queue_walk_safe(&reorder_list, pkt, pnext) {
 531                 __skb_unlink(pkt, &reorder_list);
 532                 brcmf_netif_rx(ifp, pkt);
 533         }
 534 }
 535
 536 void brcmf_rx_frame(struct device *dev, struct sk_buff *skb)
 537 {
 538         struct brcmf_if *ifp;
 539         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
 540         struct brcmf_pub *drvr = bus_if->drvr;
 541         struct brcmf_skb_reorder_data *rd;
 542         int ret;
 543
 544         brcmf_dbg(DATA, "Enter: %s: rxp=%p\n", dev_name(dev), skb);
 545
 546         /* process and remove protocol-specific header */
 547         ret = brcmf_proto_hdrpull(drvr, true, skb, &ifp);
 548
 549         if (ret || !ifp || !ifp->ndev) {
 550                 if (ret != -ENODATA && ifp)
 551                         ifp->stats.rx_errors++;
 552                 brcmu_pkt_buf_free_skb(skb);
 553                 return;
 554         }
 555
 556         rd = (struct brcmf_skb_reorder_data *)skb->cb;
 557         if (rd->reorder)
 558                 brcmf_rxreorder_process_info(ifp, rd->reorder, skb);
 559         else
 560                 brcmf_netif_rx(ifp, skb);
 561 }
 562
 563 void brcmf_txfinalize(struct brcmf_if *ifp, struct sk_buff *txp, bool success)
 564 {
 565         struct ethhdr *eh;
 566         u16 type;
 567
 568         eh = (struct ethhdr *)(txp->data);
 569         type = ntohs(eh->h_proto);
 570
 571         if (type == ETH_P_PAE) {
 572                 atomic_dec(&ifp->pend_8021x_cnt);
 573                 if (waitqueue_active(&ifp->pend_8021x_wait))
 574                         wake_up(&ifp->pend_8021x_wait);
 575         }
 576
 577         if (!success)
 578                 ifp->stats.tx_errors++;
 579
 580         brcmu_pkt_buf_free_skb(txp);
 581 }
 582
 583 void brcmf_txcomplete(struct device *dev, struct sk_buff *txp, bool success)
 584 {
 585         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
 586         struct brcmf_pub *drvr = bus_if->drvr;
 587         struct brcmf_if *ifp;
 588
 589         /* await txstatus signal for firmware if active */
 590         if (brcmf_fws_fc_active(drvr->fws)) {
 591                 if (!success)
 592                         brcmf_fws_bustxfail(drvr->fws, txp);
 593         } else {
 594                 if (brcmf_proto_hdrpull(drvr, false, txp, &ifp))
 595                         brcmu_pkt_buf_free_skb(txp);
 596                 else
 597                         brcmf_txfinalize(ifp, txp, success);
 598         }
 599 }
 600
 601 static struct net_device_stats *brcmf_netdev_get_stats(struct net_device *ndev)
 602 {
 603         struct brcmf_if *ifp = netdev_priv(ndev);
 604
 605         brcmf_dbg(TRACE, "Enter, idx=%d\n", ifp->bssidx);
 606
 607         return &ifp->stats;
 608 }
 609
 610 static void brcmf_ethtool_get_drvinfo(struct net_device *ndev,
 611                                     struct ethtool_drvinfo *info)
 612 {
 613         struct brcmf_if *ifp = netdev_priv(ndev);
 614         struct brcmf_pub *drvr = ifp->drvr;
 615         char drev[BRCMU_DOTREV_LEN] = "n/a";
 616
 617         if (drvr->revinfo.result == 0)
 618                 brcmu_dotrev_str(drvr->revinfo.driverrev, drev);
 619         strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
 620         strlcpy(info->version, drev, sizeof(info->version));
 621         strlcpy(info->fw_version, drvr->fwver, sizeof(info->fw_version));
 622         strlcpy(info->bus_info, dev_name(drvr->bus_if->dev),
 623                 sizeof(info->bus_info));
 624 }
 625
 626 static const struct ethtool_ops brcmf_ethtool_ops = {
 627         .get_drvinfo = brcmf_ethtool_get_drvinfo,
 628 };
 629
 630 static int brcmf_netdev_stop(struct net_device *ndev)
 631 {
 632         struct brcmf_if *ifp = netdev_priv(ndev);
 633
 634         brcmf_dbg(TRACE, "Enter, idx=%d\n", ifp->bssidx);
 635
 636         brcmf_cfg80211_down(ndev);
 637
 638         brcmf_net_setcarrier(ifp, false);
 639
 640         return 0;
 641 }
 642
 643 static int brcmf_netdev_open(struct net_device *ndev)
 644 {
 645         struct brcmf_if *ifp = netdev_priv(ndev);
 646         struct brcmf_pub *drvr = ifp->drvr;
 647         struct brcmf_bus *bus_if = drvr->bus_if;
 648         u32 toe_ol;
 649
 650         brcmf_dbg(TRACE, "Enter, idx=%d\n", ifp->bssidx);
 651
 652         /* If bus is not ready, can't continue */
 653         if (bus_if->state != BRCMF_BUS_UP) {
 654                 brcmf_err("failed bus is not ready\n");
 655                 return -EAGAIN;
 656         }
 657
 658         atomic_set(&ifp->pend_8021x_cnt, 0);
 659
 660         /* Get current TOE mode from dongle */
 661         if (brcmf_fil_iovar_int_get(ifp, "toe_ol", &toe_ol) >= 0
 662             && (toe_ol & TOE_TX_CSUM_OL) != 0)
 663                 ndev->features |= NETIF_F_IP_CSUM;
 664         else
 665                 ndev->features &= ~NETIF_F_IP_CSUM;
 666
 667         if (brcmf_cfg80211_up(ndev)) {
 668                 brcmf_err("failed to bring up cfg80211\n");
 669                 return -EIO;
 670         }
 671
 672         /* Clear, carrier, set when connected or AP mode. */
 673         netif_carrier_off(ndev);
 674         return 0;
 675 }
 676
 677 static const struct net_device_ops brcmf_netdev_ops_pri = {
 678         .ndo_open = brcmf_netdev_open,
 679         .ndo_stop = brcmf_netdev_stop,
 680         .ndo_get_stats = brcmf_netdev_get_stats,
 681         .ndo_start_xmit = brcmf_netdev_start_xmit,
 682         .ndo_set_mac_address = brcmf_netdev_set_mac_address,
 683         .ndo_set_rx_mode = brcmf_netdev_set_multicast_list
 684 };
 685
 686 int brcmf_net_attach(struct brcmf_if *ifp, bool rtnl_locked)
 687 {
 688         struct brcmf_pub *drvr = ifp->drvr;
 689         struct net_device *ndev;
 690         s32 err;
 691
 692         brcmf_dbg(TRACE, "Enter, idx=%d mac=%pM\n", ifp->bssidx,
 693                   ifp->mac_addr);
 694         ndev = ifp->ndev;
 695
 696         /* set appropriate operations */
 697         ndev->netdev_ops = &brcmf_netdev_ops_pri;
 698
 699         ndev->hard_header_len += drvr->hdrlen;
 700         ndev->ethtool_ops = &brcmf_ethtool_ops;
 701
 702         drvr->rxsz = ndev->mtu + ndev->hard_header_len +
 703                               drvr->hdrlen;
 704
 705         /* set the mac address */
 706         memcpy(ndev->dev_addr, ifp->mac_addr, ETH_ALEN);
 707
 708         INIT_WORK(&ifp->setmacaddr_work, _brcmf_set_mac_address);
 709         INIT_WORK(&ifp->multicast_work, _brcmf_set_multicast_list);
 710
 711         if (rtnl_locked)
 712                 err = register_netdevice(ndev);
 713         else
 714                 err = register_netdev(ndev);
 715         if (err != 0) {
 716                 brcmf_err("couldn't register the net device\n");
 717                 goto fail;
 718         }
 719
 720         brcmf_dbg(INFO, "%s: Broadcom Dongle Host Driver\n", ndev->name);
 721         return 0;
 722
 723 fail:
 724         drvr->iflist[ifp->bssidx] = NULL;
 725         ndev->netdev_ops = NULL;
 726         free_netdev(ndev);
 727         return -EBADE;
 728 }
 729
 730 static void brcmf_net_detach(struct net_device *ndev)
 731 {
 732         if (ndev->reg_state == NETREG_REGISTERED)
 733                 unregister_netdev(ndev);
 734         else
 735                 brcmf_cfg80211_free_netdev(ndev);
 736 }
 737
 738 void brcmf_net_setcarrier(struct brcmf_if *ifp, bool on)
 739 {
 740         struct net_device *ndev;
 741
 742         brcmf_dbg(TRACE, "Enter, idx=%d carrier=%d\n", ifp->bssidx, on);
 743
 744         ndev = ifp->ndev;
 745         brcmf_txflowblock_if(ifp, BRCMF_NETIF_STOP_REASON_DISCONNECTED, !on);
 746         if (on) {
 747                 if (!netif_carrier_ok(ndev))
 748                         netif_carrier_on(ndev);
 749
 750         } else {
 751                 if (netif_carrier_ok(ndev))
 752                         netif_carrier_off(ndev);
 753         }
 754 }
 755
 756 static int brcmf_net_p2p_open(struct net_device *ndev)
 757 {
 758         brcmf_dbg(TRACE, "Enter\n");
 759
 760         return brcmf_cfg80211_up(ndev);
 761 }
 762
 763 static int brcmf_net_p2p_stop(struct net_device *ndev)
 764 {
 765         brcmf_dbg(TRACE, "Enter\n");
 766
 767         return brcmf_cfg80211_down(ndev);
 768 }
 769
 770 static netdev_tx_t brcmf_net_p2p_start_xmit(struct sk_buff *skb,
 771                                             struct net_device *ndev)
 772 {
 773         if (skb)
 774                 dev_kfree_skb_any(skb);
 775
 776         return NETDEV_TX_OK;
 777 }
 778
 779 static const struct net_device_ops brcmf_netdev_ops_p2p = {
 780         .ndo_open = brcmf_net_p2p_open,
 781         .ndo_stop = brcmf_net_p2p_stop,
 782         .ndo_start_xmit = brcmf_net_p2p_start_xmit
 783 };
 784
 785 static int brcmf_net_p2p_attach(struct brcmf_if *ifp)
 786 {
 787         struct net_device *ndev;
 788
 789         brcmf_dbg(TRACE, "Enter, idx=%d mac=%pM\n", ifp->bssidx,
 790                   ifp->mac_addr);
 791         ndev = ifp->ndev;
 792
 793         ndev->netdev_ops = &brcmf_netdev_ops_p2p;
 794
 795         /* set the mac address */
 796         memcpy(ndev->dev_addr, ifp->mac_addr, ETH_ALEN);
 797
 798         if (register_netdev(ndev) != 0) {
 799                 brcmf_err("couldn't register the p2p net device\n");
 800                 goto fail;
 801         }
 802
 803         brcmf_dbg(INFO, "%s: Broadcom Dongle Host Driver\n", ndev->name);
 804
 805         return 0;
 806
 807 fail:
 808         ifp->drvr->iflist[ifp->bssidx] = NULL;
 809         ndev->netdev_ops = NULL;
 810         free_netdev(ndev);
 811         return -EBADE;
 812 }
 813
 814 struct brcmf_if *brcmf_add_if(struct brcmf_pub *drvr, s32 bssidx, s32 ifidx,
 815                               bool is_p2pdev, char *name, u8 *mac_addr)
 816 {
 817         struct brcmf_if *ifp;
 818         struct net_device *ndev;
 819
 820         brcmf_dbg(TRACE, "Enter, idx=%d, ifidx=%d\n", bssidx, ifidx);
 821
 822         ifp = drvr->iflist[bssidx];
 823         /*
 824          * Delete the existing interface before overwriting it
 825          * in case we missed the BRCMF_E_IF_DEL event.
 826          */
 827         if (ifp) {
 828                 brcmf_err("ERROR: netdev:%s already exists\n",
 829                           ifp->ndev->name);
 830                 if (ifidx) {
 831                         netif_stop_queue(ifp->ndev);
 832                         brcmf_net_detach(ifp->ndev);
 833                         drvr->iflist[bssidx] = NULL;
 834                 } else {
 835                         brcmf_err("ignore IF event\n");
 836                         return ERR_PTR(-EINVAL);
 837                 }
 838         }
 839
 840         if (!brcmf_p2p_enable && is_p2pdev) {
 841                 /* this is P2P_DEVICE interface */
 842                 brcmf_dbg(INFO, "allocate non-netdev interface\n");
 843                 ifp = kzalloc(sizeof(*ifp), GFP_KERNEL);
 844                 if (!ifp)
 845                         return ERR_PTR(-ENOMEM);
 846         } else {
 847                 brcmf_dbg(INFO, "allocate netdev interface\n");
 848                 /* Allocate netdev, including space for private structure */
 849                 ndev = alloc_netdev(sizeof(*ifp), is_p2pdev ? "p2p%d" : name,
 850                                     NET_NAME_UNKNOWN, ether_setup);
 851                 if (!ndev)
 852                         return ERR_PTR(-ENOMEM);
 853
 854                 ndev->destructor = brcmf_cfg80211_free_netdev;
 855                 ifp = netdev_priv(ndev);
 856                 ifp->ndev = ndev;
 857                 /* store mapping ifidx to bssidx */
 858                 if (drvr->if2bss[ifidx] == BRCMF_BSSIDX_INVALID)
 859                         drvr->if2bss[ifidx] = bssidx;
 860         }
 861
 862         ifp->drvr = drvr;
 863         drvr->iflist[bssidx] = ifp;
 864         ifp->ifidx = ifidx;
 865         ifp->bssidx = bssidx;
 866
 867         init_waitqueue_head(&ifp->pend_8021x_wait);
 868         spin_lock_init(&ifp->netif_stop_lock);
 869
 870         if (mac_addr != NULL)
 871                 memcpy(ifp->mac_addr, mac_addr, ETH_ALEN);
 872
 873         brcmf_dbg(TRACE, " ==== pid:%x, if:%s (%pM) created ===\n",
 874                   current->pid, name, ifp->mac_addr);
 875
 876         return ifp;
 877 }
 878
 879 static void brcmf_del_if(struct brcmf_pub *drvr, s32 bssidx)
 880 {
 881         struct brcmf_if *ifp;
 882
 883         ifp = drvr->iflist[bssidx];
 884         drvr->iflist[bssidx] = NULL;
 885         if (!ifp) {
 886                 brcmf_err("Null interface, idx=%d\n", bssidx);
 887                 return;
 888         }
 889         brcmf_dbg(TRACE, "Enter, idx=%d, ifidx=%d\n", bssidx, ifp->ifidx);
 890         if (drvr->if2bss[ifp->ifidx] == bssidx)
 891                 drvr->if2bss[ifp->ifidx] = BRCMF_BSSIDX_INVALID;
 892         if (ifp->ndev) {
 893                 if (bssidx == 0) {
 894                         if (ifp->ndev->netdev_ops == &brcmf_netdev_ops_pri) {
 895                                 rtnl_lock();
 896                                 brcmf_netdev_stop(ifp->ndev);
 897                                 rtnl_unlock();
 898                         }
 899                 } else {
 900                         netif_stop_queue(ifp->ndev);
 901                 }
 902
 903                 if (ifp->ndev->netdev_ops == &brcmf_netdev_ops_pri) {
 904                         cancel_work_sync(&ifp->setmacaddr_work);
 905                         cancel_work_sync(&ifp->multicast_work);
 906                 }
 907                 brcmf_net_detach(ifp->ndev);
 908         } else {
 909                 /* Only p2p device interfaces which get dynamically created
 910                  * end up here. In this case the p2p module should be informed
 911                  * about the removal of the interface within the firmware. If
 912                  * not then p2p commands towards the firmware will cause some
 913                  * serious troublesome side effects. The p2p module will clean
 914                  * up the ifp if needed.
 915                  */
 916                 brcmf_p2p_ifp_removed(ifp);
 917                 kfree(ifp);
 918         }
 919 }
 920
 921 void brcmf_remove_interface(struct brcmf_if *ifp)
 922 {
 923         if (!ifp || WARN_ON(ifp->drvr->iflist[ifp->bssidx] != ifp))
 924                 return;
 925         brcmf_dbg(TRACE, "Enter, bssidx=%d, ifidx=%d\n", ifp->bssidx,
 926                   ifp->ifidx);
 927         brcmf_fws_del_interface(ifp);
 928         brcmf_del_if(ifp->drvr, ifp->bssidx);
 929 }
 930
 931 int brcmf_get_next_free_bsscfgidx(struct brcmf_pub *drvr)
 932 {
 933         int ifidx;
 934         int bsscfgidx;
 935         bool available;
 936         int highest;
 937
 938         available = false;
 939         bsscfgidx = 2;
 940         highest = 2;
 941         for (ifidx = 0; ifidx < BRCMF_MAX_IFS; ifidx++) {
 942                 if (drvr->iflist[ifidx]) {
 943                         if (drvr->iflist[ifidx]->bssidx == bsscfgidx)
 944                                 bsscfgidx = highest + 1;
 945                         else if (drvr->iflist[ifidx]->bssidx > highest)
 946                                 highest = drvr->iflist[ifidx]->bssidx;
 947                 } else {
 948                         available = true;
 949                 }
 950         }
 951
 952         return available ? bsscfgidx : -ENOMEM;
 953 }
 954
 955 int brcmf_attach(struct device *dev)
 956 {
 957         struct brcmf_pub *drvr = NULL;
 958         int ret = 0;
 959         int i;
 960
 961         brcmf_dbg(TRACE, "Enter\n");
 962
 963         /* Allocate primary brcmf_info */
 964         drvr = kzalloc(sizeof(struct brcmf_pub), GFP_ATOMIC);
 965         if (!drvr)
 966                 return -ENOMEM;
 967
 968         for (i = 0; i < ARRAY_SIZE(drvr->if2bss); i++)
 969                 drvr->if2bss[i] = BRCMF_BSSIDX_INVALID;
 970
 971         mutex_init(&drvr->proto_block);
 972
 973         /* Link to bus module */
 974         drvr->hdrlen = 0;
 975         drvr->bus_if = dev_get_drvdata(dev);
 976         drvr->bus_if->drvr = drvr;
 977
 978         /* attach debug facilities */
 979         brcmf_debug_attach(drvr);
 980
 981         /* Attach and link in the protocol */
 982         ret = brcmf_proto_attach(drvr);
 983         if (ret != 0) {
 984                 brcmf_err("brcmf_prot_attach failed\n");
 985                 goto fail;
 986         }
 987
 988         /* attach firmware event handler */
 989         brcmf_fweh_attach(drvr);
 990
 991         return ret;
 992
 993 fail:
 994         brcmf_detach(dev);
 995
 996         return ret;
 997 }
 998
 999 static int brcmf_revinfo_read(struct seq_file *s, void *data)
1000 {
1001         struct brcmf_bus *bus_if = dev_get_drvdata(s->private);
1002         struct brcmf_rev_info *ri = &bus_if->drvr->revinfo;
1003         char drev[BRCMU_DOTREV_LEN];
1004         char brev[BRCMU_BOARDREV_LEN];
1005
1006         seq_printf(s, "vendorid: 0x%04x\n", ri->vendorid);
1007         seq_printf(s, "deviceid: 0x%04x\n", ri->deviceid);
1008         seq_printf(s, "radiorev: %s\n", brcmu_dotrev_str(ri->radiorev, drev));
1009         seq_printf(s, "chipnum: %u (%x)\n", ri->chipnum, ri->chipnum);
1010         seq_printf(s, "chiprev: %u\n", ri->chiprev);
1011         seq_printf(s, "chippkg: %u\n", ri->chippkg);
1012         seq_printf(s, "corerev: %u\n", ri->corerev);
1013         seq_printf(s, "boardid: 0x%04x\n", ri->boardid);
1014         seq_printf(s, "boardvendor: 0x%04x\n", ri->boardvendor);
1015         seq_printf(s, "boardrev: %s\n", brcmu_boardrev_str(ri->boardrev, brev));
1016         seq_printf(s, "driverrev: %s\n", brcmu_dotrev_str(ri->driverrev, drev));
1017         seq_printf(s, "ucoderev: %u\n", ri->ucoderev);
1018         seq_printf(s, "bus: %u\n", ri->bus);
1019         seq_printf(s, "phytype: %u\n", ri->phytype);
1020         seq_printf(s, "phyrev: %u\n", ri->phyrev);
1021         seq_printf(s, "anarev: %u\n", ri->anarev);
1022         seq_printf(s, "nvramrev: %08x\n", ri->nvramrev);
1023
1024         return 0;
1025 }
1026
1027 int brcmf_bus_start(struct device *dev)
1028 {
1029         int ret = -1;
1030         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1031         struct brcmf_pub *drvr = bus_if->drvr;
1032         struct brcmf_if *ifp;
1033         struct brcmf_if *p2p_ifp;
1034
1035         brcmf_dbg(TRACE, "\n");
1036
1037         /* add primary networking interface */
1038         ifp = brcmf_add_if(drvr, 0, 0, false, "wlan%d", NULL);
1039         if (IS_ERR(ifp))
1040                 return PTR_ERR(ifp);
1041
1042         p2p_ifp = NULL;
1043
1044         /* signal bus ready */
1045         brcmf_bus_change_state(bus_if, BRCMF_BUS_UP);
1046
1047         /* Bus is ready, do any initialization */
1048         ret = brcmf_c_preinit_dcmds(ifp);
1049         if (ret < 0)
1050                 goto fail;
1051
1052         brcmf_debugfs_add_entry(drvr, "revinfo", brcmf_revinfo_read);
1053
1054         /* assure we have chipid before feature attach */
1055         if (!bus_if->chip) {
1056                 bus_if->chip = drvr->revinfo.chipnum;
1057                 bus_if->chiprev = drvr->revinfo.chiprev;
1058                 brcmf_dbg(INFO, "firmware revinfo: chip %x (%d) rev %d\n",
1059                           bus_if->chip, bus_if->chip, bus_if->chiprev);
1060         }
1061         brcmf_feat_attach(drvr);
1062
1063         ret = brcmf_fws_init(drvr);
1064         if (ret < 0)
1065                 goto fail;
1066
1067         brcmf_fws_add_interface(ifp);
1068
1069         drvr->config = brcmf_cfg80211_attach(drvr, bus_if->dev,
1070                                              brcmf_p2p_enable);
1071         if (drvr->config == NULL) {
1072                 ret = -ENOMEM;
1073                 goto fail;
1074         }
1075
1076         ret = brcmf_net_attach(ifp, false);
1077
1078         if ((!ret) && (brcmf_p2p_enable)) {
1079                 p2p_ifp = drvr->iflist[1];
1080                 if (p2p_ifp)
1081                         ret = brcmf_net_p2p_attach(p2p_ifp);
1082         }
1083 fail:
1084         if (ret < 0) {
1085                 brcmf_err("failed: %d\n", ret);
1086                 if (drvr->config) {
1087                         brcmf_cfg80211_detach(drvr->config);
1088                         drvr->config = NULL;
1089                 }
1090                 if (drvr->fws) {
1091                         brcmf_fws_del_interface(ifp);
1092                         brcmf_fws_deinit(drvr);
1093                 }
1094                 if (ifp)
1095                         brcmf_net_detach(ifp->ndev);
1096                 if (p2p_ifp)
1097                         brcmf_net_detach(p2p_ifp->ndev);
1098                 return ret;
1099         }
1100         return 0;
1101 }
1102
1103 void brcmf_bus_add_txhdrlen(struct device *dev, uint len)
1104 {
1105         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1106         struct brcmf_pub *drvr = bus_if->drvr;
1107
1108         if (drvr) {
1109                 drvr->hdrlen += len;
1110         }
1111 }
1112
1113 static void brcmf_bus_detach(struct brcmf_pub *drvr)
1114 {
1115         brcmf_dbg(TRACE, "Enter\n");
1116
1117         if (drvr) {
1118                 /* Stop the bus module */
1119                 brcmf_bus_stop(drvr->bus_if);
1120         }
1121 }
1122
1123 void brcmf_dev_reset(struct device *dev)
1124 {
1125         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1126         struct brcmf_pub *drvr = bus_if->drvr;
1127
1128         if (drvr == NULL)
1129                 return;
1130
1131         if (drvr->iflist[0])
1132                 brcmf_fil_cmd_int_set(drvr->iflist[0], BRCMF_C_TERMINATED, 1);
1133 }
1134
1135 void brcmf_detach(struct device *dev)
1136 {
1137         s32 i;
1138         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1139         struct brcmf_pub *drvr = bus_if->drvr;
1140
1141         brcmf_dbg(TRACE, "Enter\n");
1142
1143         if (drvr == NULL)
1144                 return;
1145
1146         /* stop firmware event handling */
1147         brcmf_fweh_detach(drvr);
1148         if (drvr->config)
1149                 brcmf_p2p_detach(&drvr->config->p2p);
1150
1151         brcmf_bus_change_state(bus_if, BRCMF_BUS_DOWN);
1152
1153         /* make sure primary interface removed last */
1154         for (i = BRCMF_MAX_IFS-1; i > -1; i--)
1155                 brcmf_remove_interface(drvr->iflist[i]);
1156
1157         brcmf_cfg80211_detach(drvr->config);
1158
1159         brcmf_fws_deinit(drvr);
1160
1161         brcmf_bus_detach(drvr);
1162
1163         brcmf_proto_detach(drvr);
1164
1165         brcmf_debug_detach(drvr);
1166         bus_if->drvr = NULL;
1167         kfree(drvr);
1168 }
1169
1170 s32 brcmf_iovar_data_set(struct device *dev, char *name, void *data, u32 len)
1171 {
1172         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1173         struct brcmf_if *ifp = bus_if->drvr->iflist[0];
1174
1175         return brcmf_fil_iovar_data_set(ifp, name, data, len);
1176 }
1177
1178 static int brcmf_get_pend_8021x_cnt(struct brcmf_if *ifp)
1179 {
1180         return atomic_read(&ifp->pend_8021x_cnt);
1181 }
1182
1183 int brcmf_netdev_wait_pend8021x(struct brcmf_if *ifp)
1184 {
1185         int err;
1186
1187         err = wait_event_timeout(ifp->pend_8021x_wait,
1188                                  !brcmf_get_pend_8021x_cnt(ifp),
1189                                  msecs_to_jiffies(MAX_WAIT_FOR_8021X_TX));
1190
1191         WARN_ON(!err);
1192
1193         return !err;
1194 }
1195
1196 void brcmf_bus_change_state(struct brcmf_bus *bus, enum brcmf_bus_state state)
1197 {
1198         struct brcmf_pub *drvr = bus->drvr;
1199         struct net_device *ndev;
1200         int ifidx;
1201
1202         brcmf_dbg(TRACE, "%d -> %d\n", bus->state, state);
1203         bus->state = state;
1204
1205         if (state == BRCMF_BUS_UP) {
1206                 for (ifidx = 0; ifidx < BRCMF_MAX_IFS; ifidx++) {
1207                         if ((drvr->iflist[ifidx]) &&
1208                             (drvr->iflist[ifidx]->ndev)) {
1209                                 ndev = drvr->iflist[ifidx]->ndev;
1210                                 if (netif_queue_stopped(ndev))
1211                                         netif_wake_queue(ndev);
1212                         }
1213                 }
1214         }
1215 }
1216
1217 static void brcmf_driver_register(struct work_struct *work)
1218 {
1219 #ifdef CONFIG_BRCMFMAC_SDIO
1220         brcmf_sdio_register();
1221 #endif
1222 #ifdef CONFIG_BRCMFMAC_USB
1223         brcmf_usb_register();
1224 #endif
1225 #ifdef CONFIG_BRCMFMAC_PCIE
1226         brcmf_pcie_register();
1227 #endif
1228 }
1229 static DECLARE_WORK(brcmf_driver_work, brcmf_driver_register);
1230
1231 static int __init brcmfmac_module_init(void)
1232 {
1233         brcmf_debugfs_init();
1234 #ifdef CONFIG_BRCMFMAC_SDIO
1235         brcmf_sdio_init();
1236 #endif
1237         if (!schedule_work(&brcmf_driver_work))
1238                 return -EBUSY;
1239
1240         return 0;
1241 }
1242
1243 static void __exit brcmfmac_module_exit(void)
1244 {
1245         cancel_work_sync(&brcmf_driver_work);
1246
1247 #ifdef CONFIG_BRCMFMAC_SDIO
1248         brcmf_sdio_exit();
1249 #endif
1250 #ifdef CONFIG_BRCMFMAC_USB
1251         brcmf_usb_exit();
1252 #endif
1253 #ifdef CONFIG_BRCMFMAC_PCIE
1254         brcmf_pcie_exit();
1255 #endif
1256         brcmf_debugfs_exit();
1257 }
1258
1259 module_init(brcmfmac_module_init);
1260 module_exit(brcmfmac_module_exit);