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 #include "fwil.h"
  49
  50 MODULE_AUTHOR("Broadcom Corporation");
  51 MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN fullmac driver.");
  52 MODULE_SUPPORTED_DEVICE("Broadcom 802.11n WLAN fullmac cards");
  53 MODULE_LICENSE("Dual BSD/GPL");
  54
  55 #define MAX_WAIT_FOR_8021X_TX           50      /* msecs */
  56
  57 /* Error bits */
  58 int brcmf_msg_level = BRCMF_ERROR_VAL;
  59 module_param(brcmf_msg_level, int, 0);
  60
  61 int brcmf_ifname2idx(struct brcmf_pub *drvr, char *name)
  62 {
  63         int i = BRCMF_MAX_IFS;
  64         struct brcmf_if *ifp;
  65
  66         if (name == NULL || *name == '\0')
  67                 return 0;
  68
  69         while (--i > 0) {
  70                 ifp = drvr->iflist[i];
  71                 if (ifp && !strncmp(ifp->ndev->name, name, IFNAMSIZ))
  72                         break;
  73         }
  74
  75         brcmf_dbg(TRACE, "return idx %d for \"%s\"\n", i, name);
  76
  77         return i;               /* default - the primary interface */
  78 }
  79
  80 char *brcmf_ifname(struct brcmf_pub *drvr, int ifidx)
  81 {
  82         if (ifidx < 0 || ifidx >= BRCMF_MAX_IFS) {
  83                 brcmf_dbg(ERROR, "ifidx %d out of range\n", ifidx);
  84                 return "<if_bad>";
  85         }
  86
  87         if (drvr->iflist[ifidx] == NULL) {
  88                 brcmf_dbg(ERROR, "null i/f %d\n", ifidx);
  89                 return "<if_null>";
  90         }
  91
  92         if (drvr->iflist[ifidx]->ndev)
  93                 return drvr->iflist[ifidx]->ndev->name;
  94
  95         return "<if_none>";
  96 }
  97
  98 static void _brcmf_set_multicast_list(struct work_struct *work)
  99 {
 100         struct brcmf_if *ifp;
 101         struct net_device *ndev;
 102         struct netdev_hw_addr *ha;
 103         u32 cmd_value, cnt;
 104         __le32 cnt_le;
 105         char *buf, *bufp;
 106         u32 buflen;
 107         s32 err;
 108
 109         brcmf_dbg(TRACE, "enter\n");
 110
 111         ifp = container_of(work, struct brcmf_if, multicast_work);
 112         ndev = ifp->ndev;
 113
 114         /* Determine initial value of allmulti flag */
 115         cmd_value = (ndev->flags & IFF_ALLMULTI) ? true : false;
 116
 117         /* Send down the multicast list first. */
 118         cnt = netdev_mc_count(ndev);
 119         buflen = sizeof(cnt) + (cnt * ETH_ALEN);
 120         buf = kmalloc(buflen, GFP_ATOMIC);
 121         if (!buf)
 122                 return;
 123         bufp = buf;
 124
 125         cnt_le = cpu_to_le32(cnt);
 126         memcpy(bufp, &cnt_le, sizeof(cnt_le));
 127         bufp += sizeof(cnt_le);
 128
 129         netdev_for_each_mc_addr(ha, ndev) {
 130                 if (!cnt)
 131                         break;
 132                 memcpy(bufp, ha->addr, ETH_ALEN);
 133                 bufp += ETH_ALEN;
 134                 cnt--;
 135         }
 136
 137         err = brcmf_fil_iovar_data_set(ifp, "mcast_list", buf, buflen);
 138         if (err < 0) {
 139                 brcmf_dbg(ERROR, "Setting mcast_list failed, %d\n", err);
 140                 cmd_value = cnt ? true : cmd_value;
 141         }
 142
 143         kfree(buf);
 144
 145         /*
 146          * Now send the allmulti setting.  This is based on the setting in the
 147          * net_device flags, but might be modified above to be turned on if we
 148          * were trying to set some addresses and dongle rejected it...
 149          */
 150         err = brcmf_fil_iovar_int_set(ifp, "allmulti", cmd_value);
 151         if (err < 0)
 152                 brcmf_dbg(ERROR, "Setting allmulti failed, %d\n", err);
 153
 154         /*Finally, pick up the PROMISC flag */
 155         cmd_value = (ndev->flags & IFF_PROMISC) ? true : false;
 156         err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PROMISC, cmd_value);
 157         if (err < 0)
 158                 brcmf_dbg(ERROR, "Setting BRCMF_C_SET_PROMISC failed, %d\n",
 159                           err);
 160 }
 161
 162 static void
 163 _brcmf_set_mac_address(struct work_struct *work)
 164 {
 165         struct brcmf_if *ifp;
 166         s32 err;
 167
 168         brcmf_dbg(TRACE, "enter\n");
 169
 170         ifp = container_of(work, struct brcmf_if, setmacaddr_work);
 171         err = brcmf_fil_iovar_data_set(ifp, "cur_etheraddr", ifp->mac_addr,
 172                                        ETH_ALEN);
 173         if (err < 0) {
 174                 brcmf_dbg(ERROR, "Setting cur_etheraddr failed, %d\n", err);
 175         } else {
 176                 brcmf_dbg(TRACE, "MAC address updated to %pM\n",
 177                           ifp->mac_addr);
 178                 memcpy(ifp->ndev->dev_addr, ifp->mac_addr, ETH_ALEN);
 179         }
 180 }
 181
 182 static int brcmf_netdev_set_mac_address(struct net_device *ndev, void *addr)
 183 {
 184         struct brcmf_if *ifp = netdev_priv(ndev);
 185         struct sockaddr *sa = (struct sockaddr *)addr;
 186
 187         memcpy(&ifp->mac_addr, sa->sa_data, ETH_ALEN);
 188         schedule_work(&ifp->setmacaddr_work);
 189         return 0;
 190 }
 191
 192 static void brcmf_netdev_set_multicast_list(struct net_device *ndev)
 193 {
 194         struct brcmf_if *ifp = netdev_priv(ndev);
 195
 196         schedule_work(&ifp->multicast_work);
 197 }
 198
 199 static int brcmf_netdev_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 200 {
 201         int ret;
 202         struct brcmf_if *ifp = netdev_priv(ndev);
 203         struct brcmf_pub *drvr = ifp->drvr;
 204
 205         brcmf_dbg(TRACE, "Enter\n");
 206
 207         /* Reject if down */
 208         if (!drvr->bus_if->drvr_up ||
 209             (drvr->bus_if->state != BRCMF_BUS_DATA)) {
 210                 brcmf_dbg(ERROR, "xmit rejected drvup=%d state=%d\n",
 211                           drvr->bus_if->drvr_up,
 212                           drvr->bus_if->state);
 213                 netif_stop_queue(ndev);
 214                 return -ENODEV;
 215         }
 216
 217         if (!drvr->iflist[ifp->idx]) {
 218                 brcmf_dbg(ERROR, "bad ifidx %d\n", ifp->idx);
 219                 netif_stop_queue(ndev);
 220                 return -ENODEV;
 221         }
 222
 223         /* Make sure there's enough room for any header */
 224         if (skb_headroom(skb) < drvr->hdrlen) {
 225                 struct sk_buff *skb2;
 226
 227                 brcmf_dbg(INFO, "%s: insufficient headroom\n",
 228                           brcmf_ifname(drvr, ifp->idx));
 229                 drvr->bus_if->tx_realloc++;
 230                 skb2 = skb_realloc_headroom(skb, drvr->hdrlen);
 231                 dev_kfree_skb(skb);
 232                 skb = skb2;
 233                 if (skb == NULL) {
 234                         brcmf_dbg(ERROR, "%s: skb_realloc_headroom failed\n",
 235                                   brcmf_ifname(drvr, ifp->idx));
 236                         ret = -ENOMEM;
 237                         goto done;
 238                 }
 239         }
 240
 241         /* Update multicast statistic */
 242         if (skb->len >= ETH_ALEN) {
 243                 u8 *pktdata = (u8 *)(skb->data);
 244                 struct ethhdr *eh = (struct ethhdr *)pktdata;
 245
 246                 if (is_multicast_ether_addr(eh->h_dest))
 247                         drvr->tx_multicast++;
 248                 if (ntohs(eh->h_proto) == ETH_P_PAE)
 249                         atomic_inc(&drvr->pend_8021x_cnt);
 250         }
 251
 252         /* If the protocol uses a data header, apply it */
 253         brcmf_proto_hdrpush(drvr, ifp->idx, skb);
 254
 255         /* Use bus module to send data frame */
 256         ret =  drvr->bus_if->brcmf_bus_txdata(drvr->dev, skb);
 257
 258 done:
 259         if (ret)
 260                 drvr->bus_if->dstats.tx_dropped++;
 261         else
 262                 drvr->bus_if->dstats.tx_packets++;
 263
 264         /* Return ok: we always eat the packet */
 265         return 0;
 266 }
 267
 268 void brcmf_txflowblock(struct device *dev, bool state)
 269 {
 270         struct net_device *ndev;
 271         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
 272         struct brcmf_pub *drvr = bus_if->drvr;
 273         int i;
 274
 275         brcmf_dbg(TRACE, "Enter\n");
 276
 277         for (i = 0; i < BRCMF_MAX_IFS; i++)
 278                 if (drvr->iflist[i]) {
 279                         ndev = drvr->iflist[i]->ndev;
 280                         if (state)
 281                                 netif_stop_queue(ndev);
 282                         else
 283                                 netif_wake_queue(ndev);
 284                 }
 285 }
 286
 287 void brcmf_rx_frame(struct device *dev, u8 ifidx,
 288                     struct sk_buff_head *skb_list)
 289 {
 290         unsigned char *eth;
 291         uint len;
 292         struct sk_buff *skb, *pnext;
 293         struct brcmf_if *ifp;
 294         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
 295         struct brcmf_pub *drvr = bus_if->drvr;
 296
 297         brcmf_dbg(TRACE, "Enter\n");
 298
 299         skb_queue_walk_safe(skb_list, skb, pnext) {
 300                 skb_unlink(skb, skb_list);
 301
 302                 /* Get the protocol, maintain skb around eth_type_trans()
 303                  * The main reason for this hack is for the limitation of
 304                  * Linux 2.4 where 'eth_type_trans' uses the
 305                  * 'net->hard_header_len'
 306                  * to perform skb_pull inside vs ETH_HLEN. Since to avoid
 307                  * coping of the packet coming from the network stack to add
 308                  * BDC, Hardware header etc, during network interface
 309                  * registration
 310                  * we set the 'net->hard_header_len' to ETH_HLEN + extra space
 311                  * required
 312                  * for BDC, Hardware header etc. and not just the ETH_HLEN
 313                  */
 314                 eth = skb->data;
 315                 len = skb->len;
 316
 317                 ifp = drvr->iflist[ifidx];
 318                 if (ifp == NULL)
 319                         ifp = drvr->iflist[0];
 320
 321                 if (!ifp || !ifp->ndev ||
 322                     ifp->ndev->reg_state != NETREG_REGISTERED) {
 323                         brcmu_pkt_buf_free_skb(skb);
 324                         continue;
 325                 }
 326
 327                 skb->dev = ifp->ndev;
 328                 skb->protocol = eth_type_trans(skb, skb->dev);
 329
 330                 if (skb->pkt_type == PACKET_MULTICAST)
 331                         bus_if->dstats.multicast++;
 332
 333                 skb->data = eth;
 334                 skb->len = len;
 335
 336                 /* Strip header, count, deliver upward */
 337                 skb_pull(skb, ETH_HLEN);
 338
 339                 /* Process special event packets and then discard them */
 340                 brcmf_fweh_process_skb(drvr, skb, &ifidx);
 341
 342                 if (drvr->iflist[ifidx]) {
 343                         ifp = drvr->iflist[ifidx];
 344                         ifp->ndev->last_rx = jiffies;
 345                 }
 346
 347                 bus_if->dstats.rx_bytes += skb->len;
 348                 bus_if->dstats.rx_packets++;    /* Local count */
 349
 350                 if (in_interrupt())
 351                         netif_rx(skb);
 352                 else
 353                         /* If the receive is not processed inside an ISR,
 354                          * the softirqd must be woken explicitly to service
 355                          * the NET_RX_SOFTIRQ.  In 2.6 kernels, this is handled
 356                          * by netif_rx_ni(), but in earlier kernels, we need
 357                          * to do it manually.
 358                          */
 359                         netif_rx_ni(skb);
 360         }
 361 }
 362
 363 void brcmf_txcomplete(struct device *dev, struct sk_buff *txp, bool success)
 364 {
 365         uint ifidx;
 366         struct ethhdr *eh;
 367         u16 type;
 368         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
 369         struct brcmf_pub *drvr = bus_if->drvr;
 370
 371         brcmf_proto_hdrpull(dev, &ifidx, txp);
 372
 373         eh = (struct ethhdr *)(txp->data);
 374         type = ntohs(eh->h_proto);
 375
 376         if (type == ETH_P_PAE) {
 377                 atomic_dec(&drvr->pend_8021x_cnt);
 378                 if (waitqueue_active(&drvr->pend_8021x_wait))
 379                         wake_up(&drvr->pend_8021x_wait);
 380         }
 381 }
 382
 383 static struct net_device_stats *brcmf_netdev_get_stats(struct net_device *ndev)
 384 {
 385         struct brcmf_if *ifp = netdev_priv(ndev);
 386         struct brcmf_bus *bus_if = ifp->drvr->bus_if;
 387
 388         brcmf_dbg(TRACE, "Enter\n");
 389
 390         /* Copy dongle stats to net device stats */
 391         ifp->stats.rx_packets = bus_if->dstats.rx_packets;
 392         ifp->stats.tx_packets = bus_if->dstats.tx_packets;
 393         ifp->stats.rx_bytes = bus_if->dstats.rx_bytes;
 394         ifp->stats.tx_bytes = bus_if->dstats.tx_bytes;
 395         ifp->stats.rx_errors = bus_if->dstats.rx_errors;
 396         ifp->stats.tx_errors = bus_if->dstats.tx_errors;
 397         ifp->stats.rx_dropped = bus_if->dstats.rx_dropped;
 398         ifp->stats.tx_dropped = bus_if->dstats.tx_dropped;
 399         ifp->stats.multicast = bus_if->dstats.multicast;
 400
 401         return &ifp->stats;
 402 }
 403
 404 /*
 405  * Set current toe component enables in toe_ol iovar,
 406  * and set toe global enable iovar
 407  */
 408 static int brcmf_toe_set(struct brcmf_if *ifp, u32 toe_ol)
 409 {
 410         s32 err;
 411
 412         err = brcmf_fil_iovar_int_set(ifp, "toe_ol", toe_ol);
 413         if (err < 0) {
 414                 brcmf_dbg(ERROR, "Setting toe_ol failed, %d\n", err);
 415                 return err;
 416         }
 417
 418         err = brcmf_fil_iovar_int_set(ifp, "toe", (toe_ol != 0));
 419         if (err < 0)
 420                 brcmf_dbg(ERROR, "Setting toe failed, %d\n", err);
 421
 422         return err;
 423
 424 }
 425
 426 static void brcmf_ethtool_get_drvinfo(struct net_device *ndev,
 427                                     struct ethtool_drvinfo *info)
 428 {
 429         struct brcmf_if *ifp = netdev_priv(ndev);
 430         struct brcmf_pub *drvr = ifp->drvr;
 431
 432         sprintf(info->driver, KBUILD_MODNAME);
 433         sprintf(info->version, "%lu", drvr->drv_version);
 434         sprintf(info->bus_info, "%s", dev_name(drvr->dev));
 435 }
 436
 437 static const struct ethtool_ops brcmf_ethtool_ops = {
 438         .get_drvinfo = brcmf_ethtool_get_drvinfo,
 439 };
 440
 441 static int brcmf_ethtool(struct brcmf_if *ifp, void __user *uaddr)
 442 {
 443         struct brcmf_pub *drvr = ifp->drvr;
 444         struct ethtool_drvinfo info;
 445         char drvname[sizeof(info.driver)];
 446         u32 cmd;
 447         struct ethtool_value edata;
 448         u32 toe_cmpnt, csum_dir;
 449         int ret;
 450
 451         brcmf_dbg(TRACE, "Enter\n");
 452
 453         /* all ethtool calls start with a cmd word */
 454         if (copy_from_user(&cmd, uaddr, sizeof(u32)))
 455                 return -EFAULT;
 456
 457         switch (cmd) {
 458         case ETHTOOL_GDRVINFO:
 459                 /* Copy out any request driver name */
 460                 if (copy_from_user(&info, uaddr, sizeof(info)))
 461                         return -EFAULT;
 462                 strncpy(drvname, info.driver, sizeof(info.driver));
 463                 drvname[sizeof(info.driver) - 1] = '\0';
 464
 465                 /* clear struct for return */
 466                 memset(&info, 0, sizeof(info));
 467                 info.cmd = cmd;
 468
 469                 /* if requested, identify ourselves */
 470                 if (strcmp(drvname, "?dhd") == 0) {
 471                         sprintf(info.driver, "dhd");
 472                         strcpy(info.version, BRCMF_VERSION_STR);
 473                 }
 474
 475                 /* otherwise, require dongle to be up */
 476                 else if (!drvr->bus_if->drvr_up) {
 477                         brcmf_dbg(ERROR, "dongle is not up\n");
 478                         return -ENODEV;
 479                 }
 480                 /* finally, report dongle driver type */
 481                 else
 482                         sprintf(info.driver, "wl");
 483
 484                 sprintf(info.version, "%lu", drvr->drv_version);
 485                 if (copy_to_user(uaddr, &info, sizeof(info)))
 486                         return -EFAULT;
 487                 brcmf_dbg(CTL, "given %*s, returning %s\n",
 488                           (int)sizeof(drvname), drvname, info.driver);
 489                 break;
 490
 491                 /* Get toe offload components from dongle */
 492         case ETHTOOL_GRXCSUM:
 493         case ETHTOOL_GTXCSUM:
 494                 ret = brcmf_fil_iovar_int_get(ifp, "toe_ol", &toe_cmpnt);
 495                 if (ret < 0)
 496                         return ret;
 497
 498                 csum_dir =
 499                     (cmd == ETHTOOL_GTXCSUM) ? TOE_TX_CSUM_OL : TOE_RX_CSUM_OL;
 500
 501                 edata.cmd = cmd;
 502                 edata.data = (toe_cmpnt & csum_dir) ? 1 : 0;
 503
 504                 if (copy_to_user(uaddr, &edata, sizeof(edata)))
 505                         return -EFAULT;
 506                 break;
 507
 508                 /* Set toe offload components in dongle */
 509         case ETHTOOL_SRXCSUM:
 510         case ETHTOOL_STXCSUM:
 511                 if (copy_from_user(&edata, uaddr, sizeof(edata)))
 512                         return -EFAULT;
 513
 514                 /* Read the current settings, update and write back */
 515                 ret = brcmf_fil_iovar_int_get(ifp, "toe_ol", &toe_cmpnt);
 516                 if (ret < 0)
 517                         return ret;
 518
 519                 csum_dir =
 520                     (cmd == ETHTOOL_STXCSUM) ? TOE_TX_CSUM_OL : TOE_RX_CSUM_OL;
 521
 522                 if (edata.data != 0)
 523                         toe_cmpnt |= csum_dir;
 524                 else
 525                         toe_cmpnt &= ~csum_dir;
 526
 527                 ret = brcmf_toe_set(ifp, toe_cmpnt);
 528                 if (ret < 0)
 529                         return ret;
 530
 531                 /* If setting TX checksum mode, tell Linux the new mode */
 532                 if (cmd == ETHTOOL_STXCSUM) {
 533                         if (edata.data)
 534                                 ifp->ndev->features |= NETIF_F_IP_CSUM;
 535                         else
 536                                 ifp->ndev->features &= ~NETIF_F_IP_CSUM;
 537                 }
 538
 539                 break;
 540
 541         default:
 542                 return -EOPNOTSUPP;
 543         }
 544
 545         return 0;
 546 }
 547
 548 static int brcmf_netdev_ioctl_entry(struct net_device *ndev, struct ifreq *ifr,
 549                                     int cmd)
 550 {
 551         struct brcmf_if *ifp = netdev_priv(ndev);
 552         struct brcmf_pub *drvr = ifp->drvr;
 553
 554         brcmf_dbg(TRACE, "ifidx %d, cmd 0x%04x\n", ifp->idx, cmd);
 555
 556         if (!drvr->iflist[ifp->idx])
 557                 return -1;
 558
 559         if (cmd == SIOCETHTOOL)
 560                 return brcmf_ethtool(ifp, ifr->ifr_data);
 561
 562         return -EOPNOTSUPP;
 563 }
 564
 565 static int brcmf_netdev_stop(struct net_device *ndev)
 566 {
 567         struct brcmf_if *ifp = netdev_priv(ndev);
 568         struct brcmf_pub *drvr = ifp->drvr;
 569
 570         brcmf_dbg(TRACE, "Enter\n");
 571
 572         if (drvr->bus_if->drvr_up == 0)
 573                 return 0;
 574
 575         brcmf_cfg80211_down(ndev);
 576
 577         /* Set state and stop OS transmissions */
 578         drvr->bus_if->drvr_up = false;
 579         netif_stop_queue(ndev);
 580
 581         return 0;
 582 }
 583
 584 static int brcmf_netdev_open(struct net_device *ndev)
 585 {
 586         struct brcmf_if *ifp = netdev_priv(ndev);
 587         struct brcmf_pub *drvr = ifp->drvr;
 588         struct brcmf_bus *bus_if = drvr->bus_if;
 589         u32 toe_ol;
 590         s32 ret = 0;
 591
 592         brcmf_dbg(TRACE, "ifidx %d\n", ifp->idx);
 593
 594         /* If bus is not ready, can't continue */
 595         if (bus_if->state != BRCMF_BUS_DATA) {
 596                 brcmf_dbg(ERROR, "failed bus is not ready\n");
 597                 return -EAGAIN;
 598         }
 599
 600         atomic_set(&drvr->pend_8021x_cnt, 0);
 601
 602         memcpy(ndev->dev_addr, drvr->mac, ETH_ALEN);
 603
 604         /* Get current TOE mode from dongle */
 605         if (brcmf_fil_iovar_int_get(ifp, "toe_ol", &toe_ol) >= 0
 606             && (toe_ol & TOE_TX_CSUM_OL) != 0)
 607                 drvr->iflist[ifp->idx]->ndev->features |=
 608                         NETIF_F_IP_CSUM;
 609         else
 610                 drvr->iflist[ifp->idx]->ndev->features &=
 611                         ~NETIF_F_IP_CSUM;
 612
 613         /* make sure RF is ready for work */
 614         brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 0);
 615
 616         /* Allow transmit calls */
 617         netif_start_queue(ndev);
 618         drvr->bus_if->drvr_up = true;
 619         if (brcmf_cfg80211_up(ndev)) {
 620                 brcmf_dbg(ERROR, "failed to bring up cfg80211\n");
 621                 return -1;
 622         }
 623
 624         return ret;
 625 }
 626
 627 static const struct net_device_ops brcmf_netdev_ops_pri = {
 628         .ndo_open = brcmf_netdev_open,
 629         .ndo_stop = brcmf_netdev_stop,
 630         .ndo_get_stats = brcmf_netdev_get_stats,
 631         .ndo_do_ioctl = brcmf_netdev_ioctl_entry,
 632         .ndo_start_xmit = brcmf_netdev_start_xmit,
 633         .ndo_set_mac_address = brcmf_netdev_set_mac_address,
 634         .ndo_set_rx_mode = brcmf_netdev_set_multicast_list
 635 };
 636
 637 static const struct net_device_ops brcmf_netdev_ops_virt = {
 638         .ndo_open = brcmf_cfg80211_up,
 639         .ndo_stop = brcmf_cfg80211_down,
 640         .ndo_get_stats = brcmf_netdev_get_stats,
 641         .ndo_do_ioctl = brcmf_netdev_ioctl_entry,
 642         .ndo_start_xmit = brcmf_netdev_start_xmit,
 643         .ndo_set_mac_address = brcmf_netdev_set_mac_address,
 644         .ndo_set_rx_mode = brcmf_netdev_set_multicast_list
 645 };
 646
 647 int brcmf_net_attach(struct brcmf_if *ifp)
 648 {
 649         struct brcmf_pub *drvr = ifp->drvr;
 650         struct net_device *ndev;
 651
 652         brcmf_dbg(TRACE, "ifidx %d mac %pM\n", ifp->idx, ifp->mac_addr);
 653         ndev = ifp->ndev;
 654
 655         /* set appropriate operations */
 656         if (!ifp->idx)
 657                 ndev->netdev_ops = &brcmf_netdev_ops_pri;
 658         else
 659                 ndev->netdev_ops = &brcmf_netdev_ops_virt;
 660
 661         ndev->hard_header_len = ETH_HLEN + drvr->hdrlen;
 662         ndev->ethtool_ops = &brcmf_ethtool_ops;
 663
 664         drvr->rxsz = ndev->mtu + ndev->hard_header_len +
 665                               drvr->hdrlen;
 666
 667         /* set the mac address */
 668         memcpy(ndev->dev_addr, ifp->mac_addr, ETH_ALEN);
 669
 670         if (register_netdev(ndev) != 0) {
 671                 brcmf_dbg(ERROR, "couldn't register the net device\n");
 672                 goto fail;
 673         }
 674
 675         brcmf_dbg(INFO, "%s: Broadcom Dongle Host Driver\n", ndev->name);
 676
 677         return 0;
 678
 679 fail:
 680         ndev->netdev_ops = NULL;
 681         return -EBADE;
 682 }
 683
 684 struct brcmf_if *brcmf_add_if(struct brcmf_pub *drvr, int ifidx, s32 bssidx,
 685                               char *name, u8 *addr_mask)
 686 {
 687         struct brcmf_if *ifp;
 688         struct net_device *ndev;
 689         int i;
 690
 691         brcmf_dbg(TRACE, "idx %d\n", ifidx);
 692
 693         ifp = drvr->iflist[ifidx];
 694         /*
 695          * Delete the existing interface before overwriting it
 696          * in case we missed the BRCMF_E_IF_DEL event.
 697          */
 698         if (ifp) {
 699                 brcmf_dbg(ERROR, "ERROR: netdev:%s already exists, try free & unregister\n",
 700                           ifp->ndev->name);
 701                 netif_stop_queue(ifp->ndev);
 702                 unregister_netdev(ifp->ndev);
 703                 free_netdev(ifp->ndev);
 704                 drvr->iflist[ifidx] = NULL;
 705         }
 706
 707         /* Allocate netdev, including space for private structure */
 708         ndev = alloc_netdev(sizeof(struct brcmf_if), name, ether_setup);
 709         if (!ndev) {
 710                 brcmf_dbg(ERROR, "OOM - alloc_netdev\n");
 711                 return ERR_PTR(-ENOMEM);
 712         }
 713
 714         ifp = netdev_priv(ndev);
 715         ifp->ndev = ndev;
 716         ifp->drvr = drvr;
 717         drvr->iflist[ifidx] = ifp;
 718         ifp->idx = ifidx;
 719         ifp->bssidx = bssidx;
 720
 721         INIT_WORK(&ifp->setmacaddr_work, _brcmf_set_mac_address);
 722         INIT_WORK(&ifp->multicast_work, _brcmf_set_multicast_list);
 723
 724         if (addr_mask != NULL)
 725                 for (i = 0; i < ETH_ALEN; i++)
 726                         ifp->mac_addr[i] = drvr->mac[i] ^ addr_mask[i];
 727
 728         brcmf_dbg(TRACE, " ==== pid:%x, if:%s (%pM) created ===\n",
 729                   current->pid, ifp->ndev->name, ifp->mac_addr);
 730
 731         return ifp;
 732 }
 733
 734 void brcmf_del_if(struct brcmf_pub *drvr, int ifidx)
 735 {
 736         struct brcmf_if *ifp;
 737
 738         brcmf_dbg(TRACE, "idx %d\n", ifidx);
 739
 740         ifp = drvr->iflist[ifidx];
 741         if (!ifp) {
 742                 brcmf_dbg(ERROR, "Null interface\n");
 743                 return;
 744         }
 745         if (ifp->ndev) {
 746                 if (ifidx == 0) {
 747                         if (ifp->ndev->netdev_ops == &brcmf_netdev_ops_pri) {
 748                                 rtnl_lock();
 749                                 brcmf_netdev_stop(ifp->ndev);
 750                                 rtnl_unlock();
 751                         }
 752                 } else {
 753                         netif_stop_queue(ifp->ndev);
 754                 }
 755
 756                 cancel_work_sync(&ifp->setmacaddr_work);
 757                 cancel_work_sync(&ifp->multicast_work);
 758
 759                 unregister_netdev(ifp->ndev);
 760                 drvr->iflist[ifidx] = NULL;
 761                 if (ifidx == 0)
 762                         brcmf_cfg80211_detach(drvr->config);
 763                 free_netdev(ifp->ndev);
 764         }
 765 }
 766
 767 int brcmf_attach(uint bus_hdrlen, struct device *dev)
 768 {
 769         struct brcmf_pub *drvr = NULL;
 770         int ret = 0;
 771
 772         brcmf_dbg(TRACE, "Enter\n");
 773
 774         /* Allocate primary brcmf_info */
 775         drvr = kzalloc(sizeof(struct brcmf_pub), GFP_ATOMIC);
 776         if (!drvr)
 777                 return -ENOMEM;
 778
 779         mutex_init(&drvr->proto_block);
 780
 781         /* Link to bus module */
 782         drvr->hdrlen = bus_hdrlen;
 783         drvr->bus_if = dev_get_drvdata(dev);
 784         drvr->bus_if->drvr = drvr;
 785         drvr->dev = dev;
 786
 787         /* create device debugfs folder */
 788         brcmf_debugfs_attach(drvr);
 789
 790         /* Attach and link in the protocol */
 791         ret = brcmf_proto_attach(drvr);
 792         if (ret != 0) {
 793                 brcmf_dbg(ERROR, "brcmf_prot_attach failed\n");
 794                 goto fail;
 795         }
 796
 797         /* attach firmware event handler */
 798         brcmf_fweh_attach(drvr);
 799
 800         INIT_LIST_HEAD(&drvr->bus_if->dcmd_list);
 801
 802         init_waitqueue_head(&drvr->pend_8021x_wait);
 803
 804         return ret;
 805
 806 fail:
 807         brcmf_detach(dev);
 808
 809         return ret;
 810 }
 811
 812 int brcmf_bus_start(struct device *dev)
 813 {
 814         int ret = -1;
 815         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
 816         struct brcmf_pub *drvr = bus_if->drvr;
 817         struct brcmf_if *ifp;
 818
 819         brcmf_dbg(TRACE, "\n");
 820
 821         /* Bring up the bus */
 822         ret = bus_if->brcmf_bus_init(dev);
 823         if (ret != 0) {
 824                 brcmf_dbg(ERROR, "brcmf_sdbrcm_bus_init failed %d\n", ret);
 825                 return ret;
 826         }
 827
 828         /* add primary networking interface */
 829         ifp = brcmf_add_if(drvr, 0, 0, "wlan%d", NULL);
 830         if (IS_ERR(ifp))
 831                 return PTR_ERR(ifp);
 832
 833         /* signal bus ready */
 834         bus_if->state = BRCMF_BUS_DATA;
 835
 836         /* Bus is ready, do any initialization */
 837         ret = brcmf_c_preinit_dcmds(ifp);
 838         if (ret < 0)
 839                 goto fail;
 840
 841         drvr->config = brcmf_cfg80211_attach(drvr);
 842         if (drvr->config == NULL) {
 843                 ret = -ENOMEM;
 844                 goto fail;
 845         }
 846
 847         ret = brcmf_fweh_activate_events(ifp);
 848         if (ret < 0)
 849                 goto fail;
 850
 851         ret = brcmf_net_attach(ifp);
 852 fail:
 853         if (ret < 0) {
 854                 brcmf_dbg(ERROR, "failed: %d\n", ret);
 855                 if (drvr->config)
 856                         brcmf_cfg80211_detach(drvr->config);
 857                 free_netdev(drvr->iflist[0]->ndev);
 858                 drvr->iflist[0] = NULL;
 859                 return ret;
 860         }
 861
 862         return 0;
 863 }
 864
 865 static void brcmf_bus_detach(struct brcmf_pub *drvr)
 866 {
 867         brcmf_dbg(TRACE, "Enter\n");
 868
 869         if (drvr) {
 870                 /* Stop the protocol module */
 871                 brcmf_proto_stop(drvr);
 872
 873                 /* Stop the bus module */
 874                 drvr->bus_if->brcmf_bus_stop(drvr->dev);
 875         }
 876 }
 877
 878 void brcmf_detach(struct device *dev)
 879 {
 880         int i;
 881         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
 882         struct brcmf_pub *drvr = bus_if->drvr;
 883
 884         brcmf_dbg(TRACE, "Enter\n");
 885
 886         if (drvr == NULL)
 887                 return;
 888
 889         /* stop firmware event handling */
 890         brcmf_fweh_detach(drvr);
 891
 892         /* make sure primary interface removed last */
 893         for (i = BRCMF_MAX_IFS-1; i > -1; i--)
 894                 if (drvr->iflist[i])
 895                         brcmf_del_if(drvr, i);
 896
 897         brcmf_bus_detach(drvr);
 898
 899         if (drvr->prot) {
 900                 brcmf_proto_detach(drvr);
 901         }
 902
 903         brcmf_debugfs_detach(drvr);
 904         bus_if->drvr = NULL;
 905         kfree(drvr);
 906 }
 907
 908 static int brcmf_get_pend_8021x_cnt(struct brcmf_pub *drvr)
 909 {
 910         return atomic_read(&drvr->pend_8021x_cnt);
 911 }
 912
 913 int brcmf_netdev_wait_pend8021x(struct net_device *ndev)
 914 {
 915         struct brcmf_if *ifp = netdev_priv(ndev);
 916         struct brcmf_pub *drvr = ifp->drvr;
 917         int err;
 918
 919         err = wait_event_timeout(drvr->pend_8021x_wait,
 920                                  !brcmf_get_pend_8021x_cnt(drvr),
 921                                  msecs_to_jiffies(MAX_WAIT_FOR_8021X_TX));
 922
 923         WARN_ON(!err);
 924
 925         return !err;
 926 }
 927
 928 static void brcmf_driver_init(struct work_struct *work)
 929 {
 930         brcmf_debugfs_init();
 931
 932 #ifdef CONFIG_BRCMFMAC_SDIO
 933         brcmf_sdio_init();
 934 #endif
 935 #ifdef CONFIG_BRCMFMAC_USB
 936         brcmf_usb_init();
 937 #endif
 938 }
 939 static DECLARE_WORK(brcmf_driver_work, brcmf_driver_init);
 940
 941 static int __init brcmfmac_module_init(void)
 942 {
 943         if (!schedule_work(&brcmf_driver_work))
 944                 return -EBUSY;
 945
 946         return 0;
 947 }
 948
 949 static void __exit brcmfmac_module_exit(void)
 950 {
 951         cancel_work_sync(&brcmf_driver_work);
 952
 953 #ifdef CONFIG_BRCMFMAC_SDIO
 954         brcmf_sdio_exit();
 955 #endif
 956 #ifdef CONFIG_BRCMFMAC_USB
 957         brcmf_usb_exit();
 958 #endif
 959         brcmf_debugfs_exit();
 960 }
 961
 962 module_init(brcmfmac_module_init);
 963 module_exit(brcmfmac_module_exit);