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