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