Pileus Git - ~andy/linux/blob - drivers/net/wireless/brcm80211/brcmfmac/dhd_linux.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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  18
  19 #include <linux/init.h>
  20 #include <linux/kernel.h>
  21 #include <linux/kthread.h>
  22 #include <linux/slab.h>
  23 #include <linux/skbuff.h>
  24 #include <linux/netdevice.h>
  25 #include <linux/etherdevice.h>
  26 #include <linux/mmc/sdio_func.h>
  27 #include <linux/random.h>
  28 #include <linux/spinlock.h>
  29 #include <linux/ethtool.h>
  30 #include <linux/fcntl.h>
  31 #include <linux/fs.h>
  32 #include <linux/uaccess.h>
  33 #include <linux/hardirq.h>
  34 #include <linux/mutex.h>
  35 #include <linux/wait.h>
  36 #include <linux/module.h>
  37 #include <net/cfg80211.h>
  38 #include <net/rtnetlink.h>
  39 #include <defs.h>
  40 #include <brcmu_utils.h>
  41 #include <brcmu_wifi.h>
  42
  43 #include "dhd.h"
  44 #include "dhd_bus.h"
  45 #include "dhd_proto.h"
  46 #include "dhd_dbg.h"
  47 #include "wl_cfg80211.h"
  48
  49 MODULE_AUTHOR("Broadcom Corporation");
  50 MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN fullmac driver.");
  51 MODULE_SUPPORTED_DEVICE("Broadcom 802.11n WLAN fullmac cards");
  52 MODULE_LICENSE("Dual BSD/GPL");
  53
  54
  55 /* Interface control information */
  56 struct brcmf_if {
  57         struct brcmf_pub *drvr; /* back pointer to brcmf_pub */
  58         /* OS/stack specifics */
  59         struct net_device *ndev;
  60         struct net_device_stats stats;
  61         int idx;                /* iface idx in dongle */
  62         u8 mac_addr[ETH_ALEN];  /* assigned MAC address */
  63 };
  64
  65 /* Error bits */
  66 int brcmf_msg_level = BRCMF_ERROR_VAL;
  67 module_param(brcmf_msg_level, int, 0);
  68
  69 int brcmf_ifname2idx(struct brcmf_pub *drvr, char *name)
  70 {
  71         int i = BRCMF_MAX_IFS;
  72         struct brcmf_if *ifp;
  73
  74         if (name == NULL || *name == '\0')
  75                 return 0;
  76
  77         while (--i > 0) {
  78                 ifp = drvr->iflist[i];
  79                 if (ifp && !strncmp(ifp->ndev->name, name, IFNAMSIZ))
  80                         break;
  81         }
  82
  83         brcmf_dbg(TRACE, "return idx %d for \"%s\"\n", i, name);
  84
  85         return i;               /* default - the primary interface */
  86 }
  87
  88 char *brcmf_ifname(struct brcmf_pub *drvr, int ifidx)
  89 {
  90         if (ifidx < 0 || ifidx >= BRCMF_MAX_IFS) {
  91                 brcmf_dbg(ERROR, "ifidx %d out of range\n", ifidx);
  92                 return "<if_bad>";
  93         }
  94
  95         if (drvr->iflist[ifidx] == NULL) {
  96                 brcmf_dbg(ERROR, "null i/f %d\n", ifidx);
  97                 return "<if_null>";
  98         }
  99
 100         if (drvr->iflist[ifidx]->ndev)
 101                 return drvr->iflist[ifidx]->ndev->name;
 102
 103         return "<if_none>";
 104 }
 105
 106 static void _brcmf_set_multicast_list(struct work_struct *work)
 107 {
 108         struct net_device *ndev;
 109         struct netdev_hw_addr *ha;
 110         u32 dcmd_value, cnt;
 111         __le32 cnt_le;
 112         __le32 dcmd_le_value;
 113
 114         struct brcmf_dcmd dcmd;
 115         char *buf, *bufp;
 116         uint buflen;
 117         int ret;
 118
 119         struct brcmf_pub *drvr = container_of(work, struct brcmf_pub,
 120                                                     multicast_work);
 121
 122         ndev = drvr->iflist[0]->ndev;
 123         cnt = netdev_mc_count(ndev);
 124
 125         /* Determine initial value of allmulti flag */
 126         dcmd_value = (ndev->flags & IFF_ALLMULTI) ? true : false;
 127
 128         /* Send down the multicast list first. */
 129
 130         buflen = sizeof("mcast_list") + sizeof(cnt) + (cnt * ETH_ALEN);
 131         bufp = buf = kmalloc(buflen, GFP_ATOMIC);
 132         if (!bufp)
 133                 return;
 134
 135         strcpy(bufp, "mcast_list");
 136         bufp += strlen("mcast_list") + 1;
 137
 138         cnt_le = cpu_to_le32(cnt);
 139         memcpy(bufp, &cnt_le, sizeof(cnt));
 140         bufp += sizeof(cnt_le);
 141
 142         netdev_for_each_mc_addr(ha, ndev) {
 143                 if (!cnt)
 144                         break;
 145                 memcpy(bufp, ha->addr, ETH_ALEN);
 146                 bufp += ETH_ALEN;
 147                 cnt--;
 148         }
 149
 150         memset(&dcmd, 0, sizeof(dcmd));
 151         dcmd.cmd = BRCMF_C_SET_VAR;
 152         dcmd.buf = buf;
 153         dcmd.len = buflen;
 154         dcmd.set = true;
 155
 156         ret = brcmf_proto_dcmd(drvr, 0, &dcmd, dcmd.len);
 157         if (ret < 0) {
 158                 brcmf_dbg(ERROR, "%s: set mcast_list failed, cnt %d\n",
 159                           brcmf_ifname(drvr, 0), cnt);
 160                 dcmd_value = cnt ? true : dcmd_value;
 161         }
 162
 163         kfree(buf);
 164
 165         /* Now send the allmulti setting.  This is based on the setting in the
 166          * net_device flags, but might be modified above to be turned on if we
 167          * were trying to set some addresses and dongle rejected it...
 168          */
 169
 170         buflen = sizeof("allmulti") + sizeof(dcmd_value);
 171         buf = kmalloc(buflen, GFP_ATOMIC);
 172         if (!buf)
 173                 return;
 174
 175         dcmd_le_value = cpu_to_le32(dcmd_value);
 176
 177         if (!brcmf_c_mkiovar
 178             ("allmulti", (void *)&dcmd_le_value,
 179             sizeof(dcmd_le_value), buf, buflen)) {
 180                 brcmf_dbg(ERROR, "%s: mkiovar failed for allmulti, datalen %d buflen %u\n",
 181                           brcmf_ifname(drvr, 0),
 182                           (int)sizeof(dcmd_value), buflen);
 183                 kfree(buf);
 184                 return;
 185         }
 186
 187         memset(&dcmd, 0, sizeof(dcmd));
 188         dcmd.cmd = BRCMF_C_SET_VAR;
 189         dcmd.buf = buf;
 190         dcmd.len = buflen;
 191         dcmd.set = true;
 192
 193         ret = brcmf_proto_dcmd(drvr, 0, &dcmd, dcmd.len);
 194         if (ret < 0) {
 195                 brcmf_dbg(ERROR, "%s: set allmulti %d failed\n",
 196                           brcmf_ifname(drvr, 0),
 197                           le32_to_cpu(dcmd_le_value));
 198         }
 199
 200         kfree(buf);
 201
 202         /* Finally, pick up the PROMISC flag as well, like the NIC
 203                  driver does */
 204
 205         dcmd_value = (ndev->flags & IFF_PROMISC) ? true : false;
 206         dcmd_le_value = cpu_to_le32(dcmd_value);
 207
 208         memset(&dcmd, 0, sizeof(dcmd));
 209         dcmd.cmd = BRCMF_C_SET_PROMISC;
 210         dcmd.buf = &dcmd_le_value;
 211         dcmd.len = sizeof(dcmd_le_value);
 212         dcmd.set = true;
 213
 214         ret = brcmf_proto_dcmd(drvr, 0, &dcmd, dcmd.len);
 215         if (ret < 0) {
 216                 brcmf_dbg(ERROR, "%s: set promisc %d failed\n",
 217                           brcmf_ifname(drvr, 0),
 218                           le32_to_cpu(dcmd_le_value));
 219         }
 220 }
 221
 222 static void
 223 _brcmf_set_mac_address(struct work_struct *work)
 224 {
 225         char buf[32];
 226         struct brcmf_dcmd dcmd;
 227         int ret;
 228
 229         struct brcmf_pub *drvr = container_of(work, struct brcmf_pub,
 230                                                     setmacaddr_work);
 231
 232         brcmf_dbg(TRACE, "enter\n");
 233         if (!brcmf_c_mkiovar("cur_etheraddr", (char *)drvr->macvalue,
 234                            ETH_ALEN, buf, 32)) {
 235                 brcmf_dbg(ERROR, "%s: mkiovar failed for cur_etheraddr\n",
 236                           brcmf_ifname(drvr, 0));
 237                 return;
 238         }
 239         memset(&dcmd, 0, sizeof(dcmd));
 240         dcmd.cmd = BRCMF_C_SET_VAR;
 241         dcmd.buf = buf;
 242         dcmd.len = 32;
 243         dcmd.set = true;
 244
 245         ret = brcmf_proto_dcmd(drvr, 0, &dcmd, dcmd.len);
 246         if (ret < 0)
 247                 brcmf_dbg(ERROR, "%s: set cur_etheraddr failed\n",
 248                           brcmf_ifname(drvr, 0));
 249         else
 250                 memcpy(drvr->iflist[0]->ndev->dev_addr,
 251                        drvr->macvalue, ETH_ALEN);
 252
 253         return;
 254 }
 255
 256 static int brcmf_netdev_set_mac_address(struct net_device *ndev, void *addr)
 257 {
 258         struct brcmf_if *ifp = netdev_priv(ndev);
 259         struct brcmf_pub *drvr = ifp->drvr;
 260         struct sockaddr *sa = (struct sockaddr *)addr;
 261
 262         memcpy(&drvr->macvalue, sa->sa_data, ETH_ALEN);
 263         schedule_work(&drvr->setmacaddr_work);
 264         return 0;
 265 }
 266
 267 static void brcmf_netdev_set_multicast_list(struct net_device *ndev)
 268 {
 269         struct brcmf_if *ifp = netdev_priv(ndev);
 270         struct brcmf_pub *drvr = ifp->drvr;
 271
 272         schedule_work(&drvr->multicast_work);
 273 }
 274
 275 int brcmf_sendpkt(struct brcmf_pub *drvr, int ifidx, struct sk_buff *pktbuf)
 276 {
 277         /* Reject if down */
 278         if (!drvr->bus_if->drvr_up || (drvr->bus_if->state == BRCMF_BUS_DOWN))
 279                 return -ENODEV;
 280
 281         /* Update multicast statistic */
 282         if (pktbuf->len >= ETH_ALEN) {
 283                 u8 *pktdata = (u8 *) (pktbuf->data);
 284                 struct ethhdr *eh = (struct ethhdr *)pktdata;
 285
 286                 if (is_multicast_ether_addr(eh->h_dest))
 287                         drvr->tx_multicast++;
 288                 if (ntohs(eh->h_proto) == ETH_P_PAE)
 289                         atomic_inc(&drvr->pend_8021x_cnt);
 290         }
 291
 292         /* If the protocol uses a data header, apply it */
 293         brcmf_proto_hdrpush(drvr, ifidx, pktbuf);
 294
 295         /* Use bus module to send data frame */
 296         return drvr->bus_if->brcmf_bus_txdata(drvr->dev, pktbuf);
 297 }
 298
 299 static int brcmf_netdev_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 300 {
 301         int ret;
 302         struct brcmf_if *ifp = netdev_priv(ndev);
 303         struct brcmf_pub *drvr = ifp->drvr;
 304
 305         brcmf_dbg(TRACE, "Enter\n");
 306
 307         /* Reject if down */
 308         if (!drvr->bus_if->drvr_up ||
 309             (drvr->bus_if->state == BRCMF_BUS_DOWN)) {
 310                 brcmf_dbg(ERROR, "xmit rejected drvup=%d state=%d\n",
 311                           drvr->bus_if->drvr_up,
 312                           drvr->bus_if->state);
 313                 netif_stop_queue(ndev);
 314                 return -ENODEV;
 315         }
 316
 317         if (!drvr->iflist[ifp->idx]) {
 318                 brcmf_dbg(ERROR, "bad ifidx %d\n", ifp->idx);
 319                 netif_stop_queue(ndev);
 320                 return -ENODEV;
 321         }
 322
 323         /* Make sure there's enough room for any header */
 324         if (skb_headroom(skb) < drvr->hdrlen) {
 325                 struct sk_buff *skb2;
 326
 327                 brcmf_dbg(INFO, "%s: insufficient headroom\n",
 328                           brcmf_ifname(drvr, ifp->idx));
 329                 drvr->bus_if->tx_realloc++;
 330                 skb2 = skb_realloc_headroom(skb, drvr->hdrlen);
 331                 dev_kfree_skb(skb);
 332                 skb = skb2;
 333                 if (skb == NULL) {
 334                         brcmf_dbg(ERROR, "%s: skb_realloc_headroom failed\n",
 335                                   brcmf_ifname(drvr, ifp->idx));
 336                         ret = -ENOMEM;
 337                         goto done;
 338                 }
 339         }
 340
 341         ret = brcmf_sendpkt(drvr, ifp->idx, skb);
 342
 343 done:
 344         if (ret)
 345                 drvr->bus_if->dstats.tx_dropped++;
 346         else
 347                 drvr->bus_if->dstats.tx_packets++;
 348
 349         /* Return ok: we always eat the packet */
 350         return 0;
 351 }
 352
 353 void brcmf_txflowcontrol(struct device *dev, int ifidx, bool state)
 354 {
 355         struct net_device *ndev;
 356         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
 357         struct brcmf_pub *drvr = bus_if->drvr;
 358
 359         brcmf_dbg(TRACE, "Enter\n");
 360
 361         ndev = drvr->iflist[ifidx]->ndev;
 362         if (state == ON)
 363                 netif_stop_queue(ndev);
 364         else
 365                 netif_wake_queue(ndev);
 366 }
 367
 368 static int brcmf_host_event(struct brcmf_pub *drvr, int *ifidx,
 369                             void *pktdata, struct brcmf_event_msg *event,
 370                             void **data)
 371 {
 372         int bcmerror = 0;
 373
 374         bcmerror = brcmf_c_host_event(drvr, ifidx, pktdata, event, data);
 375         if (bcmerror != 0)
 376                 return bcmerror;
 377
 378         if (drvr->iflist[*ifidx]->ndev)
 379                 brcmf_cfg80211_event(drvr->iflist[*ifidx]->ndev,
 380                                      event, *data);
 381
 382         return bcmerror;
 383 }
 384
 385 void brcmf_rx_frame(struct device *dev, int ifidx,
 386                     struct sk_buff_head *skb_list)
 387 {
 388         unsigned char *eth;
 389         uint len;
 390         void *data;
 391         struct sk_buff *skb, *pnext;
 392         struct brcmf_if *ifp;
 393         struct brcmf_event_msg event;
 394         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
 395         struct brcmf_pub *drvr = bus_if->drvr;
 396
 397         brcmf_dbg(TRACE, "Enter\n");
 398
 399         skb_queue_walk_safe(skb_list, skb, pnext) {
 400                 skb_unlink(skb, skb_list);
 401
 402                 /* Get the protocol, maintain skb around eth_type_trans()
 403                  * The main reason for this hack is for the limitation of
 404                  * Linux 2.4 where 'eth_type_trans' uses the
 405                  * 'net->hard_header_len'
 406                  * to perform skb_pull inside vs ETH_HLEN. Since to avoid
 407                  * coping of the packet coming from the network stack to add
 408                  * BDC, Hardware header etc, during network interface
 409                  * registration
 410                  * we set the 'net->hard_header_len' to ETH_HLEN + extra space
 411                  * required
 412                  * for BDC, Hardware header etc. and not just the ETH_HLEN
 413                  */
 414                 eth = skb->data;
 415                 len = skb->len;
 416
 417                 ifp = drvr->iflist[ifidx];
 418                 if (ifp == NULL)
 419                         ifp = drvr->iflist[0];
 420
 421                 if (!ifp || !ifp->ndev ||
 422                     ifp->ndev->reg_state != NETREG_REGISTERED) {
 423                         brcmu_pkt_buf_free_skb(skb);
 424                         continue;
 425                 }
 426
 427                 skb->dev = ifp->ndev;
 428                 skb->protocol = eth_type_trans(skb, skb->dev);
 429
 430                 if (skb->pkt_type == PACKET_MULTICAST)
 431                         bus_if->dstats.multicast++;
 432
 433                 skb->data = eth;
 434                 skb->len = len;
 435
 436                 /* Strip header, count, deliver upward */
 437                 skb_pull(skb, ETH_HLEN);
 438
 439                 /* Process special event packets and then discard them */
 440                 if (ntohs(skb->protocol) == ETH_P_LINK_CTL)
 441                         brcmf_host_event(drvr, &ifidx,
 442                                           skb_mac_header(skb),
 443                                           &event, &data);
 444
 445                 if (drvr->iflist[ifidx]) {
 446                         ifp = drvr->iflist[ifidx];
 447                         ifp->ndev->last_rx = jiffies;
 448                 }
 449
 450                 bus_if->dstats.rx_bytes += skb->len;
 451                 bus_if->dstats.rx_packets++;    /* Local count */
 452
 453                 if (in_interrupt())
 454                         netif_rx(skb);
 455                 else
 456                         /* If the receive is not processed inside an ISR,
 457                          * the softirqd must be woken explicitly to service
 458                          * the NET_RX_SOFTIRQ.  In 2.6 kernels, this is handled
 459                          * by netif_rx_ni(), but in earlier kernels, we need
 460                          * to do it manually.
 461                          */
 462                         netif_rx_ni(skb);
 463         }
 464 }
 465
 466 void brcmf_txcomplete(struct device *dev, struct sk_buff *txp, bool success)
 467 {
 468         uint ifidx;
 469         struct ethhdr *eh;
 470         u16 type;
 471         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
 472         struct brcmf_pub *drvr = bus_if->drvr;
 473
 474         brcmf_proto_hdrpull(dev, &ifidx, txp);
 475
 476         eh = (struct ethhdr *)(txp->data);
 477         type = ntohs(eh->h_proto);
 478
 479         if (type == ETH_P_PAE)
 480                 atomic_dec(&drvr->pend_8021x_cnt);
 481
 482 }
 483
 484 static struct net_device_stats *brcmf_netdev_get_stats(struct net_device *ndev)
 485 {
 486         struct brcmf_if *ifp = netdev_priv(ndev);
 487         struct brcmf_bus *bus_if = ifp->drvr->bus_if;
 488
 489         brcmf_dbg(TRACE, "Enter\n");
 490
 491         /* Copy dongle stats to net device stats */
 492         ifp->stats.rx_packets = bus_if->dstats.rx_packets;
 493         ifp->stats.tx_packets = bus_if->dstats.tx_packets;
 494         ifp->stats.rx_bytes = bus_if->dstats.rx_bytes;
 495         ifp->stats.tx_bytes = bus_if->dstats.tx_bytes;
 496         ifp->stats.rx_errors = bus_if->dstats.rx_errors;
 497         ifp->stats.tx_errors = bus_if->dstats.tx_errors;
 498         ifp->stats.rx_dropped = bus_if->dstats.rx_dropped;
 499         ifp->stats.tx_dropped = bus_if->dstats.tx_dropped;
 500         ifp->stats.multicast = bus_if->dstats.multicast;
 501
 502         return &ifp->stats;
 503 }
 504
 505 /* Retrieve current toe component enables, which are kept
 506          as a bitmap in toe_ol iovar */
 507 static int brcmf_toe_get(struct brcmf_pub *drvr, int ifidx, u32 *toe_ol)
 508 {
 509         struct brcmf_dcmd dcmd;
 510         __le32 toe_le;
 511         char buf[32];
 512         int ret;
 513
 514         memset(&dcmd, 0, sizeof(dcmd));
 515
 516         dcmd.cmd = BRCMF_C_GET_VAR;
 517         dcmd.buf = buf;
 518         dcmd.len = (uint) sizeof(buf);
 519         dcmd.set = false;
 520
 521         strcpy(buf, "toe_ol");
 522         ret = brcmf_proto_dcmd(drvr, ifidx, &dcmd, dcmd.len);
 523         if (ret < 0) {
 524                 /* Check for older dongle image that doesn't support toe_ol */
 525                 if (ret == -EIO) {
 526                         brcmf_dbg(ERROR, "%s: toe not supported by device\n",
 527                                   brcmf_ifname(drvr, ifidx));
 528                         return -EOPNOTSUPP;
 529                 }
 530
 531                 brcmf_dbg(INFO, "%s: could not get toe_ol: ret=%d\n",
 532                           brcmf_ifname(drvr, ifidx), ret);
 533                 return ret;
 534         }
 535
 536         memcpy(&toe_le, buf, sizeof(u32));
 537         *toe_ol = le32_to_cpu(toe_le);
 538         return 0;
 539 }
 540
 541 /* Set current toe component enables in toe_ol iovar,
 542          and set toe global enable iovar */
 543 static int brcmf_toe_set(struct brcmf_pub *drvr, int ifidx, u32 toe_ol)
 544 {
 545         struct brcmf_dcmd dcmd;
 546         char buf[32];
 547         int ret;
 548         __le32 toe_le = cpu_to_le32(toe_ol);
 549
 550         memset(&dcmd, 0, sizeof(dcmd));
 551
 552         dcmd.cmd = BRCMF_C_SET_VAR;
 553         dcmd.buf = buf;
 554         dcmd.len = (uint) sizeof(buf);
 555         dcmd.set = true;
 556
 557         /* Set toe_ol as requested */
 558         strcpy(buf, "toe_ol");
 559         memcpy(&buf[sizeof("toe_ol")], &toe_le, sizeof(u32));
 560
 561         ret = brcmf_proto_dcmd(drvr, ifidx, &dcmd, dcmd.len);
 562         if (ret < 0) {
 563                 brcmf_dbg(ERROR, "%s: could not set toe_ol: ret=%d\n",
 564                           brcmf_ifname(drvr, ifidx), ret);
 565                 return ret;
 566         }
 567
 568         /* Enable toe globally only if any components are enabled. */
 569         toe_le = cpu_to_le32(toe_ol != 0);
 570
 571         strcpy(buf, "toe");
 572         memcpy(&buf[sizeof("toe")], &toe_le, sizeof(u32));
 573
 574         ret = brcmf_proto_dcmd(drvr, ifidx, &dcmd, dcmd.len);
 575         if (ret < 0) {
 576                 brcmf_dbg(ERROR, "%s: could not set toe: ret=%d\n",
 577                           brcmf_ifname(drvr, ifidx), ret);
 578                 return ret;
 579         }
 580
 581         return 0;
 582 }
 583
 584 static void brcmf_ethtool_get_drvinfo(struct net_device *ndev,
 585                                     struct ethtool_drvinfo *info)
 586 {
 587         struct brcmf_if *ifp = netdev_priv(ndev);
 588         struct brcmf_pub *drvr = ifp->drvr;
 589
 590         sprintf(info->driver, KBUILD_MODNAME);
 591         sprintf(info->version, "%lu", drvr->drv_version);
 592         sprintf(info->bus_info, "%s", dev_name(drvr->dev));
 593 }
 594
 595 static const struct ethtool_ops brcmf_ethtool_ops = {
 596         .get_drvinfo = brcmf_ethtool_get_drvinfo,
 597 };
 598
 599 static int brcmf_ethtool(struct brcmf_pub *drvr, void __user *uaddr)
 600 {
 601         struct ethtool_drvinfo info;
 602         char drvname[sizeof(info.driver)];
 603         u32 cmd;
 604         struct ethtool_value edata;
 605         u32 toe_cmpnt, csum_dir;
 606         int ret;
 607
 608         brcmf_dbg(TRACE, "Enter\n");
 609
 610         /* all ethtool calls start with a cmd word */
 611         if (copy_from_user(&cmd, uaddr, sizeof(u32)))
 612                 return -EFAULT;
 613
 614         switch (cmd) {
 615         case ETHTOOL_GDRVINFO:
 616                 /* Copy out any request driver name */
 617                 if (copy_from_user(&info, uaddr, sizeof(info)))
 618                         return -EFAULT;
 619                 strncpy(drvname, info.driver, sizeof(info.driver));
 620                 drvname[sizeof(info.driver) - 1] = '\0';
 621
 622                 /* clear struct for return */
 623                 memset(&info, 0, sizeof(info));
 624                 info.cmd = cmd;
 625
 626                 /* if requested, identify ourselves */
 627                 if (strcmp(drvname, "?dhd") == 0) {
 628                         sprintf(info.driver, "dhd");
 629                         strcpy(info.version, BRCMF_VERSION_STR);
 630                 }
 631
 632                 /* otherwise, require dongle to be up */
 633                 else if (!drvr->bus_if->drvr_up) {
 634                         brcmf_dbg(ERROR, "dongle is not up\n");
 635                         return -ENODEV;
 636                 }
 637
 638                 /* finally, report dongle driver type */
 639                 else if (drvr->iswl)
 640                         sprintf(info.driver, "wl");
 641                 else
 642                         sprintf(info.driver, "xx");
 643
 644                 sprintf(info.version, "%lu", drvr->drv_version);
 645                 if (copy_to_user(uaddr, &info, sizeof(info)))
 646                         return -EFAULT;
 647                 brcmf_dbg(CTL, "given %*s, returning %s\n",
 648                           (int)sizeof(drvname), drvname, info.driver);
 649                 break;
 650
 651                 /* Get toe offload components from dongle */
 652         case ETHTOOL_GRXCSUM:
 653         case ETHTOOL_GTXCSUM:
 654                 ret = brcmf_toe_get(drvr, 0, &toe_cmpnt);
 655                 if (ret < 0)
 656                         return ret;
 657
 658                 csum_dir =
 659                     (cmd == ETHTOOL_GTXCSUM) ? TOE_TX_CSUM_OL : TOE_RX_CSUM_OL;
 660
 661                 edata.cmd = cmd;
 662                 edata.data = (toe_cmpnt & csum_dir) ? 1 : 0;
 663
 664                 if (copy_to_user(uaddr, &edata, sizeof(edata)))
 665                         return -EFAULT;
 666                 break;
 667
 668                 /* Set toe offload components in dongle */
 669         case ETHTOOL_SRXCSUM:
 670         case ETHTOOL_STXCSUM:
 671                 if (copy_from_user(&edata, uaddr, sizeof(edata)))
 672                         return -EFAULT;
 673
 674                 /* Read the current settings, update and write back */
 675                 ret = brcmf_toe_get(drvr, 0, &toe_cmpnt);
 676                 if (ret < 0)
 677                         return ret;
 678
 679                 csum_dir =
 680                     (cmd == ETHTOOL_STXCSUM) ? TOE_TX_CSUM_OL : TOE_RX_CSUM_OL;
 681
 682                 if (edata.data != 0)
 683                         toe_cmpnt |= csum_dir;
 684                 else
 685                         toe_cmpnt &= ~csum_dir;
 686
 687                 ret = brcmf_toe_set(drvr, 0, toe_cmpnt);
 688                 if (ret < 0)
 689                         return ret;
 690
 691                 /* If setting TX checksum mode, tell Linux the new mode */
 692                 if (cmd == ETHTOOL_STXCSUM) {
 693                         if (edata.data)
 694                                 drvr->iflist[0]->ndev->features |=
 695                                     NETIF_F_IP_CSUM;
 696                         else
 697                                 drvr->iflist[0]->ndev->features &=
 698                                     ~NETIF_F_IP_CSUM;
 699                 }
 700
 701                 break;
 702
 703         default:
 704                 return -EOPNOTSUPP;
 705         }
 706
 707         return 0;
 708 }
 709
 710 static int brcmf_netdev_ioctl_entry(struct net_device *ndev, struct ifreq *ifr,
 711                                     int cmd)
 712 {
 713         struct brcmf_if *ifp = netdev_priv(ndev);
 714         struct brcmf_pub *drvr = ifp->drvr;
 715
 716         brcmf_dbg(TRACE, "ifidx %d, cmd 0x%04x\n", ifp->idx, cmd);
 717
 718         if (!drvr->iflist[ifp->idx])
 719                 return -1;
 720
 721         if (cmd == SIOCETHTOOL)
 722                 return brcmf_ethtool(drvr, ifr->ifr_data);
 723
 724         return -EOPNOTSUPP;
 725 }
 726
 727 /* called only from within this driver. Sends a command to the dongle. */
 728 s32 brcmf_exec_dcmd(struct net_device *ndev, u32 cmd, void *arg, u32 len)
 729 {
 730         struct brcmf_dcmd dcmd;
 731         s32 err = 0;
 732         int buflen = 0;
 733         bool is_set_key_cmd;
 734         struct brcmf_if *ifp = netdev_priv(ndev);
 735         struct brcmf_pub *drvr = ifp->drvr;
 736
 737         memset(&dcmd, 0, sizeof(dcmd));
 738         dcmd.cmd = cmd;
 739         dcmd.buf = arg;
 740         dcmd.len = len;
 741
 742         if (dcmd.buf != NULL)
 743                 buflen = min_t(uint, dcmd.len, BRCMF_DCMD_MAXLEN);
 744
 745         /* send to dongle (must be up, and wl) */
 746         if ((drvr->bus_if->state != BRCMF_BUS_DATA)) {
 747                 brcmf_dbg(ERROR, "DONGLE_DOWN\n");
 748                 err = -EIO;
 749                 goto done;
 750         }
 751
 752         if (!drvr->iswl) {
 753                 err = -EIO;
 754                 goto done;
 755         }
 756
 757         /*
 758          * Intercept BRCMF_C_SET_KEY CMD - serialize M4 send and
 759          * set key CMD to prevent M4 encryption.
 760          */
 761         is_set_key_cmd = ((dcmd.cmd == BRCMF_C_SET_KEY) ||
 762                           ((dcmd.cmd == BRCMF_C_SET_VAR) &&
 763                            !(strncmp("wsec_key", dcmd.buf, 9))) ||
 764                           ((dcmd.cmd == BRCMF_C_SET_VAR) &&
 765                            !(strncmp("bsscfg:wsec_key", dcmd.buf, 15))));
 766         if (is_set_key_cmd)
 767                 brcmf_netdev_wait_pend8021x(ndev);
 768
 769         err = brcmf_proto_dcmd(drvr, ifp->idx, &dcmd, buflen);
 770
 771 done:
 772         if (err > 0)
 773                 err = 0;
 774
 775         return err;
 776 }
 777
 778 static int brcmf_netdev_stop(struct net_device *ndev)
 779 {
 780         struct brcmf_if *ifp = netdev_priv(ndev);
 781         struct brcmf_pub *drvr = ifp->drvr;
 782
 783         brcmf_dbg(TRACE, "Enter\n");
 784         brcmf_cfg80211_down(drvr->config);
 785         if (drvr->bus_if->drvr_up == 0)
 786                 return 0;
 787
 788         /* Set state and stop OS transmissions */
 789         drvr->bus_if->drvr_up = false;
 790         netif_stop_queue(ndev);
 791
 792         return 0;
 793 }
 794
 795 static int brcmf_netdev_open(struct net_device *ndev)
 796 {
 797         struct brcmf_if *ifp = netdev_priv(ndev);
 798         struct brcmf_pub *drvr = ifp->drvr;
 799         struct brcmf_bus *bus_if = drvr->bus_if;
 800         u32 toe_ol;
 801         s32 ret = 0;
 802         uint up = 0;
 803
 804         brcmf_dbg(TRACE, "ifidx %d\n", ifp->idx);
 805
 806         if (ifp->idx == 0) {    /* do it only for primary eth0 */
 807                 /* If bus is not ready, can't continue */
 808                 if (bus_if->state != BRCMF_BUS_DATA) {
 809                         brcmf_dbg(ERROR, "failed bus is not ready\n");
 810                         return -EAGAIN;
 811                 }
 812
 813                 atomic_set(&drvr->pend_8021x_cnt, 0);
 814
 815                 memcpy(ndev->dev_addr, drvr->mac, ETH_ALEN);
 816
 817                 /* Get current TOE mode from dongle */
 818                 if (brcmf_toe_get(drvr, ifp->idx, &toe_ol) >= 0
 819                     && (toe_ol & TOE_TX_CSUM_OL) != 0)
 820                         drvr->iflist[ifp->idx]->ndev->features |=
 821                                 NETIF_F_IP_CSUM;
 822                 else
 823                         drvr->iflist[ifp->idx]->ndev->features &=
 824                                 ~NETIF_F_IP_CSUM;
 825         }
 826
 827         /* make sure RF is ready for work */
 828         brcmf_proto_cdc_set_dcmd(drvr, 0, BRCMF_C_UP, (char *)&up, sizeof(up));
 829
 830         /* Allow transmit calls */
 831         netif_start_queue(ndev);
 832         drvr->bus_if->drvr_up = true;
 833         if (brcmf_cfg80211_up(drvr->config)) {
 834                 brcmf_dbg(ERROR, "failed to bring up cfg80211\n");
 835                 return -1;
 836         }
 837
 838         return ret;
 839 }
 840
 841 static const struct net_device_ops brcmf_netdev_ops_pri = {
 842         .ndo_open = brcmf_netdev_open,
 843         .ndo_stop = brcmf_netdev_stop,
 844         .ndo_get_stats = brcmf_netdev_get_stats,
 845         .ndo_do_ioctl = brcmf_netdev_ioctl_entry,
 846         .ndo_start_xmit = brcmf_netdev_start_xmit,
 847         .ndo_set_mac_address = brcmf_netdev_set_mac_address,
 848         .ndo_set_rx_mode = brcmf_netdev_set_multicast_list
 849 };
 850
 851 static int brcmf_net_attach(struct brcmf_if *ifp)
 852 {
 853         struct brcmf_pub *drvr = ifp->drvr;
 854         struct net_device *ndev;
 855         u8 temp_addr[ETH_ALEN];
 856
 857         brcmf_dbg(TRACE, "ifidx %d\n", ifp->idx);
 858
 859         ndev = drvr->iflist[ifp->idx]->ndev;
 860         ndev->netdev_ops = &brcmf_netdev_ops_pri;
 861
 862         /*
 863          * determine mac address to use
 864          */
 865         if (is_valid_ether_addr(ifp->mac_addr))
 866                 memcpy(temp_addr, ifp->mac_addr, ETH_ALEN);
 867         else
 868                 memcpy(temp_addr, drvr->mac, ETH_ALEN);
 869
 870         if (ifp->idx == 1) {
 871                 brcmf_dbg(TRACE, "ACCESS POINT MAC:\n");
 872                 /*  ACCESSPOINT INTERFACE CASE */
 873                 temp_addr[0] |= 0X02;   /* set bit 2 ,
 874                          - Locally Administered address  */
 875
 876         }
 877         ndev->hard_header_len = ETH_HLEN + drvr->hdrlen;
 878         ndev->ethtool_ops = &brcmf_ethtool_ops;
 879
 880         drvr->rxsz = ndev->mtu + ndev->hard_header_len +
 881                               drvr->hdrlen;
 882
 883         memcpy(ndev->dev_addr, temp_addr, ETH_ALEN);
 884
 885         /* attach to cfg80211 for primary interface */
 886         if (!ifp->idx) {
 887                 drvr->config = brcmf_cfg80211_attach(ndev, drvr->dev, drvr);
 888                 if (drvr->config == NULL) {
 889                         brcmf_dbg(ERROR, "wl_cfg80211_attach failed\n");
 890                         goto fail;
 891                 }
 892         }
 893
 894         if (register_netdev(ndev) != 0) {
 895                 brcmf_dbg(ERROR, "couldn't register the net device\n");
 896                 goto fail;
 897         }
 898
 899         brcmf_dbg(INFO, "%s: Broadcom Dongle Host Driver\n", ndev->name);
 900
 901         return 0;
 902
 903 fail:
 904         ndev->netdev_ops = NULL;
 905         return -EBADE;
 906 }
 907
 908 int
 909 brcmf_add_if(struct device *dev, int ifidx, char *name, u8 *mac_addr)
 910 {
 911         struct brcmf_if *ifp;
 912         struct net_device *ndev;
 913         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
 914         struct brcmf_pub *drvr = bus_if->drvr;
 915
 916         brcmf_dbg(TRACE, "idx %d\n", ifidx);
 917
 918         ifp = drvr->iflist[ifidx];
 919         /*
 920          * Delete the existing interface before overwriting it
 921          * in case we missed the BRCMF_E_IF_DEL event.
 922          */
 923         if (ifp) {
 924                 brcmf_dbg(ERROR, "ERROR: netdev:%s already exists, try free & unregister\n",
 925                           ifp->ndev->name);
 926                 netif_stop_queue(ifp->ndev);
 927                 unregister_netdev(ifp->ndev);
 928                 free_netdev(ifp->ndev);
 929                 drvr->iflist[ifidx] = NULL;
 930         }
 931
 932         /* Allocate netdev, including space for private structure */
 933         ndev = alloc_netdev(sizeof(struct brcmf_if), name, ether_setup);
 934         if (!ndev) {
 935                 brcmf_dbg(ERROR, "OOM - alloc_netdev\n");
 936                 return -ENOMEM;
 937         }
 938
 939         ifp = netdev_priv(ndev);
 940         ifp->ndev = ndev;
 941         ifp->drvr = drvr;
 942         drvr->iflist[ifidx] = ifp;
 943         ifp->idx = ifidx;
 944         if (mac_addr != NULL)
 945                 memcpy(&ifp->mac_addr, mac_addr, ETH_ALEN);
 946
 947         if (brcmf_net_attach(ifp)) {
 948                 brcmf_dbg(ERROR, "brcmf_net_attach failed");
 949                 free_netdev(ifp->ndev);
 950                 drvr->iflist[ifidx] = NULL;
 951                 return -EOPNOTSUPP;
 952         }
 953
 954         brcmf_dbg(TRACE, " ==== pid:%x, net_device for if:%s created ===\n",
 955                   current->pid, ifp->ndev->name);
 956
 957         return 0;
 958 }
 959
 960 void brcmf_del_if(struct brcmf_pub *drvr, int ifidx)
 961 {
 962         struct brcmf_if *ifp;
 963
 964         brcmf_dbg(TRACE, "idx %d\n", ifidx);
 965
 966         ifp = drvr->iflist[ifidx];
 967         if (!ifp) {
 968                 brcmf_dbg(ERROR, "Null interface\n");
 969                 return;
 970         }
 971         if (ifp->ndev) {
 972                 if (ifidx == 0) {
 973                         if (ifp->ndev->netdev_ops == &brcmf_netdev_ops_pri) {
 974                                 rtnl_lock();
 975                                 brcmf_netdev_stop(ifp->ndev);
 976                                 rtnl_unlock();
 977                         }
 978                 } else {
 979                         netif_stop_queue(ifp->ndev);
 980                 }
 981
 982                 unregister_netdev(ifp->ndev);
 983                 drvr->iflist[ifidx] = NULL;
 984                 if (ifidx == 0)
 985                         brcmf_cfg80211_detach(drvr->config);
 986                 free_netdev(ifp->ndev);
 987         }
 988 }
 989
 990 int brcmf_attach(uint bus_hdrlen, struct device *dev)
 991 {
 992         struct brcmf_pub *drvr = NULL;
 993         int ret = 0;
 994
 995         brcmf_dbg(TRACE, "Enter\n");
 996
 997         /* Allocate primary brcmf_info */
 998         drvr = kzalloc(sizeof(struct brcmf_pub), GFP_ATOMIC);
 999         if (!drvr)
1000                 return -ENOMEM;
1001
1002         mutex_init(&drvr->proto_block);
1003
1004         /* Link to bus module */
1005         drvr->hdrlen = bus_hdrlen;
1006         drvr->bus_if = dev_get_drvdata(dev);
1007         drvr->bus_if->drvr = drvr;
1008         drvr->dev = dev;
1009
1010         /* create device debugfs folder */
1011         brcmf_debugfs_attach(drvr);
1012
1013         /* Attach and link in the protocol */
1014         ret = brcmf_proto_attach(drvr);
1015         if (ret != 0) {
1016                 brcmf_dbg(ERROR, "brcmf_prot_attach failed\n");
1017                 goto fail;
1018         }
1019
1020         INIT_WORK(&drvr->setmacaddr_work, _brcmf_set_mac_address);
1021         INIT_WORK(&drvr->multicast_work, _brcmf_set_multicast_list);
1022
1023         INIT_LIST_HEAD(&drvr->bus_if->dcmd_list);
1024
1025         return ret;
1026
1027 fail:
1028         brcmf_detach(dev);
1029
1030         return ret;
1031 }
1032
1033 int brcmf_bus_start(struct device *dev)
1034 {
1035         int ret = -1;
1036         /* Room for "event_msgs" + '\0' + bitvec */
1037         char iovbuf[BRCMF_EVENTING_MASK_LEN + 12];
1038         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1039         struct brcmf_pub *drvr = bus_if->drvr;
1040
1041         brcmf_dbg(TRACE, "\n");
1042
1043         /* Bring up the bus */
1044         ret = bus_if->brcmf_bus_init(dev);
1045         if (ret != 0) {
1046                 brcmf_dbg(ERROR, "brcmf_sdbrcm_bus_init failed %d\n", ret);
1047                 return ret;
1048         }
1049
1050         brcmf_c_mkiovar("event_msgs", drvr->eventmask, BRCMF_EVENTING_MASK_LEN,
1051                       iovbuf, sizeof(iovbuf));
1052         brcmf_proto_cdc_query_dcmd(drvr, 0, BRCMF_C_GET_VAR, iovbuf,
1053                                     sizeof(iovbuf));
1054         memcpy(drvr->eventmask, iovbuf, BRCMF_EVENTING_MASK_LEN);
1055
1056         setbit(drvr->eventmask, BRCMF_E_SET_SSID);
1057         setbit(drvr->eventmask, BRCMF_E_PRUNE);
1058         setbit(drvr->eventmask, BRCMF_E_AUTH);
1059         setbit(drvr->eventmask, BRCMF_E_REASSOC);
1060         setbit(drvr->eventmask, BRCMF_E_REASSOC_IND);
1061         setbit(drvr->eventmask, BRCMF_E_DEAUTH_IND);
1062         setbit(drvr->eventmask, BRCMF_E_DISASSOC_IND);
1063         setbit(drvr->eventmask, BRCMF_E_DISASSOC);
1064         setbit(drvr->eventmask, BRCMF_E_JOIN);
1065         setbit(drvr->eventmask, BRCMF_E_ASSOC_IND);
1066         setbit(drvr->eventmask, BRCMF_E_PSK_SUP);
1067         setbit(drvr->eventmask, BRCMF_E_LINK);
1068         setbit(drvr->eventmask, BRCMF_E_NDIS_LINK);
1069         setbit(drvr->eventmask, BRCMF_E_MIC_ERROR);
1070         setbit(drvr->eventmask, BRCMF_E_PMKID_CACHE);
1071         setbit(drvr->eventmask, BRCMF_E_TXFAIL);
1072         setbit(drvr->eventmask, BRCMF_E_JOIN_START);
1073         setbit(drvr->eventmask, BRCMF_E_SCAN_COMPLETE);
1074
1075 /* enable dongle roaming event */
1076
1077         drvr->pktfilter_count = 1;
1078         /* Setup filter to allow only unicast */
1079         drvr->pktfilter[0] = "100 0 0 0 0x01 0x00";
1080
1081         /* Bus is ready, do any protocol initialization */
1082         ret = brcmf_proto_init(drvr);
1083         if (ret < 0)
1084                 return ret;
1085
1086         /* add primary networking interface */
1087         ret = brcmf_add_if(dev, 0, "wlan%d", drvr->mac);
1088         if (ret < 0)
1089                 return ret;
1090
1091         /* signal bus ready */
1092         bus_if->state = BRCMF_BUS_DATA;
1093         return 0;
1094 }
1095
1096 static void brcmf_bus_detach(struct brcmf_pub *drvr)
1097 {
1098         brcmf_dbg(TRACE, "Enter\n");
1099
1100         if (drvr) {
1101                 /* Stop the protocol module */
1102                 brcmf_proto_stop(drvr);
1103
1104                 /* Stop the bus module */
1105                 drvr->bus_if->brcmf_bus_stop(drvr->dev);
1106         }
1107 }
1108
1109 void brcmf_detach(struct device *dev)
1110 {
1111         int i;
1112         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1113         struct brcmf_pub *drvr = bus_if->drvr;
1114
1115         brcmf_dbg(TRACE, "Enter\n");
1116
1117
1118         /* make sure primary interface removed last */
1119         for (i = BRCMF_MAX_IFS-1; i > -1; i--)
1120                 if (drvr->iflist[i])
1121                         brcmf_del_if(drvr, i);
1122
1123         brcmf_bus_detach(drvr);
1124
1125         if (drvr->prot) {
1126                 cancel_work_sync(&drvr->setmacaddr_work);
1127                 cancel_work_sync(&drvr->multicast_work);
1128                 brcmf_proto_detach(drvr);
1129         }
1130
1131         brcmf_debugfs_detach(drvr);
1132         bus_if->drvr = NULL;
1133         kfree(drvr);
1134 }
1135
1136 static int brcmf_get_pend_8021x_cnt(struct brcmf_pub *drvr)
1137 {
1138         return atomic_read(&drvr->pend_8021x_cnt);
1139 }
1140
1141 #define MAX_WAIT_FOR_8021X_TX   10
1142
1143 int brcmf_netdev_wait_pend8021x(struct net_device *ndev)
1144 {
1145         struct brcmf_if *ifp = netdev_priv(ndev);
1146         struct brcmf_pub *drvr = ifp->drvr;
1147         int timeout = 10 * HZ / 1000;
1148         int ntimes = MAX_WAIT_FOR_8021X_TX;
1149         int pend = brcmf_get_pend_8021x_cnt(drvr);
1150
1151         while (ntimes && pend) {
1152                 if (pend) {
1153                         set_current_state(TASK_INTERRUPTIBLE);
1154                         schedule_timeout(timeout);
1155                         set_current_state(TASK_RUNNING);
1156                         ntimes--;
1157                 }
1158                 pend = brcmf_get_pend_8021x_cnt(drvr);
1159         }
1160         return pend;
1161 }
1162
1163 #ifdef DEBUG
1164 int brcmf_write_to_file(struct brcmf_pub *drvr, const u8 *buf, int size)
1165 {
1166         int ret = 0;
1167         struct file *fp;
1168         mm_segment_t old_fs;
1169         loff_t pos = 0;
1170
1171         /* change to KERNEL_DS address limit */
1172         old_fs = get_fs();
1173         set_fs(KERNEL_DS);
1174
1175         /* open file to write */
1176         fp = filp_open("/tmp/mem_dump", O_WRONLY | O_CREAT, 0640);
1177         if (!fp) {
1178                 brcmf_dbg(ERROR, "open file error\n");
1179                 ret = -1;
1180                 goto exit;
1181         }
1182
1183         /* Write buf to file */
1184         fp->f_op->write(fp, (char __user *)buf, size, &pos);
1185
1186 exit:
1187         /* free buf before return */
1188         kfree(buf);
1189         /* close file before return */
1190         if (fp)
1191                 filp_close(fp, NULL);
1192         /* restore previous address limit */
1193         set_fs(old_fs);
1194
1195         return ret;
1196 }
1197 #endif                          /* DEBUG */
1198
1199 static void brcmf_driver_init(struct work_struct *work)
1200 {
1201         brcmf_debugfs_init();
1202
1203 #ifdef CONFIG_BRCMFMAC_SDIO
1204         brcmf_sdio_init();
1205 #endif
1206 #ifdef CONFIG_BRCMFMAC_USB
1207         brcmf_usb_init();
1208 #endif
1209 }
1210 static DECLARE_WORK(brcmf_driver_work, brcmf_driver_init);
1211
1212 static int __init brcmfmac_module_init(void)
1213 {
1214         if (!schedule_work(&brcmf_driver_work))
1215                 return -EBUSY;
1216
1217         return 0;
1218 }
1219
1220 static void __exit brcmfmac_module_exit(void)
1221 {
1222         cancel_work_sync(&brcmf_driver_work);
1223
1224 #ifdef CONFIG_BRCMFMAC_SDIO
1225         brcmf_sdio_exit();
1226 #endif
1227 #ifdef CONFIG_BRCMFMAC_USB
1228         brcmf_usb_exit();
1229 #endif
1230         brcmf_debugfs_exit();
1231 }
1232
1233 module_init(brcmfmac_module_init);
1234 module_exit(brcmfmac_module_exit);