1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * net/dsa/slave.c - Slave device handling 4 * Copyright (c) 2008-2009 Marvell Semiconductor 5 */ 6 7 #include <linux/list.h> 8 #include <linux/etherdevice.h> 9 #include <linux/netdevice.h> 10 #include <linux/phy.h> 11 #include <linux/phy_fixed.h> 12 #include <linux/phylink.h> 13 #include <linux/of_net.h> 14 #include <linux/of_mdio.h> 15 #include <linux/mdio.h> 16 #include <net/rtnetlink.h> 17 #include <net/pkt_cls.h> 18 #include <net/selftests.h> 19 #include <net/tc_act/tc_mirred.h> 20 #include <linux/if_bridge.h> 21 #include <linux/if_hsr.h> 22 #include <linux/netpoll.h> 23 24 #include "dsa_priv.h" 25 26 /* slave mii_bus handling ***************************************************/ 27 static int dsa_slave_phy_read(struct mii_bus *bus, int addr, int reg) 28 { 29 struct dsa_switch *ds = bus->priv; 30 31 if (ds->phys_mii_mask & (1 << addr)) 32 return ds->ops->phy_read(ds, addr, reg); 33 34 return 0xffff; 35 } 36 37 static int dsa_slave_phy_write(struct mii_bus *bus, int addr, int reg, u16 val) 38 { 39 struct dsa_switch *ds = bus->priv; 40 41 if (ds->phys_mii_mask & (1 << addr)) 42 return ds->ops->phy_write(ds, addr, reg, val); 43 44 return 0; 45 } 46 47 void dsa_slave_mii_bus_init(struct dsa_switch *ds) 48 { 49 ds->slave_mii_bus->priv = (void *)ds; 50 ds->slave_mii_bus->name = "dsa slave smi"; 51 ds->slave_mii_bus->read = dsa_slave_phy_read; 52 ds->slave_mii_bus->write = dsa_slave_phy_write; 53 snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d.%d", 54 ds->dst->index, ds->index); 55 ds->slave_mii_bus->parent = ds->dev; 56 ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask; 57 } 58 59 60 /* slave device handling ****************************************************/ 61 static int dsa_slave_get_iflink(const struct net_device *dev) 62 { 63 return dsa_slave_to_master(dev)->ifindex; 64 } 65 66 static int dsa_slave_open(struct net_device *dev) 67 { 68 struct net_device *master = dsa_slave_to_master(dev); 69 struct dsa_port *dp = dsa_slave_to_port(dev); 70 int err; 71 72 err = dev_open(master, NULL); 73 if (err < 0) { 74 netdev_err(dev, "failed to open master %s\n", master->name); 75 goto out; 76 } 77 78 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) { 79 err = dev_uc_add(master, dev->dev_addr); 80 if (err < 0) 81 goto out; 82 } 83 84 if (dev->flags & IFF_ALLMULTI) { 85 err = dev_set_allmulti(master, 1); 86 if (err < 0) 87 goto del_unicast; 88 } 89 if (dev->flags & IFF_PROMISC) { 90 err = dev_set_promiscuity(master, 1); 91 if (err < 0) 92 goto clear_allmulti; 93 } 94 95 err = dsa_port_enable_rt(dp, dev->phydev); 96 if (err) 97 goto clear_promisc; 98 99 return 0; 100 101 clear_promisc: 102 if (dev->flags & IFF_PROMISC) 103 dev_set_promiscuity(master, -1); 104 clear_allmulti: 105 if (dev->flags & IFF_ALLMULTI) 106 dev_set_allmulti(master, -1); 107 del_unicast: 108 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) 109 dev_uc_del(master, dev->dev_addr); 110 out: 111 return err; 112 } 113 114 static int dsa_slave_close(struct net_device *dev) 115 { 116 struct net_device *master = dsa_slave_to_master(dev); 117 struct dsa_port *dp = dsa_slave_to_port(dev); 118 119 dsa_port_disable_rt(dp); 120 121 dev_mc_unsync(master, dev); 122 dev_uc_unsync(master, dev); 123 if (dev->flags & IFF_ALLMULTI) 124 dev_set_allmulti(master, -1); 125 if (dev->flags & IFF_PROMISC) 126 dev_set_promiscuity(master, -1); 127 128 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) 129 dev_uc_del(master, dev->dev_addr); 130 131 return 0; 132 } 133 134 static void dsa_slave_change_rx_flags(struct net_device *dev, int change) 135 { 136 struct net_device *master = dsa_slave_to_master(dev); 137 if (dev->flags & IFF_UP) { 138 if (change & IFF_ALLMULTI) 139 dev_set_allmulti(master, 140 dev->flags & IFF_ALLMULTI ? 1 : -1); 141 if (change & IFF_PROMISC) 142 dev_set_promiscuity(master, 143 dev->flags & IFF_PROMISC ? 1 : -1); 144 } 145 } 146 147 static void dsa_slave_set_rx_mode(struct net_device *dev) 148 { 149 struct net_device *master = dsa_slave_to_master(dev); 150 151 dev_mc_sync(master, dev); 152 dev_uc_sync(master, dev); 153 } 154 155 static int dsa_slave_set_mac_address(struct net_device *dev, void *a) 156 { 157 struct net_device *master = dsa_slave_to_master(dev); 158 struct sockaddr *addr = a; 159 int err; 160 161 if (!is_valid_ether_addr(addr->sa_data)) 162 return -EADDRNOTAVAIL; 163 164 if (!(dev->flags & IFF_UP)) 165 goto out; 166 167 if (!ether_addr_equal(addr->sa_data, master->dev_addr)) { 168 err = dev_uc_add(master, addr->sa_data); 169 if (err < 0) 170 return err; 171 } 172 173 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) 174 dev_uc_del(master, dev->dev_addr); 175 176 out: 177 ether_addr_copy(dev->dev_addr, addr->sa_data); 178 179 return 0; 180 } 181 182 struct dsa_slave_dump_ctx { 183 struct net_device *dev; 184 struct sk_buff *skb; 185 struct netlink_callback *cb; 186 int idx; 187 }; 188 189 static int 190 dsa_slave_port_fdb_do_dump(const unsigned char *addr, u16 vid, 191 bool is_static, void *data) 192 { 193 struct dsa_slave_dump_ctx *dump = data; 194 u32 portid = NETLINK_CB(dump->cb->skb).portid; 195 u32 seq = dump->cb->nlh->nlmsg_seq; 196 struct nlmsghdr *nlh; 197 struct ndmsg *ndm; 198 199 if (dump->idx < dump->cb->args[2]) 200 goto skip; 201 202 nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH, 203 sizeof(*ndm), NLM_F_MULTI); 204 if (!nlh) 205 return -EMSGSIZE; 206 207 ndm = nlmsg_data(nlh); 208 ndm->ndm_family = AF_BRIDGE; 209 ndm->ndm_pad1 = 0; 210 ndm->ndm_pad2 = 0; 211 ndm->ndm_flags = NTF_SELF; 212 ndm->ndm_type = 0; 213 ndm->ndm_ifindex = dump->dev->ifindex; 214 ndm->ndm_state = is_static ? NUD_NOARP : NUD_REACHABLE; 215 216 if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, addr)) 217 goto nla_put_failure; 218 219 if (vid && nla_put_u16(dump->skb, NDA_VLAN, vid)) 220 goto nla_put_failure; 221 222 nlmsg_end(dump->skb, nlh); 223 224 skip: 225 dump->idx++; 226 return 0; 227 228 nla_put_failure: 229 nlmsg_cancel(dump->skb, nlh); 230 return -EMSGSIZE; 231 } 232 233 static int 234 dsa_slave_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb, 235 struct net_device *dev, struct net_device *filter_dev, 236 int *idx) 237 { 238 struct dsa_port *dp = dsa_slave_to_port(dev); 239 struct dsa_slave_dump_ctx dump = { 240 .dev = dev, 241 .skb = skb, 242 .cb = cb, 243 .idx = *idx, 244 }; 245 int err; 246 247 err = dsa_port_fdb_dump(dp, dsa_slave_port_fdb_do_dump, &dump); 248 *idx = dump.idx; 249 250 return err; 251 } 252 253 static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 254 { 255 struct dsa_slave_priv *p = netdev_priv(dev); 256 struct dsa_switch *ds = p->dp->ds; 257 int port = p->dp->index; 258 259 /* Pass through to switch driver if it supports timestamping */ 260 switch (cmd) { 261 case SIOCGHWTSTAMP: 262 if (ds->ops->port_hwtstamp_get) 263 return ds->ops->port_hwtstamp_get(ds, port, ifr); 264 break; 265 case SIOCSHWTSTAMP: 266 if (ds->ops->port_hwtstamp_set) 267 return ds->ops->port_hwtstamp_set(ds, port, ifr); 268 break; 269 } 270 271 return phylink_mii_ioctl(p->dp->pl, ifr, cmd); 272 } 273 274 static int dsa_slave_port_attr_set(struct net_device *dev, const void *ctx, 275 const struct switchdev_attr *attr, 276 struct netlink_ext_ack *extack) 277 { 278 struct dsa_port *dp = dsa_slave_to_port(dev); 279 int ret; 280 281 if (ctx && ctx != dp) 282 return 0; 283 284 switch (attr->id) { 285 case SWITCHDEV_ATTR_ID_PORT_STP_STATE: 286 if (!dsa_port_offloads_bridge_port(dp, attr->orig_dev)) 287 return -EOPNOTSUPP; 288 289 ret = dsa_port_set_state(dp, attr->u.stp_state, true); 290 break; 291 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING: 292 if (!dsa_port_offloads_bridge(dp, attr->orig_dev)) 293 return -EOPNOTSUPP; 294 295 ret = dsa_port_vlan_filtering(dp, attr->u.vlan_filtering, 296 extack); 297 break; 298 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME: 299 if (!dsa_port_offloads_bridge(dp, attr->orig_dev)) 300 return -EOPNOTSUPP; 301 302 ret = dsa_port_ageing_time(dp, attr->u.ageing_time); 303 break; 304 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS: 305 if (!dsa_port_offloads_bridge_port(dp, attr->orig_dev)) 306 return -EOPNOTSUPP; 307 308 ret = dsa_port_pre_bridge_flags(dp, attr->u.brport_flags, 309 extack); 310 break; 311 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS: 312 if (!dsa_port_offloads_bridge_port(dp, attr->orig_dev)) 313 return -EOPNOTSUPP; 314 315 ret = dsa_port_bridge_flags(dp, attr->u.brport_flags, extack); 316 break; 317 default: 318 ret = -EOPNOTSUPP; 319 break; 320 } 321 322 return ret; 323 } 324 325 /* Must be called under rcu_read_lock() */ 326 static int 327 dsa_slave_vlan_check_for_8021q_uppers(struct net_device *slave, 328 const struct switchdev_obj_port_vlan *vlan) 329 { 330 struct net_device *upper_dev; 331 struct list_head *iter; 332 333 netdev_for_each_upper_dev_rcu(slave, upper_dev, iter) { 334 u16 vid; 335 336 if (!is_vlan_dev(upper_dev)) 337 continue; 338 339 vid = vlan_dev_vlan_id(upper_dev); 340 if (vid == vlan->vid) 341 return -EBUSY; 342 } 343 344 return 0; 345 } 346 347 static int dsa_slave_vlan_add(struct net_device *dev, 348 const struct switchdev_obj *obj, 349 struct netlink_ext_ack *extack) 350 { 351 struct net_device *master = dsa_slave_to_master(dev); 352 struct dsa_port *dp = dsa_slave_to_port(dev); 353 struct switchdev_obj_port_vlan vlan; 354 int err; 355 356 if (dsa_port_skip_vlan_configuration(dp)) { 357 NL_SET_ERR_MSG_MOD(extack, "skipping configuration of VLAN"); 358 return 0; 359 } 360 361 vlan = *SWITCHDEV_OBJ_PORT_VLAN(obj); 362 363 /* Deny adding a bridge VLAN when there is already an 802.1Q upper with 364 * the same VID. 365 */ 366 if (br_vlan_enabled(dp->bridge_dev)) { 367 rcu_read_lock(); 368 err = dsa_slave_vlan_check_for_8021q_uppers(dev, &vlan); 369 rcu_read_unlock(); 370 if (err) { 371 NL_SET_ERR_MSG_MOD(extack, 372 "Port already has a VLAN upper with this VID"); 373 return err; 374 } 375 } 376 377 err = dsa_port_vlan_add(dp, &vlan, extack); 378 if (err) 379 return err; 380 381 /* We need the dedicated CPU port to be a member of the VLAN as well. 382 * Even though drivers often handle CPU membership in special ways, 383 * it doesn't make sense to program a PVID, so clear this flag. 384 */ 385 vlan.flags &= ~BRIDGE_VLAN_INFO_PVID; 386 387 err = dsa_port_vlan_add(dp->cpu_dp, &vlan, extack); 388 if (err) 389 return err; 390 391 return vlan_vid_add(master, htons(ETH_P_8021Q), vlan.vid); 392 } 393 394 static int dsa_slave_port_obj_add(struct net_device *dev, const void *ctx, 395 const struct switchdev_obj *obj, 396 struct netlink_ext_ack *extack) 397 { 398 struct dsa_port *dp = dsa_slave_to_port(dev); 399 int err; 400 401 if (ctx && ctx != dp) 402 return 0; 403 404 switch (obj->id) { 405 case SWITCHDEV_OBJ_ID_PORT_MDB: 406 if (!dsa_port_offloads_bridge_port(dp, obj->orig_dev)) 407 return -EOPNOTSUPP; 408 409 err = dsa_port_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj)); 410 break; 411 case SWITCHDEV_OBJ_ID_HOST_MDB: 412 if (!dsa_port_offloads_bridge(dp, obj->orig_dev)) 413 return -EOPNOTSUPP; 414 415 err = dsa_port_host_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj)); 416 break; 417 case SWITCHDEV_OBJ_ID_PORT_VLAN: 418 if (!dsa_port_offloads_bridge_port(dp, obj->orig_dev)) 419 return -EOPNOTSUPP; 420 421 err = dsa_slave_vlan_add(dev, obj, extack); 422 break; 423 case SWITCHDEV_OBJ_ID_MRP: 424 if (!dsa_port_offloads_bridge(dp, obj->orig_dev)) 425 return -EOPNOTSUPP; 426 427 err = dsa_port_mrp_add(dp, SWITCHDEV_OBJ_MRP(obj)); 428 break; 429 case SWITCHDEV_OBJ_ID_RING_ROLE_MRP: 430 if (!dsa_port_offloads_bridge(dp, obj->orig_dev)) 431 return -EOPNOTSUPP; 432 433 err = dsa_port_mrp_add_ring_role(dp, 434 SWITCHDEV_OBJ_RING_ROLE_MRP(obj)); 435 break; 436 default: 437 err = -EOPNOTSUPP; 438 break; 439 } 440 441 return err; 442 } 443 444 static int dsa_slave_vlan_del(struct net_device *dev, 445 const struct switchdev_obj *obj) 446 { 447 struct net_device *master = dsa_slave_to_master(dev); 448 struct dsa_port *dp = dsa_slave_to_port(dev); 449 struct switchdev_obj_port_vlan *vlan; 450 int err; 451 452 if (dsa_port_skip_vlan_configuration(dp)) 453 return 0; 454 455 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj); 456 457 /* Do not deprogram the CPU port as it may be shared with other user 458 * ports which can be members of this VLAN as well. 459 */ 460 err = dsa_port_vlan_del(dp, vlan); 461 if (err) 462 return err; 463 464 vlan_vid_del(master, htons(ETH_P_8021Q), vlan->vid); 465 466 return 0; 467 } 468 469 static int dsa_slave_port_obj_del(struct net_device *dev, const void *ctx, 470 const struct switchdev_obj *obj) 471 { 472 struct dsa_port *dp = dsa_slave_to_port(dev); 473 int err; 474 475 if (ctx && ctx != dp) 476 return 0; 477 478 switch (obj->id) { 479 case SWITCHDEV_OBJ_ID_PORT_MDB: 480 if (!dsa_port_offloads_bridge_port(dp, obj->orig_dev)) 481 return -EOPNOTSUPP; 482 483 err = dsa_port_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj)); 484 break; 485 case SWITCHDEV_OBJ_ID_HOST_MDB: 486 if (!dsa_port_offloads_bridge(dp, obj->orig_dev)) 487 return -EOPNOTSUPP; 488 489 err = dsa_port_host_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj)); 490 break; 491 case SWITCHDEV_OBJ_ID_PORT_VLAN: 492 if (!dsa_port_offloads_bridge_port(dp, obj->orig_dev)) 493 return -EOPNOTSUPP; 494 495 err = dsa_slave_vlan_del(dev, obj); 496 break; 497 case SWITCHDEV_OBJ_ID_MRP: 498 if (!dsa_port_offloads_bridge(dp, obj->orig_dev)) 499 return -EOPNOTSUPP; 500 501 err = dsa_port_mrp_del(dp, SWITCHDEV_OBJ_MRP(obj)); 502 break; 503 case SWITCHDEV_OBJ_ID_RING_ROLE_MRP: 504 if (!dsa_port_offloads_bridge(dp, obj->orig_dev)) 505 return -EOPNOTSUPP; 506 507 err = dsa_port_mrp_del_ring_role(dp, 508 SWITCHDEV_OBJ_RING_ROLE_MRP(obj)); 509 break; 510 default: 511 err = -EOPNOTSUPP; 512 break; 513 } 514 515 return err; 516 } 517 518 static int dsa_slave_get_port_parent_id(struct net_device *dev, 519 struct netdev_phys_item_id *ppid) 520 { 521 struct dsa_port *dp = dsa_slave_to_port(dev); 522 struct dsa_switch *ds = dp->ds; 523 struct dsa_switch_tree *dst = ds->dst; 524 525 /* For non-legacy ports, devlink is used and it takes 526 * care of the name generation. This ndo implementation 527 * should be removed with legacy support. 528 */ 529 if (dp->ds->devlink) 530 return -EOPNOTSUPP; 531 532 ppid->id_len = sizeof(dst->index); 533 memcpy(&ppid->id, &dst->index, ppid->id_len); 534 535 return 0; 536 } 537 538 static inline netdev_tx_t dsa_slave_netpoll_send_skb(struct net_device *dev, 539 struct sk_buff *skb) 540 { 541 #ifdef CONFIG_NET_POLL_CONTROLLER 542 struct dsa_slave_priv *p = netdev_priv(dev); 543 544 return netpoll_send_skb(p->netpoll, skb); 545 #else 546 BUG(); 547 return NETDEV_TX_OK; 548 #endif 549 } 550 551 static void dsa_skb_tx_timestamp(struct dsa_slave_priv *p, 552 struct sk_buff *skb) 553 { 554 struct dsa_switch *ds = p->dp->ds; 555 556 if (!(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)) 557 return; 558 559 if (!ds->ops->port_txtstamp) 560 return; 561 562 ds->ops->port_txtstamp(ds, p->dp->index, skb); 563 } 564 565 netdev_tx_t dsa_enqueue_skb(struct sk_buff *skb, struct net_device *dev) 566 { 567 /* SKB for netpoll still need to be mangled with the protocol-specific 568 * tag to be successfully transmitted 569 */ 570 if (unlikely(netpoll_tx_running(dev))) 571 return dsa_slave_netpoll_send_skb(dev, skb); 572 573 /* Queue the SKB for transmission on the parent interface, but 574 * do not modify its EtherType 575 */ 576 skb->dev = dsa_slave_to_master(dev); 577 dev_queue_xmit(skb); 578 579 return NETDEV_TX_OK; 580 } 581 EXPORT_SYMBOL_GPL(dsa_enqueue_skb); 582 583 static int dsa_realloc_skb(struct sk_buff *skb, struct net_device *dev) 584 { 585 int needed_headroom = dev->needed_headroom; 586 int needed_tailroom = dev->needed_tailroom; 587 588 /* For tail taggers, we need to pad short frames ourselves, to ensure 589 * that the tail tag does not fail at its role of being at the end of 590 * the packet, once the master interface pads the frame. Account for 591 * that pad length here, and pad later. 592 */ 593 if (unlikely(needed_tailroom && skb->len < ETH_ZLEN)) 594 needed_tailroom += ETH_ZLEN - skb->len; 595 /* skb_headroom() returns unsigned int... */ 596 needed_headroom = max_t(int, needed_headroom - skb_headroom(skb), 0); 597 needed_tailroom = max_t(int, needed_tailroom - skb_tailroom(skb), 0); 598 599 if (likely(!needed_headroom && !needed_tailroom && !skb_cloned(skb))) 600 /* No reallocation needed, yay! */ 601 return 0; 602 603 return pskb_expand_head(skb, needed_headroom, needed_tailroom, 604 GFP_ATOMIC); 605 } 606 607 static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev) 608 { 609 struct dsa_slave_priv *p = netdev_priv(dev); 610 struct sk_buff *nskb; 611 612 dev_sw_netstats_tx_add(dev, 1, skb->len); 613 614 memset(skb->cb, 0, sizeof(skb->cb)); 615 616 /* Handle tx timestamp if any */ 617 dsa_skb_tx_timestamp(p, skb); 618 619 if (dsa_realloc_skb(skb, dev)) { 620 dev_kfree_skb_any(skb); 621 return NETDEV_TX_OK; 622 } 623 624 /* needed_tailroom should still be 'warm' in the cache line from 625 * dsa_realloc_skb(), which has also ensured that padding is safe. 626 */ 627 if (dev->needed_tailroom) 628 eth_skb_pad(skb); 629 630 /* Transmit function may have to reallocate the original SKB, 631 * in which case it must have freed it. Only free it here on error. 632 */ 633 nskb = p->xmit(skb, dev); 634 if (!nskb) { 635 kfree_skb(skb); 636 return NETDEV_TX_OK; 637 } 638 639 return dsa_enqueue_skb(nskb, dev); 640 } 641 642 /* ethtool operations *******************************************************/ 643 644 static void dsa_slave_get_drvinfo(struct net_device *dev, 645 struct ethtool_drvinfo *drvinfo) 646 { 647 strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver)); 648 strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version)); 649 strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info)); 650 } 651 652 static int dsa_slave_get_regs_len(struct net_device *dev) 653 { 654 struct dsa_port *dp = dsa_slave_to_port(dev); 655 struct dsa_switch *ds = dp->ds; 656 657 if (ds->ops->get_regs_len) 658 return ds->ops->get_regs_len(ds, dp->index); 659 660 return -EOPNOTSUPP; 661 } 662 663 static void 664 dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p) 665 { 666 struct dsa_port *dp = dsa_slave_to_port(dev); 667 struct dsa_switch *ds = dp->ds; 668 669 if (ds->ops->get_regs) 670 ds->ops->get_regs(ds, dp->index, regs, _p); 671 } 672 673 static int dsa_slave_nway_reset(struct net_device *dev) 674 { 675 struct dsa_port *dp = dsa_slave_to_port(dev); 676 677 return phylink_ethtool_nway_reset(dp->pl); 678 } 679 680 static int dsa_slave_get_eeprom_len(struct net_device *dev) 681 { 682 struct dsa_port *dp = dsa_slave_to_port(dev); 683 struct dsa_switch *ds = dp->ds; 684 685 if (ds->cd && ds->cd->eeprom_len) 686 return ds->cd->eeprom_len; 687 688 if (ds->ops->get_eeprom_len) 689 return ds->ops->get_eeprom_len(ds); 690 691 return 0; 692 } 693 694 static int dsa_slave_get_eeprom(struct net_device *dev, 695 struct ethtool_eeprom *eeprom, u8 *data) 696 { 697 struct dsa_port *dp = dsa_slave_to_port(dev); 698 struct dsa_switch *ds = dp->ds; 699 700 if (ds->ops->get_eeprom) 701 return ds->ops->get_eeprom(ds, eeprom, data); 702 703 return -EOPNOTSUPP; 704 } 705 706 static int dsa_slave_set_eeprom(struct net_device *dev, 707 struct ethtool_eeprom *eeprom, u8 *data) 708 { 709 struct dsa_port *dp = dsa_slave_to_port(dev); 710 struct dsa_switch *ds = dp->ds; 711 712 if (ds->ops->set_eeprom) 713 return ds->ops->set_eeprom(ds, eeprom, data); 714 715 return -EOPNOTSUPP; 716 } 717 718 static void dsa_slave_get_strings(struct net_device *dev, 719 uint32_t stringset, uint8_t *data) 720 { 721 struct dsa_port *dp = dsa_slave_to_port(dev); 722 struct dsa_switch *ds = dp->ds; 723 724 if (stringset == ETH_SS_STATS) { 725 int len = ETH_GSTRING_LEN; 726 727 strncpy(data, "tx_packets", len); 728 strncpy(data + len, "tx_bytes", len); 729 strncpy(data + 2 * len, "rx_packets", len); 730 strncpy(data + 3 * len, "rx_bytes", len); 731 if (ds->ops->get_strings) 732 ds->ops->get_strings(ds, dp->index, stringset, 733 data + 4 * len); 734 } else if (stringset == ETH_SS_TEST) { 735 net_selftest_get_strings(data); 736 } 737 738 } 739 740 static void dsa_slave_get_ethtool_stats(struct net_device *dev, 741 struct ethtool_stats *stats, 742 uint64_t *data) 743 { 744 struct dsa_port *dp = dsa_slave_to_port(dev); 745 struct dsa_switch *ds = dp->ds; 746 struct pcpu_sw_netstats *s; 747 unsigned int start; 748 int i; 749 750 for_each_possible_cpu(i) { 751 u64 tx_packets, tx_bytes, rx_packets, rx_bytes; 752 753 s = per_cpu_ptr(dev->tstats, i); 754 do { 755 start = u64_stats_fetch_begin_irq(&s->syncp); 756 tx_packets = s->tx_packets; 757 tx_bytes = s->tx_bytes; 758 rx_packets = s->rx_packets; 759 rx_bytes = s->rx_bytes; 760 } while (u64_stats_fetch_retry_irq(&s->syncp, start)); 761 data[0] += tx_packets; 762 data[1] += tx_bytes; 763 data[2] += rx_packets; 764 data[3] += rx_bytes; 765 } 766 if (ds->ops->get_ethtool_stats) 767 ds->ops->get_ethtool_stats(ds, dp->index, data + 4); 768 } 769 770 static int dsa_slave_get_sset_count(struct net_device *dev, int sset) 771 { 772 struct dsa_port *dp = dsa_slave_to_port(dev); 773 struct dsa_switch *ds = dp->ds; 774 775 if (sset == ETH_SS_STATS) { 776 int count = 0; 777 778 if (ds->ops->get_sset_count) { 779 count = ds->ops->get_sset_count(ds, dp->index, sset); 780 if (count < 0) 781 return count; 782 } 783 784 return count + 4; 785 } else if (sset == ETH_SS_TEST) { 786 return net_selftest_get_count(); 787 } 788 789 return -EOPNOTSUPP; 790 } 791 792 static void dsa_slave_net_selftest(struct net_device *ndev, 793 struct ethtool_test *etest, u64 *buf) 794 { 795 struct dsa_port *dp = dsa_slave_to_port(ndev); 796 struct dsa_switch *ds = dp->ds; 797 798 if (ds->ops->self_test) { 799 ds->ops->self_test(ds, dp->index, etest, buf); 800 return; 801 } 802 803 net_selftest(ndev, etest, buf); 804 } 805 806 static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w) 807 { 808 struct dsa_port *dp = dsa_slave_to_port(dev); 809 struct dsa_switch *ds = dp->ds; 810 811 phylink_ethtool_get_wol(dp->pl, w); 812 813 if (ds->ops->get_wol) 814 ds->ops->get_wol(ds, dp->index, w); 815 } 816 817 static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w) 818 { 819 struct dsa_port *dp = dsa_slave_to_port(dev); 820 struct dsa_switch *ds = dp->ds; 821 int ret = -EOPNOTSUPP; 822 823 phylink_ethtool_set_wol(dp->pl, w); 824 825 if (ds->ops->set_wol) 826 ret = ds->ops->set_wol(ds, dp->index, w); 827 828 return ret; 829 } 830 831 static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e) 832 { 833 struct dsa_port *dp = dsa_slave_to_port(dev); 834 struct dsa_switch *ds = dp->ds; 835 int ret; 836 837 /* Port's PHY and MAC both need to be EEE capable */ 838 if (!dev->phydev || !dp->pl) 839 return -ENODEV; 840 841 if (!ds->ops->set_mac_eee) 842 return -EOPNOTSUPP; 843 844 ret = ds->ops->set_mac_eee(ds, dp->index, e); 845 if (ret) 846 return ret; 847 848 return phylink_ethtool_set_eee(dp->pl, e); 849 } 850 851 static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e) 852 { 853 struct dsa_port *dp = dsa_slave_to_port(dev); 854 struct dsa_switch *ds = dp->ds; 855 int ret; 856 857 /* Port's PHY and MAC both need to be EEE capable */ 858 if (!dev->phydev || !dp->pl) 859 return -ENODEV; 860 861 if (!ds->ops->get_mac_eee) 862 return -EOPNOTSUPP; 863 864 ret = ds->ops->get_mac_eee(ds, dp->index, e); 865 if (ret) 866 return ret; 867 868 return phylink_ethtool_get_eee(dp->pl, e); 869 } 870 871 static int dsa_slave_get_link_ksettings(struct net_device *dev, 872 struct ethtool_link_ksettings *cmd) 873 { 874 struct dsa_port *dp = dsa_slave_to_port(dev); 875 876 return phylink_ethtool_ksettings_get(dp->pl, cmd); 877 } 878 879 static int dsa_slave_set_link_ksettings(struct net_device *dev, 880 const struct ethtool_link_ksettings *cmd) 881 { 882 struct dsa_port *dp = dsa_slave_to_port(dev); 883 884 return phylink_ethtool_ksettings_set(dp->pl, cmd); 885 } 886 887 static void dsa_slave_get_pauseparam(struct net_device *dev, 888 struct ethtool_pauseparam *pause) 889 { 890 struct dsa_port *dp = dsa_slave_to_port(dev); 891 892 phylink_ethtool_get_pauseparam(dp->pl, pause); 893 } 894 895 static int dsa_slave_set_pauseparam(struct net_device *dev, 896 struct ethtool_pauseparam *pause) 897 { 898 struct dsa_port *dp = dsa_slave_to_port(dev); 899 900 return phylink_ethtool_set_pauseparam(dp->pl, pause); 901 } 902 903 #ifdef CONFIG_NET_POLL_CONTROLLER 904 static int dsa_slave_netpoll_setup(struct net_device *dev, 905 struct netpoll_info *ni) 906 { 907 struct net_device *master = dsa_slave_to_master(dev); 908 struct dsa_slave_priv *p = netdev_priv(dev); 909 struct netpoll *netpoll; 910 int err = 0; 911 912 netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL); 913 if (!netpoll) 914 return -ENOMEM; 915 916 err = __netpoll_setup(netpoll, master); 917 if (err) { 918 kfree(netpoll); 919 goto out; 920 } 921 922 p->netpoll = netpoll; 923 out: 924 return err; 925 } 926 927 static void dsa_slave_netpoll_cleanup(struct net_device *dev) 928 { 929 struct dsa_slave_priv *p = netdev_priv(dev); 930 struct netpoll *netpoll = p->netpoll; 931 932 if (!netpoll) 933 return; 934 935 p->netpoll = NULL; 936 937 __netpoll_free(netpoll); 938 } 939 940 static void dsa_slave_poll_controller(struct net_device *dev) 941 { 942 } 943 #endif 944 945 static int dsa_slave_get_phys_port_name(struct net_device *dev, 946 char *name, size_t len) 947 { 948 struct dsa_port *dp = dsa_slave_to_port(dev); 949 950 /* For non-legacy ports, devlink is used and it takes 951 * care of the name generation. This ndo implementation 952 * should be removed with legacy support. 953 */ 954 if (dp->ds->devlink) 955 return -EOPNOTSUPP; 956 957 if (snprintf(name, len, "p%d", dp->index) >= len) 958 return -EINVAL; 959 960 return 0; 961 } 962 963 static struct dsa_mall_tc_entry * 964 dsa_slave_mall_tc_entry_find(struct net_device *dev, unsigned long cookie) 965 { 966 struct dsa_slave_priv *p = netdev_priv(dev); 967 struct dsa_mall_tc_entry *mall_tc_entry; 968 969 list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list) 970 if (mall_tc_entry->cookie == cookie) 971 return mall_tc_entry; 972 973 return NULL; 974 } 975 976 static int 977 dsa_slave_add_cls_matchall_mirred(struct net_device *dev, 978 struct tc_cls_matchall_offload *cls, 979 bool ingress) 980 { 981 struct dsa_port *dp = dsa_slave_to_port(dev); 982 struct dsa_slave_priv *p = netdev_priv(dev); 983 struct dsa_mall_mirror_tc_entry *mirror; 984 struct dsa_mall_tc_entry *mall_tc_entry; 985 struct dsa_switch *ds = dp->ds; 986 struct flow_action_entry *act; 987 struct dsa_port *to_dp; 988 int err; 989 990 if (!ds->ops->port_mirror_add) 991 return -EOPNOTSUPP; 992 993 if (!flow_action_basic_hw_stats_check(&cls->rule->action, 994 cls->common.extack)) 995 return -EOPNOTSUPP; 996 997 act = &cls->rule->action.entries[0]; 998 999 if (!act->dev) 1000 return -EINVAL; 1001 1002 if (!dsa_slave_dev_check(act->dev)) 1003 return -EOPNOTSUPP; 1004 1005 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL); 1006 if (!mall_tc_entry) 1007 return -ENOMEM; 1008 1009 mall_tc_entry->cookie = cls->cookie; 1010 mall_tc_entry->type = DSA_PORT_MALL_MIRROR; 1011 mirror = &mall_tc_entry->mirror; 1012 1013 to_dp = dsa_slave_to_port(act->dev); 1014 1015 mirror->to_local_port = to_dp->index; 1016 mirror->ingress = ingress; 1017 1018 err = ds->ops->port_mirror_add(ds, dp->index, mirror, ingress); 1019 if (err) { 1020 kfree(mall_tc_entry); 1021 return err; 1022 } 1023 1024 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list); 1025 1026 return err; 1027 } 1028 1029 static int 1030 dsa_slave_add_cls_matchall_police(struct net_device *dev, 1031 struct tc_cls_matchall_offload *cls, 1032 bool ingress) 1033 { 1034 struct netlink_ext_ack *extack = cls->common.extack; 1035 struct dsa_port *dp = dsa_slave_to_port(dev); 1036 struct dsa_slave_priv *p = netdev_priv(dev); 1037 struct dsa_mall_policer_tc_entry *policer; 1038 struct dsa_mall_tc_entry *mall_tc_entry; 1039 struct dsa_switch *ds = dp->ds; 1040 struct flow_action_entry *act; 1041 int err; 1042 1043 if (!ds->ops->port_policer_add) { 1044 NL_SET_ERR_MSG_MOD(extack, 1045 "Policing offload not implemented"); 1046 return -EOPNOTSUPP; 1047 } 1048 1049 if (!ingress) { 1050 NL_SET_ERR_MSG_MOD(extack, 1051 "Only supported on ingress qdisc"); 1052 return -EOPNOTSUPP; 1053 } 1054 1055 if (!flow_action_basic_hw_stats_check(&cls->rule->action, 1056 cls->common.extack)) 1057 return -EOPNOTSUPP; 1058 1059 list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list) { 1060 if (mall_tc_entry->type == DSA_PORT_MALL_POLICER) { 1061 NL_SET_ERR_MSG_MOD(extack, 1062 "Only one port policer allowed"); 1063 return -EEXIST; 1064 } 1065 } 1066 1067 act = &cls->rule->action.entries[0]; 1068 1069 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL); 1070 if (!mall_tc_entry) 1071 return -ENOMEM; 1072 1073 mall_tc_entry->cookie = cls->cookie; 1074 mall_tc_entry->type = DSA_PORT_MALL_POLICER; 1075 policer = &mall_tc_entry->policer; 1076 policer->rate_bytes_per_sec = act->police.rate_bytes_ps; 1077 policer->burst = act->police.burst; 1078 1079 err = ds->ops->port_policer_add(ds, dp->index, policer); 1080 if (err) { 1081 kfree(mall_tc_entry); 1082 return err; 1083 } 1084 1085 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list); 1086 1087 return err; 1088 } 1089 1090 static int dsa_slave_add_cls_matchall(struct net_device *dev, 1091 struct tc_cls_matchall_offload *cls, 1092 bool ingress) 1093 { 1094 int err = -EOPNOTSUPP; 1095 1096 if (cls->common.protocol == htons(ETH_P_ALL) && 1097 flow_offload_has_one_action(&cls->rule->action) && 1098 cls->rule->action.entries[0].id == FLOW_ACTION_MIRRED) 1099 err = dsa_slave_add_cls_matchall_mirred(dev, cls, ingress); 1100 else if (flow_offload_has_one_action(&cls->rule->action) && 1101 cls->rule->action.entries[0].id == FLOW_ACTION_POLICE) 1102 err = dsa_slave_add_cls_matchall_police(dev, cls, ingress); 1103 1104 return err; 1105 } 1106 1107 static void dsa_slave_del_cls_matchall(struct net_device *dev, 1108 struct tc_cls_matchall_offload *cls) 1109 { 1110 struct dsa_port *dp = dsa_slave_to_port(dev); 1111 struct dsa_mall_tc_entry *mall_tc_entry; 1112 struct dsa_switch *ds = dp->ds; 1113 1114 mall_tc_entry = dsa_slave_mall_tc_entry_find(dev, cls->cookie); 1115 if (!mall_tc_entry) 1116 return; 1117 1118 list_del(&mall_tc_entry->list); 1119 1120 switch (mall_tc_entry->type) { 1121 case DSA_PORT_MALL_MIRROR: 1122 if (ds->ops->port_mirror_del) 1123 ds->ops->port_mirror_del(ds, dp->index, 1124 &mall_tc_entry->mirror); 1125 break; 1126 case DSA_PORT_MALL_POLICER: 1127 if (ds->ops->port_policer_del) 1128 ds->ops->port_policer_del(ds, dp->index); 1129 break; 1130 default: 1131 WARN_ON(1); 1132 } 1133 1134 kfree(mall_tc_entry); 1135 } 1136 1137 static int dsa_slave_setup_tc_cls_matchall(struct net_device *dev, 1138 struct tc_cls_matchall_offload *cls, 1139 bool ingress) 1140 { 1141 if (cls->common.chain_index) 1142 return -EOPNOTSUPP; 1143 1144 switch (cls->command) { 1145 case TC_CLSMATCHALL_REPLACE: 1146 return dsa_slave_add_cls_matchall(dev, cls, ingress); 1147 case TC_CLSMATCHALL_DESTROY: 1148 dsa_slave_del_cls_matchall(dev, cls); 1149 return 0; 1150 default: 1151 return -EOPNOTSUPP; 1152 } 1153 } 1154 1155 static int dsa_slave_add_cls_flower(struct net_device *dev, 1156 struct flow_cls_offload *cls, 1157 bool ingress) 1158 { 1159 struct dsa_port *dp = dsa_slave_to_port(dev); 1160 struct dsa_switch *ds = dp->ds; 1161 int port = dp->index; 1162 1163 if (!ds->ops->cls_flower_add) 1164 return -EOPNOTSUPP; 1165 1166 return ds->ops->cls_flower_add(ds, port, cls, ingress); 1167 } 1168 1169 static int dsa_slave_del_cls_flower(struct net_device *dev, 1170 struct flow_cls_offload *cls, 1171 bool ingress) 1172 { 1173 struct dsa_port *dp = dsa_slave_to_port(dev); 1174 struct dsa_switch *ds = dp->ds; 1175 int port = dp->index; 1176 1177 if (!ds->ops->cls_flower_del) 1178 return -EOPNOTSUPP; 1179 1180 return ds->ops->cls_flower_del(ds, port, cls, ingress); 1181 } 1182 1183 static int dsa_slave_stats_cls_flower(struct net_device *dev, 1184 struct flow_cls_offload *cls, 1185 bool ingress) 1186 { 1187 struct dsa_port *dp = dsa_slave_to_port(dev); 1188 struct dsa_switch *ds = dp->ds; 1189 int port = dp->index; 1190 1191 if (!ds->ops->cls_flower_stats) 1192 return -EOPNOTSUPP; 1193 1194 return ds->ops->cls_flower_stats(ds, port, cls, ingress); 1195 } 1196 1197 static int dsa_slave_setup_tc_cls_flower(struct net_device *dev, 1198 struct flow_cls_offload *cls, 1199 bool ingress) 1200 { 1201 switch (cls->command) { 1202 case FLOW_CLS_REPLACE: 1203 return dsa_slave_add_cls_flower(dev, cls, ingress); 1204 case FLOW_CLS_DESTROY: 1205 return dsa_slave_del_cls_flower(dev, cls, ingress); 1206 case FLOW_CLS_STATS: 1207 return dsa_slave_stats_cls_flower(dev, cls, ingress); 1208 default: 1209 return -EOPNOTSUPP; 1210 } 1211 } 1212 1213 static int dsa_slave_setup_tc_block_cb(enum tc_setup_type type, void *type_data, 1214 void *cb_priv, bool ingress) 1215 { 1216 struct net_device *dev = cb_priv; 1217 1218 if (!tc_can_offload(dev)) 1219 return -EOPNOTSUPP; 1220 1221 switch (type) { 1222 case TC_SETUP_CLSMATCHALL: 1223 return dsa_slave_setup_tc_cls_matchall(dev, type_data, ingress); 1224 case TC_SETUP_CLSFLOWER: 1225 return dsa_slave_setup_tc_cls_flower(dev, type_data, ingress); 1226 default: 1227 return -EOPNOTSUPP; 1228 } 1229 } 1230 1231 static int dsa_slave_setup_tc_block_cb_ig(enum tc_setup_type type, 1232 void *type_data, void *cb_priv) 1233 { 1234 return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, true); 1235 } 1236 1237 static int dsa_slave_setup_tc_block_cb_eg(enum tc_setup_type type, 1238 void *type_data, void *cb_priv) 1239 { 1240 return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, false); 1241 } 1242 1243 static LIST_HEAD(dsa_slave_block_cb_list); 1244 1245 static int dsa_slave_setup_tc_block(struct net_device *dev, 1246 struct flow_block_offload *f) 1247 { 1248 struct flow_block_cb *block_cb; 1249 flow_setup_cb_t *cb; 1250 1251 if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS) 1252 cb = dsa_slave_setup_tc_block_cb_ig; 1253 else if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS) 1254 cb = dsa_slave_setup_tc_block_cb_eg; 1255 else 1256 return -EOPNOTSUPP; 1257 1258 f->driver_block_list = &dsa_slave_block_cb_list; 1259 1260 switch (f->command) { 1261 case FLOW_BLOCK_BIND: 1262 if (flow_block_cb_is_busy(cb, dev, &dsa_slave_block_cb_list)) 1263 return -EBUSY; 1264 1265 block_cb = flow_block_cb_alloc(cb, dev, dev, NULL); 1266 if (IS_ERR(block_cb)) 1267 return PTR_ERR(block_cb); 1268 1269 flow_block_cb_add(block_cb, f); 1270 list_add_tail(&block_cb->driver_list, &dsa_slave_block_cb_list); 1271 return 0; 1272 case FLOW_BLOCK_UNBIND: 1273 block_cb = flow_block_cb_lookup(f->block, cb, dev); 1274 if (!block_cb) 1275 return -ENOENT; 1276 1277 flow_block_cb_remove(block_cb, f); 1278 list_del(&block_cb->driver_list); 1279 return 0; 1280 default: 1281 return -EOPNOTSUPP; 1282 } 1283 } 1284 1285 static int dsa_slave_setup_ft_block(struct dsa_switch *ds, int port, 1286 void *type_data) 1287 { 1288 struct dsa_port *cpu_dp = dsa_to_port(ds, port)->cpu_dp; 1289 struct net_device *master = cpu_dp->master; 1290 1291 if (!master->netdev_ops->ndo_setup_tc) 1292 return -EOPNOTSUPP; 1293 1294 return master->netdev_ops->ndo_setup_tc(master, TC_SETUP_FT, type_data); 1295 } 1296 1297 static int dsa_slave_setup_tc(struct net_device *dev, enum tc_setup_type type, 1298 void *type_data) 1299 { 1300 struct dsa_port *dp = dsa_slave_to_port(dev); 1301 struct dsa_switch *ds = dp->ds; 1302 1303 switch (type) { 1304 case TC_SETUP_BLOCK: 1305 return dsa_slave_setup_tc_block(dev, type_data); 1306 case TC_SETUP_FT: 1307 return dsa_slave_setup_ft_block(ds, dp->index, type_data); 1308 default: 1309 break; 1310 } 1311 1312 if (!ds->ops->port_setup_tc) 1313 return -EOPNOTSUPP; 1314 1315 return ds->ops->port_setup_tc(ds, dp->index, type, type_data); 1316 } 1317 1318 static int dsa_slave_get_rxnfc(struct net_device *dev, 1319 struct ethtool_rxnfc *nfc, u32 *rule_locs) 1320 { 1321 struct dsa_port *dp = dsa_slave_to_port(dev); 1322 struct dsa_switch *ds = dp->ds; 1323 1324 if (!ds->ops->get_rxnfc) 1325 return -EOPNOTSUPP; 1326 1327 return ds->ops->get_rxnfc(ds, dp->index, nfc, rule_locs); 1328 } 1329 1330 static int dsa_slave_set_rxnfc(struct net_device *dev, 1331 struct ethtool_rxnfc *nfc) 1332 { 1333 struct dsa_port *dp = dsa_slave_to_port(dev); 1334 struct dsa_switch *ds = dp->ds; 1335 1336 if (!ds->ops->set_rxnfc) 1337 return -EOPNOTSUPP; 1338 1339 return ds->ops->set_rxnfc(ds, dp->index, nfc); 1340 } 1341 1342 static int dsa_slave_get_ts_info(struct net_device *dev, 1343 struct ethtool_ts_info *ts) 1344 { 1345 struct dsa_slave_priv *p = netdev_priv(dev); 1346 struct dsa_switch *ds = p->dp->ds; 1347 1348 if (!ds->ops->get_ts_info) 1349 return -EOPNOTSUPP; 1350 1351 return ds->ops->get_ts_info(ds, p->dp->index, ts); 1352 } 1353 1354 static int dsa_slave_vlan_rx_add_vid(struct net_device *dev, __be16 proto, 1355 u16 vid) 1356 { 1357 struct net_device *master = dsa_slave_to_master(dev); 1358 struct dsa_port *dp = dsa_slave_to_port(dev); 1359 struct switchdev_obj_port_vlan vlan = { 1360 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN, 1361 .vid = vid, 1362 /* This API only allows programming tagged, non-PVID VIDs */ 1363 .flags = 0, 1364 }; 1365 struct netlink_ext_ack extack = {0}; 1366 int ret; 1367 1368 /* User port... */ 1369 ret = dsa_port_vlan_add(dp, &vlan, &extack); 1370 if (ret) { 1371 if (extack._msg) 1372 netdev_err(dev, "%s\n", extack._msg); 1373 return ret; 1374 } 1375 1376 /* And CPU port... */ 1377 ret = dsa_port_vlan_add(dp->cpu_dp, &vlan, &extack); 1378 if (ret) { 1379 if (extack._msg) 1380 netdev_err(dev, "CPU port %d: %s\n", dp->cpu_dp->index, 1381 extack._msg); 1382 return ret; 1383 } 1384 1385 return vlan_vid_add(master, proto, vid); 1386 } 1387 1388 static int dsa_slave_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, 1389 u16 vid) 1390 { 1391 struct net_device *master = dsa_slave_to_master(dev); 1392 struct dsa_port *dp = dsa_slave_to_port(dev); 1393 struct switchdev_obj_port_vlan vlan = { 1394 .vid = vid, 1395 /* This API only allows programming tagged, non-PVID VIDs */ 1396 .flags = 0, 1397 }; 1398 int err; 1399 1400 /* Do not deprogram the CPU port as it may be shared with other user 1401 * ports which can be members of this VLAN as well. 1402 */ 1403 err = dsa_port_vlan_del(dp, &vlan); 1404 if (err) 1405 return err; 1406 1407 vlan_vid_del(master, proto, vid); 1408 1409 return 0; 1410 } 1411 1412 struct dsa_hw_port { 1413 struct list_head list; 1414 struct net_device *dev; 1415 int old_mtu; 1416 }; 1417 1418 static int dsa_hw_port_list_set_mtu(struct list_head *hw_port_list, int mtu) 1419 { 1420 const struct dsa_hw_port *p; 1421 int err; 1422 1423 list_for_each_entry(p, hw_port_list, list) { 1424 if (p->dev->mtu == mtu) 1425 continue; 1426 1427 err = dev_set_mtu(p->dev, mtu); 1428 if (err) 1429 goto rollback; 1430 } 1431 1432 return 0; 1433 1434 rollback: 1435 list_for_each_entry_continue_reverse(p, hw_port_list, list) { 1436 if (p->dev->mtu == p->old_mtu) 1437 continue; 1438 1439 if (dev_set_mtu(p->dev, p->old_mtu)) 1440 netdev_err(p->dev, "Failed to restore MTU\n"); 1441 } 1442 1443 return err; 1444 } 1445 1446 static void dsa_hw_port_list_free(struct list_head *hw_port_list) 1447 { 1448 struct dsa_hw_port *p, *n; 1449 1450 list_for_each_entry_safe(p, n, hw_port_list, list) 1451 kfree(p); 1452 } 1453 1454 /* Make the hardware datapath to/from @dev limited to a common MTU */ 1455 static void dsa_bridge_mtu_normalization(struct dsa_port *dp) 1456 { 1457 struct list_head hw_port_list; 1458 struct dsa_switch_tree *dst; 1459 int min_mtu = ETH_MAX_MTU; 1460 struct dsa_port *other_dp; 1461 int err; 1462 1463 if (!dp->ds->mtu_enforcement_ingress) 1464 return; 1465 1466 if (!dp->bridge_dev) 1467 return; 1468 1469 INIT_LIST_HEAD(&hw_port_list); 1470 1471 /* Populate the list of ports that are part of the same bridge 1472 * as the newly added/modified port 1473 */ 1474 list_for_each_entry(dst, &dsa_tree_list, list) { 1475 list_for_each_entry(other_dp, &dst->ports, list) { 1476 struct dsa_hw_port *hw_port; 1477 struct net_device *slave; 1478 1479 if (other_dp->type != DSA_PORT_TYPE_USER) 1480 continue; 1481 1482 if (other_dp->bridge_dev != dp->bridge_dev) 1483 continue; 1484 1485 if (!other_dp->ds->mtu_enforcement_ingress) 1486 continue; 1487 1488 slave = other_dp->slave; 1489 1490 if (min_mtu > slave->mtu) 1491 min_mtu = slave->mtu; 1492 1493 hw_port = kzalloc(sizeof(*hw_port), GFP_KERNEL); 1494 if (!hw_port) 1495 goto out; 1496 1497 hw_port->dev = slave; 1498 hw_port->old_mtu = slave->mtu; 1499 1500 list_add(&hw_port->list, &hw_port_list); 1501 } 1502 } 1503 1504 /* Attempt to configure the entire hardware bridge to the newly added 1505 * interface's MTU first, regardless of whether the intention of the 1506 * user was to raise or lower it. 1507 */ 1508 err = dsa_hw_port_list_set_mtu(&hw_port_list, dp->slave->mtu); 1509 if (!err) 1510 goto out; 1511 1512 /* Clearly that didn't work out so well, so just set the minimum MTU on 1513 * all hardware bridge ports now. If this fails too, then all ports will 1514 * still have their old MTU rolled back anyway. 1515 */ 1516 dsa_hw_port_list_set_mtu(&hw_port_list, min_mtu); 1517 1518 out: 1519 dsa_hw_port_list_free(&hw_port_list); 1520 } 1521 1522 int dsa_slave_change_mtu(struct net_device *dev, int new_mtu) 1523 { 1524 struct net_device *master = dsa_slave_to_master(dev); 1525 struct dsa_port *dp = dsa_slave_to_port(dev); 1526 struct dsa_slave_priv *p = netdev_priv(dev); 1527 struct dsa_switch *ds = p->dp->ds; 1528 struct dsa_port *dp_iter; 1529 struct dsa_port *cpu_dp; 1530 int port = p->dp->index; 1531 int largest_mtu = 0; 1532 int new_master_mtu; 1533 int old_master_mtu; 1534 int mtu_limit; 1535 int cpu_mtu; 1536 int err; 1537 1538 if (!ds->ops->port_change_mtu) 1539 return -EOPNOTSUPP; 1540 1541 list_for_each_entry(dp_iter, &ds->dst->ports, list) { 1542 int slave_mtu; 1543 1544 if (!dsa_port_is_user(dp_iter)) 1545 continue; 1546 1547 /* During probe, this function will be called for each slave 1548 * device, while not all of them have been allocated. That's 1549 * ok, it doesn't change what the maximum is, so ignore it. 1550 */ 1551 if (!dp_iter->slave) 1552 continue; 1553 1554 /* Pretend that we already applied the setting, which we 1555 * actually haven't (still haven't done all integrity checks) 1556 */ 1557 if (dp_iter == dp) 1558 slave_mtu = new_mtu; 1559 else 1560 slave_mtu = dp_iter->slave->mtu; 1561 1562 if (largest_mtu < slave_mtu) 1563 largest_mtu = slave_mtu; 1564 } 1565 1566 cpu_dp = dsa_to_port(ds, port)->cpu_dp; 1567 1568 mtu_limit = min_t(int, master->max_mtu, dev->max_mtu); 1569 old_master_mtu = master->mtu; 1570 new_master_mtu = largest_mtu + dsa_tag_protocol_overhead(cpu_dp->tag_ops); 1571 if (new_master_mtu > mtu_limit) 1572 return -ERANGE; 1573 1574 /* If the master MTU isn't over limit, there's no need to check the CPU 1575 * MTU, since that surely isn't either. 1576 */ 1577 cpu_mtu = largest_mtu; 1578 1579 /* Start applying stuff */ 1580 if (new_master_mtu != old_master_mtu) { 1581 err = dev_set_mtu(master, new_master_mtu); 1582 if (err < 0) 1583 goto out_master_failed; 1584 1585 /* We only need to propagate the MTU of the CPU port to 1586 * upstream switches, so create a non-targeted notifier which 1587 * updates all switches. 1588 */ 1589 err = dsa_port_mtu_change(cpu_dp, cpu_mtu, false); 1590 if (err) 1591 goto out_cpu_failed; 1592 } 1593 1594 err = dsa_port_mtu_change(dp, new_mtu, true); 1595 if (err) 1596 goto out_port_failed; 1597 1598 dev->mtu = new_mtu; 1599 1600 dsa_bridge_mtu_normalization(dp); 1601 1602 return 0; 1603 1604 out_port_failed: 1605 if (new_master_mtu != old_master_mtu) 1606 dsa_port_mtu_change(cpu_dp, old_master_mtu - 1607 dsa_tag_protocol_overhead(cpu_dp->tag_ops), 1608 false); 1609 out_cpu_failed: 1610 if (new_master_mtu != old_master_mtu) 1611 dev_set_mtu(master, old_master_mtu); 1612 out_master_failed: 1613 return err; 1614 } 1615 1616 static const struct ethtool_ops dsa_slave_ethtool_ops = { 1617 .get_drvinfo = dsa_slave_get_drvinfo, 1618 .get_regs_len = dsa_slave_get_regs_len, 1619 .get_regs = dsa_slave_get_regs, 1620 .nway_reset = dsa_slave_nway_reset, 1621 .get_link = ethtool_op_get_link, 1622 .get_eeprom_len = dsa_slave_get_eeprom_len, 1623 .get_eeprom = dsa_slave_get_eeprom, 1624 .set_eeprom = dsa_slave_set_eeprom, 1625 .get_strings = dsa_slave_get_strings, 1626 .get_ethtool_stats = dsa_slave_get_ethtool_stats, 1627 .get_sset_count = dsa_slave_get_sset_count, 1628 .set_wol = dsa_slave_set_wol, 1629 .get_wol = dsa_slave_get_wol, 1630 .set_eee = dsa_slave_set_eee, 1631 .get_eee = dsa_slave_get_eee, 1632 .get_link_ksettings = dsa_slave_get_link_ksettings, 1633 .set_link_ksettings = dsa_slave_set_link_ksettings, 1634 .get_pauseparam = dsa_slave_get_pauseparam, 1635 .set_pauseparam = dsa_slave_set_pauseparam, 1636 .get_rxnfc = dsa_slave_get_rxnfc, 1637 .set_rxnfc = dsa_slave_set_rxnfc, 1638 .get_ts_info = dsa_slave_get_ts_info, 1639 .self_test = dsa_slave_net_selftest, 1640 }; 1641 1642 static struct devlink_port *dsa_slave_get_devlink_port(struct net_device *dev) 1643 { 1644 struct dsa_port *dp = dsa_slave_to_port(dev); 1645 1646 return dp->ds->devlink ? &dp->devlink_port : NULL; 1647 } 1648 1649 static void dsa_slave_get_stats64(struct net_device *dev, 1650 struct rtnl_link_stats64 *s) 1651 { 1652 struct dsa_port *dp = dsa_slave_to_port(dev); 1653 struct dsa_switch *ds = dp->ds; 1654 1655 if (ds->ops->get_stats64) 1656 ds->ops->get_stats64(ds, dp->index, s); 1657 else 1658 dev_get_tstats64(dev, s); 1659 } 1660 1661 static int dsa_slave_fill_forward_path(struct net_device_path_ctx *ctx, 1662 struct net_device_path *path) 1663 { 1664 struct dsa_port *dp = dsa_slave_to_port(ctx->dev); 1665 struct dsa_port *cpu_dp = dp->cpu_dp; 1666 1667 path->dev = ctx->dev; 1668 path->type = DEV_PATH_DSA; 1669 path->dsa.proto = cpu_dp->tag_ops->proto; 1670 path->dsa.port = dp->index; 1671 ctx->dev = cpu_dp->master; 1672 1673 return 0; 1674 } 1675 1676 static const struct net_device_ops dsa_slave_netdev_ops = { 1677 .ndo_open = dsa_slave_open, 1678 .ndo_stop = dsa_slave_close, 1679 .ndo_start_xmit = dsa_slave_xmit, 1680 .ndo_change_rx_flags = dsa_slave_change_rx_flags, 1681 .ndo_set_rx_mode = dsa_slave_set_rx_mode, 1682 .ndo_set_mac_address = dsa_slave_set_mac_address, 1683 .ndo_fdb_dump = dsa_slave_fdb_dump, 1684 .ndo_eth_ioctl = dsa_slave_ioctl, 1685 .ndo_get_iflink = dsa_slave_get_iflink, 1686 #ifdef CONFIG_NET_POLL_CONTROLLER 1687 .ndo_netpoll_setup = dsa_slave_netpoll_setup, 1688 .ndo_netpoll_cleanup = dsa_slave_netpoll_cleanup, 1689 .ndo_poll_controller = dsa_slave_poll_controller, 1690 #endif 1691 .ndo_get_phys_port_name = dsa_slave_get_phys_port_name, 1692 .ndo_setup_tc = dsa_slave_setup_tc, 1693 .ndo_get_stats64 = dsa_slave_get_stats64, 1694 .ndo_get_port_parent_id = dsa_slave_get_port_parent_id, 1695 .ndo_vlan_rx_add_vid = dsa_slave_vlan_rx_add_vid, 1696 .ndo_vlan_rx_kill_vid = dsa_slave_vlan_rx_kill_vid, 1697 .ndo_get_devlink_port = dsa_slave_get_devlink_port, 1698 .ndo_change_mtu = dsa_slave_change_mtu, 1699 .ndo_fill_forward_path = dsa_slave_fill_forward_path, 1700 }; 1701 1702 static struct device_type dsa_type = { 1703 .name = "dsa", 1704 }; 1705 1706 void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up) 1707 { 1708 const struct dsa_port *dp = dsa_to_port(ds, port); 1709 1710 if (dp->pl) 1711 phylink_mac_change(dp->pl, up); 1712 } 1713 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_change); 1714 1715 static void dsa_slave_phylink_fixed_state(struct phylink_config *config, 1716 struct phylink_link_state *state) 1717 { 1718 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 1719 struct dsa_switch *ds = dp->ds; 1720 1721 /* No need to check that this operation is valid, the callback would 1722 * not be called if it was not. 1723 */ 1724 ds->ops->phylink_fixed_state(ds, dp->index, state); 1725 } 1726 1727 /* slave device setup *******************************************************/ 1728 static int dsa_slave_phy_connect(struct net_device *slave_dev, int addr, 1729 u32 flags) 1730 { 1731 struct dsa_port *dp = dsa_slave_to_port(slave_dev); 1732 struct dsa_switch *ds = dp->ds; 1733 1734 slave_dev->phydev = mdiobus_get_phy(ds->slave_mii_bus, addr); 1735 if (!slave_dev->phydev) { 1736 netdev_err(slave_dev, "no phy at %d\n", addr); 1737 return -ENODEV; 1738 } 1739 1740 slave_dev->phydev->dev_flags |= flags; 1741 1742 return phylink_connect_phy(dp->pl, slave_dev->phydev); 1743 } 1744 1745 static int dsa_slave_phy_setup(struct net_device *slave_dev) 1746 { 1747 struct dsa_port *dp = dsa_slave_to_port(slave_dev); 1748 struct device_node *port_dn = dp->dn; 1749 struct dsa_switch *ds = dp->ds; 1750 phy_interface_t mode; 1751 u32 phy_flags = 0; 1752 int ret; 1753 1754 ret = of_get_phy_mode(port_dn, &mode); 1755 if (ret) 1756 mode = PHY_INTERFACE_MODE_NA; 1757 1758 dp->pl_config.dev = &slave_dev->dev; 1759 dp->pl_config.type = PHYLINK_NETDEV; 1760 1761 /* The get_fixed_state callback takes precedence over polling the 1762 * link GPIO in PHYLINK (see phylink_get_fixed_state). Only set 1763 * this if the switch provides such a callback. 1764 */ 1765 if (ds->ops->phylink_fixed_state) { 1766 dp->pl_config.get_fixed_state = dsa_slave_phylink_fixed_state; 1767 dp->pl_config.poll_fixed_state = true; 1768 } 1769 1770 dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn), mode, 1771 &dsa_port_phylink_mac_ops); 1772 if (IS_ERR(dp->pl)) { 1773 netdev_err(slave_dev, 1774 "error creating PHYLINK: %ld\n", PTR_ERR(dp->pl)); 1775 return PTR_ERR(dp->pl); 1776 } 1777 1778 if (ds->ops->get_phy_flags) 1779 phy_flags = ds->ops->get_phy_flags(ds, dp->index); 1780 1781 ret = phylink_of_phy_connect(dp->pl, port_dn, phy_flags); 1782 if (ret == -ENODEV && ds->slave_mii_bus) { 1783 /* We could not connect to a designated PHY or SFP, so try to 1784 * use the switch internal MDIO bus instead 1785 */ 1786 ret = dsa_slave_phy_connect(slave_dev, dp->index, phy_flags); 1787 if (ret) { 1788 netdev_err(slave_dev, 1789 "failed to connect to port %d: %d\n", 1790 dp->index, ret); 1791 phylink_destroy(dp->pl); 1792 return ret; 1793 } 1794 } 1795 1796 return ret; 1797 } 1798 1799 void dsa_slave_setup_tagger(struct net_device *slave) 1800 { 1801 struct dsa_port *dp = dsa_slave_to_port(slave); 1802 struct dsa_slave_priv *p = netdev_priv(slave); 1803 const struct dsa_port *cpu_dp = dp->cpu_dp; 1804 struct net_device *master = cpu_dp->master; 1805 const struct dsa_switch *ds = dp->ds; 1806 1807 slave->needed_headroom = cpu_dp->tag_ops->needed_headroom; 1808 slave->needed_tailroom = cpu_dp->tag_ops->needed_tailroom; 1809 /* Try to save one extra realloc later in the TX path (in the master) 1810 * by also inheriting the master's needed headroom and tailroom. 1811 * The 8021q driver also does this. 1812 */ 1813 slave->needed_headroom += master->needed_headroom; 1814 slave->needed_tailroom += master->needed_tailroom; 1815 1816 p->xmit = cpu_dp->tag_ops->xmit; 1817 1818 slave->features = master->vlan_features | NETIF_F_HW_TC; 1819 if (ds->ops->port_vlan_add && ds->ops->port_vlan_del) 1820 slave->features |= NETIF_F_HW_VLAN_CTAG_FILTER; 1821 slave->hw_features |= NETIF_F_HW_TC; 1822 slave->features |= NETIF_F_LLTX; 1823 if (slave->needed_tailroom) 1824 slave->features &= ~(NETIF_F_SG | NETIF_F_FRAGLIST); 1825 } 1826 1827 static struct lock_class_key dsa_slave_netdev_xmit_lock_key; 1828 static void dsa_slave_set_lockdep_class_one(struct net_device *dev, 1829 struct netdev_queue *txq, 1830 void *_unused) 1831 { 1832 lockdep_set_class(&txq->_xmit_lock, 1833 &dsa_slave_netdev_xmit_lock_key); 1834 } 1835 1836 int dsa_slave_suspend(struct net_device *slave_dev) 1837 { 1838 struct dsa_port *dp = dsa_slave_to_port(slave_dev); 1839 1840 if (!netif_running(slave_dev)) 1841 return 0; 1842 1843 netif_device_detach(slave_dev); 1844 1845 rtnl_lock(); 1846 phylink_stop(dp->pl); 1847 rtnl_unlock(); 1848 1849 return 0; 1850 } 1851 1852 int dsa_slave_resume(struct net_device *slave_dev) 1853 { 1854 struct dsa_port *dp = dsa_slave_to_port(slave_dev); 1855 1856 if (!netif_running(slave_dev)) 1857 return 0; 1858 1859 netif_device_attach(slave_dev); 1860 1861 rtnl_lock(); 1862 phylink_start(dp->pl); 1863 rtnl_unlock(); 1864 1865 return 0; 1866 } 1867 1868 int dsa_slave_create(struct dsa_port *port) 1869 { 1870 const struct dsa_port *cpu_dp = port->cpu_dp; 1871 struct net_device *master = cpu_dp->master; 1872 struct dsa_switch *ds = port->ds; 1873 const char *name = port->name; 1874 struct net_device *slave_dev; 1875 struct dsa_slave_priv *p; 1876 int ret; 1877 1878 if (!ds->num_tx_queues) 1879 ds->num_tx_queues = 1; 1880 1881 slave_dev = alloc_netdev_mqs(sizeof(struct dsa_slave_priv), name, 1882 NET_NAME_UNKNOWN, ether_setup, 1883 ds->num_tx_queues, 1); 1884 if (slave_dev == NULL) 1885 return -ENOMEM; 1886 1887 slave_dev->ethtool_ops = &dsa_slave_ethtool_ops; 1888 if (!is_zero_ether_addr(port->mac)) 1889 ether_addr_copy(slave_dev->dev_addr, port->mac); 1890 else 1891 eth_hw_addr_inherit(slave_dev, master); 1892 slave_dev->priv_flags |= IFF_NO_QUEUE; 1893 slave_dev->netdev_ops = &dsa_slave_netdev_ops; 1894 if (ds->ops->port_max_mtu) 1895 slave_dev->max_mtu = ds->ops->port_max_mtu(ds, port->index); 1896 SET_NETDEV_DEVTYPE(slave_dev, &dsa_type); 1897 1898 netdev_for_each_tx_queue(slave_dev, dsa_slave_set_lockdep_class_one, 1899 NULL); 1900 1901 SET_NETDEV_DEV(slave_dev, port->ds->dev); 1902 slave_dev->dev.of_node = port->dn; 1903 slave_dev->vlan_features = master->vlan_features; 1904 1905 p = netdev_priv(slave_dev); 1906 slave_dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats); 1907 if (!slave_dev->tstats) { 1908 free_netdev(slave_dev); 1909 return -ENOMEM; 1910 } 1911 1912 ret = gro_cells_init(&p->gcells, slave_dev); 1913 if (ret) 1914 goto out_free; 1915 1916 p->dp = port; 1917 INIT_LIST_HEAD(&p->mall_tc_list); 1918 port->slave = slave_dev; 1919 dsa_slave_setup_tagger(slave_dev); 1920 1921 rtnl_lock(); 1922 ret = dsa_slave_change_mtu(slave_dev, ETH_DATA_LEN); 1923 rtnl_unlock(); 1924 if (ret && ret != -EOPNOTSUPP) 1925 dev_warn(ds->dev, "nonfatal error %d setting MTU to %d on port %d\n", 1926 ret, ETH_DATA_LEN, port->index); 1927 1928 netif_carrier_off(slave_dev); 1929 1930 ret = dsa_slave_phy_setup(slave_dev); 1931 if (ret) { 1932 netdev_err(slave_dev, 1933 "error %d setting up PHY for tree %d, switch %d, port %d\n", 1934 ret, ds->dst->index, ds->index, port->index); 1935 goto out_gcells; 1936 } 1937 1938 rtnl_lock(); 1939 1940 ret = register_netdevice(slave_dev); 1941 if (ret) { 1942 netdev_err(master, "error %d registering interface %s\n", 1943 ret, slave_dev->name); 1944 rtnl_unlock(); 1945 goto out_phy; 1946 } 1947 1948 ret = netdev_upper_dev_link(master, slave_dev, NULL); 1949 1950 rtnl_unlock(); 1951 1952 if (ret) 1953 goto out_unregister; 1954 1955 return 0; 1956 1957 out_unregister: 1958 unregister_netdev(slave_dev); 1959 out_phy: 1960 rtnl_lock(); 1961 phylink_disconnect_phy(p->dp->pl); 1962 rtnl_unlock(); 1963 phylink_destroy(p->dp->pl); 1964 out_gcells: 1965 gro_cells_destroy(&p->gcells); 1966 out_free: 1967 free_percpu(slave_dev->tstats); 1968 free_netdev(slave_dev); 1969 port->slave = NULL; 1970 return ret; 1971 } 1972 1973 void dsa_slave_destroy(struct net_device *slave_dev) 1974 { 1975 struct net_device *master = dsa_slave_to_master(slave_dev); 1976 struct dsa_port *dp = dsa_slave_to_port(slave_dev); 1977 struct dsa_slave_priv *p = netdev_priv(slave_dev); 1978 1979 netif_carrier_off(slave_dev); 1980 rtnl_lock(); 1981 netdev_upper_dev_unlink(master, slave_dev); 1982 unregister_netdevice(slave_dev); 1983 phylink_disconnect_phy(dp->pl); 1984 rtnl_unlock(); 1985 1986 phylink_destroy(dp->pl); 1987 gro_cells_destroy(&p->gcells); 1988 free_percpu(slave_dev->tstats); 1989 free_netdev(slave_dev); 1990 } 1991 1992 bool dsa_slave_dev_check(const struct net_device *dev) 1993 { 1994 return dev->netdev_ops == &dsa_slave_netdev_ops; 1995 } 1996 EXPORT_SYMBOL_GPL(dsa_slave_dev_check); 1997 1998 static int dsa_slave_changeupper(struct net_device *dev, 1999 struct netdev_notifier_changeupper_info *info) 2000 { 2001 struct dsa_port *dp = dsa_slave_to_port(dev); 2002 struct netlink_ext_ack *extack; 2003 int err = NOTIFY_DONE; 2004 2005 extack = netdev_notifier_info_to_extack(&info->info); 2006 2007 if (netif_is_bridge_master(info->upper_dev)) { 2008 if (info->linking) { 2009 err = dsa_port_bridge_join(dp, info->upper_dev, extack); 2010 if (!err) 2011 dsa_bridge_mtu_normalization(dp); 2012 err = notifier_from_errno(err); 2013 } else { 2014 dsa_port_bridge_leave(dp, info->upper_dev); 2015 err = NOTIFY_OK; 2016 } 2017 } else if (netif_is_lag_master(info->upper_dev)) { 2018 if (info->linking) { 2019 err = dsa_port_lag_join(dp, info->upper_dev, 2020 info->upper_info, extack); 2021 if (err == -EOPNOTSUPP) { 2022 NL_SET_ERR_MSG_MOD(info->info.extack, 2023 "Offloading not supported"); 2024 err = 0; 2025 } 2026 err = notifier_from_errno(err); 2027 } else { 2028 dsa_port_lag_leave(dp, info->upper_dev); 2029 err = NOTIFY_OK; 2030 } 2031 } else if (is_hsr_master(info->upper_dev)) { 2032 if (info->linking) { 2033 err = dsa_port_hsr_join(dp, info->upper_dev); 2034 if (err == -EOPNOTSUPP) { 2035 NL_SET_ERR_MSG_MOD(info->info.extack, 2036 "Offloading not supported"); 2037 err = 0; 2038 } 2039 err = notifier_from_errno(err); 2040 } else { 2041 dsa_port_hsr_leave(dp, info->upper_dev); 2042 err = NOTIFY_OK; 2043 } 2044 } 2045 2046 return err; 2047 } 2048 2049 static int dsa_slave_prechangeupper(struct net_device *dev, 2050 struct netdev_notifier_changeupper_info *info) 2051 { 2052 struct dsa_port *dp = dsa_slave_to_port(dev); 2053 2054 if (netif_is_bridge_master(info->upper_dev) && !info->linking) 2055 dsa_port_pre_bridge_leave(dp, info->upper_dev); 2056 else if (netif_is_lag_master(info->upper_dev) && !info->linking) 2057 dsa_port_pre_lag_leave(dp, info->upper_dev); 2058 /* dsa_port_pre_hsr_leave is not yet necessary since hsr cannot be 2059 * meaningfully enslaved to a bridge yet 2060 */ 2061 2062 return NOTIFY_DONE; 2063 } 2064 2065 static int 2066 dsa_slave_lag_changeupper(struct net_device *dev, 2067 struct netdev_notifier_changeupper_info *info) 2068 { 2069 struct net_device *lower; 2070 struct list_head *iter; 2071 int err = NOTIFY_DONE; 2072 struct dsa_port *dp; 2073 2074 netdev_for_each_lower_dev(dev, lower, iter) { 2075 if (!dsa_slave_dev_check(lower)) 2076 continue; 2077 2078 dp = dsa_slave_to_port(lower); 2079 if (!dp->lag_dev) 2080 /* Software LAG */ 2081 continue; 2082 2083 err = dsa_slave_changeupper(lower, info); 2084 if (notifier_to_errno(err)) 2085 break; 2086 } 2087 2088 return err; 2089 } 2090 2091 /* Same as dsa_slave_lag_changeupper() except that it calls 2092 * dsa_slave_prechangeupper() 2093 */ 2094 static int 2095 dsa_slave_lag_prechangeupper(struct net_device *dev, 2096 struct netdev_notifier_changeupper_info *info) 2097 { 2098 struct net_device *lower; 2099 struct list_head *iter; 2100 int err = NOTIFY_DONE; 2101 struct dsa_port *dp; 2102 2103 netdev_for_each_lower_dev(dev, lower, iter) { 2104 if (!dsa_slave_dev_check(lower)) 2105 continue; 2106 2107 dp = dsa_slave_to_port(lower); 2108 if (!dp->lag_dev) 2109 /* Software LAG */ 2110 continue; 2111 2112 err = dsa_slave_prechangeupper(lower, info); 2113 if (notifier_to_errno(err)) 2114 break; 2115 } 2116 2117 return err; 2118 } 2119 2120 static int 2121 dsa_prevent_bridging_8021q_upper(struct net_device *dev, 2122 struct netdev_notifier_changeupper_info *info) 2123 { 2124 struct netlink_ext_ack *ext_ack; 2125 struct net_device *slave; 2126 struct dsa_port *dp; 2127 2128 ext_ack = netdev_notifier_info_to_extack(&info->info); 2129 2130 if (!is_vlan_dev(dev)) 2131 return NOTIFY_DONE; 2132 2133 slave = vlan_dev_real_dev(dev); 2134 if (!dsa_slave_dev_check(slave)) 2135 return NOTIFY_DONE; 2136 2137 dp = dsa_slave_to_port(slave); 2138 if (!dp->bridge_dev) 2139 return NOTIFY_DONE; 2140 2141 /* Deny enslaving a VLAN device into a VLAN-aware bridge */ 2142 if (br_vlan_enabled(dp->bridge_dev) && 2143 netif_is_bridge_master(info->upper_dev) && info->linking) { 2144 NL_SET_ERR_MSG_MOD(ext_ack, 2145 "Cannot enslave VLAN device into VLAN aware bridge"); 2146 return notifier_from_errno(-EINVAL); 2147 } 2148 2149 return NOTIFY_DONE; 2150 } 2151 2152 static int 2153 dsa_slave_check_8021q_upper(struct net_device *dev, 2154 struct netdev_notifier_changeupper_info *info) 2155 { 2156 struct dsa_port *dp = dsa_slave_to_port(dev); 2157 struct net_device *br = dp->bridge_dev; 2158 struct bridge_vlan_info br_info; 2159 struct netlink_ext_ack *extack; 2160 int err = NOTIFY_DONE; 2161 u16 vid; 2162 2163 if (!br || !br_vlan_enabled(br)) 2164 return NOTIFY_DONE; 2165 2166 extack = netdev_notifier_info_to_extack(&info->info); 2167 vid = vlan_dev_vlan_id(info->upper_dev); 2168 2169 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the 2170 * device, respectively the VID is not found, returning 2171 * 0 means success, which is a failure for us here. 2172 */ 2173 err = br_vlan_get_info(br, vid, &br_info); 2174 if (err == 0) { 2175 NL_SET_ERR_MSG_MOD(extack, 2176 "This VLAN is already configured by the bridge"); 2177 return notifier_from_errno(-EBUSY); 2178 } 2179 2180 return NOTIFY_DONE; 2181 } 2182 2183 static int 2184 dsa_slave_prechangeupper_sanity_check(struct net_device *dev, 2185 struct netdev_notifier_changeupper_info *info) 2186 { 2187 struct dsa_switch *ds; 2188 struct dsa_port *dp; 2189 int err; 2190 2191 if (!dsa_slave_dev_check(dev)) 2192 return dsa_prevent_bridging_8021q_upper(dev, info); 2193 2194 dp = dsa_slave_to_port(dev); 2195 ds = dp->ds; 2196 2197 if (ds->ops->port_prechangeupper) { 2198 err = ds->ops->port_prechangeupper(ds, dp->index, info); 2199 if (err) 2200 return notifier_from_errno(err); 2201 } 2202 2203 if (is_vlan_dev(info->upper_dev)) 2204 return dsa_slave_check_8021q_upper(dev, info); 2205 2206 return NOTIFY_DONE; 2207 } 2208 2209 static int dsa_slave_netdevice_event(struct notifier_block *nb, 2210 unsigned long event, void *ptr) 2211 { 2212 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 2213 2214 switch (event) { 2215 case NETDEV_PRECHANGEUPPER: { 2216 struct netdev_notifier_changeupper_info *info = ptr; 2217 int err; 2218 2219 err = dsa_slave_prechangeupper_sanity_check(dev, info); 2220 if (err != NOTIFY_DONE) 2221 return err; 2222 2223 if (dsa_slave_dev_check(dev)) 2224 return dsa_slave_prechangeupper(dev, ptr); 2225 2226 if (netif_is_lag_master(dev)) 2227 return dsa_slave_lag_prechangeupper(dev, ptr); 2228 2229 break; 2230 } 2231 case NETDEV_CHANGEUPPER: 2232 if (dsa_slave_dev_check(dev)) 2233 return dsa_slave_changeupper(dev, ptr); 2234 2235 if (netif_is_lag_master(dev)) 2236 return dsa_slave_lag_changeupper(dev, ptr); 2237 2238 break; 2239 case NETDEV_CHANGELOWERSTATE: { 2240 struct netdev_notifier_changelowerstate_info *info = ptr; 2241 struct dsa_port *dp; 2242 int err; 2243 2244 if (!dsa_slave_dev_check(dev)) 2245 break; 2246 2247 dp = dsa_slave_to_port(dev); 2248 2249 err = dsa_port_lag_change(dp, info->lower_state_info); 2250 return notifier_from_errno(err); 2251 } 2252 case NETDEV_GOING_DOWN: { 2253 struct dsa_port *dp, *cpu_dp; 2254 struct dsa_switch_tree *dst; 2255 LIST_HEAD(close_list); 2256 2257 if (!netdev_uses_dsa(dev)) 2258 return NOTIFY_DONE; 2259 2260 cpu_dp = dev->dsa_ptr; 2261 dst = cpu_dp->ds->dst; 2262 2263 list_for_each_entry(dp, &dst->ports, list) { 2264 if (!dsa_is_user_port(dp->ds, dp->index)) 2265 continue; 2266 2267 list_add(&dp->slave->close_list, &close_list); 2268 } 2269 2270 dev_close_many(&close_list, true); 2271 2272 return NOTIFY_OK; 2273 } 2274 default: 2275 break; 2276 } 2277 2278 return NOTIFY_DONE; 2279 } 2280 2281 static void 2282 dsa_fdb_offload_notify(struct dsa_switchdev_event_work *switchdev_work) 2283 { 2284 struct switchdev_notifier_fdb_info info = {}; 2285 struct dsa_switch *ds = switchdev_work->ds; 2286 struct dsa_port *dp; 2287 2288 if (!dsa_is_user_port(ds, switchdev_work->port)) 2289 return; 2290 2291 info.addr = switchdev_work->addr; 2292 info.vid = switchdev_work->vid; 2293 info.offloaded = true; 2294 dp = dsa_to_port(ds, switchdev_work->port); 2295 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, 2296 dp->slave, &info.info, NULL); 2297 } 2298 2299 static void dsa_slave_switchdev_event_work(struct work_struct *work) 2300 { 2301 struct dsa_switchdev_event_work *switchdev_work = 2302 container_of(work, struct dsa_switchdev_event_work, work); 2303 struct dsa_switch *ds = switchdev_work->ds; 2304 struct dsa_port *dp; 2305 int err; 2306 2307 dp = dsa_to_port(ds, switchdev_work->port); 2308 2309 rtnl_lock(); 2310 switch (switchdev_work->event) { 2311 case SWITCHDEV_FDB_ADD_TO_DEVICE: 2312 if (switchdev_work->host_addr) 2313 err = dsa_port_host_fdb_add(dp, switchdev_work->addr, 2314 switchdev_work->vid); 2315 else 2316 err = dsa_port_fdb_add(dp, switchdev_work->addr, 2317 switchdev_work->vid); 2318 if (err) { 2319 dev_err(ds->dev, 2320 "port %d failed to add %pM vid %d to fdb: %d\n", 2321 dp->index, switchdev_work->addr, 2322 switchdev_work->vid, err); 2323 break; 2324 } 2325 dsa_fdb_offload_notify(switchdev_work); 2326 break; 2327 2328 case SWITCHDEV_FDB_DEL_TO_DEVICE: 2329 if (switchdev_work->host_addr) 2330 err = dsa_port_host_fdb_del(dp, switchdev_work->addr, 2331 switchdev_work->vid); 2332 else 2333 err = dsa_port_fdb_del(dp, switchdev_work->addr, 2334 switchdev_work->vid); 2335 if (err) { 2336 dev_err(ds->dev, 2337 "port %d failed to delete %pM vid %d from fdb: %d\n", 2338 dp->index, switchdev_work->addr, 2339 switchdev_work->vid, err); 2340 } 2341 2342 break; 2343 } 2344 rtnl_unlock(); 2345 2346 dev_put(switchdev_work->dev); 2347 kfree(switchdev_work); 2348 } 2349 2350 static bool dsa_foreign_dev_check(const struct net_device *dev, 2351 const struct net_device *foreign_dev) 2352 { 2353 const struct dsa_port *dp = dsa_slave_to_port(dev); 2354 struct dsa_switch_tree *dst = dp->ds->dst; 2355 2356 if (netif_is_bridge_master(foreign_dev)) 2357 return !dsa_tree_offloads_bridge(dst, foreign_dev); 2358 2359 if (netif_is_bridge_port(foreign_dev)) 2360 return !dsa_tree_offloads_bridge_port(dst, foreign_dev); 2361 2362 /* Everything else is foreign */ 2363 return true; 2364 } 2365 2366 static int dsa_slave_fdb_event(struct net_device *dev, 2367 const struct net_device *orig_dev, 2368 const void *ctx, 2369 const struct switchdev_notifier_fdb_info *fdb_info, 2370 unsigned long event) 2371 { 2372 struct dsa_switchdev_event_work *switchdev_work; 2373 struct dsa_port *dp = dsa_slave_to_port(dev); 2374 bool host_addr = fdb_info->is_local; 2375 struct dsa_switch *ds = dp->ds; 2376 2377 if (ctx && ctx != dp) 2378 return 0; 2379 2380 if (!ds->ops->port_fdb_add || !ds->ops->port_fdb_del) 2381 return -EOPNOTSUPP; 2382 2383 if (dsa_slave_dev_check(orig_dev) && 2384 switchdev_fdb_is_dynamically_learned(fdb_info)) 2385 return 0; 2386 2387 /* FDB entries learned by the software bridge should be installed as 2388 * host addresses only if the driver requests assisted learning. 2389 */ 2390 if (switchdev_fdb_is_dynamically_learned(fdb_info) && 2391 !ds->assisted_learning_on_cpu_port) 2392 return 0; 2393 2394 /* Also treat FDB entries on foreign interfaces bridged with us as host 2395 * addresses. 2396 */ 2397 if (dsa_foreign_dev_check(dev, orig_dev)) 2398 host_addr = true; 2399 2400 switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC); 2401 if (!switchdev_work) 2402 return -ENOMEM; 2403 2404 netdev_dbg(dev, "%s FDB entry towards %s, addr %pM vid %d%s\n", 2405 event == SWITCHDEV_FDB_ADD_TO_DEVICE ? "Adding" : "Deleting", 2406 orig_dev->name, fdb_info->addr, fdb_info->vid, 2407 host_addr ? " as host address" : ""); 2408 2409 INIT_WORK(&switchdev_work->work, dsa_slave_switchdev_event_work); 2410 switchdev_work->ds = ds; 2411 switchdev_work->port = dp->index; 2412 switchdev_work->event = event; 2413 switchdev_work->dev = dev; 2414 2415 ether_addr_copy(switchdev_work->addr, fdb_info->addr); 2416 switchdev_work->vid = fdb_info->vid; 2417 switchdev_work->host_addr = host_addr; 2418 2419 /* Hold a reference for dsa_fdb_offload_notify */ 2420 dev_hold(dev); 2421 dsa_schedule_work(&switchdev_work->work); 2422 2423 return 0; 2424 } 2425 2426 static int 2427 dsa_slave_fdb_add_to_device(struct net_device *dev, 2428 const struct net_device *orig_dev, const void *ctx, 2429 const struct switchdev_notifier_fdb_info *fdb_info) 2430 { 2431 return dsa_slave_fdb_event(dev, orig_dev, ctx, fdb_info, 2432 SWITCHDEV_FDB_ADD_TO_DEVICE); 2433 } 2434 2435 static int 2436 dsa_slave_fdb_del_to_device(struct net_device *dev, 2437 const struct net_device *orig_dev, const void *ctx, 2438 const struct switchdev_notifier_fdb_info *fdb_info) 2439 { 2440 return dsa_slave_fdb_event(dev, orig_dev, ctx, fdb_info, 2441 SWITCHDEV_FDB_DEL_TO_DEVICE); 2442 } 2443 2444 /* Called under rcu_read_lock() */ 2445 static int dsa_slave_switchdev_event(struct notifier_block *unused, 2446 unsigned long event, void *ptr) 2447 { 2448 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 2449 int err; 2450 2451 switch (event) { 2452 case SWITCHDEV_PORT_ATTR_SET: 2453 err = switchdev_handle_port_attr_set(dev, ptr, 2454 dsa_slave_dev_check, 2455 dsa_slave_port_attr_set); 2456 return notifier_from_errno(err); 2457 case SWITCHDEV_FDB_ADD_TO_DEVICE: 2458 err = switchdev_handle_fdb_add_to_device(dev, ptr, 2459 dsa_slave_dev_check, 2460 dsa_foreign_dev_check, 2461 dsa_slave_fdb_add_to_device, 2462 NULL); 2463 return notifier_from_errno(err); 2464 case SWITCHDEV_FDB_DEL_TO_DEVICE: 2465 err = switchdev_handle_fdb_del_to_device(dev, ptr, 2466 dsa_slave_dev_check, 2467 dsa_foreign_dev_check, 2468 dsa_slave_fdb_del_to_device, 2469 NULL); 2470 return notifier_from_errno(err); 2471 default: 2472 return NOTIFY_DONE; 2473 } 2474 2475 return NOTIFY_OK; 2476 } 2477 2478 static int dsa_slave_switchdev_blocking_event(struct notifier_block *unused, 2479 unsigned long event, void *ptr) 2480 { 2481 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 2482 int err; 2483 2484 switch (event) { 2485 case SWITCHDEV_PORT_OBJ_ADD: 2486 err = switchdev_handle_port_obj_add(dev, ptr, 2487 dsa_slave_dev_check, 2488 dsa_slave_port_obj_add); 2489 return notifier_from_errno(err); 2490 case SWITCHDEV_PORT_OBJ_DEL: 2491 err = switchdev_handle_port_obj_del(dev, ptr, 2492 dsa_slave_dev_check, 2493 dsa_slave_port_obj_del); 2494 return notifier_from_errno(err); 2495 case SWITCHDEV_PORT_ATTR_SET: 2496 err = switchdev_handle_port_attr_set(dev, ptr, 2497 dsa_slave_dev_check, 2498 dsa_slave_port_attr_set); 2499 return notifier_from_errno(err); 2500 } 2501 2502 return NOTIFY_DONE; 2503 } 2504 2505 static struct notifier_block dsa_slave_nb __read_mostly = { 2506 .notifier_call = dsa_slave_netdevice_event, 2507 }; 2508 2509 struct notifier_block dsa_slave_switchdev_notifier = { 2510 .notifier_call = dsa_slave_switchdev_event, 2511 }; 2512 2513 struct notifier_block dsa_slave_switchdev_blocking_notifier = { 2514 .notifier_call = dsa_slave_switchdev_blocking_event, 2515 }; 2516 2517 int dsa_slave_register_notifier(void) 2518 { 2519 struct notifier_block *nb; 2520 int err; 2521 2522 err = register_netdevice_notifier(&dsa_slave_nb); 2523 if (err) 2524 return err; 2525 2526 err = register_switchdev_notifier(&dsa_slave_switchdev_notifier); 2527 if (err) 2528 goto err_switchdev_nb; 2529 2530 nb = &dsa_slave_switchdev_blocking_notifier; 2531 err = register_switchdev_blocking_notifier(nb); 2532 if (err) 2533 goto err_switchdev_blocking_nb; 2534 2535 return 0; 2536 2537 err_switchdev_blocking_nb: 2538 unregister_switchdev_notifier(&dsa_slave_switchdev_notifier); 2539 err_switchdev_nb: 2540 unregister_netdevice_notifier(&dsa_slave_nb); 2541 return err; 2542 } 2543 2544 void dsa_slave_unregister_notifier(void) 2545 { 2546 struct notifier_block *nb; 2547 int err; 2548 2549 nb = &dsa_slave_switchdev_blocking_notifier; 2550 err = unregister_switchdev_blocking_notifier(nb); 2551 if (err) 2552 pr_err("DSA: failed to unregister switchdev blocking notifier (%d)\n", err); 2553 2554 err = unregister_switchdev_notifier(&dsa_slave_switchdev_notifier); 2555 if (err) 2556 pr_err("DSA: failed to unregister switchdev notifier (%d)\n", err); 2557 2558 err = unregister_netdevice_notifier(&dsa_slave_nb); 2559 if (err) 2560 pr_err("DSA: failed to unregister slave notifier (%d)\n", err); 2561 } 2562