1 /* 2 * Copyright (c) 2010 Broadcom Corporation 3 * 4 * Permission to use, copy, modify, and/or distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 11 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION 13 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 14 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 15 */ 16 17 #include <linux/kernel.h> 18 #include <linux/etherdevice.h> 19 #include <linux/module.h> 20 #include <linux/inetdevice.h> 21 #include <net/cfg80211.h> 22 #include <net/rtnetlink.h> 23 #include <net/addrconf.h> 24 #include <net/ipv6.h> 25 #include <brcmu_utils.h> 26 #include <brcmu_wifi.h> 27 28 #include "core.h" 29 #include "bus.h" 30 #include "debug.h" 31 #include "fwil_types.h" 32 #include "p2p.h" 33 #include "pno.h" 34 #include "cfg80211.h" 35 #include "fwil.h" 36 #include "feature.h" 37 #include "proto.h" 38 #include "pcie.h" 39 #include "common.h" 40 41 #define MAX_WAIT_FOR_8021X_TX msecs_to_jiffies(950) 42 43 #define BRCMF_BSSIDX_INVALID -1 44 45 char *brcmf_ifname(struct brcmf_if *ifp) 46 { 47 if (!ifp) 48 return "<if_null>"; 49 50 if (ifp->ndev) 51 return ifp->ndev->name; 52 53 return "<if_none>"; 54 } 55 56 struct brcmf_if *brcmf_get_ifp(struct brcmf_pub *drvr, int ifidx) 57 { 58 struct brcmf_if *ifp; 59 s32 bsscfgidx; 60 61 if (ifidx < 0 || ifidx >= BRCMF_MAX_IFS) { 62 brcmf_err("ifidx %d out of range\n", ifidx); 63 return NULL; 64 } 65 66 ifp = NULL; 67 bsscfgidx = drvr->if2bss[ifidx]; 68 if (bsscfgidx >= 0) 69 ifp = drvr->iflist[bsscfgidx]; 70 71 return ifp; 72 } 73 74 void brcmf_configure_arp_nd_offload(struct brcmf_if *ifp, bool enable) 75 { 76 s32 err; 77 u32 mode; 78 79 if (enable) 80 mode = BRCMF_ARP_OL_AGENT | BRCMF_ARP_OL_PEER_AUTO_REPLY; 81 else 82 mode = 0; 83 84 /* Try to set and enable ARP offload feature, this may fail, then it */ 85 /* is simply not supported and err 0 will be returned */ 86 err = brcmf_fil_iovar_int_set(ifp, "arp_ol", mode); 87 if (err) { 88 brcmf_dbg(TRACE, "failed to set ARP offload mode to 0x%x, err = %d\n", 89 mode, err); 90 } else { 91 err = brcmf_fil_iovar_int_set(ifp, "arpoe", enable); 92 if (err) { 93 brcmf_dbg(TRACE, "failed to configure (%d) ARP offload err = %d\n", 94 enable, err); 95 } else { 96 brcmf_dbg(TRACE, "successfully configured (%d) ARP offload to 0x%x\n", 97 enable, mode); 98 } 99 } 100 101 err = brcmf_fil_iovar_int_set(ifp, "ndoe", enable); 102 if (err) { 103 brcmf_dbg(TRACE, "failed to configure (%d) ND offload err = %d\n", 104 enable, err); 105 } else { 106 brcmf_dbg(TRACE, "successfully configured (%d) ND offload to 0x%x\n", 107 enable, mode); 108 } 109 } 110 111 static void _brcmf_set_multicast_list(struct work_struct *work) 112 { 113 struct brcmf_if *ifp; 114 struct net_device *ndev; 115 struct netdev_hw_addr *ha; 116 u32 cmd_value, cnt; 117 __le32 cnt_le; 118 char *buf, *bufp; 119 u32 buflen; 120 s32 err; 121 122 ifp = container_of(work, struct brcmf_if, multicast_work); 123 124 brcmf_dbg(TRACE, "Enter, bsscfgidx=%d\n", ifp->bsscfgidx); 125 126 ndev = ifp->ndev; 127 128 /* Determine initial value of allmulti flag */ 129 cmd_value = (ndev->flags & IFF_ALLMULTI) ? true : false; 130 131 /* Send down the multicast list first. */ 132 cnt = netdev_mc_count(ndev); 133 buflen = sizeof(cnt) + (cnt * ETH_ALEN); 134 buf = kmalloc(buflen, GFP_ATOMIC); 135 if (!buf) 136 return; 137 bufp = buf; 138 139 cnt_le = cpu_to_le32(cnt); 140 memcpy(bufp, &cnt_le, sizeof(cnt_le)); 141 bufp += sizeof(cnt_le); 142 143 netdev_for_each_mc_addr(ha, ndev) { 144 if (!cnt) 145 break; 146 memcpy(bufp, ha->addr, ETH_ALEN); 147 bufp += ETH_ALEN; 148 cnt--; 149 } 150 151 err = brcmf_fil_iovar_data_set(ifp, "mcast_list", buf, buflen); 152 if (err < 0) { 153 brcmf_err("Setting mcast_list failed, %d\n", err); 154 cmd_value = cnt ? true : cmd_value; 155 } 156 157 kfree(buf); 158 159 /* 160 * Now send the allmulti setting. This is based on the setting in the 161 * net_device flags, but might be modified above to be turned on if we 162 * were trying to set some addresses and dongle rejected it... 163 */ 164 err = brcmf_fil_iovar_int_set(ifp, "allmulti", cmd_value); 165 if (err < 0) 166 brcmf_err("Setting allmulti failed, %d\n", err); 167 168 /*Finally, pick up the PROMISC flag */ 169 cmd_value = (ndev->flags & IFF_PROMISC) ? true : false; 170 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PROMISC, cmd_value); 171 if (err < 0) 172 brcmf_err("Setting BRCMF_C_SET_PROMISC failed, %d\n", 173 err); 174 brcmf_configure_arp_nd_offload(ifp, !cmd_value); 175 } 176 177 #if IS_ENABLED(CONFIG_IPV6) 178 static void _brcmf_update_ndtable(struct work_struct *work) 179 { 180 struct brcmf_if *ifp; 181 int i, ret; 182 183 ifp = container_of(work, struct brcmf_if, ndoffload_work); 184 185 /* clear the table in firmware */ 186 ret = brcmf_fil_iovar_data_set(ifp, "nd_hostip_clear", NULL, 0); 187 if (ret) { 188 brcmf_dbg(TRACE, "fail to clear nd ip table err:%d\n", ret); 189 return; 190 } 191 192 for (i = 0; i < ifp->ipv6addr_idx; i++) { 193 ret = brcmf_fil_iovar_data_set(ifp, "nd_hostip", 194 &ifp->ipv6_addr_tbl[i], 195 sizeof(struct in6_addr)); 196 if (ret) 197 brcmf_err("add nd ip err %d\n", ret); 198 } 199 } 200 #else 201 static void _brcmf_update_ndtable(struct work_struct *work) 202 { 203 } 204 #endif 205 206 static int brcmf_netdev_set_mac_address(struct net_device *ndev, void *addr) 207 { 208 struct brcmf_if *ifp = netdev_priv(ndev); 209 struct sockaddr *sa = (struct sockaddr *)addr; 210 int err; 211 212 brcmf_dbg(TRACE, "Enter, bsscfgidx=%d\n", ifp->bsscfgidx); 213 214 err = brcmf_fil_iovar_data_set(ifp, "cur_etheraddr", sa->sa_data, 215 ETH_ALEN); 216 if (err < 0) { 217 brcmf_err("Setting cur_etheraddr failed, %d\n", err); 218 } else { 219 brcmf_dbg(TRACE, "updated to %pM\n", sa->sa_data); 220 memcpy(ifp->mac_addr, sa->sa_data, ETH_ALEN); 221 memcpy(ifp->ndev->dev_addr, ifp->mac_addr, ETH_ALEN); 222 } 223 return err; 224 } 225 226 static void brcmf_netdev_set_multicast_list(struct net_device *ndev) 227 { 228 struct brcmf_if *ifp = netdev_priv(ndev); 229 230 schedule_work(&ifp->multicast_work); 231 } 232 233 static netdev_tx_t brcmf_netdev_start_xmit(struct sk_buff *skb, 234 struct net_device *ndev) 235 { 236 int ret; 237 struct brcmf_if *ifp = netdev_priv(ndev); 238 struct brcmf_pub *drvr = ifp->drvr; 239 struct ethhdr *eh; 240 int head_delta; 241 242 brcmf_dbg(DATA, "Enter, bsscfgidx=%d\n", ifp->bsscfgidx); 243 244 /* Can the device send data? */ 245 if (drvr->bus_if->state != BRCMF_BUS_UP) { 246 brcmf_err("xmit rejected state=%d\n", drvr->bus_if->state); 247 netif_stop_queue(ndev); 248 dev_kfree_skb(skb); 249 ret = -ENODEV; 250 goto done; 251 } 252 253 /* Make sure there's enough writeable headroom */ 254 if (skb_headroom(skb) < drvr->hdrlen || skb_header_cloned(skb)) { 255 head_delta = max_t(int, drvr->hdrlen - skb_headroom(skb), 0); 256 257 brcmf_dbg(INFO, "%s: insufficient headroom (%d)\n", 258 brcmf_ifname(ifp), head_delta); 259 atomic_inc(&drvr->bus_if->stats.pktcowed); 260 ret = pskb_expand_head(skb, ALIGN(head_delta, NET_SKB_PAD), 0, 261 GFP_ATOMIC); 262 if (ret < 0) { 263 brcmf_err("%s: failed to expand headroom\n", 264 brcmf_ifname(ifp)); 265 atomic_inc(&drvr->bus_if->stats.pktcow_failed); 266 goto done; 267 } 268 } 269 270 /* validate length for ether packet */ 271 if (skb->len < sizeof(*eh)) { 272 ret = -EINVAL; 273 dev_kfree_skb(skb); 274 goto done; 275 } 276 277 eh = (struct ethhdr *)(skb->data); 278 279 if (eh->h_proto == htons(ETH_P_PAE)) 280 atomic_inc(&ifp->pend_8021x_cnt); 281 282 /* determine the priority */ 283 if ((skb->priority == 0) || (skb->priority > 7)) 284 skb->priority = cfg80211_classify8021d(skb, NULL); 285 286 ret = brcmf_proto_tx_queue_data(drvr, ifp->ifidx, skb); 287 if (ret < 0) 288 brcmf_txfinalize(ifp, skb, false); 289 290 done: 291 if (ret) { 292 ndev->stats.tx_dropped++; 293 } else { 294 ndev->stats.tx_packets++; 295 ndev->stats.tx_bytes += skb->len; 296 } 297 298 /* Return ok: we always eat the packet */ 299 return NETDEV_TX_OK; 300 } 301 302 void brcmf_txflowblock_if(struct brcmf_if *ifp, 303 enum brcmf_netif_stop_reason reason, bool state) 304 { 305 unsigned long flags; 306 307 if (!ifp || !ifp->ndev) 308 return; 309 310 brcmf_dbg(TRACE, "enter: bsscfgidx=%d stop=0x%X reason=%d state=%d\n", 311 ifp->bsscfgidx, ifp->netif_stop, reason, state); 312 313 spin_lock_irqsave(&ifp->netif_stop_lock, flags); 314 if (state) { 315 if (!ifp->netif_stop) 316 netif_stop_queue(ifp->ndev); 317 ifp->netif_stop |= reason; 318 } else { 319 ifp->netif_stop &= ~reason; 320 if (!ifp->netif_stop) 321 netif_wake_queue(ifp->ndev); 322 } 323 spin_unlock_irqrestore(&ifp->netif_stop_lock, flags); 324 } 325 326 void brcmf_netif_rx(struct brcmf_if *ifp, struct sk_buff *skb) 327 { 328 if (skb->pkt_type == PACKET_MULTICAST) 329 ifp->ndev->stats.multicast++; 330 331 if (!(ifp->ndev->flags & IFF_UP)) { 332 brcmu_pkt_buf_free_skb(skb); 333 return; 334 } 335 336 ifp->ndev->stats.rx_bytes += skb->len; 337 ifp->ndev->stats.rx_packets++; 338 339 brcmf_dbg(DATA, "rx proto=0x%X\n", ntohs(skb->protocol)); 340 if (in_interrupt()) 341 netif_rx(skb); 342 else 343 /* If the receive is not processed inside an ISR, 344 * the softirqd must be woken explicitly to service 345 * the NET_RX_SOFTIRQ. This is handled by netif_rx_ni(). 346 */ 347 netif_rx_ni(skb); 348 } 349 350 static int brcmf_rx_hdrpull(struct brcmf_pub *drvr, struct sk_buff *skb, 351 struct brcmf_if **ifp) 352 { 353 int ret; 354 355 /* process and remove protocol-specific header */ 356 ret = brcmf_proto_hdrpull(drvr, true, skb, ifp); 357 358 if (ret || !(*ifp) || !(*ifp)->ndev) { 359 if (ret != -ENODATA && *ifp) 360 (*ifp)->ndev->stats.rx_errors++; 361 brcmu_pkt_buf_free_skb(skb); 362 return -ENODATA; 363 } 364 365 skb->protocol = eth_type_trans(skb, (*ifp)->ndev); 366 return 0; 367 } 368 369 void brcmf_rx_frame(struct device *dev, struct sk_buff *skb, bool handle_event) 370 { 371 struct brcmf_if *ifp; 372 struct brcmf_bus *bus_if = dev_get_drvdata(dev); 373 struct brcmf_pub *drvr = bus_if->drvr; 374 375 brcmf_dbg(DATA, "Enter: %s: rxp=%p\n", dev_name(dev), skb); 376 377 if (brcmf_rx_hdrpull(drvr, skb, &ifp)) 378 return; 379 380 if (brcmf_proto_is_reorder_skb(skb)) { 381 brcmf_proto_rxreorder(ifp, skb); 382 } else { 383 /* Process special event packets */ 384 if (handle_event) 385 brcmf_fweh_process_skb(ifp->drvr, skb); 386 387 brcmf_netif_rx(ifp, skb); 388 } 389 } 390 391 void brcmf_rx_event(struct device *dev, struct sk_buff *skb) 392 { 393 struct brcmf_if *ifp; 394 struct brcmf_bus *bus_if = dev_get_drvdata(dev); 395 struct brcmf_pub *drvr = bus_if->drvr; 396 397 brcmf_dbg(EVENT, "Enter: %s: rxp=%p\n", dev_name(dev), skb); 398 399 if (brcmf_rx_hdrpull(drvr, skb, &ifp)) 400 return; 401 402 brcmf_fweh_process_skb(ifp->drvr, skb); 403 brcmu_pkt_buf_free_skb(skb); 404 } 405 406 void brcmf_txfinalize(struct brcmf_if *ifp, struct sk_buff *txp, bool success) 407 { 408 struct ethhdr *eh; 409 u16 type; 410 411 eh = (struct ethhdr *)(txp->data); 412 type = ntohs(eh->h_proto); 413 414 if (type == ETH_P_PAE) { 415 atomic_dec(&ifp->pend_8021x_cnt); 416 if (waitqueue_active(&ifp->pend_8021x_wait)) 417 wake_up(&ifp->pend_8021x_wait); 418 } 419 420 if (!success) 421 ifp->ndev->stats.tx_errors++; 422 423 brcmu_pkt_buf_free_skb(txp); 424 } 425 426 static void brcmf_ethtool_get_drvinfo(struct net_device *ndev, 427 struct ethtool_drvinfo *info) 428 { 429 struct brcmf_if *ifp = netdev_priv(ndev); 430 struct brcmf_pub *drvr = ifp->drvr; 431 char drev[BRCMU_DOTREV_LEN] = "n/a"; 432 433 if (drvr->revinfo.result == 0) 434 brcmu_dotrev_str(drvr->revinfo.driverrev, drev); 435 strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver)); 436 strlcpy(info->version, drev, sizeof(info->version)); 437 strlcpy(info->fw_version, drvr->fwver, sizeof(info->fw_version)); 438 strlcpy(info->bus_info, dev_name(drvr->bus_if->dev), 439 sizeof(info->bus_info)); 440 } 441 442 static const struct ethtool_ops brcmf_ethtool_ops = { 443 .get_drvinfo = brcmf_ethtool_get_drvinfo, 444 }; 445 446 static int brcmf_netdev_stop(struct net_device *ndev) 447 { 448 struct brcmf_if *ifp = netdev_priv(ndev); 449 450 brcmf_dbg(TRACE, "Enter, bsscfgidx=%d\n", ifp->bsscfgidx); 451 452 brcmf_cfg80211_down(ndev); 453 454 brcmf_fil_iovar_data_set(ifp, "arp_hostip_clear", NULL, 0); 455 456 brcmf_net_setcarrier(ifp, false); 457 458 return 0; 459 } 460 461 static int brcmf_netdev_open(struct net_device *ndev) 462 { 463 struct brcmf_if *ifp = netdev_priv(ndev); 464 struct brcmf_pub *drvr = ifp->drvr; 465 struct brcmf_bus *bus_if = drvr->bus_if; 466 u32 toe_ol; 467 468 brcmf_dbg(TRACE, "Enter, bsscfgidx=%d\n", ifp->bsscfgidx); 469 470 /* If bus is not ready, can't continue */ 471 if (bus_if->state != BRCMF_BUS_UP) { 472 brcmf_err("failed bus is not ready\n"); 473 return -EAGAIN; 474 } 475 476 atomic_set(&ifp->pend_8021x_cnt, 0); 477 478 /* Get current TOE mode from dongle */ 479 if (brcmf_fil_iovar_int_get(ifp, "toe_ol", &toe_ol) >= 0 480 && (toe_ol & TOE_TX_CSUM_OL) != 0) 481 ndev->features |= NETIF_F_IP_CSUM; 482 else 483 ndev->features &= ~NETIF_F_IP_CSUM; 484 485 if (brcmf_cfg80211_up(ndev)) { 486 brcmf_err("failed to bring up cfg80211\n"); 487 return -EIO; 488 } 489 490 /* Clear, carrier, set when connected or AP mode. */ 491 netif_carrier_off(ndev); 492 return 0; 493 } 494 495 static const struct net_device_ops brcmf_netdev_ops_pri = { 496 .ndo_open = brcmf_netdev_open, 497 .ndo_stop = brcmf_netdev_stop, 498 .ndo_start_xmit = brcmf_netdev_start_xmit, 499 .ndo_set_mac_address = brcmf_netdev_set_mac_address, 500 .ndo_set_rx_mode = brcmf_netdev_set_multicast_list 501 }; 502 503 int brcmf_net_attach(struct brcmf_if *ifp, bool rtnl_locked) 504 { 505 struct brcmf_pub *drvr = ifp->drvr; 506 struct net_device *ndev; 507 s32 err; 508 509 brcmf_dbg(TRACE, "Enter, bsscfgidx=%d mac=%pM\n", ifp->bsscfgidx, 510 ifp->mac_addr); 511 ndev = ifp->ndev; 512 513 /* set appropriate operations */ 514 ndev->netdev_ops = &brcmf_netdev_ops_pri; 515 516 ndev->needed_headroom += drvr->hdrlen; 517 ndev->ethtool_ops = &brcmf_ethtool_ops; 518 519 /* set the mac address & netns */ 520 memcpy(ndev->dev_addr, ifp->mac_addr, ETH_ALEN); 521 dev_net_set(ndev, wiphy_net(cfg_to_wiphy(drvr->config))); 522 523 INIT_WORK(&ifp->multicast_work, _brcmf_set_multicast_list); 524 INIT_WORK(&ifp->ndoffload_work, _brcmf_update_ndtable); 525 526 if (rtnl_locked) 527 err = register_netdevice(ndev); 528 else 529 err = register_netdev(ndev); 530 if (err != 0) { 531 brcmf_err("couldn't register the net device\n"); 532 goto fail; 533 } 534 535 ndev->priv_destructor = brcmf_cfg80211_free_netdev; 536 brcmf_dbg(INFO, "%s: Broadcom Dongle Host Driver\n", ndev->name); 537 return 0; 538 539 fail: 540 drvr->iflist[ifp->bsscfgidx] = NULL; 541 ndev->netdev_ops = NULL; 542 return -EBADE; 543 } 544 545 static void brcmf_net_detach(struct net_device *ndev, bool rtnl_locked) 546 { 547 if (ndev->reg_state == NETREG_REGISTERED) { 548 if (rtnl_locked) 549 unregister_netdevice(ndev); 550 else 551 unregister_netdev(ndev); 552 } else { 553 brcmf_cfg80211_free_netdev(ndev); 554 free_netdev(ndev); 555 } 556 } 557 558 void brcmf_net_setcarrier(struct brcmf_if *ifp, bool on) 559 { 560 struct net_device *ndev; 561 562 brcmf_dbg(TRACE, "Enter, bsscfgidx=%d carrier=%d\n", ifp->bsscfgidx, 563 on); 564 565 ndev = ifp->ndev; 566 brcmf_txflowblock_if(ifp, BRCMF_NETIF_STOP_REASON_DISCONNECTED, !on); 567 if (on) { 568 if (!netif_carrier_ok(ndev)) 569 netif_carrier_on(ndev); 570 571 } else { 572 if (netif_carrier_ok(ndev)) 573 netif_carrier_off(ndev); 574 } 575 } 576 577 static int brcmf_net_p2p_open(struct net_device *ndev) 578 { 579 brcmf_dbg(TRACE, "Enter\n"); 580 581 return brcmf_cfg80211_up(ndev); 582 } 583 584 static int brcmf_net_p2p_stop(struct net_device *ndev) 585 { 586 brcmf_dbg(TRACE, "Enter\n"); 587 588 return brcmf_cfg80211_down(ndev); 589 } 590 591 static netdev_tx_t brcmf_net_p2p_start_xmit(struct sk_buff *skb, 592 struct net_device *ndev) 593 { 594 if (skb) 595 dev_kfree_skb_any(skb); 596 597 return NETDEV_TX_OK; 598 } 599 600 static const struct net_device_ops brcmf_netdev_ops_p2p = { 601 .ndo_open = brcmf_net_p2p_open, 602 .ndo_stop = brcmf_net_p2p_stop, 603 .ndo_start_xmit = brcmf_net_p2p_start_xmit 604 }; 605 606 static int brcmf_net_p2p_attach(struct brcmf_if *ifp) 607 { 608 struct net_device *ndev; 609 610 brcmf_dbg(TRACE, "Enter, bsscfgidx=%d mac=%pM\n", ifp->bsscfgidx, 611 ifp->mac_addr); 612 ndev = ifp->ndev; 613 614 ndev->netdev_ops = &brcmf_netdev_ops_p2p; 615 616 /* set the mac address */ 617 memcpy(ndev->dev_addr, ifp->mac_addr, ETH_ALEN); 618 619 if (register_netdev(ndev) != 0) { 620 brcmf_err("couldn't register the p2p net device\n"); 621 goto fail; 622 } 623 624 brcmf_dbg(INFO, "%s: Broadcom Dongle Host Driver\n", ndev->name); 625 626 return 0; 627 628 fail: 629 ifp->drvr->iflist[ifp->bsscfgidx] = NULL; 630 ndev->netdev_ops = NULL; 631 return -EBADE; 632 } 633 634 struct brcmf_if *brcmf_add_if(struct brcmf_pub *drvr, s32 bsscfgidx, s32 ifidx, 635 bool is_p2pdev, const char *name, u8 *mac_addr) 636 { 637 struct brcmf_if *ifp; 638 struct net_device *ndev; 639 640 brcmf_dbg(TRACE, "Enter, bsscfgidx=%d, ifidx=%d\n", bsscfgidx, ifidx); 641 642 ifp = drvr->iflist[bsscfgidx]; 643 /* 644 * Delete the existing interface before overwriting it 645 * in case we missed the BRCMF_E_IF_DEL event. 646 */ 647 if (ifp) { 648 if (ifidx) { 649 brcmf_err("ERROR: netdev:%s already exists\n", 650 ifp->ndev->name); 651 netif_stop_queue(ifp->ndev); 652 brcmf_net_detach(ifp->ndev, false); 653 drvr->iflist[bsscfgidx] = NULL; 654 } else { 655 brcmf_dbg(INFO, "netdev:%s ignore IF event\n", 656 ifp->ndev->name); 657 return ERR_PTR(-EINVAL); 658 } 659 } 660 661 if (!drvr->settings->p2p_enable && is_p2pdev) { 662 /* this is P2P_DEVICE interface */ 663 brcmf_dbg(INFO, "allocate non-netdev interface\n"); 664 ifp = kzalloc(sizeof(*ifp), GFP_KERNEL); 665 if (!ifp) 666 return ERR_PTR(-ENOMEM); 667 } else { 668 brcmf_dbg(INFO, "allocate netdev interface\n"); 669 /* Allocate netdev, including space for private structure */ 670 ndev = alloc_netdev(sizeof(*ifp), is_p2pdev ? "p2p%d" : name, 671 NET_NAME_UNKNOWN, ether_setup); 672 if (!ndev) 673 return ERR_PTR(-ENOMEM); 674 675 ndev->needs_free_netdev = true; 676 ifp = netdev_priv(ndev); 677 ifp->ndev = ndev; 678 /* store mapping ifidx to bsscfgidx */ 679 if (drvr->if2bss[ifidx] == BRCMF_BSSIDX_INVALID) 680 drvr->if2bss[ifidx] = bsscfgidx; 681 } 682 683 ifp->drvr = drvr; 684 drvr->iflist[bsscfgidx] = ifp; 685 ifp->ifidx = ifidx; 686 ifp->bsscfgidx = bsscfgidx; 687 688 init_waitqueue_head(&ifp->pend_8021x_wait); 689 spin_lock_init(&ifp->netif_stop_lock); 690 691 if (mac_addr != NULL) 692 memcpy(ifp->mac_addr, mac_addr, ETH_ALEN); 693 694 brcmf_dbg(TRACE, " ==== pid:%x, if:%s (%pM) created ===\n", 695 current->pid, name, ifp->mac_addr); 696 697 return ifp; 698 } 699 700 static void brcmf_del_if(struct brcmf_pub *drvr, s32 bsscfgidx, 701 bool rtnl_locked) 702 { 703 struct brcmf_if *ifp; 704 705 ifp = drvr->iflist[bsscfgidx]; 706 drvr->iflist[bsscfgidx] = NULL; 707 if (!ifp) { 708 brcmf_err("Null interface, bsscfgidx=%d\n", bsscfgidx); 709 return; 710 } 711 brcmf_dbg(TRACE, "Enter, bsscfgidx=%d, ifidx=%d\n", bsscfgidx, 712 ifp->ifidx); 713 if (drvr->if2bss[ifp->ifidx] == bsscfgidx) 714 drvr->if2bss[ifp->ifidx] = BRCMF_BSSIDX_INVALID; 715 if (ifp->ndev) { 716 if (bsscfgidx == 0) { 717 if (ifp->ndev->netdev_ops == &brcmf_netdev_ops_pri) { 718 rtnl_lock(); 719 brcmf_netdev_stop(ifp->ndev); 720 rtnl_unlock(); 721 } 722 } else { 723 netif_stop_queue(ifp->ndev); 724 } 725 726 if (ifp->ndev->netdev_ops == &brcmf_netdev_ops_pri) { 727 cancel_work_sync(&ifp->multicast_work); 728 cancel_work_sync(&ifp->ndoffload_work); 729 } 730 brcmf_net_detach(ifp->ndev, rtnl_locked); 731 } else { 732 /* Only p2p device interfaces which get dynamically created 733 * end up here. In this case the p2p module should be informed 734 * about the removal of the interface within the firmware. If 735 * not then p2p commands towards the firmware will cause some 736 * serious troublesome side effects. The p2p module will clean 737 * up the ifp if needed. 738 */ 739 brcmf_p2p_ifp_removed(ifp, rtnl_locked); 740 kfree(ifp); 741 } 742 } 743 744 void brcmf_remove_interface(struct brcmf_if *ifp, bool rtnl_locked) 745 { 746 if (!ifp || WARN_ON(ifp->drvr->iflist[ifp->bsscfgidx] != ifp)) 747 return; 748 brcmf_dbg(TRACE, "Enter, bsscfgidx=%d, ifidx=%d\n", ifp->bsscfgidx, 749 ifp->ifidx); 750 brcmf_proto_del_if(ifp->drvr, ifp); 751 brcmf_del_if(ifp->drvr, ifp->bsscfgidx, rtnl_locked); 752 } 753 754 static int brcmf_psm_watchdog_notify(struct brcmf_if *ifp, 755 const struct brcmf_event_msg *evtmsg, 756 void *data) 757 { 758 int err; 759 760 brcmf_dbg(TRACE, "enter: bsscfgidx=%d\n", ifp->bsscfgidx); 761 762 brcmf_err("PSM's watchdog has fired!\n"); 763 764 err = brcmf_debug_create_memdump(ifp->drvr->bus_if, data, 765 evtmsg->datalen); 766 if (err) 767 brcmf_err("Failed to get memory dump, %d\n", err); 768 769 return err; 770 } 771 772 #ifdef CONFIG_INET 773 #define ARPOL_MAX_ENTRIES 8 774 static int brcmf_inetaddr_changed(struct notifier_block *nb, 775 unsigned long action, void *data) 776 { 777 struct brcmf_pub *drvr = container_of(nb, struct brcmf_pub, 778 inetaddr_notifier); 779 struct in_ifaddr *ifa = data; 780 struct net_device *ndev = ifa->ifa_dev->dev; 781 struct brcmf_if *ifp; 782 int idx, i, ret; 783 u32 val; 784 __be32 addr_table[ARPOL_MAX_ENTRIES] = {0}; 785 786 /* Find out if the notification is meant for us */ 787 for (idx = 0; idx < BRCMF_MAX_IFS; idx++) { 788 ifp = drvr->iflist[idx]; 789 if (ifp && ifp->ndev == ndev) 790 break; 791 if (idx == BRCMF_MAX_IFS - 1) 792 return NOTIFY_DONE; 793 } 794 795 /* check if arp offload is supported */ 796 ret = brcmf_fil_iovar_int_get(ifp, "arpoe", &val); 797 if (ret) 798 return NOTIFY_OK; 799 800 /* old version only support primary index */ 801 ret = brcmf_fil_iovar_int_get(ifp, "arp_version", &val); 802 if (ret) 803 val = 1; 804 if (val == 1) 805 ifp = drvr->iflist[0]; 806 807 /* retrieve the table from firmware */ 808 ret = brcmf_fil_iovar_data_get(ifp, "arp_hostip", addr_table, 809 sizeof(addr_table)); 810 if (ret) { 811 brcmf_err("fail to get arp ip table err:%d\n", ret); 812 return NOTIFY_OK; 813 } 814 815 for (i = 0; i < ARPOL_MAX_ENTRIES; i++) 816 if (ifa->ifa_address == addr_table[i]) 817 break; 818 819 switch (action) { 820 case NETDEV_UP: 821 if (i == ARPOL_MAX_ENTRIES) { 822 brcmf_dbg(TRACE, "add %pI4 to arp table\n", 823 &ifa->ifa_address); 824 /* set it directly */ 825 ret = brcmf_fil_iovar_data_set(ifp, "arp_hostip", 826 &ifa->ifa_address, sizeof(ifa->ifa_address)); 827 if (ret) 828 brcmf_err("add arp ip err %d\n", ret); 829 } 830 break; 831 case NETDEV_DOWN: 832 if (i < ARPOL_MAX_ENTRIES) { 833 addr_table[i] = 0; 834 brcmf_dbg(TRACE, "remove %pI4 from arp table\n", 835 &ifa->ifa_address); 836 /* clear the table in firmware */ 837 ret = brcmf_fil_iovar_data_set(ifp, "arp_hostip_clear", 838 NULL, 0); 839 if (ret) { 840 brcmf_err("fail to clear arp ip table err:%d\n", 841 ret); 842 return NOTIFY_OK; 843 } 844 for (i = 0; i < ARPOL_MAX_ENTRIES; i++) { 845 if (addr_table[i] == 0) 846 continue; 847 ret = brcmf_fil_iovar_data_set(ifp, "arp_hostip", 848 &addr_table[i], 849 sizeof(addr_table[i])); 850 if (ret) 851 brcmf_err("add arp ip err %d\n", 852 ret); 853 } 854 } 855 break; 856 default: 857 break; 858 } 859 860 return NOTIFY_OK; 861 } 862 #endif 863 864 #if IS_ENABLED(CONFIG_IPV6) 865 static int brcmf_inet6addr_changed(struct notifier_block *nb, 866 unsigned long action, void *data) 867 { 868 struct brcmf_pub *drvr = container_of(nb, struct brcmf_pub, 869 inet6addr_notifier); 870 struct inet6_ifaddr *ifa = data; 871 struct brcmf_if *ifp; 872 int i; 873 struct in6_addr *table; 874 875 /* Only handle primary interface */ 876 ifp = drvr->iflist[0]; 877 if (!ifp) 878 return NOTIFY_DONE; 879 if (ifp->ndev != ifa->idev->dev) 880 return NOTIFY_DONE; 881 882 table = ifp->ipv6_addr_tbl; 883 for (i = 0; i < NDOL_MAX_ENTRIES; i++) 884 if (ipv6_addr_equal(&ifa->addr, &table[i])) 885 break; 886 887 switch (action) { 888 case NETDEV_UP: 889 if (i == NDOL_MAX_ENTRIES) { 890 if (ifp->ipv6addr_idx < NDOL_MAX_ENTRIES) { 891 table[ifp->ipv6addr_idx++] = ifa->addr; 892 } else { 893 for (i = 0; i < NDOL_MAX_ENTRIES - 1; i++) 894 table[i] = table[i + 1]; 895 table[NDOL_MAX_ENTRIES - 1] = ifa->addr; 896 } 897 } 898 break; 899 case NETDEV_DOWN: 900 if (i < NDOL_MAX_ENTRIES) { 901 for (; i < ifp->ipv6addr_idx - 1; i++) 902 table[i] = table[i + 1]; 903 memset(&table[i], 0, sizeof(table[i])); 904 ifp->ipv6addr_idx--; 905 } 906 break; 907 default: 908 break; 909 } 910 911 schedule_work(&ifp->ndoffload_work); 912 913 return NOTIFY_OK; 914 } 915 #endif 916 917 int brcmf_attach(struct device *dev, struct brcmf_mp_device *settings) 918 { 919 struct brcmf_pub *drvr = NULL; 920 int ret = 0; 921 int i; 922 923 brcmf_dbg(TRACE, "Enter\n"); 924 925 /* Allocate primary brcmf_info */ 926 drvr = kzalloc(sizeof(struct brcmf_pub), GFP_ATOMIC); 927 if (!drvr) 928 return -ENOMEM; 929 930 for (i = 0; i < ARRAY_SIZE(drvr->if2bss); i++) 931 drvr->if2bss[i] = BRCMF_BSSIDX_INVALID; 932 933 mutex_init(&drvr->proto_block); 934 935 /* Link to bus module */ 936 drvr->hdrlen = 0; 937 drvr->bus_if = dev_get_drvdata(dev); 938 drvr->bus_if->drvr = drvr; 939 drvr->settings = settings; 940 941 /* attach debug facilities */ 942 brcmf_debug_attach(drvr); 943 944 /* Attach and link in the protocol */ 945 ret = brcmf_proto_attach(drvr); 946 if (ret != 0) { 947 brcmf_err("brcmf_prot_attach failed\n"); 948 goto fail; 949 } 950 951 /* Attach to events important for core code */ 952 brcmf_fweh_register(drvr, BRCMF_E_PSM_WATCHDOG, 953 brcmf_psm_watchdog_notify); 954 955 /* attach firmware event handler */ 956 brcmf_fweh_attach(drvr); 957 958 return ret; 959 960 fail: 961 brcmf_detach(dev); 962 963 return ret; 964 } 965 966 static int brcmf_revinfo_read(struct seq_file *s, void *data) 967 { 968 struct brcmf_bus *bus_if = dev_get_drvdata(s->private); 969 struct brcmf_rev_info *ri = &bus_if->drvr->revinfo; 970 char drev[BRCMU_DOTREV_LEN]; 971 char brev[BRCMU_BOARDREV_LEN]; 972 973 seq_printf(s, "vendorid: 0x%04x\n", ri->vendorid); 974 seq_printf(s, "deviceid: 0x%04x\n", ri->deviceid); 975 seq_printf(s, "radiorev: %s\n", brcmu_dotrev_str(ri->radiorev, drev)); 976 seq_printf(s, "chipnum: %u (%x)\n", ri->chipnum, ri->chipnum); 977 seq_printf(s, "chiprev: %u\n", ri->chiprev); 978 seq_printf(s, "chippkg: %u\n", ri->chippkg); 979 seq_printf(s, "corerev: %u\n", ri->corerev); 980 seq_printf(s, "boardid: 0x%04x\n", ri->boardid); 981 seq_printf(s, "boardvendor: 0x%04x\n", ri->boardvendor); 982 seq_printf(s, "boardrev: %s\n", brcmu_boardrev_str(ri->boardrev, brev)); 983 seq_printf(s, "driverrev: %s\n", brcmu_dotrev_str(ri->driverrev, drev)); 984 seq_printf(s, "ucoderev: %u\n", ri->ucoderev); 985 seq_printf(s, "bus: %u\n", ri->bus); 986 seq_printf(s, "phytype: %u\n", ri->phytype); 987 seq_printf(s, "phyrev: %u\n", ri->phyrev); 988 seq_printf(s, "anarev: %u\n", ri->anarev); 989 seq_printf(s, "nvramrev: %08x\n", ri->nvramrev); 990 991 seq_printf(s, "clmver: %s\n", bus_if->drvr->clmver); 992 993 return 0; 994 } 995 996 int brcmf_bus_started(struct device *dev) 997 { 998 int ret = -1; 999 struct brcmf_bus *bus_if = dev_get_drvdata(dev); 1000 struct brcmf_pub *drvr = bus_if->drvr; 1001 struct brcmf_if *ifp; 1002 struct brcmf_if *p2p_ifp; 1003 1004 brcmf_dbg(TRACE, "\n"); 1005 1006 /* add primary networking interface */ 1007 ifp = brcmf_add_if(drvr, 0, 0, false, "wlan%d", NULL); 1008 if (IS_ERR(ifp)) 1009 return PTR_ERR(ifp); 1010 1011 p2p_ifp = NULL; 1012 1013 /* signal bus ready */ 1014 brcmf_bus_change_state(bus_if, BRCMF_BUS_UP); 1015 1016 /* Bus is ready, do any initialization */ 1017 ret = brcmf_c_preinit_dcmds(ifp); 1018 if (ret < 0) 1019 goto fail; 1020 1021 brcmf_debugfs_add_entry(drvr, "revinfo", brcmf_revinfo_read); 1022 1023 /* assure we have chipid before feature attach */ 1024 if (!bus_if->chip) { 1025 bus_if->chip = drvr->revinfo.chipnum; 1026 bus_if->chiprev = drvr->revinfo.chiprev; 1027 brcmf_dbg(INFO, "firmware revinfo: chip %x (%d) rev %d\n", 1028 bus_if->chip, bus_if->chip, bus_if->chiprev); 1029 } 1030 brcmf_feat_attach(drvr); 1031 1032 ret = brcmf_proto_init_done(drvr); 1033 if (ret < 0) 1034 goto fail; 1035 1036 brcmf_proto_add_if(drvr, ifp); 1037 1038 drvr->config = brcmf_cfg80211_attach(drvr, bus_if->dev, 1039 drvr->settings->p2p_enable); 1040 if (drvr->config == NULL) { 1041 ret = -ENOMEM; 1042 goto fail; 1043 } 1044 1045 ret = brcmf_net_attach(ifp, false); 1046 1047 if ((!ret) && (drvr->settings->p2p_enable)) { 1048 p2p_ifp = drvr->iflist[1]; 1049 if (p2p_ifp) 1050 ret = brcmf_net_p2p_attach(p2p_ifp); 1051 } 1052 1053 if (ret) 1054 goto fail; 1055 1056 #ifdef CONFIG_INET 1057 drvr->inetaddr_notifier.notifier_call = brcmf_inetaddr_changed; 1058 ret = register_inetaddr_notifier(&drvr->inetaddr_notifier); 1059 if (ret) 1060 goto fail; 1061 1062 #if IS_ENABLED(CONFIG_IPV6) 1063 drvr->inet6addr_notifier.notifier_call = brcmf_inet6addr_changed; 1064 ret = register_inet6addr_notifier(&drvr->inet6addr_notifier); 1065 if (ret) { 1066 unregister_inetaddr_notifier(&drvr->inetaddr_notifier); 1067 goto fail; 1068 } 1069 #endif 1070 #endif /* CONFIG_INET */ 1071 1072 return 0; 1073 1074 fail: 1075 brcmf_err("failed: %d\n", ret); 1076 if (drvr->config) { 1077 brcmf_cfg80211_detach(drvr->config); 1078 drvr->config = NULL; 1079 } 1080 brcmf_net_detach(ifp->ndev, false); 1081 if (p2p_ifp) 1082 brcmf_net_detach(p2p_ifp->ndev, false); 1083 drvr->iflist[0] = NULL; 1084 drvr->iflist[1] = NULL; 1085 if (drvr->settings->ignore_probe_fail) 1086 ret = 0; 1087 1088 return ret; 1089 } 1090 1091 void brcmf_bus_add_txhdrlen(struct device *dev, uint len) 1092 { 1093 struct brcmf_bus *bus_if = dev_get_drvdata(dev); 1094 struct brcmf_pub *drvr = bus_if->drvr; 1095 1096 if (drvr) { 1097 drvr->hdrlen += len; 1098 } 1099 } 1100 1101 void brcmf_dev_reset(struct device *dev) 1102 { 1103 struct brcmf_bus *bus_if = dev_get_drvdata(dev); 1104 struct brcmf_pub *drvr = bus_if->drvr; 1105 1106 if (drvr == NULL) 1107 return; 1108 1109 if (drvr->iflist[0]) 1110 brcmf_fil_cmd_int_set(drvr->iflist[0], BRCMF_C_TERMINATED, 1); 1111 } 1112 1113 void brcmf_detach(struct device *dev) 1114 { 1115 s32 i; 1116 struct brcmf_bus *bus_if = dev_get_drvdata(dev); 1117 struct brcmf_pub *drvr = bus_if->drvr; 1118 1119 brcmf_dbg(TRACE, "Enter\n"); 1120 1121 if (drvr == NULL) 1122 return; 1123 1124 #ifdef CONFIG_INET 1125 unregister_inetaddr_notifier(&drvr->inetaddr_notifier); 1126 #endif 1127 1128 #if IS_ENABLED(CONFIG_IPV6) 1129 unregister_inet6addr_notifier(&drvr->inet6addr_notifier); 1130 #endif 1131 1132 /* stop firmware event handling */ 1133 brcmf_fweh_detach(drvr); 1134 if (drvr->config) 1135 brcmf_p2p_detach(&drvr->config->p2p); 1136 1137 brcmf_bus_change_state(bus_if, BRCMF_BUS_DOWN); 1138 1139 /* make sure primary interface removed last */ 1140 for (i = BRCMF_MAX_IFS-1; i > -1; i--) 1141 brcmf_remove_interface(drvr->iflist[i], false); 1142 1143 brcmf_cfg80211_detach(drvr->config); 1144 1145 brcmf_bus_stop(drvr->bus_if); 1146 1147 brcmf_proto_detach(drvr); 1148 1149 brcmf_debug_detach(drvr); 1150 bus_if->drvr = NULL; 1151 kfree(drvr); 1152 } 1153 1154 s32 brcmf_iovar_data_set(struct device *dev, char *name, void *data, u32 len) 1155 { 1156 struct brcmf_bus *bus_if = dev_get_drvdata(dev); 1157 struct brcmf_if *ifp = bus_if->drvr->iflist[0]; 1158 1159 return brcmf_fil_iovar_data_set(ifp, name, data, len); 1160 } 1161 1162 static int brcmf_get_pend_8021x_cnt(struct brcmf_if *ifp) 1163 { 1164 return atomic_read(&ifp->pend_8021x_cnt); 1165 } 1166 1167 int brcmf_netdev_wait_pend8021x(struct brcmf_if *ifp) 1168 { 1169 int err; 1170 1171 err = wait_event_timeout(ifp->pend_8021x_wait, 1172 !brcmf_get_pend_8021x_cnt(ifp), 1173 MAX_WAIT_FOR_8021X_TX); 1174 1175 if (!err) 1176 brcmf_err("Timed out waiting for no pending 802.1x packets\n"); 1177 1178 return !err; 1179 } 1180 1181 void brcmf_bus_change_state(struct brcmf_bus *bus, enum brcmf_bus_state state) 1182 { 1183 struct brcmf_pub *drvr = bus->drvr; 1184 struct net_device *ndev; 1185 int ifidx; 1186 1187 brcmf_dbg(TRACE, "%d -> %d\n", bus->state, state); 1188 bus->state = state; 1189 1190 if (state == BRCMF_BUS_UP) { 1191 for (ifidx = 0; ifidx < BRCMF_MAX_IFS; ifidx++) { 1192 if ((drvr->iflist[ifidx]) && 1193 (drvr->iflist[ifidx]->ndev)) { 1194 ndev = drvr->iflist[ifidx]->ndev; 1195 if (netif_queue_stopped(ndev)) 1196 netif_wake_queue(ndev); 1197 } 1198 } 1199 } 1200 } 1201 1202 static void brcmf_driver_register(struct work_struct *work) 1203 { 1204 #ifdef CONFIG_BRCMFMAC_SDIO 1205 brcmf_sdio_register(); 1206 #endif 1207 #ifdef CONFIG_BRCMFMAC_USB 1208 brcmf_usb_register(); 1209 #endif 1210 #ifdef CONFIG_BRCMFMAC_PCIE 1211 brcmf_pcie_register(); 1212 #endif 1213 } 1214 static DECLARE_WORK(brcmf_driver_work, brcmf_driver_register); 1215 1216 int __init brcmf_core_init(void) 1217 { 1218 if (!schedule_work(&brcmf_driver_work)) 1219 return -EBUSY; 1220 1221 return 0; 1222 } 1223 1224 void __exit brcmf_core_exit(void) 1225 { 1226 cancel_work_sync(&brcmf_driver_work); 1227 1228 #ifdef CONFIG_BRCMFMAC_SDIO 1229 brcmf_sdio_exit(); 1230 #endif 1231 #ifdef CONFIG_BRCMFMAC_USB 1232 brcmf_usb_exit(); 1233 #endif 1234 #ifdef CONFIG_BRCMFMAC_PCIE 1235 brcmf_pcie_exit(); 1236 #endif 1237 } 1238 1239