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 eth_hw_addr_set(dev, 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_dev(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_dev(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(dsa_port_bridge_dev_get(dp))) { 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_dev(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_dev(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_dev(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_dev(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_dev(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_dev(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 inline netdev_tx_t dsa_slave_netpoll_send_skb(struct net_device *dev, 519 struct sk_buff *skb) 520 { 521 #ifdef CONFIG_NET_POLL_CONTROLLER 522 struct dsa_slave_priv *p = netdev_priv(dev); 523 524 return netpoll_send_skb(p->netpoll, skb); 525 #else 526 BUG(); 527 return NETDEV_TX_OK; 528 #endif 529 } 530 531 static void dsa_skb_tx_timestamp(struct dsa_slave_priv *p, 532 struct sk_buff *skb) 533 { 534 struct dsa_switch *ds = p->dp->ds; 535 536 if (!(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)) 537 return; 538 539 if (!ds->ops->port_txtstamp) 540 return; 541 542 ds->ops->port_txtstamp(ds, p->dp->index, skb); 543 } 544 545 netdev_tx_t dsa_enqueue_skb(struct sk_buff *skb, struct net_device *dev) 546 { 547 /* SKB for netpoll still need to be mangled with the protocol-specific 548 * tag to be successfully transmitted 549 */ 550 if (unlikely(netpoll_tx_running(dev))) 551 return dsa_slave_netpoll_send_skb(dev, skb); 552 553 /* Queue the SKB for transmission on the parent interface, but 554 * do not modify its EtherType 555 */ 556 skb->dev = dsa_slave_to_master(dev); 557 dev_queue_xmit(skb); 558 559 return NETDEV_TX_OK; 560 } 561 EXPORT_SYMBOL_GPL(dsa_enqueue_skb); 562 563 static int dsa_realloc_skb(struct sk_buff *skb, struct net_device *dev) 564 { 565 int needed_headroom = dev->needed_headroom; 566 int needed_tailroom = dev->needed_tailroom; 567 568 /* For tail taggers, we need to pad short frames ourselves, to ensure 569 * that the tail tag does not fail at its role of being at the end of 570 * the packet, once the master interface pads the frame. Account for 571 * that pad length here, and pad later. 572 */ 573 if (unlikely(needed_tailroom && skb->len < ETH_ZLEN)) 574 needed_tailroom += ETH_ZLEN - skb->len; 575 /* skb_headroom() returns unsigned int... */ 576 needed_headroom = max_t(int, needed_headroom - skb_headroom(skb), 0); 577 needed_tailroom = max_t(int, needed_tailroom - skb_tailroom(skb), 0); 578 579 if (likely(!needed_headroom && !needed_tailroom && !skb_cloned(skb))) 580 /* No reallocation needed, yay! */ 581 return 0; 582 583 return pskb_expand_head(skb, needed_headroom, needed_tailroom, 584 GFP_ATOMIC); 585 } 586 587 static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev) 588 { 589 struct dsa_slave_priv *p = netdev_priv(dev); 590 struct sk_buff *nskb; 591 592 dev_sw_netstats_tx_add(dev, 1, skb->len); 593 594 memset(skb->cb, 0, sizeof(skb->cb)); 595 596 /* Handle tx timestamp if any */ 597 dsa_skb_tx_timestamp(p, skb); 598 599 if (dsa_realloc_skb(skb, dev)) { 600 dev_kfree_skb_any(skb); 601 return NETDEV_TX_OK; 602 } 603 604 /* needed_tailroom should still be 'warm' in the cache line from 605 * dsa_realloc_skb(), which has also ensured that padding is safe. 606 */ 607 if (dev->needed_tailroom) 608 eth_skb_pad(skb); 609 610 /* Transmit function may have to reallocate the original SKB, 611 * in which case it must have freed it. Only free it here on error. 612 */ 613 nskb = p->xmit(skb, dev); 614 if (!nskb) { 615 kfree_skb(skb); 616 return NETDEV_TX_OK; 617 } 618 619 return dsa_enqueue_skb(nskb, dev); 620 } 621 622 /* ethtool operations *******************************************************/ 623 624 static void dsa_slave_get_drvinfo(struct net_device *dev, 625 struct ethtool_drvinfo *drvinfo) 626 { 627 strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver)); 628 strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version)); 629 strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info)); 630 } 631 632 static int dsa_slave_get_regs_len(struct net_device *dev) 633 { 634 struct dsa_port *dp = dsa_slave_to_port(dev); 635 struct dsa_switch *ds = dp->ds; 636 637 if (ds->ops->get_regs_len) 638 return ds->ops->get_regs_len(ds, dp->index); 639 640 return -EOPNOTSUPP; 641 } 642 643 static void 644 dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p) 645 { 646 struct dsa_port *dp = dsa_slave_to_port(dev); 647 struct dsa_switch *ds = dp->ds; 648 649 if (ds->ops->get_regs) 650 ds->ops->get_regs(ds, dp->index, regs, _p); 651 } 652 653 static int dsa_slave_nway_reset(struct net_device *dev) 654 { 655 struct dsa_port *dp = dsa_slave_to_port(dev); 656 657 return phylink_ethtool_nway_reset(dp->pl); 658 } 659 660 static int dsa_slave_get_eeprom_len(struct net_device *dev) 661 { 662 struct dsa_port *dp = dsa_slave_to_port(dev); 663 struct dsa_switch *ds = dp->ds; 664 665 if (ds->cd && ds->cd->eeprom_len) 666 return ds->cd->eeprom_len; 667 668 if (ds->ops->get_eeprom_len) 669 return ds->ops->get_eeprom_len(ds); 670 671 return 0; 672 } 673 674 static int dsa_slave_get_eeprom(struct net_device *dev, 675 struct ethtool_eeprom *eeprom, u8 *data) 676 { 677 struct dsa_port *dp = dsa_slave_to_port(dev); 678 struct dsa_switch *ds = dp->ds; 679 680 if (ds->ops->get_eeprom) 681 return ds->ops->get_eeprom(ds, eeprom, data); 682 683 return -EOPNOTSUPP; 684 } 685 686 static int dsa_slave_set_eeprom(struct net_device *dev, 687 struct ethtool_eeprom *eeprom, u8 *data) 688 { 689 struct dsa_port *dp = dsa_slave_to_port(dev); 690 struct dsa_switch *ds = dp->ds; 691 692 if (ds->ops->set_eeprom) 693 return ds->ops->set_eeprom(ds, eeprom, data); 694 695 return -EOPNOTSUPP; 696 } 697 698 static void dsa_slave_get_strings(struct net_device *dev, 699 uint32_t stringset, uint8_t *data) 700 { 701 struct dsa_port *dp = dsa_slave_to_port(dev); 702 struct dsa_switch *ds = dp->ds; 703 704 if (stringset == ETH_SS_STATS) { 705 int len = ETH_GSTRING_LEN; 706 707 strncpy(data, "tx_packets", len); 708 strncpy(data + len, "tx_bytes", len); 709 strncpy(data + 2 * len, "rx_packets", len); 710 strncpy(data + 3 * len, "rx_bytes", len); 711 if (ds->ops->get_strings) 712 ds->ops->get_strings(ds, dp->index, stringset, 713 data + 4 * len); 714 } else if (stringset == ETH_SS_TEST) { 715 net_selftest_get_strings(data); 716 } 717 718 } 719 720 static void dsa_slave_get_ethtool_stats(struct net_device *dev, 721 struct ethtool_stats *stats, 722 uint64_t *data) 723 { 724 struct dsa_port *dp = dsa_slave_to_port(dev); 725 struct dsa_switch *ds = dp->ds; 726 struct pcpu_sw_netstats *s; 727 unsigned int start; 728 int i; 729 730 for_each_possible_cpu(i) { 731 u64 tx_packets, tx_bytes, rx_packets, rx_bytes; 732 733 s = per_cpu_ptr(dev->tstats, i); 734 do { 735 start = u64_stats_fetch_begin_irq(&s->syncp); 736 tx_packets = s->tx_packets; 737 tx_bytes = s->tx_bytes; 738 rx_packets = s->rx_packets; 739 rx_bytes = s->rx_bytes; 740 } while (u64_stats_fetch_retry_irq(&s->syncp, start)); 741 data[0] += tx_packets; 742 data[1] += tx_bytes; 743 data[2] += rx_packets; 744 data[3] += rx_bytes; 745 } 746 if (ds->ops->get_ethtool_stats) 747 ds->ops->get_ethtool_stats(ds, dp->index, data + 4); 748 } 749 750 static int dsa_slave_get_sset_count(struct net_device *dev, int sset) 751 { 752 struct dsa_port *dp = dsa_slave_to_port(dev); 753 struct dsa_switch *ds = dp->ds; 754 755 if (sset == ETH_SS_STATS) { 756 int count = 0; 757 758 if (ds->ops->get_sset_count) { 759 count = ds->ops->get_sset_count(ds, dp->index, sset); 760 if (count < 0) 761 return count; 762 } 763 764 return count + 4; 765 } else if (sset == ETH_SS_TEST) { 766 return net_selftest_get_count(); 767 } 768 769 return -EOPNOTSUPP; 770 } 771 772 static void dsa_slave_get_eth_phy_stats(struct net_device *dev, 773 struct ethtool_eth_phy_stats *phy_stats) 774 { 775 struct dsa_port *dp = dsa_slave_to_port(dev); 776 struct dsa_switch *ds = dp->ds; 777 778 if (ds->ops->get_eth_phy_stats) 779 ds->ops->get_eth_phy_stats(ds, dp->index, phy_stats); 780 } 781 782 static void dsa_slave_get_eth_mac_stats(struct net_device *dev, 783 struct ethtool_eth_mac_stats *mac_stats) 784 { 785 struct dsa_port *dp = dsa_slave_to_port(dev); 786 struct dsa_switch *ds = dp->ds; 787 788 if (ds->ops->get_eth_mac_stats) 789 ds->ops->get_eth_mac_stats(ds, dp->index, mac_stats); 790 } 791 792 static void 793 dsa_slave_get_eth_ctrl_stats(struct net_device *dev, 794 struct ethtool_eth_ctrl_stats *ctrl_stats) 795 { 796 struct dsa_port *dp = dsa_slave_to_port(dev); 797 struct dsa_switch *ds = dp->ds; 798 799 if (ds->ops->get_eth_ctrl_stats) 800 ds->ops->get_eth_ctrl_stats(ds, dp->index, ctrl_stats); 801 } 802 803 static void dsa_slave_net_selftest(struct net_device *ndev, 804 struct ethtool_test *etest, u64 *buf) 805 { 806 struct dsa_port *dp = dsa_slave_to_port(ndev); 807 struct dsa_switch *ds = dp->ds; 808 809 if (ds->ops->self_test) { 810 ds->ops->self_test(ds, dp->index, etest, buf); 811 return; 812 } 813 814 net_selftest(ndev, etest, buf); 815 } 816 817 static void dsa_slave_get_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 822 phylink_ethtool_get_wol(dp->pl, w); 823 824 if (ds->ops->get_wol) 825 ds->ops->get_wol(ds, dp->index, w); 826 } 827 828 static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w) 829 { 830 struct dsa_port *dp = dsa_slave_to_port(dev); 831 struct dsa_switch *ds = dp->ds; 832 int ret = -EOPNOTSUPP; 833 834 phylink_ethtool_set_wol(dp->pl, w); 835 836 if (ds->ops->set_wol) 837 ret = ds->ops->set_wol(ds, dp->index, w); 838 839 return ret; 840 } 841 842 static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e) 843 { 844 struct dsa_port *dp = dsa_slave_to_port(dev); 845 struct dsa_switch *ds = dp->ds; 846 int ret; 847 848 /* Port's PHY and MAC both need to be EEE capable */ 849 if (!dev->phydev || !dp->pl) 850 return -ENODEV; 851 852 if (!ds->ops->set_mac_eee) 853 return -EOPNOTSUPP; 854 855 ret = ds->ops->set_mac_eee(ds, dp->index, e); 856 if (ret) 857 return ret; 858 859 return phylink_ethtool_set_eee(dp->pl, e); 860 } 861 862 static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e) 863 { 864 struct dsa_port *dp = dsa_slave_to_port(dev); 865 struct dsa_switch *ds = dp->ds; 866 int ret; 867 868 /* Port's PHY and MAC both need to be EEE capable */ 869 if (!dev->phydev || !dp->pl) 870 return -ENODEV; 871 872 if (!ds->ops->get_mac_eee) 873 return -EOPNOTSUPP; 874 875 ret = ds->ops->get_mac_eee(ds, dp->index, e); 876 if (ret) 877 return ret; 878 879 return phylink_ethtool_get_eee(dp->pl, e); 880 } 881 882 static int dsa_slave_get_link_ksettings(struct net_device *dev, 883 struct ethtool_link_ksettings *cmd) 884 { 885 struct dsa_port *dp = dsa_slave_to_port(dev); 886 887 return phylink_ethtool_ksettings_get(dp->pl, cmd); 888 } 889 890 static int dsa_slave_set_link_ksettings(struct net_device *dev, 891 const struct ethtool_link_ksettings *cmd) 892 { 893 struct dsa_port *dp = dsa_slave_to_port(dev); 894 895 return phylink_ethtool_ksettings_set(dp->pl, cmd); 896 } 897 898 static void dsa_slave_get_pauseparam(struct net_device *dev, 899 struct ethtool_pauseparam *pause) 900 { 901 struct dsa_port *dp = dsa_slave_to_port(dev); 902 903 phylink_ethtool_get_pauseparam(dp->pl, pause); 904 } 905 906 static int dsa_slave_set_pauseparam(struct net_device *dev, 907 struct ethtool_pauseparam *pause) 908 { 909 struct dsa_port *dp = dsa_slave_to_port(dev); 910 911 return phylink_ethtool_set_pauseparam(dp->pl, pause); 912 } 913 914 #ifdef CONFIG_NET_POLL_CONTROLLER 915 static int dsa_slave_netpoll_setup(struct net_device *dev, 916 struct netpoll_info *ni) 917 { 918 struct net_device *master = dsa_slave_to_master(dev); 919 struct dsa_slave_priv *p = netdev_priv(dev); 920 struct netpoll *netpoll; 921 int err = 0; 922 923 netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL); 924 if (!netpoll) 925 return -ENOMEM; 926 927 err = __netpoll_setup(netpoll, master); 928 if (err) { 929 kfree(netpoll); 930 goto out; 931 } 932 933 p->netpoll = netpoll; 934 out: 935 return err; 936 } 937 938 static void dsa_slave_netpoll_cleanup(struct net_device *dev) 939 { 940 struct dsa_slave_priv *p = netdev_priv(dev); 941 struct netpoll *netpoll = p->netpoll; 942 943 if (!netpoll) 944 return; 945 946 p->netpoll = NULL; 947 948 __netpoll_free(netpoll); 949 } 950 951 static void dsa_slave_poll_controller(struct net_device *dev) 952 { 953 } 954 #endif 955 956 static struct dsa_mall_tc_entry * 957 dsa_slave_mall_tc_entry_find(struct net_device *dev, unsigned long cookie) 958 { 959 struct dsa_slave_priv *p = netdev_priv(dev); 960 struct dsa_mall_tc_entry *mall_tc_entry; 961 962 list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list) 963 if (mall_tc_entry->cookie == cookie) 964 return mall_tc_entry; 965 966 return NULL; 967 } 968 969 static int 970 dsa_slave_add_cls_matchall_mirred(struct net_device *dev, 971 struct tc_cls_matchall_offload *cls, 972 bool ingress) 973 { 974 struct dsa_port *dp = dsa_slave_to_port(dev); 975 struct dsa_slave_priv *p = netdev_priv(dev); 976 struct dsa_mall_mirror_tc_entry *mirror; 977 struct dsa_mall_tc_entry *mall_tc_entry; 978 struct dsa_switch *ds = dp->ds; 979 struct flow_action_entry *act; 980 struct dsa_port *to_dp; 981 int err; 982 983 if (!ds->ops->port_mirror_add) 984 return -EOPNOTSUPP; 985 986 if (!flow_action_basic_hw_stats_check(&cls->rule->action, 987 cls->common.extack)) 988 return -EOPNOTSUPP; 989 990 act = &cls->rule->action.entries[0]; 991 992 if (!act->dev) 993 return -EINVAL; 994 995 if (!dsa_slave_dev_check(act->dev)) 996 return -EOPNOTSUPP; 997 998 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL); 999 if (!mall_tc_entry) 1000 return -ENOMEM; 1001 1002 mall_tc_entry->cookie = cls->cookie; 1003 mall_tc_entry->type = DSA_PORT_MALL_MIRROR; 1004 mirror = &mall_tc_entry->mirror; 1005 1006 to_dp = dsa_slave_to_port(act->dev); 1007 1008 mirror->to_local_port = to_dp->index; 1009 mirror->ingress = ingress; 1010 1011 err = ds->ops->port_mirror_add(ds, dp->index, mirror, ingress); 1012 if (err) { 1013 kfree(mall_tc_entry); 1014 return err; 1015 } 1016 1017 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list); 1018 1019 return err; 1020 } 1021 1022 static int 1023 dsa_slave_add_cls_matchall_police(struct net_device *dev, 1024 struct tc_cls_matchall_offload *cls, 1025 bool ingress) 1026 { 1027 struct netlink_ext_ack *extack = cls->common.extack; 1028 struct dsa_port *dp = dsa_slave_to_port(dev); 1029 struct dsa_slave_priv *p = netdev_priv(dev); 1030 struct dsa_mall_policer_tc_entry *policer; 1031 struct dsa_mall_tc_entry *mall_tc_entry; 1032 struct dsa_switch *ds = dp->ds; 1033 struct flow_action_entry *act; 1034 int err; 1035 1036 if (!ds->ops->port_policer_add) { 1037 NL_SET_ERR_MSG_MOD(extack, 1038 "Policing offload not implemented"); 1039 return -EOPNOTSUPP; 1040 } 1041 1042 if (!ingress) { 1043 NL_SET_ERR_MSG_MOD(extack, 1044 "Only supported on ingress qdisc"); 1045 return -EOPNOTSUPP; 1046 } 1047 1048 if (!flow_action_basic_hw_stats_check(&cls->rule->action, 1049 cls->common.extack)) 1050 return -EOPNOTSUPP; 1051 1052 list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list) { 1053 if (mall_tc_entry->type == DSA_PORT_MALL_POLICER) { 1054 NL_SET_ERR_MSG_MOD(extack, 1055 "Only one port policer allowed"); 1056 return -EEXIST; 1057 } 1058 } 1059 1060 act = &cls->rule->action.entries[0]; 1061 1062 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL); 1063 if (!mall_tc_entry) 1064 return -ENOMEM; 1065 1066 mall_tc_entry->cookie = cls->cookie; 1067 mall_tc_entry->type = DSA_PORT_MALL_POLICER; 1068 policer = &mall_tc_entry->policer; 1069 policer->rate_bytes_per_sec = act->police.rate_bytes_ps; 1070 policer->burst = act->police.burst; 1071 1072 err = ds->ops->port_policer_add(ds, dp->index, policer); 1073 if (err) { 1074 kfree(mall_tc_entry); 1075 return err; 1076 } 1077 1078 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list); 1079 1080 return err; 1081 } 1082 1083 static int dsa_slave_add_cls_matchall(struct net_device *dev, 1084 struct tc_cls_matchall_offload *cls, 1085 bool ingress) 1086 { 1087 int err = -EOPNOTSUPP; 1088 1089 if (cls->common.protocol == htons(ETH_P_ALL) && 1090 flow_offload_has_one_action(&cls->rule->action) && 1091 cls->rule->action.entries[0].id == FLOW_ACTION_MIRRED) 1092 err = dsa_slave_add_cls_matchall_mirred(dev, cls, ingress); 1093 else if (flow_offload_has_one_action(&cls->rule->action) && 1094 cls->rule->action.entries[0].id == FLOW_ACTION_POLICE) 1095 err = dsa_slave_add_cls_matchall_police(dev, cls, ingress); 1096 1097 return err; 1098 } 1099 1100 static void dsa_slave_del_cls_matchall(struct net_device *dev, 1101 struct tc_cls_matchall_offload *cls) 1102 { 1103 struct dsa_port *dp = dsa_slave_to_port(dev); 1104 struct dsa_mall_tc_entry *mall_tc_entry; 1105 struct dsa_switch *ds = dp->ds; 1106 1107 mall_tc_entry = dsa_slave_mall_tc_entry_find(dev, cls->cookie); 1108 if (!mall_tc_entry) 1109 return; 1110 1111 list_del(&mall_tc_entry->list); 1112 1113 switch (mall_tc_entry->type) { 1114 case DSA_PORT_MALL_MIRROR: 1115 if (ds->ops->port_mirror_del) 1116 ds->ops->port_mirror_del(ds, dp->index, 1117 &mall_tc_entry->mirror); 1118 break; 1119 case DSA_PORT_MALL_POLICER: 1120 if (ds->ops->port_policer_del) 1121 ds->ops->port_policer_del(ds, dp->index); 1122 break; 1123 default: 1124 WARN_ON(1); 1125 } 1126 1127 kfree(mall_tc_entry); 1128 } 1129 1130 static int dsa_slave_setup_tc_cls_matchall(struct net_device *dev, 1131 struct tc_cls_matchall_offload *cls, 1132 bool ingress) 1133 { 1134 if (cls->common.chain_index) 1135 return -EOPNOTSUPP; 1136 1137 switch (cls->command) { 1138 case TC_CLSMATCHALL_REPLACE: 1139 return dsa_slave_add_cls_matchall(dev, cls, ingress); 1140 case TC_CLSMATCHALL_DESTROY: 1141 dsa_slave_del_cls_matchall(dev, cls); 1142 return 0; 1143 default: 1144 return -EOPNOTSUPP; 1145 } 1146 } 1147 1148 static int dsa_slave_add_cls_flower(struct net_device *dev, 1149 struct flow_cls_offload *cls, 1150 bool ingress) 1151 { 1152 struct dsa_port *dp = dsa_slave_to_port(dev); 1153 struct dsa_switch *ds = dp->ds; 1154 int port = dp->index; 1155 1156 if (!ds->ops->cls_flower_add) 1157 return -EOPNOTSUPP; 1158 1159 return ds->ops->cls_flower_add(ds, port, cls, ingress); 1160 } 1161 1162 static int dsa_slave_del_cls_flower(struct net_device *dev, 1163 struct flow_cls_offload *cls, 1164 bool ingress) 1165 { 1166 struct dsa_port *dp = dsa_slave_to_port(dev); 1167 struct dsa_switch *ds = dp->ds; 1168 int port = dp->index; 1169 1170 if (!ds->ops->cls_flower_del) 1171 return -EOPNOTSUPP; 1172 1173 return ds->ops->cls_flower_del(ds, port, cls, ingress); 1174 } 1175 1176 static int dsa_slave_stats_cls_flower(struct net_device *dev, 1177 struct flow_cls_offload *cls, 1178 bool ingress) 1179 { 1180 struct dsa_port *dp = dsa_slave_to_port(dev); 1181 struct dsa_switch *ds = dp->ds; 1182 int port = dp->index; 1183 1184 if (!ds->ops->cls_flower_stats) 1185 return -EOPNOTSUPP; 1186 1187 return ds->ops->cls_flower_stats(ds, port, cls, ingress); 1188 } 1189 1190 static int dsa_slave_setup_tc_cls_flower(struct net_device *dev, 1191 struct flow_cls_offload *cls, 1192 bool ingress) 1193 { 1194 switch (cls->command) { 1195 case FLOW_CLS_REPLACE: 1196 return dsa_slave_add_cls_flower(dev, cls, ingress); 1197 case FLOW_CLS_DESTROY: 1198 return dsa_slave_del_cls_flower(dev, cls, ingress); 1199 case FLOW_CLS_STATS: 1200 return dsa_slave_stats_cls_flower(dev, cls, ingress); 1201 default: 1202 return -EOPNOTSUPP; 1203 } 1204 } 1205 1206 static int dsa_slave_setup_tc_block_cb(enum tc_setup_type type, void *type_data, 1207 void *cb_priv, bool ingress) 1208 { 1209 struct net_device *dev = cb_priv; 1210 1211 if (!tc_can_offload(dev)) 1212 return -EOPNOTSUPP; 1213 1214 switch (type) { 1215 case TC_SETUP_CLSMATCHALL: 1216 return dsa_slave_setup_tc_cls_matchall(dev, type_data, ingress); 1217 case TC_SETUP_CLSFLOWER: 1218 return dsa_slave_setup_tc_cls_flower(dev, type_data, ingress); 1219 default: 1220 return -EOPNOTSUPP; 1221 } 1222 } 1223 1224 static int dsa_slave_setup_tc_block_cb_ig(enum tc_setup_type type, 1225 void *type_data, void *cb_priv) 1226 { 1227 return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, true); 1228 } 1229 1230 static int dsa_slave_setup_tc_block_cb_eg(enum tc_setup_type type, 1231 void *type_data, void *cb_priv) 1232 { 1233 return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, false); 1234 } 1235 1236 static LIST_HEAD(dsa_slave_block_cb_list); 1237 1238 static int dsa_slave_setup_tc_block(struct net_device *dev, 1239 struct flow_block_offload *f) 1240 { 1241 struct flow_block_cb *block_cb; 1242 flow_setup_cb_t *cb; 1243 1244 if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS) 1245 cb = dsa_slave_setup_tc_block_cb_ig; 1246 else if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS) 1247 cb = dsa_slave_setup_tc_block_cb_eg; 1248 else 1249 return -EOPNOTSUPP; 1250 1251 f->driver_block_list = &dsa_slave_block_cb_list; 1252 1253 switch (f->command) { 1254 case FLOW_BLOCK_BIND: 1255 if (flow_block_cb_is_busy(cb, dev, &dsa_slave_block_cb_list)) 1256 return -EBUSY; 1257 1258 block_cb = flow_block_cb_alloc(cb, dev, dev, NULL); 1259 if (IS_ERR(block_cb)) 1260 return PTR_ERR(block_cb); 1261 1262 flow_block_cb_add(block_cb, f); 1263 list_add_tail(&block_cb->driver_list, &dsa_slave_block_cb_list); 1264 return 0; 1265 case FLOW_BLOCK_UNBIND: 1266 block_cb = flow_block_cb_lookup(f->block, cb, dev); 1267 if (!block_cb) 1268 return -ENOENT; 1269 1270 flow_block_cb_remove(block_cb, f); 1271 list_del(&block_cb->driver_list); 1272 return 0; 1273 default: 1274 return -EOPNOTSUPP; 1275 } 1276 } 1277 1278 static int dsa_slave_setup_ft_block(struct dsa_switch *ds, int port, 1279 void *type_data) 1280 { 1281 struct dsa_port *cpu_dp = dsa_to_port(ds, port)->cpu_dp; 1282 struct net_device *master = cpu_dp->master; 1283 1284 if (!master->netdev_ops->ndo_setup_tc) 1285 return -EOPNOTSUPP; 1286 1287 return master->netdev_ops->ndo_setup_tc(master, TC_SETUP_FT, type_data); 1288 } 1289 1290 static int dsa_slave_setup_tc(struct net_device *dev, enum tc_setup_type type, 1291 void *type_data) 1292 { 1293 struct dsa_port *dp = dsa_slave_to_port(dev); 1294 struct dsa_switch *ds = dp->ds; 1295 1296 switch (type) { 1297 case TC_SETUP_BLOCK: 1298 return dsa_slave_setup_tc_block(dev, type_data); 1299 case TC_SETUP_FT: 1300 return dsa_slave_setup_ft_block(ds, dp->index, type_data); 1301 default: 1302 break; 1303 } 1304 1305 if (!ds->ops->port_setup_tc) 1306 return -EOPNOTSUPP; 1307 1308 return ds->ops->port_setup_tc(ds, dp->index, type, type_data); 1309 } 1310 1311 static int dsa_slave_get_rxnfc(struct net_device *dev, 1312 struct ethtool_rxnfc *nfc, u32 *rule_locs) 1313 { 1314 struct dsa_port *dp = dsa_slave_to_port(dev); 1315 struct dsa_switch *ds = dp->ds; 1316 1317 if (!ds->ops->get_rxnfc) 1318 return -EOPNOTSUPP; 1319 1320 return ds->ops->get_rxnfc(ds, dp->index, nfc, rule_locs); 1321 } 1322 1323 static int dsa_slave_set_rxnfc(struct net_device *dev, 1324 struct ethtool_rxnfc *nfc) 1325 { 1326 struct dsa_port *dp = dsa_slave_to_port(dev); 1327 struct dsa_switch *ds = dp->ds; 1328 1329 if (!ds->ops->set_rxnfc) 1330 return -EOPNOTSUPP; 1331 1332 return ds->ops->set_rxnfc(ds, dp->index, nfc); 1333 } 1334 1335 static int dsa_slave_get_ts_info(struct net_device *dev, 1336 struct ethtool_ts_info *ts) 1337 { 1338 struct dsa_slave_priv *p = netdev_priv(dev); 1339 struct dsa_switch *ds = p->dp->ds; 1340 1341 if (!ds->ops->get_ts_info) 1342 return -EOPNOTSUPP; 1343 1344 return ds->ops->get_ts_info(ds, p->dp->index, ts); 1345 } 1346 1347 static int dsa_slave_vlan_rx_add_vid(struct net_device *dev, __be16 proto, 1348 u16 vid) 1349 { 1350 struct net_device *master = dsa_slave_to_master(dev); 1351 struct dsa_port *dp = dsa_slave_to_port(dev); 1352 struct switchdev_obj_port_vlan vlan = { 1353 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN, 1354 .vid = vid, 1355 /* This API only allows programming tagged, non-PVID VIDs */ 1356 .flags = 0, 1357 }; 1358 struct netlink_ext_ack extack = {0}; 1359 int ret; 1360 1361 /* User port... */ 1362 ret = dsa_port_vlan_add(dp, &vlan, &extack); 1363 if (ret) { 1364 if (extack._msg) 1365 netdev_err(dev, "%s\n", extack._msg); 1366 return ret; 1367 } 1368 1369 /* And CPU port... */ 1370 ret = dsa_port_vlan_add(dp->cpu_dp, &vlan, &extack); 1371 if (ret) { 1372 if (extack._msg) 1373 netdev_err(dev, "CPU port %d: %s\n", dp->cpu_dp->index, 1374 extack._msg); 1375 return ret; 1376 } 1377 1378 return vlan_vid_add(master, proto, vid); 1379 } 1380 1381 static int dsa_slave_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, 1382 u16 vid) 1383 { 1384 struct net_device *master = dsa_slave_to_master(dev); 1385 struct dsa_port *dp = dsa_slave_to_port(dev); 1386 struct switchdev_obj_port_vlan vlan = { 1387 .vid = vid, 1388 /* This API only allows programming tagged, non-PVID VIDs */ 1389 .flags = 0, 1390 }; 1391 int err; 1392 1393 /* Do not deprogram the CPU port as it may be shared with other user 1394 * ports which can be members of this VLAN as well. 1395 */ 1396 err = dsa_port_vlan_del(dp, &vlan); 1397 if (err) 1398 return err; 1399 1400 vlan_vid_del(master, proto, vid); 1401 1402 return 0; 1403 } 1404 1405 static int dsa_slave_restore_vlan(struct net_device *vdev, int vid, void *arg) 1406 { 1407 __be16 proto = vdev ? vlan_dev_vlan_proto(vdev) : htons(ETH_P_8021Q); 1408 1409 return dsa_slave_vlan_rx_add_vid(arg, proto, vid); 1410 } 1411 1412 static int dsa_slave_clear_vlan(struct net_device *vdev, int vid, void *arg) 1413 { 1414 __be16 proto = vdev ? vlan_dev_vlan_proto(vdev) : htons(ETH_P_8021Q); 1415 1416 return dsa_slave_vlan_rx_kill_vid(arg, proto, vid); 1417 } 1418 1419 /* Keep the VLAN RX filtering list in sync with the hardware only if VLAN 1420 * filtering is enabled. The baseline is that only ports that offload a 1421 * VLAN-aware bridge are VLAN-aware, and standalone ports are VLAN-unaware, 1422 * but there are exceptions for quirky hardware. 1423 * 1424 * If ds->vlan_filtering_is_global = true, then standalone ports which share 1425 * the same switch with other ports that offload a VLAN-aware bridge are also 1426 * inevitably VLAN-aware. 1427 * 1428 * To summarize, a DSA switch port offloads: 1429 * 1430 * - If standalone (this includes software bridge, software LAG): 1431 * - if ds->needs_standalone_vlan_filtering = true, OR if 1432 * (ds->vlan_filtering_is_global = true AND there are bridges spanning 1433 * this switch chip which have vlan_filtering=1) 1434 * - the 8021q upper VLANs 1435 * - else (standalone VLAN filtering is not needed, VLAN filtering is not 1436 * global, or it is, but no port is under a VLAN-aware bridge): 1437 * - no VLAN (any 8021q upper is a software VLAN) 1438 * 1439 * - If under a vlan_filtering=0 bridge which it offload: 1440 * - if ds->configure_vlan_while_not_filtering = true (default): 1441 * - the bridge VLANs. These VLANs are committed to hardware but inactive. 1442 * - else (deprecated): 1443 * - no VLAN. The bridge VLANs are not restored when VLAN awareness is 1444 * enabled, so this behavior is broken and discouraged. 1445 * 1446 * - If under a vlan_filtering=1 bridge which it offload: 1447 * - the bridge VLANs 1448 * - the 8021q upper VLANs 1449 */ 1450 int dsa_slave_manage_vlan_filtering(struct net_device *slave, 1451 bool vlan_filtering) 1452 { 1453 int err; 1454 1455 if (vlan_filtering) { 1456 slave->features |= NETIF_F_HW_VLAN_CTAG_FILTER; 1457 1458 err = vlan_for_each(slave, dsa_slave_restore_vlan, slave); 1459 if (err) { 1460 vlan_for_each(slave, dsa_slave_clear_vlan, slave); 1461 slave->features &= ~NETIF_F_HW_VLAN_CTAG_FILTER; 1462 return err; 1463 } 1464 } else { 1465 err = vlan_for_each(slave, dsa_slave_clear_vlan, slave); 1466 if (err) 1467 return err; 1468 1469 slave->features &= ~NETIF_F_HW_VLAN_CTAG_FILTER; 1470 } 1471 1472 return 0; 1473 } 1474 1475 struct dsa_hw_port { 1476 struct list_head list; 1477 struct net_device *dev; 1478 int old_mtu; 1479 }; 1480 1481 static int dsa_hw_port_list_set_mtu(struct list_head *hw_port_list, int mtu) 1482 { 1483 const struct dsa_hw_port *p; 1484 int err; 1485 1486 list_for_each_entry(p, hw_port_list, list) { 1487 if (p->dev->mtu == mtu) 1488 continue; 1489 1490 err = dev_set_mtu(p->dev, mtu); 1491 if (err) 1492 goto rollback; 1493 } 1494 1495 return 0; 1496 1497 rollback: 1498 list_for_each_entry_continue_reverse(p, hw_port_list, list) { 1499 if (p->dev->mtu == p->old_mtu) 1500 continue; 1501 1502 if (dev_set_mtu(p->dev, p->old_mtu)) 1503 netdev_err(p->dev, "Failed to restore MTU\n"); 1504 } 1505 1506 return err; 1507 } 1508 1509 static void dsa_hw_port_list_free(struct list_head *hw_port_list) 1510 { 1511 struct dsa_hw_port *p, *n; 1512 1513 list_for_each_entry_safe(p, n, hw_port_list, list) 1514 kfree(p); 1515 } 1516 1517 /* Make the hardware datapath to/from @dev limited to a common MTU */ 1518 static void dsa_bridge_mtu_normalization(struct dsa_port *dp) 1519 { 1520 struct list_head hw_port_list; 1521 struct dsa_switch_tree *dst; 1522 int min_mtu = ETH_MAX_MTU; 1523 struct dsa_port *other_dp; 1524 int err; 1525 1526 if (!dp->ds->mtu_enforcement_ingress) 1527 return; 1528 1529 if (!dp->bridge) 1530 return; 1531 1532 INIT_LIST_HEAD(&hw_port_list); 1533 1534 /* Populate the list of ports that are part of the same bridge 1535 * as the newly added/modified port 1536 */ 1537 list_for_each_entry(dst, &dsa_tree_list, list) { 1538 list_for_each_entry(other_dp, &dst->ports, list) { 1539 struct dsa_hw_port *hw_port; 1540 struct net_device *slave; 1541 1542 if (other_dp->type != DSA_PORT_TYPE_USER) 1543 continue; 1544 1545 if (!dsa_port_bridge_same(dp, other_dp)) 1546 continue; 1547 1548 if (!other_dp->ds->mtu_enforcement_ingress) 1549 continue; 1550 1551 slave = other_dp->slave; 1552 1553 if (min_mtu > slave->mtu) 1554 min_mtu = slave->mtu; 1555 1556 hw_port = kzalloc(sizeof(*hw_port), GFP_KERNEL); 1557 if (!hw_port) 1558 goto out; 1559 1560 hw_port->dev = slave; 1561 hw_port->old_mtu = slave->mtu; 1562 1563 list_add(&hw_port->list, &hw_port_list); 1564 } 1565 } 1566 1567 /* Attempt to configure the entire hardware bridge to the newly added 1568 * interface's MTU first, regardless of whether the intention of the 1569 * user was to raise or lower it. 1570 */ 1571 err = dsa_hw_port_list_set_mtu(&hw_port_list, dp->slave->mtu); 1572 if (!err) 1573 goto out; 1574 1575 /* Clearly that didn't work out so well, so just set the minimum MTU on 1576 * all hardware bridge ports now. If this fails too, then all ports will 1577 * still have their old MTU rolled back anyway. 1578 */ 1579 dsa_hw_port_list_set_mtu(&hw_port_list, min_mtu); 1580 1581 out: 1582 dsa_hw_port_list_free(&hw_port_list); 1583 } 1584 1585 int dsa_slave_change_mtu(struct net_device *dev, int new_mtu) 1586 { 1587 struct net_device *master = dsa_slave_to_master(dev); 1588 struct dsa_port *dp = dsa_slave_to_port(dev); 1589 struct dsa_slave_priv *p = netdev_priv(dev); 1590 struct dsa_switch *ds = p->dp->ds; 1591 struct dsa_port *dp_iter; 1592 struct dsa_port *cpu_dp; 1593 int port = p->dp->index; 1594 int largest_mtu = 0; 1595 int new_master_mtu; 1596 int old_master_mtu; 1597 int mtu_limit; 1598 int cpu_mtu; 1599 int err; 1600 1601 if (!ds->ops->port_change_mtu) 1602 return -EOPNOTSUPP; 1603 1604 list_for_each_entry(dp_iter, &ds->dst->ports, list) { 1605 int slave_mtu; 1606 1607 if (!dsa_port_is_user(dp_iter)) 1608 continue; 1609 1610 /* During probe, this function will be called for each slave 1611 * device, while not all of them have been allocated. That's 1612 * ok, it doesn't change what the maximum is, so ignore it. 1613 */ 1614 if (!dp_iter->slave) 1615 continue; 1616 1617 /* Pretend that we already applied the setting, which we 1618 * actually haven't (still haven't done all integrity checks) 1619 */ 1620 if (dp_iter == dp) 1621 slave_mtu = new_mtu; 1622 else 1623 slave_mtu = dp_iter->slave->mtu; 1624 1625 if (largest_mtu < slave_mtu) 1626 largest_mtu = slave_mtu; 1627 } 1628 1629 cpu_dp = dsa_to_port(ds, port)->cpu_dp; 1630 1631 mtu_limit = min_t(int, master->max_mtu, dev->max_mtu); 1632 old_master_mtu = master->mtu; 1633 new_master_mtu = largest_mtu + dsa_tag_protocol_overhead(cpu_dp->tag_ops); 1634 if (new_master_mtu > mtu_limit) 1635 return -ERANGE; 1636 1637 /* If the master MTU isn't over limit, there's no need to check the CPU 1638 * MTU, since that surely isn't either. 1639 */ 1640 cpu_mtu = largest_mtu; 1641 1642 /* Start applying stuff */ 1643 if (new_master_mtu != old_master_mtu) { 1644 err = dev_set_mtu(master, new_master_mtu); 1645 if (err < 0) 1646 goto out_master_failed; 1647 1648 /* We only need to propagate the MTU of the CPU port to 1649 * upstream switches, so create a non-targeted notifier which 1650 * updates all switches. 1651 */ 1652 err = dsa_port_mtu_change(cpu_dp, cpu_mtu, false); 1653 if (err) 1654 goto out_cpu_failed; 1655 } 1656 1657 err = dsa_port_mtu_change(dp, new_mtu, true); 1658 if (err) 1659 goto out_port_failed; 1660 1661 dev->mtu = new_mtu; 1662 1663 dsa_bridge_mtu_normalization(dp); 1664 1665 return 0; 1666 1667 out_port_failed: 1668 if (new_master_mtu != old_master_mtu) 1669 dsa_port_mtu_change(cpu_dp, old_master_mtu - 1670 dsa_tag_protocol_overhead(cpu_dp->tag_ops), 1671 false); 1672 out_cpu_failed: 1673 if (new_master_mtu != old_master_mtu) 1674 dev_set_mtu(master, old_master_mtu); 1675 out_master_failed: 1676 return err; 1677 } 1678 1679 static const struct ethtool_ops dsa_slave_ethtool_ops = { 1680 .get_drvinfo = dsa_slave_get_drvinfo, 1681 .get_regs_len = dsa_slave_get_regs_len, 1682 .get_regs = dsa_slave_get_regs, 1683 .nway_reset = dsa_slave_nway_reset, 1684 .get_link = ethtool_op_get_link, 1685 .get_eeprom_len = dsa_slave_get_eeprom_len, 1686 .get_eeprom = dsa_slave_get_eeprom, 1687 .set_eeprom = dsa_slave_set_eeprom, 1688 .get_strings = dsa_slave_get_strings, 1689 .get_ethtool_stats = dsa_slave_get_ethtool_stats, 1690 .get_sset_count = dsa_slave_get_sset_count, 1691 .get_eth_phy_stats = dsa_slave_get_eth_phy_stats, 1692 .get_eth_mac_stats = dsa_slave_get_eth_mac_stats, 1693 .get_eth_ctrl_stats = dsa_slave_get_eth_ctrl_stats, 1694 .set_wol = dsa_slave_set_wol, 1695 .get_wol = dsa_slave_get_wol, 1696 .set_eee = dsa_slave_set_eee, 1697 .get_eee = dsa_slave_get_eee, 1698 .get_link_ksettings = dsa_slave_get_link_ksettings, 1699 .set_link_ksettings = dsa_slave_set_link_ksettings, 1700 .get_pauseparam = dsa_slave_get_pauseparam, 1701 .set_pauseparam = dsa_slave_set_pauseparam, 1702 .get_rxnfc = dsa_slave_get_rxnfc, 1703 .set_rxnfc = dsa_slave_set_rxnfc, 1704 .get_ts_info = dsa_slave_get_ts_info, 1705 .self_test = dsa_slave_net_selftest, 1706 }; 1707 1708 static struct devlink_port *dsa_slave_get_devlink_port(struct net_device *dev) 1709 { 1710 struct dsa_port *dp = dsa_slave_to_port(dev); 1711 1712 return &dp->devlink_port; 1713 } 1714 1715 static void dsa_slave_get_stats64(struct net_device *dev, 1716 struct rtnl_link_stats64 *s) 1717 { 1718 struct dsa_port *dp = dsa_slave_to_port(dev); 1719 struct dsa_switch *ds = dp->ds; 1720 1721 if (ds->ops->get_stats64) 1722 ds->ops->get_stats64(ds, dp->index, s); 1723 else 1724 dev_get_tstats64(dev, s); 1725 } 1726 1727 static int dsa_slave_fill_forward_path(struct net_device_path_ctx *ctx, 1728 struct net_device_path *path) 1729 { 1730 struct dsa_port *dp = dsa_slave_to_port(ctx->dev); 1731 struct dsa_port *cpu_dp = dp->cpu_dp; 1732 1733 path->dev = ctx->dev; 1734 path->type = DEV_PATH_DSA; 1735 path->dsa.proto = cpu_dp->tag_ops->proto; 1736 path->dsa.port = dp->index; 1737 ctx->dev = cpu_dp->master; 1738 1739 return 0; 1740 } 1741 1742 static const struct net_device_ops dsa_slave_netdev_ops = { 1743 .ndo_open = dsa_slave_open, 1744 .ndo_stop = dsa_slave_close, 1745 .ndo_start_xmit = dsa_slave_xmit, 1746 .ndo_change_rx_flags = dsa_slave_change_rx_flags, 1747 .ndo_set_rx_mode = dsa_slave_set_rx_mode, 1748 .ndo_set_mac_address = dsa_slave_set_mac_address, 1749 .ndo_fdb_dump = dsa_slave_fdb_dump, 1750 .ndo_eth_ioctl = dsa_slave_ioctl, 1751 .ndo_get_iflink = dsa_slave_get_iflink, 1752 #ifdef CONFIG_NET_POLL_CONTROLLER 1753 .ndo_netpoll_setup = dsa_slave_netpoll_setup, 1754 .ndo_netpoll_cleanup = dsa_slave_netpoll_cleanup, 1755 .ndo_poll_controller = dsa_slave_poll_controller, 1756 #endif 1757 .ndo_setup_tc = dsa_slave_setup_tc, 1758 .ndo_get_stats64 = dsa_slave_get_stats64, 1759 .ndo_vlan_rx_add_vid = dsa_slave_vlan_rx_add_vid, 1760 .ndo_vlan_rx_kill_vid = dsa_slave_vlan_rx_kill_vid, 1761 .ndo_get_devlink_port = dsa_slave_get_devlink_port, 1762 .ndo_change_mtu = dsa_slave_change_mtu, 1763 .ndo_fill_forward_path = dsa_slave_fill_forward_path, 1764 }; 1765 1766 static struct device_type dsa_type = { 1767 .name = "dsa", 1768 }; 1769 1770 void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up) 1771 { 1772 const struct dsa_port *dp = dsa_to_port(ds, port); 1773 1774 if (dp->pl) 1775 phylink_mac_change(dp->pl, up); 1776 } 1777 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_change); 1778 1779 static void dsa_slave_phylink_fixed_state(struct phylink_config *config, 1780 struct phylink_link_state *state) 1781 { 1782 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 1783 struct dsa_switch *ds = dp->ds; 1784 1785 /* No need to check that this operation is valid, the callback would 1786 * not be called if it was not. 1787 */ 1788 ds->ops->phylink_fixed_state(ds, dp->index, state); 1789 } 1790 1791 /* slave device setup *******************************************************/ 1792 static int dsa_slave_phy_connect(struct net_device *slave_dev, int addr, 1793 u32 flags) 1794 { 1795 struct dsa_port *dp = dsa_slave_to_port(slave_dev); 1796 struct dsa_switch *ds = dp->ds; 1797 1798 slave_dev->phydev = mdiobus_get_phy(ds->slave_mii_bus, addr); 1799 if (!slave_dev->phydev) { 1800 netdev_err(slave_dev, "no phy at %d\n", addr); 1801 return -ENODEV; 1802 } 1803 1804 slave_dev->phydev->dev_flags |= flags; 1805 1806 return phylink_connect_phy(dp->pl, slave_dev->phydev); 1807 } 1808 1809 static int dsa_slave_phy_setup(struct net_device *slave_dev) 1810 { 1811 struct dsa_port *dp = dsa_slave_to_port(slave_dev); 1812 struct device_node *port_dn = dp->dn; 1813 struct dsa_switch *ds = dp->ds; 1814 u32 phy_flags = 0; 1815 int ret; 1816 1817 dp->pl_config.dev = &slave_dev->dev; 1818 dp->pl_config.type = PHYLINK_NETDEV; 1819 1820 /* The get_fixed_state callback takes precedence over polling the 1821 * link GPIO in PHYLINK (see phylink_get_fixed_state). Only set 1822 * this if the switch provides such a callback. 1823 */ 1824 if (ds->ops->phylink_fixed_state) { 1825 dp->pl_config.get_fixed_state = dsa_slave_phylink_fixed_state; 1826 dp->pl_config.poll_fixed_state = true; 1827 } 1828 1829 ret = dsa_port_phylink_create(dp); 1830 if (ret) 1831 return ret; 1832 1833 if (ds->ops->get_phy_flags) 1834 phy_flags = ds->ops->get_phy_flags(ds, dp->index); 1835 1836 ret = phylink_of_phy_connect(dp->pl, port_dn, phy_flags); 1837 if (ret == -ENODEV && ds->slave_mii_bus) { 1838 /* We could not connect to a designated PHY or SFP, so try to 1839 * use the switch internal MDIO bus instead 1840 */ 1841 ret = dsa_slave_phy_connect(slave_dev, dp->index, phy_flags); 1842 } 1843 if (ret) { 1844 netdev_err(slave_dev, "failed to connect to PHY: %pe\n", 1845 ERR_PTR(ret)); 1846 phylink_destroy(dp->pl); 1847 } 1848 1849 return ret; 1850 } 1851 1852 void dsa_slave_setup_tagger(struct net_device *slave) 1853 { 1854 struct dsa_port *dp = dsa_slave_to_port(slave); 1855 struct dsa_slave_priv *p = netdev_priv(slave); 1856 const struct dsa_port *cpu_dp = dp->cpu_dp; 1857 struct net_device *master = cpu_dp->master; 1858 const struct dsa_switch *ds = dp->ds; 1859 1860 slave->needed_headroom = cpu_dp->tag_ops->needed_headroom; 1861 slave->needed_tailroom = cpu_dp->tag_ops->needed_tailroom; 1862 /* Try to save one extra realloc later in the TX path (in the master) 1863 * by also inheriting the master's needed headroom and tailroom. 1864 * The 8021q driver also does this. 1865 */ 1866 slave->needed_headroom += master->needed_headroom; 1867 slave->needed_tailroom += master->needed_tailroom; 1868 1869 p->xmit = cpu_dp->tag_ops->xmit; 1870 1871 slave->features = master->vlan_features | NETIF_F_HW_TC; 1872 slave->hw_features |= NETIF_F_HW_TC; 1873 slave->features |= NETIF_F_LLTX; 1874 if (slave->needed_tailroom) 1875 slave->features &= ~(NETIF_F_SG | NETIF_F_FRAGLIST); 1876 if (ds->needs_standalone_vlan_filtering) 1877 slave->features |= NETIF_F_HW_VLAN_CTAG_FILTER; 1878 } 1879 1880 int dsa_slave_suspend(struct net_device *slave_dev) 1881 { 1882 struct dsa_port *dp = dsa_slave_to_port(slave_dev); 1883 1884 if (!netif_running(slave_dev)) 1885 return 0; 1886 1887 netif_device_detach(slave_dev); 1888 1889 rtnl_lock(); 1890 phylink_stop(dp->pl); 1891 rtnl_unlock(); 1892 1893 return 0; 1894 } 1895 1896 int dsa_slave_resume(struct net_device *slave_dev) 1897 { 1898 struct dsa_port *dp = dsa_slave_to_port(slave_dev); 1899 1900 if (!netif_running(slave_dev)) 1901 return 0; 1902 1903 netif_device_attach(slave_dev); 1904 1905 rtnl_lock(); 1906 phylink_start(dp->pl); 1907 rtnl_unlock(); 1908 1909 return 0; 1910 } 1911 1912 int dsa_slave_create(struct dsa_port *port) 1913 { 1914 const struct dsa_port *cpu_dp = port->cpu_dp; 1915 struct net_device *master = cpu_dp->master; 1916 struct dsa_switch *ds = port->ds; 1917 const char *name = port->name; 1918 struct net_device *slave_dev; 1919 struct dsa_slave_priv *p; 1920 int ret; 1921 1922 if (!ds->num_tx_queues) 1923 ds->num_tx_queues = 1; 1924 1925 slave_dev = alloc_netdev_mqs(sizeof(struct dsa_slave_priv), name, 1926 NET_NAME_UNKNOWN, ether_setup, 1927 ds->num_tx_queues, 1); 1928 if (slave_dev == NULL) 1929 return -ENOMEM; 1930 1931 slave_dev->ethtool_ops = &dsa_slave_ethtool_ops; 1932 if (!is_zero_ether_addr(port->mac)) 1933 eth_hw_addr_set(slave_dev, port->mac); 1934 else 1935 eth_hw_addr_inherit(slave_dev, master); 1936 slave_dev->priv_flags |= IFF_NO_QUEUE; 1937 slave_dev->netdev_ops = &dsa_slave_netdev_ops; 1938 if (ds->ops->port_max_mtu) 1939 slave_dev->max_mtu = ds->ops->port_max_mtu(ds, port->index); 1940 SET_NETDEV_DEVTYPE(slave_dev, &dsa_type); 1941 1942 SET_NETDEV_DEV(slave_dev, port->ds->dev); 1943 slave_dev->dev.of_node = port->dn; 1944 slave_dev->vlan_features = master->vlan_features; 1945 1946 p = netdev_priv(slave_dev); 1947 slave_dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats); 1948 if (!slave_dev->tstats) { 1949 free_netdev(slave_dev); 1950 return -ENOMEM; 1951 } 1952 1953 ret = gro_cells_init(&p->gcells, slave_dev); 1954 if (ret) 1955 goto out_free; 1956 1957 p->dp = port; 1958 INIT_LIST_HEAD(&p->mall_tc_list); 1959 port->slave = slave_dev; 1960 dsa_slave_setup_tagger(slave_dev); 1961 1962 netif_carrier_off(slave_dev); 1963 1964 ret = dsa_slave_phy_setup(slave_dev); 1965 if (ret) { 1966 netdev_err(slave_dev, 1967 "error %d setting up PHY for tree %d, switch %d, port %d\n", 1968 ret, ds->dst->index, ds->index, port->index); 1969 goto out_gcells; 1970 } 1971 1972 rtnl_lock(); 1973 1974 ret = dsa_slave_change_mtu(slave_dev, ETH_DATA_LEN); 1975 if (ret && ret != -EOPNOTSUPP) 1976 dev_warn(ds->dev, "nonfatal error %d setting MTU to %d on port %d\n", 1977 ret, ETH_DATA_LEN, port->index); 1978 1979 ret = register_netdevice(slave_dev); 1980 if (ret) { 1981 netdev_err(master, "error %d registering interface %s\n", 1982 ret, slave_dev->name); 1983 rtnl_unlock(); 1984 goto out_phy; 1985 } 1986 1987 ret = netdev_upper_dev_link(master, slave_dev, NULL); 1988 1989 rtnl_unlock(); 1990 1991 if (ret) 1992 goto out_unregister; 1993 1994 return 0; 1995 1996 out_unregister: 1997 unregister_netdev(slave_dev); 1998 out_phy: 1999 rtnl_lock(); 2000 phylink_disconnect_phy(p->dp->pl); 2001 rtnl_unlock(); 2002 phylink_destroy(p->dp->pl); 2003 out_gcells: 2004 gro_cells_destroy(&p->gcells); 2005 out_free: 2006 free_percpu(slave_dev->tstats); 2007 free_netdev(slave_dev); 2008 port->slave = NULL; 2009 return ret; 2010 } 2011 2012 void dsa_slave_destroy(struct net_device *slave_dev) 2013 { 2014 struct net_device *master = dsa_slave_to_master(slave_dev); 2015 struct dsa_port *dp = dsa_slave_to_port(slave_dev); 2016 struct dsa_slave_priv *p = netdev_priv(slave_dev); 2017 2018 netif_carrier_off(slave_dev); 2019 rtnl_lock(); 2020 netdev_upper_dev_unlink(master, slave_dev); 2021 unregister_netdevice(slave_dev); 2022 phylink_disconnect_phy(dp->pl); 2023 rtnl_unlock(); 2024 2025 phylink_destroy(dp->pl); 2026 gro_cells_destroy(&p->gcells); 2027 free_percpu(slave_dev->tstats); 2028 free_netdev(slave_dev); 2029 } 2030 2031 bool dsa_slave_dev_check(const struct net_device *dev) 2032 { 2033 return dev->netdev_ops == &dsa_slave_netdev_ops; 2034 } 2035 EXPORT_SYMBOL_GPL(dsa_slave_dev_check); 2036 2037 static int dsa_slave_changeupper(struct net_device *dev, 2038 struct netdev_notifier_changeupper_info *info) 2039 { 2040 struct dsa_port *dp = dsa_slave_to_port(dev); 2041 struct netlink_ext_ack *extack; 2042 int err = NOTIFY_DONE; 2043 2044 extack = netdev_notifier_info_to_extack(&info->info); 2045 2046 if (netif_is_bridge_master(info->upper_dev)) { 2047 if (info->linking) { 2048 err = dsa_port_bridge_join(dp, info->upper_dev, extack); 2049 if (!err) 2050 dsa_bridge_mtu_normalization(dp); 2051 if (err == -EOPNOTSUPP) { 2052 NL_SET_ERR_MSG_MOD(extack, 2053 "Offloading not supported"); 2054 err = 0; 2055 } 2056 err = notifier_from_errno(err); 2057 } else { 2058 dsa_port_bridge_leave(dp, info->upper_dev); 2059 err = NOTIFY_OK; 2060 } 2061 } else if (netif_is_lag_master(info->upper_dev)) { 2062 if (info->linking) { 2063 err = dsa_port_lag_join(dp, info->upper_dev, 2064 info->upper_info, extack); 2065 if (err == -EOPNOTSUPP) { 2066 NL_SET_ERR_MSG_MOD(info->info.extack, 2067 "Offloading not supported"); 2068 err = 0; 2069 } 2070 err = notifier_from_errno(err); 2071 } else { 2072 dsa_port_lag_leave(dp, info->upper_dev); 2073 err = NOTIFY_OK; 2074 } 2075 } else if (is_hsr_master(info->upper_dev)) { 2076 if (info->linking) { 2077 err = dsa_port_hsr_join(dp, info->upper_dev); 2078 if (err == -EOPNOTSUPP) { 2079 NL_SET_ERR_MSG_MOD(info->info.extack, 2080 "Offloading not supported"); 2081 err = 0; 2082 } 2083 err = notifier_from_errno(err); 2084 } else { 2085 dsa_port_hsr_leave(dp, info->upper_dev); 2086 err = NOTIFY_OK; 2087 } 2088 } 2089 2090 return err; 2091 } 2092 2093 static int dsa_slave_prechangeupper(struct net_device *dev, 2094 struct netdev_notifier_changeupper_info *info) 2095 { 2096 struct dsa_port *dp = dsa_slave_to_port(dev); 2097 2098 if (netif_is_bridge_master(info->upper_dev) && !info->linking) 2099 dsa_port_pre_bridge_leave(dp, info->upper_dev); 2100 else if (netif_is_lag_master(info->upper_dev) && !info->linking) 2101 dsa_port_pre_lag_leave(dp, info->upper_dev); 2102 /* dsa_port_pre_hsr_leave is not yet necessary since hsr cannot be 2103 * meaningfully enslaved to a bridge yet 2104 */ 2105 2106 return NOTIFY_DONE; 2107 } 2108 2109 static int 2110 dsa_slave_lag_changeupper(struct net_device *dev, 2111 struct netdev_notifier_changeupper_info *info) 2112 { 2113 struct net_device *lower; 2114 struct list_head *iter; 2115 int err = NOTIFY_DONE; 2116 struct dsa_port *dp; 2117 2118 netdev_for_each_lower_dev(dev, lower, iter) { 2119 if (!dsa_slave_dev_check(lower)) 2120 continue; 2121 2122 dp = dsa_slave_to_port(lower); 2123 if (!dp->lag_dev) 2124 /* Software LAG */ 2125 continue; 2126 2127 err = dsa_slave_changeupper(lower, info); 2128 if (notifier_to_errno(err)) 2129 break; 2130 } 2131 2132 return err; 2133 } 2134 2135 /* Same as dsa_slave_lag_changeupper() except that it calls 2136 * dsa_slave_prechangeupper() 2137 */ 2138 static int 2139 dsa_slave_lag_prechangeupper(struct net_device *dev, 2140 struct netdev_notifier_changeupper_info *info) 2141 { 2142 struct net_device *lower; 2143 struct list_head *iter; 2144 int err = NOTIFY_DONE; 2145 struct dsa_port *dp; 2146 2147 netdev_for_each_lower_dev(dev, lower, iter) { 2148 if (!dsa_slave_dev_check(lower)) 2149 continue; 2150 2151 dp = dsa_slave_to_port(lower); 2152 if (!dp->lag_dev) 2153 /* Software LAG */ 2154 continue; 2155 2156 err = dsa_slave_prechangeupper(lower, info); 2157 if (notifier_to_errno(err)) 2158 break; 2159 } 2160 2161 return err; 2162 } 2163 2164 static int 2165 dsa_prevent_bridging_8021q_upper(struct net_device *dev, 2166 struct netdev_notifier_changeupper_info *info) 2167 { 2168 struct netlink_ext_ack *ext_ack; 2169 struct net_device *slave, *br; 2170 struct dsa_port *dp; 2171 2172 ext_ack = netdev_notifier_info_to_extack(&info->info); 2173 2174 if (!is_vlan_dev(dev)) 2175 return NOTIFY_DONE; 2176 2177 slave = vlan_dev_real_dev(dev); 2178 if (!dsa_slave_dev_check(slave)) 2179 return NOTIFY_DONE; 2180 2181 dp = dsa_slave_to_port(slave); 2182 br = dsa_port_bridge_dev_get(dp); 2183 if (!br) 2184 return NOTIFY_DONE; 2185 2186 /* Deny enslaving a VLAN device into a VLAN-aware bridge */ 2187 if (br_vlan_enabled(br) && 2188 netif_is_bridge_master(info->upper_dev) && info->linking) { 2189 NL_SET_ERR_MSG_MOD(ext_ack, 2190 "Cannot enslave VLAN device into VLAN aware bridge"); 2191 return notifier_from_errno(-EINVAL); 2192 } 2193 2194 return NOTIFY_DONE; 2195 } 2196 2197 static int 2198 dsa_slave_check_8021q_upper(struct net_device *dev, 2199 struct netdev_notifier_changeupper_info *info) 2200 { 2201 struct dsa_port *dp = dsa_slave_to_port(dev); 2202 struct net_device *br = dsa_port_bridge_dev_get(dp); 2203 struct bridge_vlan_info br_info; 2204 struct netlink_ext_ack *extack; 2205 int err = NOTIFY_DONE; 2206 u16 vid; 2207 2208 if (!br || !br_vlan_enabled(br)) 2209 return NOTIFY_DONE; 2210 2211 extack = netdev_notifier_info_to_extack(&info->info); 2212 vid = vlan_dev_vlan_id(info->upper_dev); 2213 2214 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the 2215 * device, respectively the VID is not found, returning 2216 * 0 means success, which is a failure for us here. 2217 */ 2218 err = br_vlan_get_info(br, vid, &br_info); 2219 if (err == 0) { 2220 NL_SET_ERR_MSG_MOD(extack, 2221 "This VLAN is already configured by the bridge"); 2222 return notifier_from_errno(-EBUSY); 2223 } 2224 2225 return NOTIFY_DONE; 2226 } 2227 2228 static int 2229 dsa_slave_prechangeupper_sanity_check(struct net_device *dev, 2230 struct netdev_notifier_changeupper_info *info) 2231 { 2232 struct dsa_switch *ds; 2233 struct dsa_port *dp; 2234 int err; 2235 2236 if (!dsa_slave_dev_check(dev)) 2237 return dsa_prevent_bridging_8021q_upper(dev, info); 2238 2239 dp = dsa_slave_to_port(dev); 2240 ds = dp->ds; 2241 2242 if (ds->ops->port_prechangeupper) { 2243 err = ds->ops->port_prechangeupper(ds, dp->index, info); 2244 if (err) 2245 return notifier_from_errno(err); 2246 } 2247 2248 if (is_vlan_dev(info->upper_dev)) 2249 return dsa_slave_check_8021q_upper(dev, info); 2250 2251 return NOTIFY_DONE; 2252 } 2253 2254 static int dsa_slave_netdevice_event(struct notifier_block *nb, 2255 unsigned long event, void *ptr) 2256 { 2257 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 2258 2259 switch (event) { 2260 case NETDEV_PRECHANGEUPPER: { 2261 struct netdev_notifier_changeupper_info *info = ptr; 2262 int err; 2263 2264 err = dsa_slave_prechangeupper_sanity_check(dev, info); 2265 if (err != NOTIFY_DONE) 2266 return err; 2267 2268 if (dsa_slave_dev_check(dev)) 2269 return dsa_slave_prechangeupper(dev, ptr); 2270 2271 if (netif_is_lag_master(dev)) 2272 return dsa_slave_lag_prechangeupper(dev, ptr); 2273 2274 break; 2275 } 2276 case NETDEV_CHANGEUPPER: 2277 if (dsa_slave_dev_check(dev)) 2278 return dsa_slave_changeupper(dev, ptr); 2279 2280 if (netif_is_lag_master(dev)) 2281 return dsa_slave_lag_changeupper(dev, ptr); 2282 2283 break; 2284 case NETDEV_CHANGELOWERSTATE: { 2285 struct netdev_notifier_changelowerstate_info *info = ptr; 2286 struct dsa_port *dp; 2287 int err; 2288 2289 if (!dsa_slave_dev_check(dev)) 2290 break; 2291 2292 dp = dsa_slave_to_port(dev); 2293 2294 err = dsa_port_lag_change(dp, info->lower_state_info); 2295 return notifier_from_errno(err); 2296 } 2297 case NETDEV_CHANGE: 2298 case NETDEV_UP: { 2299 /* Track state of master port. 2300 * DSA driver may require the master port (and indirectly 2301 * the tagger) to be available for some special operation. 2302 */ 2303 if (netdev_uses_dsa(dev)) { 2304 struct dsa_port *cpu_dp = dev->dsa_ptr; 2305 struct dsa_switch_tree *dst = cpu_dp->ds->dst; 2306 2307 /* Track when the master port is UP */ 2308 dsa_tree_master_oper_state_change(dst, dev, 2309 netif_oper_up(dev)); 2310 2311 /* Track when the master port is ready and can accept 2312 * packet. 2313 * NETDEV_UP event is not enough to flag a port as ready. 2314 * We also have to wait for linkwatch_do_dev to dev_activate 2315 * and emit a NETDEV_CHANGE event. 2316 * We check if a master port is ready by checking if the dev 2317 * have a qdisc assigned and is not noop. 2318 */ 2319 dsa_tree_master_admin_state_change(dst, dev, 2320 !qdisc_tx_is_noop(dev)); 2321 2322 return NOTIFY_OK; 2323 } 2324 2325 return NOTIFY_DONE; 2326 } 2327 case NETDEV_GOING_DOWN: { 2328 struct dsa_port *dp, *cpu_dp; 2329 struct dsa_switch_tree *dst; 2330 LIST_HEAD(close_list); 2331 2332 if (!netdev_uses_dsa(dev)) 2333 return NOTIFY_DONE; 2334 2335 cpu_dp = dev->dsa_ptr; 2336 dst = cpu_dp->ds->dst; 2337 2338 dsa_tree_master_admin_state_change(dst, dev, false); 2339 2340 list_for_each_entry(dp, &dst->ports, list) { 2341 if (!dsa_port_is_user(dp)) 2342 continue; 2343 2344 list_add(&dp->slave->close_list, &close_list); 2345 } 2346 2347 dev_close_many(&close_list, true); 2348 2349 return NOTIFY_OK; 2350 } 2351 default: 2352 break; 2353 } 2354 2355 return NOTIFY_DONE; 2356 } 2357 2358 static void 2359 dsa_fdb_offload_notify(struct dsa_switchdev_event_work *switchdev_work) 2360 { 2361 struct switchdev_notifier_fdb_info info = {}; 2362 struct dsa_switch *ds = switchdev_work->ds; 2363 struct dsa_port *dp; 2364 2365 if (!dsa_is_user_port(ds, switchdev_work->port)) 2366 return; 2367 2368 info.addr = switchdev_work->addr; 2369 info.vid = switchdev_work->vid; 2370 info.offloaded = true; 2371 dp = dsa_to_port(ds, switchdev_work->port); 2372 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, 2373 dp->slave, &info.info, NULL); 2374 } 2375 2376 static void dsa_slave_switchdev_event_work(struct work_struct *work) 2377 { 2378 struct dsa_switchdev_event_work *switchdev_work = 2379 container_of(work, struct dsa_switchdev_event_work, work); 2380 struct dsa_switch *ds = switchdev_work->ds; 2381 struct dsa_port *dp; 2382 int err; 2383 2384 dp = dsa_to_port(ds, switchdev_work->port); 2385 2386 switch (switchdev_work->event) { 2387 case SWITCHDEV_FDB_ADD_TO_DEVICE: 2388 if (switchdev_work->host_addr) 2389 err = dsa_port_host_fdb_add(dp, switchdev_work->addr, 2390 switchdev_work->vid); 2391 else 2392 err = dsa_port_fdb_add(dp, switchdev_work->addr, 2393 switchdev_work->vid); 2394 if (err) { 2395 dev_err(ds->dev, 2396 "port %d failed to add %pM vid %d to fdb: %d\n", 2397 dp->index, switchdev_work->addr, 2398 switchdev_work->vid, err); 2399 break; 2400 } 2401 dsa_fdb_offload_notify(switchdev_work); 2402 break; 2403 2404 case SWITCHDEV_FDB_DEL_TO_DEVICE: 2405 if (switchdev_work->host_addr) 2406 err = dsa_port_host_fdb_del(dp, switchdev_work->addr, 2407 switchdev_work->vid); 2408 else 2409 err = dsa_port_fdb_del(dp, switchdev_work->addr, 2410 switchdev_work->vid); 2411 if (err) { 2412 dev_err(ds->dev, 2413 "port %d failed to delete %pM vid %d from fdb: %d\n", 2414 dp->index, switchdev_work->addr, 2415 switchdev_work->vid, err); 2416 } 2417 2418 break; 2419 } 2420 2421 kfree(switchdev_work); 2422 } 2423 2424 static bool dsa_foreign_dev_check(const struct net_device *dev, 2425 const struct net_device *foreign_dev) 2426 { 2427 const struct dsa_port *dp = dsa_slave_to_port(dev); 2428 struct dsa_switch_tree *dst = dp->ds->dst; 2429 2430 if (netif_is_bridge_master(foreign_dev)) 2431 return !dsa_tree_offloads_bridge_dev(dst, foreign_dev); 2432 2433 if (netif_is_bridge_port(foreign_dev)) 2434 return !dsa_tree_offloads_bridge_port(dst, foreign_dev); 2435 2436 /* Everything else is foreign */ 2437 return true; 2438 } 2439 2440 static int dsa_slave_fdb_event(struct net_device *dev, 2441 struct net_device *orig_dev, 2442 unsigned long event, const void *ctx, 2443 const struct switchdev_notifier_fdb_info *fdb_info) 2444 { 2445 struct dsa_switchdev_event_work *switchdev_work; 2446 struct dsa_port *dp = dsa_slave_to_port(dev); 2447 bool host_addr = fdb_info->is_local; 2448 struct dsa_switch *ds = dp->ds; 2449 2450 if (ctx && ctx != dp) 2451 return 0; 2452 2453 if (!ds->ops->port_fdb_add || !ds->ops->port_fdb_del) 2454 return -EOPNOTSUPP; 2455 2456 if (dsa_slave_dev_check(orig_dev) && 2457 switchdev_fdb_is_dynamically_learned(fdb_info)) 2458 return 0; 2459 2460 /* FDB entries learned by the software bridge should be installed as 2461 * host addresses only if the driver requests assisted learning. 2462 */ 2463 if (switchdev_fdb_is_dynamically_learned(fdb_info) && 2464 !ds->assisted_learning_on_cpu_port) 2465 return 0; 2466 2467 /* Also treat FDB entries on foreign interfaces bridged with us as host 2468 * addresses. 2469 */ 2470 if (dsa_foreign_dev_check(dev, orig_dev)) 2471 host_addr = true; 2472 2473 switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC); 2474 if (!switchdev_work) 2475 return -ENOMEM; 2476 2477 netdev_dbg(dev, "%s FDB entry towards %s, addr %pM vid %d%s\n", 2478 event == SWITCHDEV_FDB_ADD_TO_DEVICE ? "Adding" : "Deleting", 2479 orig_dev->name, fdb_info->addr, fdb_info->vid, 2480 host_addr ? " as host address" : ""); 2481 2482 INIT_WORK(&switchdev_work->work, dsa_slave_switchdev_event_work); 2483 switchdev_work->ds = ds; 2484 switchdev_work->port = dp->index; 2485 switchdev_work->event = event; 2486 switchdev_work->dev = dev; 2487 2488 ether_addr_copy(switchdev_work->addr, fdb_info->addr); 2489 switchdev_work->vid = fdb_info->vid; 2490 switchdev_work->host_addr = host_addr; 2491 2492 dsa_schedule_work(&switchdev_work->work); 2493 2494 return 0; 2495 } 2496 2497 /* Called under rcu_read_lock() */ 2498 static int dsa_slave_switchdev_event(struct notifier_block *unused, 2499 unsigned long event, void *ptr) 2500 { 2501 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 2502 int err; 2503 2504 switch (event) { 2505 case SWITCHDEV_PORT_ATTR_SET: 2506 err = switchdev_handle_port_attr_set(dev, ptr, 2507 dsa_slave_dev_check, 2508 dsa_slave_port_attr_set); 2509 return notifier_from_errno(err); 2510 case SWITCHDEV_FDB_ADD_TO_DEVICE: 2511 case SWITCHDEV_FDB_DEL_TO_DEVICE: 2512 err = switchdev_handle_fdb_event_to_device(dev, event, ptr, 2513 dsa_slave_dev_check, 2514 dsa_foreign_dev_check, 2515 dsa_slave_fdb_event, 2516 NULL); 2517 return notifier_from_errno(err); 2518 default: 2519 return NOTIFY_DONE; 2520 } 2521 2522 return NOTIFY_OK; 2523 } 2524 2525 static int dsa_slave_switchdev_blocking_event(struct notifier_block *unused, 2526 unsigned long event, void *ptr) 2527 { 2528 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 2529 int err; 2530 2531 switch (event) { 2532 case SWITCHDEV_PORT_OBJ_ADD: 2533 err = switchdev_handle_port_obj_add(dev, ptr, 2534 dsa_slave_dev_check, 2535 dsa_slave_port_obj_add); 2536 return notifier_from_errno(err); 2537 case SWITCHDEV_PORT_OBJ_DEL: 2538 err = switchdev_handle_port_obj_del(dev, ptr, 2539 dsa_slave_dev_check, 2540 dsa_slave_port_obj_del); 2541 return notifier_from_errno(err); 2542 case SWITCHDEV_PORT_ATTR_SET: 2543 err = switchdev_handle_port_attr_set(dev, ptr, 2544 dsa_slave_dev_check, 2545 dsa_slave_port_attr_set); 2546 return notifier_from_errno(err); 2547 } 2548 2549 return NOTIFY_DONE; 2550 } 2551 2552 static struct notifier_block dsa_slave_nb __read_mostly = { 2553 .notifier_call = dsa_slave_netdevice_event, 2554 }; 2555 2556 struct notifier_block dsa_slave_switchdev_notifier = { 2557 .notifier_call = dsa_slave_switchdev_event, 2558 }; 2559 2560 struct notifier_block dsa_slave_switchdev_blocking_notifier = { 2561 .notifier_call = dsa_slave_switchdev_blocking_event, 2562 }; 2563 2564 int dsa_slave_register_notifier(void) 2565 { 2566 struct notifier_block *nb; 2567 int err; 2568 2569 err = register_netdevice_notifier(&dsa_slave_nb); 2570 if (err) 2571 return err; 2572 2573 err = register_switchdev_notifier(&dsa_slave_switchdev_notifier); 2574 if (err) 2575 goto err_switchdev_nb; 2576 2577 nb = &dsa_slave_switchdev_blocking_notifier; 2578 err = register_switchdev_blocking_notifier(nb); 2579 if (err) 2580 goto err_switchdev_blocking_nb; 2581 2582 return 0; 2583 2584 err_switchdev_blocking_nb: 2585 unregister_switchdev_notifier(&dsa_slave_switchdev_notifier); 2586 err_switchdev_nb: 2587 unregister_netdevice_notifier(&dsa_slave_nb); 2588 return err; 2589 } 2590 2591 void dsa_slave_unregister_notifier(void) 2592 { 2593 struct notifier_block *nb; 2594 int err; 2595 2596 nb = &dsa_slave_switchdev_blocking_notifier; 2597 err = unregister_switchdev_blocking_notifier(nb); 2598 if (err) 2599 pr_err("DSA: failed to unregister switchdev blocking notifier (%d)\n", err); 2600 2601 err = unregister_switchdev_notifier(&dsa_slave_switchdev_notifier); 2602 if (err) 2603 pr_err("DSA: failed to unregister switchdev notifier (%d)\n", err); 2604 2605 err = unregister_netdevice_notifier(&dsa_slave_nb); 2606 if (err) 2607 pr_err("DSA: failed to unregister slave notifier (%d)\n", err); 2608 } 2609