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