drivers/net/wireless/broadcom/brcm80211/brcmfmac/core.c

   1 // SPDX-License-Identifier: ISC
   2 /*
   3  * Copyright (c) 2010 Broadcom Corporation
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/etherdevice.h>
   8 #include <linux/module.h>
   9 #include <linux/inetdevice.h>
  10 #include <net/cfg80211.h>
  11 #include <net/rtnetlink.h>
  12 #include <net/addrconf.h>
  13 #include <net/ieee80211_radiotap.h>
  14 #include <net/ipv6.h>
  15 #include <brcmu_utils.h>
  16 #include <brcmu_wifi.h>
  17
  18 #include "core.h"
  19 #include "bus.h"
  20 #include "debug.h"
  21 #include "fwil_types.h"
  22 #include "p2p.h"
  23 #include "pno.h"
  24 #include "cfg80211.h"
  25 #include "fwil.h"
  26 #include "feature.h"
  27 #include "proto.h"
  28 #include "pcie.h"
  29 #include "common.h"
  30
  31 #define MAX_WAIT_FOR_8021X_TX                   msecs_to_jiffies(950)
  32
  33 #define BRCMF_BSSIDX_INVALID                    -1
  34
  35 #define RXS_PBPRES                              BIT(2)
  36
  37 #define D11_PHY_HDR_LEN                         6
  38
  39 struct d11rxhdr_le {
  40         __le16 RxFrameSize;
  41         u16 PAD;
  42         __le16 PhyRxStatus_0;
  43         __le16 PhyRxStatus_1;
  44         __le16 PhyRxStatus_2;
  45         __le16 PhyRxStatus_3;
  46         __le16 PhyRxStatus_4;
  47         __le16 PhyRxStatus_5;
  48         __le16 RxStatus1;
  49         __le16 RxStatus2;
  50         __le16 RxTSFTime;
  51         __le16 RxChan;
  52         u8 unknown[12];
  53 } __packed;
  54
  55 struct wlc_d11rxhdr {
  56         struct d11rxhdr_le rxhdr;
  57         __le32 tsf_l;
  58         s8 rssi;
  59         s8 rxpwr0;
  60         s8 rxpwr1;
  61         s8 do_rssi_ma;
  62         s8 rxpwr[4];
  63 } __packed;
  64
  65 char *brcmf_ifname(struct brcmf_if *ifp)
  66 {
  67         if (!ifp)
  68                 return "<if_null>";
  69
  70         if (ifp->ndev)
  71                 return ifp->ndev->name;
  72
  73         return "<if_none>";
  74 }
  75
  76 struct brcmf_if *brcmf_get_ifp(struct brcmf_pub *drvr, int ifidx)
  77 {
  78         struct brcmf_if *ifp;
  79         s32 bsscfgidx;
  80
  81         if (ifidx < 0 || ifidx >= BRCMF_MAX_IFS) {
  82                 bphy_err(drvr, "ifidx %d out of range\n", ifidx);
  83                 return NULL;
  84         }
  85
  86         ifp = NULL;
  87         bsscfgidx = drvr->if2bss[ifidx];
  88         if (bsscfgidx >= 0)
  89                 ifp = drvr->iflist[bsscfgidx];
  90
  91         return ifp;
  92 }
  93
  94 void brcmf_configure_arp_nd_offload(struct brcmf_if *ifp, bool enable)
  95 {
  96         s32 err;
  97         u32 mode;
  98
  99         if (enable)
 100                 mode = BRCMF_ARP_OL_AGENT | BRCMF_ARP_OL_PEER_AUTO_REPLY;
 101         else
 102                 mode = 0;
 103
 104         /* Try to set and enable ARP offload feature, this may fail, then it  */
 105         /* is simply not supported and err 0 will be returned                 */
 106         err = brcmf_fil_iovar_int_set(ifp, "arp_ol", mode);
 107         if (err) {
 108                 brcmf_dbg(TRACE, "failed to set ARP offload mode to 0x%x, err = %d\n",
 109                           mode, err);
 110         } else {
 111                 err = brcmf_fil_iovar_int_set(ifp, "arpoe", enable);
 112                 if (err) {
 113                         brcmf_dbg(TRACE, "failed to configure (%d) ARP offload err = %d\n",
 114                                   enable, err);
 115                 } else {
 116                         brcmf_dbg(TRACE, "successfully configured (%d) ARP offload to 0x%x\n",
 117                                   enable, mode);
 118                 }
 119         }
 120
 121         err = brcmf_fil_iovar_int_set(ifp, "ndoe", enable);
 122         if (err) {
 123                 brcmf_dbg(TRACE, "failed to configure (%d) ND offload err = %d\n",
 124                           enable, err);
 125         } else {
 126                 brcmf_dbg(TRACE, "successfully configured (%d) ND offload to 0x%x\n",
 127                           enable, mode);
 128         }
 129 }
 130
 131 static void _brcmf_set_multicast_list(struct work_struct *work)
 132 {
 133         struct brcmf_if *ifp = container_of(work, struct brcmf_if,
 134                                             multicast_work);
 135         struct brcmf_pub *drvr = ifp->drvr;
 136         struct net_device *ndev;
 137         struct netdev_hw_addr *ha;
 138         u32 cmd_value, cnt;
 139         __le32 cnt_le;
 140         char *buf, *bufp;
 141         u32 buflen;
 142         s32 err;
 143
 144         brcmf_dbg(TRACE, "Enter, bsscfgidx=%d\n", ifp->bsscfgidx);
 145
 146         ndev = ifp->ndev;
 147
 148         /* Determine initial value of allmulti flag */
 149         cmd_value = (ndev->flags & IFF_ALLMULTI) ? true : false;
 150
 151         /* Send down the multicast list first. */
 152         cnt = netdev_mc_count(ndev);
 153         buflen = sizeof(cnt) + (cnt * ETH_ALEN);
 154         buf = kmalloc(buflen, GFP_ATOMIC);
 155         if (!buf)
 156                 return;
 157         bufp = buf;
 158
 159         cnt_le = cpu_to_le32(cnt);
 160         memcpy(bufp, &cnt_le, sizeof(cnt_le));
 161         bufp += sizeof(cnt_le);
 162
 163         netdev_for_each_mc_addr(ha, ndev) {
 164                 if (!cnt)
 165                         break;
 166                 memcpy(bufp, ha->addr, ETH_ALEN);
 167                 bufp += ETH_ALEN;
 168                 cnt--;
 169         }
 170
 171         err = brcmf_fil_iovar_data_set(ifp, "mcast_list", buf, buflen);
 172         if (err < 0) {
 173                 bphy_err(drvr, "Setting mcast_list failed, %d\n", err);
 174                 cmd_value = cnt ? true : cmd_value;
 175         }
 176
 177         kfree(buf);
 178
 179         /*
 180          * Now send the allmulti setting.  This is based on the setting in the
 181          * net_device flags, but might be modified above to be turned on if we
 182          * were trying to set some addresses and dongle rejected it...
 183          */
 184         err = brcmf_fil_iovar_int_set(ifp, "allmulti", cmd_value);
 185         if (err < 0)
 186                 bphy_err(drvr, "Setting allmulti failed, %d\n", err);
 187
 188         /*Finally, pick up the PROMISC flag */
 189         cmd_value = (ndev->flags & IFF_PROMISC) ? true : false;
 190         err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PROMISC, cmd_value);
 191         if (err < 0)
 192                 bphy_err(drvr, "Setting BRCMF_C_SET_PROMISC failed, %d\n",
 193                          err);
 194         brcmf_configure_arp_nd_offload(ifp, !cmd_value);
 195 }
 196
 197 #if IS_ENABLED(CONFIG_IPV6)
 198 static void _brcmf_update_ndtable(struct work_struct *work)
 199 {
 200         struct brcmf_if *ifp = container_of(work, struct brcmf_if,
 201                                             ndoffload_work);
 202         struct brcmf_pub *drvr = ifp->drvr;
 203         int i, ret;
 204
 205         /* clear the table in firmware */
 206         ret = brcmf_fil_iovar_data_set(ifp, "nd_hostip_clear", NULL, 0);
 207         if (ret) {
 208                 brcmf_dbg(TRACE, "fail to clear nd ip table err:%d\n", ret);
 209                 return;
 210         }
 211
 212         for (i = 0; i < ifp->ipv6addr_idx; i++) {
 213                 ret = brcmf_fil_iovar_data_set(ifp, "nd_hostip",
 214                                                &ifp->ipv6_addr_tbl[i],
 215                                                sizeof(struct in6_addr));
 216                 if (ret)
 217                         bphy_err(drvr, "add nd ip err %d\n", ret);
 218         }
 219 }
 220 #else
 221 static void _brcmf_update_ndtable(struct work_struct *work)
 222 {
 223 }
 224 #endif
 225
 226 static int brcmf_netdev_set_mac_address(struct net_device *ndev, void *addr)
 227 {
 228         struct brcmf_if *ifp = netdev_priv(ndev);
 229         struct sockaddr *sa = (struct sockaddr *)addr;
 230         struct brcmf_pub *drvr = ifp->drvr;
 231         int err;
 232
 233         brcmf_dbg(TRACE, "Enter, bsscfgidx=%d\n", ifp->bsscfgidx);
 234
 235         err = brcmf_fil_iovar_data_set(ifp, "cur_etheraddr", sa->sa_data,
 236                                        ETH_ALEN);
 237         if (err < 0) {
 238                 bphy_err(drvr, "Setting cur_etheraddr failed, %d\n", err);
 239         } else {
 240                 brcmf_dbg(TRACE, "updated to %pM\n", sa->sa_data);
 241                 memcpy(ifp->mac_addr, sa->sa_data, ETH_ALEN);
 242                 memcpy(ifp->ndev->dev_addr, ifp->mac_addr, ETH_ALEN);
 243         }
 244         return err;
 245 }
 246
 247 static void brcmf_netdev_set_multicast_list(struct net_device *ndev)
 248 {
 249         struct brcmf_if *ifp = netdev_priv(ndev);
 250
 251         schedule_work(&ifp->multicast_work);
 252 }
 253
 254 /**
 255  * brcmf_skb_is_iapp - checks if skb is an IAPP packet
 256  *
 257  * @skb: skb to check
 258  */
 259 static bool brcmf_skb_is_iapp(struct sk_buff *skb)
 260 {
 261         static const u8 iapp_l2_update_packet[6] __aligned(2) = {
 262                 0x00, 0x01, 0xaf, 0x81, 0x01, 0x00,
 263         };
 264         unsigned char *eth_data;
 265 #if !defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
 266         const u16 *a, *b;
 267 #endif
 268
 269         if (skb->len - skb->mac_len != 6 ||
 270             !is_multicast_ether_addr(eth_hdr(skb)->h_dest))
 271                 return false;
 272
 273         eth_data = skb_mac_header(skb) + ETH_HLEN;
 274 #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
 275         return !(((*(const u32 *)eth_data) ^ (*(const u32 *)iapp_l2_update_packet)) |
 276                  ((*(const u16 *)(eth_data + 4)) ^ (*(const u16 *)(iapp_l2_update_packet + 4))));
 277 #else
 278         a = (const u16 *)eth_data;
 279         b = (const u16 *)iapp_l2_update_packet;
 280
 281         return !((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2]));
 282 #endif
 283 }
 284
 285 static netdev_tx_t brcmf_netdev_start_xmit(struct sk_buff *skb,
 286                                            struct net_device *ndev)
 287 {
 288         int ret;
 289         struct brcmf_if *ifp = netdev_priv(ndev);
 290         struct brcmf_pub *drvr = ifp->drvr;
 291         struct ethhdr *eh;
 292         int head_delta;
 293
 294         brcmf_dbg(DATA, "Enter, bsscfgidx=%d\n", ifp->bsscfgidx);
 295
 296         /* Can the device send data? */
 297         if (drvr->bus_if->state != BRCMF_BUS_UP) {
 298                 bphy_err(drvr, "xmit rejected state=%d\n", drvr->bus_if->state);
 299                 netif_stop_queue(ndev);
 300                 dev_kfree_skb(skb);
 301                 ret = -ENODEV;
 302                 goto done;
 303         }
 304
 305         /* Some recent Broadcom's firmwares disassociate STA when they receive
 306          * an 802.11f ADD frame. This behavior can lead to a local DoS security
 307          * issue. Attacker may trigger disassociation of any STA by sending a
 308          * proper Ethernet frame to the wireless interface.
 309          *
 310          * Moreover this feature may break AP interfaces in some specific
 311          * setups. This applies e.g. to the bridge with hairpin mode enabled and
 312          * IFLA_BRPORT_MCAST_TO_UCAST set. IAPP packet generated by a firmware
 313          * will get passed back to the wireless interface and cause immediate
 314          * disassociation of a just-connected STA.
 315          */
 316         if (!drvr->settings->iapp && brcmf_skb_is_iapp(skb)) {
 317                 dev_kfree_skb(skb);
 318                 ret = -EINVAL;
 319                 goto done;
 320         }
 321
 322         /* Make sure there's enough writeable headroom */
 323         if (skb_headroom(skb) < drvr->hdrlen || skb_header_cloned(skb)) {
 324                 head_delta = max_t(int, drvr->hdrlen - skb_headroom(skb), 0);
 325
 326                 brcmf_dbg(INFO, "%s: insufficient headroom (%d)\n",
 327                           brcmf_ifname(ifp), head_delta);
 328                 atomic_inc(&drvr->bus_if->stats.pktcowed);
 329                 ret = pskb_expand_head(skb, ALIGN(head_delta, NET_SKB_PAD), 0,
 330                                        GFP_ATOMIC);
 331                 if (ret < 0) {
 332                         bphy_err(drvr, "%s: failed to expand headroom\n",
 333                                  brcmf_ifname(ifp));
 334                         atomic_inc(&drvr->bus_if->stats.pktcow_failed);
 335                         goto done;
 336                 }
 337         }
 338
 339         /* validate length for ether packet */
 340         if (skb->len < sizeof(*eh)) {
 341                 ret = -EINVAL;
 342                 dev_kfree_skb(skb);
 343                 goto done;
 344         }
 345
 346         eh = (struct ethhdr *)(skb->data);
 347
 348         if (eh->h_proto == htons(ETH_P_PAE))
 349                 atomic_inc(&ifp->pend_8021x_cnt);
 350
 351         /* determine the priority */
 352         if ((skb->priority == 0) || (skb->priority > 7))
 353                 skb->priority = cfg80211_classify8021d(skb, NULL);
 354
 355         ret = brcmf_proto_tx_queue_data(drvr, ifp->ifidx, skb);
 356         if (ret < 0)
 357                 brcmf_txfinalize(ifp, skb, false);
 358
 359 done:
 360         if (ret) {
 361                 ndev->stats.tx_dropped++;
 362         } else {
 363                 ndev->stats.tx_packets++;
 364                 ndev->stats.tx_bytes += skb->len;
 365         }
 366
 367         /* Return ok: we always eat the packet */
 368         return NETDEV_TX_OK;
 369 }
 370
 371 void brcmf_txflowblock_if(struct brcmf_if *ifp,
 372                           enum brcmf_netif_stop_reason reason, bool state)
 373 {
 374         unsigned long flags;
 375
 376         if (!ifp || !ifp->ndev)
 377                 return;
 378
 379         brcmf_dbg(TRACE, "enter: bsscfgidx=%d stop=0x%X reason=%d state=%d\n",
 380                   ifp->bsscfgidx, ifp->netif_stop, reason, state);
 381
 382         spin_lock_irqsave(&ifp->netif_stop_lock, flags);
 383         if (state) {
 384                 if (!ifp->netif_stop)
 385                         netif_stop_queue(ifp->ndev);
 386                 ifp->netif_stop |= reason;
 387         } else {
 388                 ifp->netif_stop &= ~reason;
 389                 if (!ifp->netif_stop)
 390                         netif_wake_queue(ifp->ndev);
 391         }
 392         spin_unlock_irqrestore(&ifp->netif_stop_lock, flags);
 393 }
 394
 395 void brcmf_netif_rx(struct brcmf_if *ifp, struct sk_buff *skb)
 396 {
 397         /* Most of Broadcom's firmwares send 802.11f ADD frame every time a new
 398          * STA connects to the AP interface. This is an obsoleted standard most
 399          * users don't use, so don't pass these frames up unless requested.
 400          */
 401         if (!ifp->drvr->settings->iapp && brcmf_skb_is_iapp(skb)) {
 402                 brcmu_pkt_buf_free_skb(skb);
 403                 return;
 404         }
 405
 406         if (skb->pkt_type == PACKET_MULTICAST)
 407                 ifp->ndev->stats.multicast++;
 408
 409         if (!(ifp->ndev->flags & IFF_UP)) {
 410                 brcmu_pkt_buf_free_skb(skb);
 411                 return;
 412         }
 413
 414         ifp->ndev->stats.rx_bytes += skb->len;
 415         ifp->ndev->stats.rx_packets++;
 416
 417         brcmf_dbg(DATA, "rx proto=0x%X\n", ntohs(skb->protocol));
 418         if (in_interrupt())
 419                 netif_rx(skb);
 420         else
 421                 /* If the receive is not processed inside an ISR,
 422                  * the softirqd must be woken explicitly to service
 423                  * the NET_RX_SOFTIRQ.  This is handled by netif_rx_ni().
 424                  */
 425                 netif_rx_ni(skb);
 426 }
 427
 428 void brcmf_netif_mon_rx(struct brcmf_if *ifp, struct sk_buff *skb)
 429 {
 430         if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MONITOR_FMT_RADIOTAP)) {
 431                 /* Do nothing */
 432         } else if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MONITOR_FMT_HW_RX_HDR)) {
 433                 struct wlc_d11rxhdr *wlc_rxhdr = (struct wlc_d11rxhdr *)skb->data;
 434                 struct ieee80211_radiotap_header *radiotap;
 435                 unsigned int offset;
 436                 u16 RxStatus1;
 437
 438                 RxStatus1 = le16_to_cpu(wlc_rxhdr->rxhdr.RxStatus1);
 439
 440                 offset = sizeof(struct wlc_d11rxhdr);
 441                 /* MAC inserts 2 pad bytes for a4 headers or QoS or A-MSDU
 442                  * subframes
 443                  */
 444                 if (RxStatus1 & RXS_PBPRES)
 445                         offset += 2;
 446                 offset += D11_PHY_HDR_LEN;
 447
 448                 skb_pull(skb, offset);
 449
 450                 /* TODO: use RX header to fill some radiotap data */
 451                 radiotap = skb_push(skb, sizeof(*radiotap));
 452                 memset(radiotap, 0, sizeof(*radiotap));
 453                 radiotap->it_len = cpu_to_le16(sizeof(*radiotap));
 454
 455                 /* TODO: 4 bytes with receive status? */
 456                 skb->len -= 4;
 457         } else {
 458                 struct ieee80211_radiotap_header *radiotap;
 459
 460                 /* TODO: use RX status to fill some radiotap data */
 461                 radiotap = skb_push(skb, sizeof(*radiotap));
 462                 memset(radiotap, 0, sizeof(*radiotap));
 463                 radiotap->it_len = cpu_to_le16(sizeof(*radiotap));
 464
 465                 /* TODO: 4 bytes with receive status? */
 466                 skb->len -= 4;
 467         }
 468
 469         skb->dev = ifp->ndev;
 470         skb_reset_mac_header(skb);
 471         skb->pkt_type = PACKET_OTHERHOST;
 472         skb->protocol = htons(ETH_P_802_2);
 473
 474         brcmf_netif_rx(ifp, skb);
 475 }
 476
 477 static int brcmf_rx_hdrpull(struct brcmf_pub *drvr, struct sk_buff *skb,
 478                             struct brcmf_if **ifp)
 479 {
 480         int ret;
 481
 482         /* process and remove protocol-specific header */
 483         ret = brcmf_proto_hdrpull(drvr, true, skb, ifp);
 484
 485         if (ret || !(*ifp) || !(*ifp)->ndev) {
 486                 if (ret != -ENODATA && *ifp)
 487                         (*ifp)->ndev->stats.rx_errors++;
 488                 brcmu_pkt_buf_free_skb(skb);
 489                 return -ENODATA;
 490         }
 491
 492         skb->protocol = eth_type_trans(skb, (*ifp)->ndev);
 493         return 0;
 494 }
 495
 496 void brcmf_rx_frame(struct device *dev, struct sk_buff *skb, bool handle_event)
 497 {
 498         struct brcmf_if *ifp;
 499         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
 500         struct brcmf_pub *drvr = bus_if->drvr;
 501
 502         brcmf_dbg(DATA, "Enter: %s: rxp=%p\n", dev_name(dev), skb);
 503
 504         if (brcmf_rx_hdrpull(drvr, skb, &ifp))
 505                 return;
 506
 507         if (brcmf_proto_is_reorder_skb(skb)) {
 508                 brcmf_proto_rxreorder(ifp, skb);
 509         } else {
 510                 /* Process special event packets */
 511                 if (handle_event)
 512                         brcmf_fweh_process_skb(ifp->drvr, skb,
 513                                                BCMILCP_SUBTYPE_VENDOR_LONG);
 514
 515                 brcmf_netif_rx(ifp, skb);
 516         }
 517 }
 518
 519 void brcmf_rx_event(struct device *dev, struct sk_buff *skb)
 520 {
 521         struct brcmf_if *ifp;
 522         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
 523         struct brcmf_pub *drvr = bus_if->drvr;
 524
 525         brcmf_dbg(EVENT, "Enter: %s: rxp=%p\n", dev_name(dev), skb);
 526
 527         if (brcmf_rx_hdrpull(drvr, skb, &ifp))
 528                 return;
 529
 530         brcmf_fweh_process_skb(ifp->drvr, skb, 0);
 531         brcmu_pkt_buf_free_skb(skb);
 532 }
 533
 534 void brcmf_txfinalize(struct brcmf_if *ifp, struct sk_buff *txp, bool success)
 535 {
 536         struct ethhdr *eh;
 537         u16 type;
 538
 539         eh = (struct ethhdr *)(txp->data);
 540         type = ntohs(eh->h_proto);
 541
 542         if (type == ETH_P_PAE) {
 543                 atomic_dec(&ifp->pend_8021x_cnt);
 544                 if (waitqueue_active(&ifp->pend_8021x_wait))
 545                         wake_up(&ifp->pend_8021x_wait);
 546         }
 547
 548         if (!success)
 549                 ifp->ndev->stats.tx_errors++;
 550
 551         brcmu_pkt_buf_free_skb(txp);
 552 }
 553
 554 static void brcmf_ethtool_get_drvinfo(struct net_device *ndev,
 555                                     struct ethtool_drvinfo *info)
 556 {
 557         struct brcmf_if *ifp = netdev_priv(ndev);
 558         struct brcmf_pub *drvr = ifp->drvr;
 559         char drev[BRCMU_DOTREV_LEN] = "n/a";
 560
 561         if (drvr->revinfo.result == 0)
 562                 brcmu_dotrev_str(drvr->revinfo.driverrev, drev);
 563         strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
 564         strlcpy(info->version, drev, sizeof(info->version));
 565         strlcpy(info->fw_version, drvr->fwver, sizeof(info->fw_version));
 566         strlcpy(info->bus_info, dev_name(drvr->bus_if->dev),
 567                 sizeof(info->bus_info));
 568 }
 569
 570 static const struct ethtool_ops brcmf_ethtool_ops = {
 571         .get_drvinfo = brcmf_ethtool_get_drvinfo,
 572 };
 573
 574 static int brcmf_netdev_stop(struct net_device *ndev)
 575 {
 576         struct brcmf_if *ifp = netdev_priv(ndev);
 577
 578         brcmf_dbg(TRACE, "Enter, bsscfgidx=%d\n", ifp->bsscfgidx);
 579
 580         brcmf_cfg80211_down(ndev);
 581
 582         if (ifp->drvr->bus_if->state == BRCMF_BUS_UP)
 583                 brcmf_fil_iovar_data_set(ifp, "arp_hostip_clear", NULL, 0);
 584
 585         brcmf_net_setcarrier(ifp, false);
 586
 587         return 0;
 588 }
 589
 590 static int brcmf_netdev_open(struct net_device *ndev)
 591 {
 592         struct brcmf_if *ifp = netdev_priv(ndev);
 593         struct brcmf_pub *drvr = ifp->drvr;
 594         struct brcmf_bus *bus_if = drvr->bus_if;
 595         u32 toe_ol;
 596
 597         brcmf_dbg(TRACE, "Enter, bsscfgidx=%d\n", ifp->bsscfgidx);
 598
 599         /* If bus is not ready, can't continue */
 600         if (bus_if->state != BRCMF_BUS_UP) {
 601                 bphy_err(drvr, "failed bus is not ready\n");
 602                 return -EAGAIN;
 603         }
 604
 605         atomic_set(&ifp->pend_8021x_cnt, 0);
 606
 607         /* Get current TOE mode from dongle */
 608         if (brcmf_fil_iovar_int_get(ifp, "toe_ol", &toe_ol) >= 0
 609             && (toe_ol & TOE_TX_CSUM_OL) != 0)
 610                 ndev->features |= NETIF_F_IP_CSUM;
 611         else
 612                 ndev->features &= ~NETIF_F_IP_CSUM;
 613
 614         if (brcmf_cfg80211_up(ndev)) {
 615                 bphy_err(drvr, "failed to bring up cfg80211\n");
 616                 return -EIO;
 617         }
 618
 619         /* Clear, carrier, set when connected or AP mode. */
 620         netif_carrier_off(ndev);
 621         return 0;
 622 }
 623
 624 static const struct net_device_ops brcmf_netdev_ops_pri = {
 625         .ndo_open = brcmf_netdev_open,
 626         .ndo_stop = brcmf_netdev_stop,
 627         .ndo_start_xmit = brcmf_netdev_start_xmit,
 628         .ndo_set_mac_address = brcmf_netdev_set_mac_address,
 629         .ndo_set_rx_mode = brcmf_netdev_set_multicast_list
 630 };
 631
 632 int brcmf_net_attach(struct brcmf_if *ifp, bool rtnl_locked)
 633 {
 634         struct brcmf_pub *drvr = ifp->drvr;
 635         struct net_device *ndev;
 636         s32 err;
 637
 638         brcmf_dbg(TRACE, "Enter, bsscfgidx=%d mac=%pM\n", ifp->bsscfgidx,
 639                   ifp->mac_addr);
 640         ndev = ifp->ndev;
 641
 642         /* set appropriate operations */
 643         ndev->netdev_ops = &brcmf_netdev_ops_pri;
 644
 645         ndev->needed_headroom += drvr->hdrlen;
 646         ndev->ethtool_ops = &brcmf_ethtool_ops;
 647
 648         /* set the mac address & netns */
 649         memcpy(ndev->dev_addr, ifp->mac_addr, ETH_ALEN);
 650         dev_net_set(ndev, wiphy_net(cfg_to_wiphy(drvr->config)));
 651
 652         INIT_WORK(&ifp->multicast_work, _brcmf_set_multicast_list);
 653         INIT_WORK(&ifp->ndoffload_work, _brcmf_update_ndtable);
 654
 655         if (rtnl_locked)
 656                 err = register_netdevice(ndev);
 657         else
 658                 err = register_netdev(ndev);
 659         if (err != 0) {
 660                 bphy_err(drvr, "couldn't register the net device\n");
 661                 goto fail;
 662         }
 663
 664         netif_carrier_off(ndev);
 665
 666         ndev->priv_destructor = brcmf_cfg80211_free_netdev;
 667         brcmf_dbg(INFO, "%s: Broadcom Dongle Host Driver\n", ndev->name);
 668         return 0;
 669
 670 fail:
 671         drvr->iflist[ifp->bsscfgidx] = NULL;
 672         ndev->netdev_ops = NULL;
 673         return -EBADE;
 674 }
 675
 676 void brcmf_net_detach(struct net_device *ndev, bool rtnl_locked)
 677 {
 678         if (ndev->reg_state == NETREG_REGISTERED) {
 679                 if (rtnl_locked)
 680                         unregister_netdevice(ndev);
 681                 else
 682                         unregister_netdev(ndev);
 683         } else {
 684                 brcmf_cfg80211_free_netdev(ndev);
 685                 free_netdev(ndev);
 686         }
 687 }
 688
 689 static int brcmf_net_mon_open(struct net_device *ndev)
 690 {
 691         struct brcmf_if *ifp = netdev_priv(ndev);
 692         struct brcmf_pub *drvr = ifp->drvr;
 693         u32 monitor;
 694         int err;
 695
 696         brcmf_dbg(TRACE, "Enter\n");
 697
 698         err = brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_MONITOR, &monitor);
 699         if (err) {
 700                 bphy_err(drvr, "BRCMF_C_GET_MONITOR error (%d)\n", err);
 701                 return err;
 702         } else if (monitor) {
 703                 bphy_err(drvr, "Monitor mode is already enabled\n");
 704                 return -EEXIST;
 705         }
 706
 707         monitor = 3;
 708         err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_MONITOR, monitor);
 709         if (err)
 710                 bphy_err(drvr, "BRCMF_C_SET_MONITOR error (%d)\n", err);
 711
 712         return err;
 713 }
 714
 715 static int brcmf_net_mon_stop(struct net_device *ndev)
 716 {
 717         struct brcmf_if *ifp = netdev_priv(ndev);
 718         struct brcmf_pub *drvr = ifp->drvr;
 719         u32 monitor;
 720         int err;
 721
 722         brcmf_dbg(TRACE, "Enter\n");
 723
 724         monitor = 0;
 725         err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_MONITOR, monitor);
 726         if (err)
 727                 bphy_err(drvr, "BRCMF_C_SET_MONITOR error (%d)\n", err);
 728
 729         return err;
 730 }
 731
 732 static netdev_tx_t brcmf_net_mon_start_xmit(struct sk_buff *skb,
 733                                             struct net_device *ndev)
 734 {
 735         dev_kfree_skb_any(skb);
 736
 737         return NETDEV_TX_OK;
 738 }
 739
 740 static const struct net_device_ops brcmf_netdev_ops_mon = {
 741         .ndo_open = brcmf_net_mon_open,
 742         .ndo_stop = brcmf_net_mon_stop,
 743         .ndo_start_xmit = brcmf_net_mon_start_xmit,
 744 };
 745
 746 int brcmf_net_mon_attach(struct brcmf_if *ifp)
 747 {
 748         struct brcmf_pub *drvr = ifp->drvr;
 749         struct net_device *ndev;
 750         int err;
 751
 752         brcmf_dbg(TRACE, "Enter\n");
 753
 754         ndev = ifp->ndev;
 755         ndev->netdev_ops = &brcmf_netdev_ops_mon;
 756
 757         err = register_netdevice(ndev);
 758         if (err)
 759                 bphy_err(drvr, "Failed to register %s device\n", ndev->name);
 760
 761         return err;
 762 }
 763
 764 void brcmf_net_setcarrier(struct brcmf_if *ifp, bool on)
 765 {
 766         struct net_device *ndev;
 767
 768         brcmf_dbg(TRACE, "Enter, bsscfgidx=%d carrier=%d\n", ifp->bsscfgidx,
 769                   on);
 770
 771         ndev = ifp->ndev;
 772         brcmf_txflowblock_if(ifp, BRCMF_NETIF_STOP_REASON_DISCONNECTED, !on);
 773         if (on) {
 774                 if (!netif_carrier_ok(ndev))
 775                         netif_carrier_on(ndev);
 776
 777         } else {
 778                 if (netif_carrier_ok(ndev))
 779                         netif_carrier_off(ndev);
 780         }
 781 }
 782
 783 static int brcmf_net_p2p_open(struct net_device *ndev)
 784 {
 785         brcmf_dbg(TRACE, "Enter\n");
 786
 787         return brcmf_cfg80211_up(ndev);
 788 }
 789
 790 static int brcmf_net_p2p_stop(struct net_device *ndev)
 791 {
 792         brcmf_dbg(TRACE, "Enter\n");
 793
 794         return brcmf_cfg80211_down(ndev);
 795 }
 796
 797 static netdev_tx_t brcmf_net_p2p_start_xmit(struct sk_buff *skb,
 798                                             struct net_device *ndev)
 799 {
 800         if (skb)
 801                 dev_kfree_skb_any(skb);
 802
 803         return NETDEV_TX_OK;
 804 }
 805
 806 static const struct net_device_ops brcmf_netdev_ops_p2p = {
 807         .ndo_open = brcmf_net_p2p_open,
 808         .ndo_stop = brcmf_net_p2p_stop,
 809         .ndo_start_xmit = brcmf_net_p2p_start_xmit
 810 };
 811
 812 static int brcmf_net_p2p_attach(struct brcmf_if *ifp)
 813 {
 814         struct brcmf_pub *drvr = ifp->drvr;
 815         struct net_device *ndev;
 816
 817         brcmf_dbg(TRACE, "Enter, bsscfgidx=%d mac=%pM\n", ifp->bsscfgidx,
 818                   ifp->mac_addr);
 819         ndev = ifp->ndev;
 820
 821         ndev->netdev_ops = &brcmf_netdev_ops_p2p;
 822
 823         /* set the mac address */
 824         memcpy(ndev->dev_addr, ifp->mac_addr, ETH_ALEN);
 825
 826         if (register_netdev(ndev) != 0) {
 827                 bphy_err(drvr, "couldn't register the p2p net device\n");
 828                 goto fail;
 829         }
 830
 831         brcmf_dbg(INFO, "%s: Broadcom Dongle Host Driver\n", ndev->name);
 832
 833         return 0;
 834
 835 fail:
 836         ifp->drvr->iflist[ifp->bsscfgidx] = NULL;
 837         ndev->netdev_ops = NULL;
 838         return -EBADE;
 839 }
 840
 841 struct brcmf_if *brcmf_add_if(struct brcmf_pub *drvr, s32 bsscfgidx, s32 ifidx,
 842                               bool is_p2pdev, const char *name, u8 *mac_addr)
 843 {
 844         struct brcmf_if *ifp;
 845         struct net_device *ndev;
 846
 847         brcmf_dbg(TRACE, "Enter, bsscfgidx=%d, ifidx=%d\n", bsscfgidx, ifidx);
 848
 849         ifp = drvr->iflist[bsscfgidx];
 850         /*
 851          * Delete the existing interface before overwriting it
 852          * in case we missed the BRCMF_E_IF_DEL event.
 853          */
 854         if (ifp) {
 855                 if (ifidx) {
 856                         bphy_err(drvr, "ERROR: netdev:%s already exists\n",
 857                                  ifp->ndev->name);
 858                         netif_stop_queue(ifp->ndev);
 859                         brcmf_net_detach(ifp->ndev, false);
 860                         drvr->iflist[bsscfgidx] = NULL;
 861                 } else {
 862                         brcmf_dbg(INFO, "netdev:%s ignore IF event\n",
 863                                   ifp->ndev->name);
 864                         return ERR_PTR(-EINVAL);
 865                 }
 866         }
 867
 868         if (!drvr->settings->p2p_enable && is_p2pdev) {
 869                 /* this is P2P_DEVICE interface */
 870                 brcmf_dbg(INFO, "allocate non-netdev interface\n");
 871                 ifp = kzalloc(sizeof(*ifp), GFP_KERNEL);
 872                 if (!ifp)
 873                         return ERR_PTR(-ENOMEM);
 874         } else {
 875                 brcmf_dbg(INFO, "allocate netdev interface\n");
 876                 /* Allocate netdev, including space for private structure */
 877                 ndev = alloc_netdev(sizeof(*ifp), is_p2pdev ? "p2p%d" : name,
 878                                     NET_NAME_UNKNOWN, ether_setup);
 879                 if (!ndev)
 880                         return ERR_PTR(-ENOMEM);
 881
 882                 ndev->needs_free_netdev = true;
 883                 ifp = netdev_priv(ndev);
 884                 ifp->ndev = ndev;
 885                 /* store mapping ifidx to bsscfgidx */
 886                 if (drvr->if2bss[ifidx] == BRCMF_BSSIDX_INVALID)
 887                         drvr->if2bss[ifidx] = bsscfgidx;
 888         }
 889
 890         ifp->drvr = drvr;
 891         drvr->iflist[bsscfgidx] = ifp;
 892         ifp->ifidx = ifidx;
 893         ifp->bsscfgidx = bsscfgidx;
 894
 895         init_waitqueue_head(&ifp->pend_8021x_wait);
 896         spin_lock_init(&ifp->netif_stop_lock);
 897
 898         if (mac_addr != NULL)
 899                 memcpy(ifp->mac_addr, mac_addr, ETH_ALEN);
 900
 901         brcmf_dbg(TRACE, " ==== pid:%x, if:%s (%pM) created ===\n",
 902                   current->pid, name, ifp->mac_addr);
 903
 904         return ifp;
 905 }
 906
 907 static void brcmf_del_if(struct brcmf_pub *drvr, s32 bsscfgidx,
 908                          bool rtnl_locked)
 909 {
 910         struct brcmf_if *ifp;
 911         int ifidx;
 912
 913         ifp = drvr->iflist[bsscfgidx];
 914         if (!ifp) {
 915                 bphy_err(drvr, "Null interface, bsscfgidx=%d\n", bsscfgidx);
 916                 return;
 917         }
 918         brcmf_dbg(TRACE, "Enter, bsscfgidx=%d, ifidx=%d\n", bsscfgidx,
 919                   ifp->ifidx);
 920         ifidx = ifp->ifidx;
 921
 922         if (ifp->ndev) {
 923                 if (bsscfgidx == 0) {
 924                         if (ifp->ndev->netdev_ops == &brcmf_netdev_ops_pri) {
 925                                 rtnl_lock();
 926                                 brcmf_netdev_stop(ifp->ndev);
 927                                 rtnl_unlock();
 928                         }
 929                 } else {
 930                         netif_stop_queue(ifp->ndev);
 931                 }
 932
 933                 if (ifp->ndev->netdev_ops == &brcmf_netdev_ops_pri) {
 934                         cancel_work_sync(&ifp->multicast_work);
 935                         cancel_work_sync(&ifp->ndoffload_work);
 936                 }
 937                 brcmf_net_detach(ifp->ndev, rtnl_locked);
 938         } else {
 939                 /* Only p2p device interfaces which get dynamically created
 940                  * end up here. In this case the p2p module should be informed
 941                  * about the removal of the interface within the firmware. If
 942                  * not then p2p commands towards the firmware will cause some
 943                  * serious troublesome side effects. The p2p module will clean
 944                  * up the ifp if needed.
 945                  */
 946                 brcmf_p2p_ifp_removed(ifp, rtnl_locked);
 947                 kfree(ifp);
 948         }
 949
 950         drvr->iflist[bsscfgidx] = NULL;
 951         if (drvr->if2bss[ifidx] == bsscfgidx)
 952                 drvr->if2bss[ifidx] = BRCMF_BSSIDX_INVALID;
 953 }
 954
 955 void brcmf_remove_interface(struct brcmf_if *ifp, bool rtnl_locked)
 956 {
 957         if (!ifp || WARN_ON(ifp->drvr->iflist[ifp->bsscfgidx] != ifp))
 958                 return;
 959         brcmf_dbg(TRACE, "Enter, bsscfgidx=%d, ifidx=%d\n", ifp->bsscfgidx,
 960                   ifp->ifidx);
 961         brcmf_proto_del_if(ifp->drvr, ifp);
 962         brcmf_del_if(ifp->drvr, ifp->bsscfgidx, rtnl_locked);
 963 }
 964
 965 static int brcmf_psm_watchdog_notify(struct brcmf_if *ifp,
 966                                      const struct brcmf_event_msg *evtmsg,
 967                                      void *data)
 968 {
 969         struct brcmf_pub *drvr = ifp->drvr;
 970         int err;
 971
 972         brcmf_dbg(TRACE, "enter: bsscfgidx=%d\n", ifp->bsscfgidx);
 973
 974         bphy_err(drvr, "PSM's watchdog has fired!\n");
 975
 976         err = brcmf_debug_create_memdump(ifp->drvr->bus_if, data,
 977                                          evtmsg->datalen);
 978         if (err)
 979                 bphy_err(drvr, "Failed to get memory dump, %d\n", err);
 980
 981         return err;
 982 }
 983
 984 #ifdef CONFIG_INET
 985 #define ARPOL_MAX_ENTRIES       8
 986 static int brcmf_inetaddr_changed(struct notifier_block *nb,
 987                                   unsigned long action, void *data)
 988 {
 989         struct brcmf_pub *drvr = container_of(nb, struct brcmf_pub,
 990                                               inetaddr_notifier);
 991         struct in_ifaddr *ifa = data;
 992         struct net_device *ndev = ifa->ifa_dev->dev;
 993         struct brcmf_if *ifp;
 994         int idx, i, ret;
 995         u32 val;
 996         __be32 addr_table[ARPOL_MAX_ENTRIES] = {0};
 997
 998         /* Find out if the notification is meant for us */
 999         for (idx = 0; idx < BRCMF_MAX_IFS; idx++) {
1000                 ifp = drvr->iflist[idx];
1001                 if (ifp && ifp->ndev == ndev)
1002                         break;
1003                 if (idx == BRCMF_MAX_IFS - 1)
1004                         return NOTIFY_DONE;
1005         }
1006
1007         /* check if arp offload is supported */
1008         ret = brcmf_fil_iovar_int_get(ifp, "arpoe", &val);
1009         if (ret)
1010                 return NOTIFY_OK;
1011
1012         /* old version only support primary index */
1013         ret = brcmf_fil_iovar_int_get(ifp, "arp_version", &val);
1014         if (ret)
1015                 val = 1;
1016         if (val == 1)
1017                 ifp = drvr->iflist[0];
1018
1019         /* retrieve the table from firmware */
1020         ret = brcmf_fil_iovar_data_get(ifp, "arp_hostip", addr_table,
1021                                        sizeof(addr_table));
1022         if (ret) {
1023                 bphy_err(drvr, "fail to get arp ip table err:%d\n", ret);
1024                 return NOTIFY_OK;
1025         }
1026
1027         for (i = 0; i < ARPOL_MAX_ENTRIES; i++)
1028                 if (ifa->ifa_address == addr_table[i])
1029                         break;
1030
1031         switch (action) {
1032         case NETDEV_UP:
1033                 if (i == ARPOL_MAX_ENTRIES) {
1034                         brcmf_dbg(TRACE, "add %pI4 to arp table\n",
1035                                   &ifa->ifa_address);
1036                         /* set it directly */
1037                         ret = brcmf_fil_iovar_data_set(ifp, "arp_hostip",
1038                                 &ifa->ifa_address, sizeof(ifa->ifa_address));
1039                         if (ret)
1040                                 bphy_err(drvr, "add arp ip err %d\n", ret);
1041                 }
1042                 break;
1043         case NETDEV_DOWN:
1044                 if (i < ARPOL_MAX_ENTRIES) {
1045                         addr_table[i] = 0;
1046                         brcmf_dbg(TRACE, "remove %pI4 from arp table\n",
1047                                   &ifa->ifa_address);
1048                         /* clear the table in firmware */
1049                         ret = brcmf_fil_iovar_data_set(ifp, "arp_hostip_clear",
1050                                                        NULL, 0);
1051                         if (ret) {
1052                                 bphy_err(drvr, "fail to clear arp ip table err:%d\n",
1053                                          ret);
1054                                 return NOTIFY_OK;
1055                         }
1056                         for (i = 0; i < ARPOL_MAX_ENTRIES; i++) {
1057                                 if (addr_table[i] == 0)
1058                                         continue;
1059                                 ret = brcmf_fil_iovar_data_set(ifp, "arp_hostip",
1060                                                                &addr_table[i],
1061                                                                sizeof(addr_table[i]));
1062                                 if (ret)
1063                                         bphy_err(drvr, "add arp ip err %d\n",
1064                                                  ret);
1065                         }
1066                 }
1067                 break;
1068         default:
1069                 break;
1070         }
1071
1072         return NOTIFY_OK;
1073 }
1074 #endif
1075
1076 #if IS_ENABLED(CONFIG_IPV6)
1077 static int brcmf_inet6addr_changed(struct notifier_block *nb,
1078                                    unsigned long action, void *data)
1079 {
1080         struct brcmf_pub *drvr = container_of(nb, struct brcmf_pub,
1081                                               inet6addr_notifier);
1082         struct inet6_ifaddr *ifa = data;
1083         struct brcmf_if *ifp;
1084         int i;
1085         struct in6_addr *table;
1086
1087         /* Only handle primary interface */
1088         ifp = drvr->iflist[0];
1089         if (!ifp)
1090                 return NOTIFY_DONE;
1091         if (ifp->ndev != ifa->idev->dev)
1092                 return NOTIFY_DONE;
1093
1094         table = ifp->ipv6_addr_tbl;
1095         for (i = 0; i < NDOL_MAX_ENTRIES; i++)
1096                 if (ipv6_addr_equal(&ifa->addr, &table[i]))
1097                         break;
1098
1099         switch (action) {
1100         case NETDEV_UP:
1101                 if (i == NDOL_MAX_ENTRIES) {
1102                         if (ifp->ipv6addr_idx < NDOL_MAX_ENTRIES) {
1103                                 table[ifp->ipv6addr_idx++] = ifa->addr;
1104                         } else {
1105                                 for (i = 0; i < NDOL_MAX_ENTRIES - 1; i++)
1106                                         table[i] = table[i + 1];
1107                                 table[NDOL_MAX_ENTRIES - 1] = ifa->addr;
1108                         }
1109                 }
1110                 break;
1111         case NETDEV_DOWN:
1112                 if (i < NDOL_MAX_ENTRIES) {
1113                         for (; i < ifp->ipv6addr_idx - 1; i++)
1114                                 table[i] = table[i + 1];
1115                         memset(&table[i], 0, sizeof(table[i]));
1116                         ifp->ipv6addr_idx--;
1117                 }
1118                 break;
1119         default:
1120                 break;
1121         }
1122
1123         schedule_work(&ifp->ndoffload_work);
1124
1125         return NOTIFY_OK;
1126 }
1127 #endif
1128
1129 static int brcmf_revinfo_read(struct seq_file *s, void *data)
1130 {
1131         struct brcmf_bus *bus_if = dev_get_drvdata(s->private);
1132         struct brcmf_rev_info *ri = &bus_if->drvr->revinfo;
1133         char drev[BRCMU_DOTREV_LEN];
1134         char brev[BRCMU_BOARDREV_LEN];
1135
1136         seq_printf(s, "vendorid: 0x%04x\n", ri->vendorid);
1137         seq_printf(s, "deviceid: 0x%04x\n", ri->deviceid);
1138         seq_printf(s, "radiorev: %s\n", brcmu_dotrev_str(ri->radiorev, drev));
1139         seq_printf(s, "chip: %s\n", ri->chipname);
1140         seq_printf(s, "chippkg: %u\n", ri->chippkg);
1141         seq_printf(s, "corerev: %u\n", ri->corerev);
1142         seq_printf(s, "boardid: 0x%04x\n", ri->boardid);
1143         seq_printf(s, "boardvendor: 0x%04x\n", ri->boardvendor);
1144         seq_printf(s, "boardrev: %s\n", brcmu_boardrev_str(ri->boardrev, brev));
1145         seq_printf(s, "driverrev: %s\n", brcmu_dotrev_str(ri->driverrev, drev));
1146         seq_printf(s, "ucoderev: %u\n", ri->ucoderev);
1147         seq_printf(s, "bus: %u\n", ri->bus);
1148         seq_printf(s, "phytype: %u\n", ri->phytype);
1149         seq_printf(s, "phyrev: %u\n", ri->phyrev);
1150         seq_printf(s, "anarev: %u\n", ri->anarev);
1151         seq_printf(s, "nvramrev: %08x\n", ri->nvramrev);
1152
1153         seq_printf(s, "clmver: %s\n", bus_if->drvr->clmver);
1154
1155         return 0;
1156 }
1157
1158 static void brcmf_core_bus_reset(struct work_struct *work)
1159 {
1160         struct brcmf_pub *drvr = container_of(work, struct brcmf_pub,
1161                                               bus_reset);
1162
1163         brcmf_bus_reset(drvr->bus_if);
1164 }
1165
1166 static ssize_t bus_reset_write(struct file *file, const char __user *user_buf,
1167                                size_t count, loff_t *ppos)
1168 {
1169         struct brcmf_pub *drvr = file->private_data;
1170         u8 value;
1171
1172         if (kstrtou8_from_user(user_buf, count, 0, &value))
1173                 return -EINVAL;
1174
1175         if (value != 1)
1176                 return -EINVAL;
1177
1178         schedule_work(&drvr->bus_reset);
1179
1180         return count;
1181 }
1182
1183 static const struct file_operations bus_reset_fops = {
1184         .open   = simple_open,
1185         .llseek = no_llseek,
1186         .write  = bus_reset_write,
1187 };
1188
1189 static int brcmf_bus_started(struct brcmf_pub *drvr, struct cfg80211_ops *ops)
1190 {
1191         int ret = -1;
1192         struct brcmf_bus *bus_if = drvr->bus_if;
1193         struct brcmf_if *ifp;
1194         struct brcmf_if *p2p_ifp;
1195
1196         brcmf_dbg(TRACE, "\n");
1197
1198         /* add primary networking interface */
1199         ifp = brcmf_add_if(drvr, 0, 0, false, "wlan%d", NULL);
1200         if (IS_ERR(ifp))
1201                 return PTR_ERR(ifp);
1202
1203         p2p_ifp = NULL;
1204
1205         /* signal bus ready */
1206         brcmf_bus_change_state(bus_if, BRCMF_BUS_UP);
1207
1208         /* do bus specific preinit here */
1209         ret = brcmf_bus_preinit(bus_if);
1210         if (ret < 0)
1211                 goto fail;
1212
1213         /* Bus is ready, do any initialization */
1214         ret = brcmf_c_preinit_dcmds(ifp);
1215         if (ret < 0)
1216                 goto fail;
1217
1218         brcmf_feat_attach(drvr);
1219
1220         ret = brcmf_proto_init_done(drvr);
1221         if (ret < 0)
1222                 goto fail;
1223
1224         brcmf_proto_add_if(drvr, ifp);
1225
1226         drvr->config = brcmf_cfg80211_attach(drvr, ops,
1227                                              drvr->settings->p2p_enable);
1228         if (drvr->config == NULL) {
1229                 ret = -ENOMEM;
1230                 goto fail;
1231         }
1232
1233         ret = brcmf_net_attach(ifp, false);
1234
1235         if ((!ret) && (drvr->settings->p2p_enable)) {
1236                 p2p_ifp = drvr->iflist[1];
1237                 if (p2p_ifp)
1238                         ret = brcmf_net_p2p_attach(p2p_ifp);
1239         }
1240
1241         if (ret)
1242                 goto fail;
1243
1244 #ifdef CONFIG_INET
1245         drvr->inetaddr_notifier.notifier_call = brcmf_inetaddr_changed;
1246         ret = register_inetaddr_notifier(&drvr->inetaddr_notifier);
1247         if (ret)
1248                 goto fail;
1249
1250 #if IS_ENABLED(CONFIG_IPV6)
1251         drvr->inet6addr_notifier.notifier_call = brcmf_inet6addr_changed;
1252         ret = register_inet6addr_notifier(&drvr->inet6addr_notifier);
1253         if (ret) {
1254                 unregister_inetaddr_notifier(&drvr->inetaddr_notifier);
1255                 goto fail;
1256         }
1257 #endif
1258 #endif /* CONFIG_INET */
1259
1260         INIT_WORK(&drvr->bus_reset, brcmf_core_bus_reset);
1261
1262         /* populate debugfs */
1263         brcmf_debugfs_add_entry(drvr, "revinfo", brcmf_revinfo_read);
1264         debugfs_create_file("reset", 0600, brcmf_debugfs_get_devdir(drvr), drvr,
1265                             &bus_reset_fops);
1266         brcmf_feat_debugfs_create(drvr);
1267         brcmf_proto_debugfs_create(drvr);
1268         brcmf_bus_debugfs_create(bus_if);
1269
1270         return 0;
1271
1272 fail:
1273         bphy_err(drvr, "failed: %d\n", ret);
1274         if (drvr->config) {
1275                 brcmf_cfg80211_detach(drvr->config);
1276                 drvr->config = NULL;
1277         }
1278         brcmf_net_detach(ifp->ndev, false);
1279         if (p2p_ifp)
1280                 brcmf_net_detach(p2p_ifp->ndev, false);
1281         drvr->iflist[0] = NULL;
1282         drvr->iflist[1] = NULL;
1283         if (drvr->settings->ignore_probe_fail)
1284                 ret = 0;
1285
1286         return ret;
1287 }
1288
1289 int brcmf_alloc(struct device *dev, struct brcmf_mp_device *settings)
1290 {
1291         struct wiphy *wiphy;
1292         struct cfg80211_ops *ops;
1293         struct brcmf_pub *drvr = NULL;
1294
1295         brcmf_dbg(TRACE, "Enter\n");
1296
1297         ops = brcmf_cfg80211_get_ops(settings);
1298         if (!ops)
1299                 return -ENOMEM;
1300
1301         wiphy = wiphy_new(ops, sizeof(*drvr));
1302         if (!wiphy) {
1303                 kfree(ops);
1304                 return -ENOMEM;
1305         }
1306
1307         set_wiphy_dev(wiphy, dev);
1308         drvr = wiphy_priv(wiphy);
1309         drvr->wiphy = wiphy;
1310         drvr->ops = ops;
1311         drvr->bus_if = dev_get_drvdata(dev);
1312         drvr->bus_if->drvr = drvr;
1313         drvr->settings = settings;
1314
1315         return 0;
1316 }
1317
1318 int brcmf_attach(struct device *dev)
1319 {
1320         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1321         struct brcmf_pub *drvr = bus_if->drvr;
1322         int ret = 0;
1323         int i;
1324
1325         brcmf_dbg(TRACE, "Enter\n");
1326
1327         for (i = 0; i < ARRAY_SIZE(drvr->if2bss); i++)
1328                 drvr->if2bss[i] = BRCMF_BSSIDX_INVALID;
1329
1330         mutex_init(&drvr->proto_block);
1331
1332         /* Link to bus module */
1333         drvr->hdrlen = 0;
1334
1335         /* Attach and link in the protocol */
1336         ret = brcmf_proto_attach(drvr);
1337         if (ret != 0) {
1338                 bphy_err(drvr, "brcmf_prot_attach failed\n");
1339                 goto fail;
1340         }
1341
1342         /* Attach to events important for core code */
1343         brcmf_fweh_register(drvr, BRCMF_E_PSM_WATCHDOG,
1344                             brcmf_psm_watchdog_notify);
1345
1346         /* attach firmware event handler */
1347         brcmf_fweh_attach(drvr);
1348
1349         ret = brcmf_bus_started(drvr, drvr->ops);
1350         if (ret != 0) {
1351                 bphy_err(drvr, "dongle is not responding: err=%d\n", ret);
1352                 goto fail;
1353         }
1354
1355         return 0;
1356
1357 fail:
1358         brcmf_detach(dev);
1359
1360         return ret;
1361 }
1362
1363 void brcmf_bus_add_txhdrlen(struct device *dev, uint len)
1364 {
1365         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1366         struct brcmf_pub *drvr = bus_if->drvr;
1367
1368         if (drvr) {
1369                 drvr->hdrlen += len;
1370         }
1371 }
1372
1373 void brcmf_dev_reset(struct device *dev)
1374 {
1375         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1376         struct brcmf_pub *drvr = bus_if->drvr;
1377
1378         if (drvr == NULL)
1379                 return;
1380
1381         if (drvr->iflist[0])
1382                 brcmf_fil_cmd_int_set(drvr->iflist[0], BRCMF_C_TERMINATED, 1);
1383 }
1384
1385 void brcmf_dev_coredump(struct device *dev)
1386 {
1387         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1388
1389         if (brcmf_debug_create_memdump(bus_if, NULL, 0) < 0)
1390                 brcmf_dbg(TRACE, "failed to create coredump\n");
1391 }
1392
1393 void brcmf_fw_crashed(struct device *dev)
1394 {
1395         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1396         struct brcmf_pub *drvr = bus_if->drvr;
1397
1398         bphy_err(drvr, "Firmware has halted or crashed\n");
1399
1400         brcmf_dev_coredump(dev);
1401
1402         schedule_work(&drvr->bus_reset);
1403 }
1404
1405 void brcmf_detach(struct device *dev)
1406 {
1407         s32 i;
1408         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1409         struct brcmf_pub *drvr = bus_if->drvr;
1410
1411         brcmf_dbg(TRACE, "Enter\n");
1412
1413         if (drvr == NULL)
1414                 return;
1415
1416 #ifdef CONFIG_INET
1417         unregister_inetaddr_notifier(&drvr->inetaddr_notifier);
1418 #endif
1419
1420 #if IS_ENABLED(CONFIG_IPV6)
1421         unregister_inet6addr_notifier(&drvr->inet6addr_notifier);
1422 #endif
1423
1424         brcmf_bus_change_state(bus_if, BRCMF_BUS_DOWN);
1425         brcmf_bus_stop(drvr->bus_if);
1426
1427         brcmf_fweh_detach(drvr);
1428         brcmf_proto_detach(drvr);
1429
1430         if (drvr->mon_if) {
1431                 brcmf_net_detach(drvr->mon_if->ndev, false);
1432                 drvr->mon_if = NULL;
1433         }
1434
1435         /* make sure primary interface removed last */
1436         for (i = BRCMF_MAX_IFS - 1; i > -1; i--) {
1437                 if (drvr->iflist[i])
1438                         brcmf_del_if(drvr, drvr->iflist[i]->bsscfgidx, false);
1439         }
1440
1441         if (drvr->config) {
1442                 brcmf_p2p_detach(&drvr->config->p2p);
1443                 brcmf_cfg80211_detach(drvr->config);
1444                 drvr->config = NULL;
1445         }
1446 }
1447
1448 void brcmf_free(struct device *dev)
1449 {
1450         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1451         struct brcmf_pub *drvr = bus_if->drvr;
1452
1453         if (!drvr)
1454                 return;
1455
1456         bus_if->drvr = NULL;
1457
1458         kfree(drvr->ops);
1459
1460         wiphy_free(drvr->wiphy);
1461 }
1462
1463 s32 brcmf_iovar_data_set(struct device *dev, char *name, void *data, u32 len)
1464 {
1465         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1466         struct brcmf_if *ifp = bus_if->drvr->iflist[0];
1467
1468         return brcmf_fil_iovar_data_set(ifp, name, data, len);
1469 }
1470
1471 static int brcmf_get_pend_8021x_cnt(struct brcmf_if *ifp)
1472 {
1473         return atomic_read(&ifp->pend_8021x_cnt);
1474 }
1475
1476 int brcmf_netdev_wait_pend8021x(struct brcmf_if *ifp)
1477 {
1478         struct brcmf_pub *drvr = ifp->drvr;
1479         int err;
1480
1481         err = wait_event_timeout(ifp->pend_8021x_wait,
1482                                  !brcmf_get_pend_8021x_cnt(ifp),
1483                                  MAX_WAIT_FOR_8021X_TX);
1484
1485         if (!err)
1486                 bphy_err(drvr, "Timed out waiting for no pending 802.1x packets\n");
1487
1488         return !err;
1489 }
1490
1491 void brcmf_bus_change_state(struct brcmf_bus *bus, enum brcmf_bus_state state)
1492 {
1493         struct brcmf_pub *drvr = bus->drvr;
1494         struct net_device *ndev;
1495         int ifidx;
1496
1497         brcmf_dbg(TRACE, "%d -> %d\n", bus->state, state);
1498
1499         if (!drvr) {
1500                 brcmf_dbg(INFO, "ignoring transition, bus not attached yet\n");
1501                 return;
1502         }
1503
1504         bus->state = state;
1505
1506         if (state == BRCMF_BUS_UP) {
1507                 for (ifidx = 0; ifidx < BRCMF_MAX_IFS; ifidx++) {
1508                         if ((drvr->iflist[ifidx]) &&
1509                             (drvr->iflist[ifidx]->ndev)) {
1510                                 ndev = drvr->iflist[ifidx]->ndev;
1511                                 if (netif_queue_stopped(ndev))
1512                                         netif_wake_queue(ndev);
1513                         }
1514                 }
1515         }
1516 }
1517
1518 static void brcmf_driver_register(struct work_struct *work)
1519 {
1520 #ifdef CONFIG_BRCMFMAC_SDIO
1521         brcmf_sdio_register();
1522 #endif
1523 #ifdef CONFIG_BRCMFMAC_USB
1524         brcmf_usb_register();
1525 #endif
1526 #ifdef CONFIG_BRCMFMAC_PCIE
1527         brcmf_pcie_register();
1528 #endif
1529 }
1530 static DECLARE_WORK(brcmf_driver_work, brcmf_driver_register);
1531
1532 int __init brcmf_core_init(void)
1533 {
1534         if (!schedule_work(&brcmf_driver_work))
1535                 return -EBUSY;
1536
1537         return 0;
1538 }
1539
1540 void __exit brcmf_core_exit(void)
1541 {
1542         cancel_work_sync(&brcmf_driver_work);
1543
1544 #ifdef CONFIG_BRCMFMAC_SDIO
1545         brcmf_sdio_exit();
1546 #endif
1547 #ifdef CONFIG_BRCMFMAC_USB
1548         brcmf_usb_exit();
1549 #endif
1550 #ifdef CONFIG_BRCMFMAC_PCIE
1551         brcmf_pcie_exit();
1552 #endif
1553 }
1554