1 // SPDX-License-Identifier: (GPL-2.0 OR MIT) 2 /* Microsemi Ocelot Switch driver 3 * 4 * This contains glue logic between the switchdev driver operations and the 5 * mscc_ocelot_switch_lib. 6 * 7 * Copyright (c) 2017, 2019 Microsemi Corporation 8 * Copyright 2020-2021 NXP 9 */ 10 11 #include <linux/dsa/ocelot.h> 12 #include <linux/if_bridge.h> 13 #include <linux/of_net.h> 14 #include <linux/phy/phy.h> 15 #include <net/pkt_cls.h> 16 #include "ocelot.h" 17 #include "ocelot_police.h" 18 #include "ocelot_vcap.h" 19 #include "ocelot_fdma.h" 20 21 #define OCELOT_MAC_QUIRKS OCELOT_QUIRK_QSGMII_PORTS_MUST_BE_UP 22 23 struct ocelot_dump_ctx { 24 struct net_device *dev; 25 struct sk_buff *skb; 26 struct netlink_callback *cb; 27 int idx; 28 }; 29 30 static bool ocelot_netdevice_dev_check(const struct net_device *dev); 31 32 static struct ocelot *devlink_port_to_ocelot(struct devlink_port *dlp) 33 { 34 return devlink_priv(dlp->devlink); 35 } 36 37 static int devlink_port_to_port(struct devlink_port *dlp) 38 { 39 struct ocelot *ocelot = devlink_port_to_ocelot(dlp); 40 41 return dlp - ocelot->devlink_ports; 42 } 43 44 static int ocelot_devlink_sb_pool_get(struct devlink *dl, 45 unsigned int sb_index, u16 pool_index, 46 struct devlink_sb_pool_info *pool_info) 47 { 48 struct ocelot *ocelot = devlink_priv(dl); 49 50 return ocelot_sb_pool_get(ocelot, sb_index, pool_index, pool_info); 51 } 52 53 static int ocelot_devlink_sb_pool_set(struct devlink *dl, unsigned int sb_index, 54 u16 pool_index, u32 size, 55 enum devlink_sb_threshold_type threshold_type, 56 struct netlink_ext_ack *extack) 57 { 58 struct ocelot *ocelot = devlink_priv(dl); 59 60 return ocelot_sb_pool_set(ocelot, sb_index, pool_index, size, 61 threshold_type, extack); 62 } 63 64 static int ocelot_devlink_sb_port_pool_get(struct devlink_port *dlp, 65 unsigned int sb_index, u16 pool_index, 66 u32 *p_threshold) 67 { 68 struct ocelot *ocelot = devlink_port_to_ocelot(dlp); 69 int port = devlink_port_to_port(dlp); 70 71 return ocelot_sb_port_pool_get(ocelot, port, sb_index, pool_index, 72 p_threshold); 73 } 74 75 static int ocelot_devlink_sb_port_pool_set(struct devlink_port *dlp, 76 unsigned int sb_index, u16 pool_index, 77 u32 threshold, 78 struct netlink_ext_ack *extack) 79 { 80 struct ocelot *ocelot = devlink_port_to_ocelot(dlp); 81 int port = devlink_port_to_port(dlp); 82 83 return ocelot_sb_port_pool_set(ocelot, port, sb_index, pool_index, 84 threshold, extack); 85 } 86 87 static int 88 ocelot_devlink_sb_tc_pool_bind_get(struct devlink_port *dlp, 89 unsigned int sb_index, u16 tc_index, 90 enum devlink_sb_pool_type pool_type, 91 u16 *p_pool_index, u32 *p_threshold) 92 { 93 struct ocelot *ocelot = devlink_port_to_ocelot(dlp); 94 int port = devlink_port_to_port(dlp); 95 96 return ocelot_sb_tc_pool_bind_get(ocelot, port, sb_index, tc_index, 97 pool_type, p_pool_index, 98 p_threshold); 99 } 100 101 static int 102 ocelot_devlink_sb_tc_pool_bind_set(struct devlink_port *dlp, 103 unsigned int sb_index, u16 tc_index, 104 enum devlink_sb_pool_type pool_type, 105 u16 pool_index, u32 threshold, 106 struct netlink_ext_ack *extack) 107 { 108 struct ocelot *ocelot = devlink_port_to_ocelot(dlp); 109 int port = devlink_port_to_port(dlp); 110 111 return ocelot_sb_tc_pool_bind_set(ocelot, port, sb_index, tc_index, 112 pool_type, pool_index, threshold, 113 extack); 114 } 115 116 static int ocelot_devlink_sb_occ_snapshot(struct devlink *dl, 117 unsigned int sb_index) 118 { 119 struct ocelot *ocelot = devlink_priv(dl); 120 121 return ocelot_sb_occ_snapshot(ocelot, sb_index); 122 } 123 124 static int ocelot_devlink_sb_occ_max_clear(struct devlink *dl, 125 unsigned int sb_index) 126 { 127 struct ocelot *ocelot = devlink_priv(dl); 128 129 return ocelot_sb_occ_max_clear(ocelot, sb_index); 130 } 131 132 static int ocelot_devlink_sb_occ_port_pool_get(struct devlink_port *dlp, 133 unsigned int sb_index, 134 u16 pool_index, u32 *p_cur, 135 u32 *p_max) 136 { 137 struct ocelot *ocelot = devlink_port_to_ocelot(dlp); 138 int port = devlink_port_to_port(dlp); 139 140 return ocelot_sb_occ_port_pool_get(ocelot, port, sb_index, pool_index, 141 p_cur, p_max); 142 } 143 144 static int 145 ocelot_devlink_sb_occ_tc_port_bind_get(struct devlink_port *dlp, 146 unsigned int sb_index, u16 tc_index, 147 enum devlink_sb_pool_type pool_type, 148 u32 *p_cur, u32 *p_max) 149 { 150 struct ocelot *ocelot = devlink_port_to_ocelot(dlp); 151 int port = devlink_port_to_port(dlp); 152 153 return ocelot_sb_occ_tc_port_bind_get(ocelot, port, sb_index, 154 tc_index, pool_type, 155 p_cur, p_max); 156 } 157 158 const struct devlink_ops ocelot_devlink_ops = { 159 .sb_pool_get = ocelot_devlink_sb_pool_get, 160 .sb_pool_set = ocelot_devlink_sb_pool_set, 161 .sb_port_pool_get = ocelot_devlink_sb_port_pool_get, 162 .sb_port_pool_set = ocelot_devlink_sb_port_pool_set, 163 .sb_tc_pool_bind_get = ocelot_devlink_sb_tc_pool_bind_get, 164 .sb_tc_pool_bind_set = ocelot_devlink_sb_tc_pool_bind_set, 165 .sb_occ_snapshot = ocelot_devlink_sb_occ_snapshot, 166 .sb_occ_max_clear = ocelot_devlink_sb_occ_max_clear, 167 .sb_occ_port_pool_get = ocelot_devlink_sb_occ_port_pool_get, 168 .sb_occ_tc_port_bind_get = ocelot_devlink_sb_occ_tc_port_bind_get, 169 }; 170 171 int ocelot_port_devlink_init(struct ocelot *ocelot, int port, 172 enum devlink_port_flavour flavour) 173 { 174 struct devlink_port *dlp = &ocelot->devlink_ports[port]; 175 int id_len = sizeof(ocelot->base_mac); 176 struct devlink *dl = ocelot->devlink; 177 struct devlink_port_attrs attrs = {}; 178 179 memset(dlp, 0, sizeof(*dlp)); 180 memcpy(attrs.switch_id.id, &ocelot->base_mac, id_len); 181 attrs.switch_id.id_len = id_len; 182 attrs.phys.port_number = port; 183 attrs.flavour = flavour; 184 185 devlink_port_attrs_set(dlp, &attrs); 186 187 return devlink_port_register(dl, dlp, port); 188 } 189 190 void ocelot_port_devlink_teardown(struct ocelot *ocelot, int port) 191 { 192 struct devlink_port *dlp = &ocelot->devlink_ports[port]; 193 194 devlink_port_unregister(dlp); 195 } 196 197 int ocelot_setup_tc_cls_flower(struct ocelot_port_private *priv, 198 struct flow_cls_offload *f, 199 bool ingress) 200 { 201 struct ocelot *ocelot = priv->port.ocelot; 202 int port = priv->port.index; 203 204 if (!ingress) 205 return -EOPNOTSUPP; 206 207 switch (f->command) { 208 case FLOW_CLS_REPLACE: 209 return ocelot_cls_flower_replace(ocelot, port, f, ingress); 210 case FLOW_CLS_DESTROY: 211 return ocelot_cls_flower_destroy(ocelot, port, f, ingress); 212 case FLOW_CLS_STATS: 213 return ocelot_cls_flower_stats(ocelot, port, f, ingress); 214 default: 215 return -EOPNOTSUPP; 216 } 217 } 218 219 static int ocelot_setup_tc_cls_matchall_police(struct ocelot_port_private *priv, 220 struct tc_cls_matchall_offload *f, 221 bool ingress, 222 struct netlink_ext_ack *extack) 223 { 224 struct flow_action_entry *action = &f->rule->action.entries[0]; 225 struct ocelot *ocelot = priv->port.ocelot; 226 struct ocelot_policer pol = { 0 }; 227 int port = priv->port.index; 228 int err; 229 230 if (!ingress) { 231 NL_SET_ERR_MSG_MOD(extack, "Only ingress is supported"); 232 return -EOPNOTSUPP; 233 } 234 235 if (priv->tc.police_id && priv->tc.police_id != f->cookie) { 236 NL_SET_ERR_MSG_MOD(extack, 237 "Only one policer per port is supported"); 238 return -EEXIST; 239 } 240 241 err = ocelot_policer_validate(&f->rule->action, action, extack); 242 if (err) 243 return err; 244 245 pol.rate = (u32)div_u64(action->police.rate_bytes_ps, 1000) * 8; 246 pol.burst = action->police.burst; 247 248 err = ocelot_port_policer_add(ocelot, port, &pol); 249 if (err) { 250 NL_SET_ERR_MSG_MOD(extack, "Could not add policer"); 251 return err; 252 } 253 254 priv->tc.police_id = f->cookie; 255 priv->tc.offload_cnt++; 256 257 return 0; 258 } 259 260 static int ocelot_setup_tc_cls_matchall_mirred(struct ocelot_port_private *priv, 261 struct tc_cls_matchall_offload *f, 262 bool ingress, 263 struct netlink_ext_ack *extack) 264 { 265 struct flow_action *action = &f->rule->action; 266 struct ocelot *ocelot = priv->port.ocelot; 267 struct ocelot_port_private *other_priv; 268 const struct flow_action_entry *a; 269 int err; 270 271 if (f->common.protocol != htons(ETH_P_ALL)) 272 return -EOPNOTSUPP; 273 274 if (!flow_action_basic_hw_stats_check(action, extack)) 275 return -EOPNOTSUPP; 276 277 a = &action->entries[0]; 278 if (!a->dev) 279 return -EINVAL; 280 281 if (!ocelot_netdevice_dev_check(a->dev)) { 282 NL_SET_ERR_MSG_MOD(extack, 283 "Destination not an ocelot port"); 284 return -EOPNOTSUPP; 285 } 286 287 other_priv = netdev_priv(a->dev); 288 289 err = ocelot_port_mirror_add(ocelot, priv->port.index, 290 other_priv->port.index, ingress, extack); 291 if (err) 292 return err; 293 294 if (ingress) 295 priv->tc.ingress_mirred_id = f->cookie; 296 else 297 priv->tc.egress_mirred_id = f->cookie; 298 priv->tc.offload_cnt++; 299 300 return 0; 301 } 302 303 static int ocelot_del_tc_cls_matchall_police(struct ocelot_port_private *priv, 304 struct netlink_ext_ack *extack) 305 { 306 struct ocelot *ocelot = priv->port.ocelot; 307 int port = priv->port.index; 308 int err; 309 310 err = ocelot_port_policer_del(ocelot, port); 311 if (err) { 312 NL_SET_ERR_MSG_MOD(extack, 313 "Could not delete policer"); 314 return err; 315 } 316 317 priv->tc.police_id = 0; 318 priv->tc.offload_cnt--; 319 320 return 0; 321 } 322 323 static int ocelot_del_tc_cls_matchall_mirred(struct ocelot_port_private *priv, 324 bool ingress, 325 struct netlink_ext_ack *extack) 326 { 327 struct ocelot *ocelot = priv->port.ocelot; 328 int port = priv->port.index; 329 330 ocelot_port_mirror_del(ocelot, port, ingress); 331 332 if (ingress) 333 priv->tc.ingress_mirred_id = 0; 334 else 335 priv->tc.egress_mirred_id = 0; 336 priv->tc.offload_cnt--; 337 338 return 0; 339 } 340 341 static int ocelot_setup_tc_cls_matchall(struct ocelot_port_private *priv, 342 struct tc_cls_matchall_offload *f, 343 bool ingress) 344 { 345 struct netlink_ext_ack *extack = f->common.extack; 346 struct flow_action_entry *action; 347 348 switch (f->command) { 349 case TC_CLSMATCHALL_REPLACE: 350 if (!flow_offload_has_one_action(&f->rule->action)) { 351 NL_SET_ERR_MSG_MOD(extack, 352 "Only one action is supported"); 353 return -EOPNOTSUPP; 354 } 355 356 if (priv->tc.block_shared) { 357 NL_SET_ERR_MSG_MOD(extack, 358 "Matchall offloads not supported on shared blocks"); 359 return -EOPNOTSUPP; 360 } 361 362 action = &f->rule->action.entries[0]; 363 364 switch (action->id) { 365 case FLOW_ACTION_POLICE: 366 return ocelot_setup_tc_cls_matchall_police(priv, f, 367 ingress, 368 extack); 369 break; 370 case FLOW_ACTION_MIRRED: 371 return ocelot_setup_tc_cls_matchall_mirred(priv, f, 372 ingress, 373 extack); 374 default: 375 NL_SET_ERR_MSG_MOD(extack, "Unsupported action"); 376 return -EOPNOTSUPP; 377 } 378 379 break; 380 case TC_CLSMATCHALL_DESTROY: 381 action = &f->rule->action.entries[0]; 382 383 if (f->cookie == priv->tc.police_id) 384 return ocelot_del_tc_cls_matchall_police(priv, extack); 385 else if (f->cookie == priv->tc.ingress_mirred_id || 386 f->cookie == priv->tc.egress_mirred_id) 387 return ocelot_del_tc_cls_matchall_mirred(priv, ingress, 388 extack); 389 else 390 return -ENOENT; 391 392 break; 393 case TC_CLSMATCHALL_STATS: 394 default: 395 return -EOPNOTSUPP; 396 } 397 } 398 399 static int ocelot_setup_tc_block_cb(enum tc_setup_type type, 400 void *type_data, 401 void *cb_priv, bool ingress) 402 { 403 struct ocelot_port_private *priv = cb_priv; 404 405 if (!tc_cls_can_offload_and_chain0(priv->dev, type_data)) 406 return -EOPNOTSUPP; 407 408 switch (type) { 409 case TC_SETUP_CLSMATCHALL: 410 return ocelot_setup_tc_cls_matchall(priv, type_data, ingress); 411 case TC_SETUP_CLSFLOWER: 412 return ocelot_setup_tc_cls_flower(priv, type_data, ingress); 413 default: 414 return -EOPNOTSUPP; 415 } 416 } 417 418 static int ocelot_setup_tc_block_cb_ig(enum tc_setup_type type, 419 void *type_data, 420 void *cb_priv) 421 { 422 return ocelot_setup_tc_block_cb(type, type_data, 423 cb_priv, true); 424 } 425 426 static int ocelot_setup_tc_block_cb_eg(enum tc_setup_type type, 427 void *type_data, 428 void *cb_priv) 429 { 430 return ocelot_setup_tc_block_cb(type, type_data, 431 cb_priv, false); 432 } 433 434 static LIST_HEAD(ocelot_block_cb_list); 435 436 static int ocelot_setup_tc_block(struct ocelot_port_private *priv, 437 struct flow_block_offload *f) 438 { 439 struct flow_block_cb *block_cb; 440 flow_setup_cb_t *cb; 441 442 if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS) { 443 cb = ocelot_setup_tc_block_cb_ig; 444 priv->tc.block_shared = f->block_shared; 445 } else if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS) { 446 cb = ocelot_setup_tc_block_cb_eg; 447 } else { 448 return -EOPNOTSUPP; 449 } 450 451 f->driver_block_list = &ocelot_block_cb_list; 452 453 switch (f->command) { 454 case FLOW_BLOCK_BIND: 455 if (flow_block_cb_is_busy(cb, priv, &ocelot_block_cb_list)) 456 return -EBUSY; 457 458 block_cb = flow_block_cb_alloc(cb, priv, priv, NULL); 459 if (IS_ERR(block_cb)) 460 return PTR_ERR(block_cb); 461 462 flow_block_cb_add(block_cb, f); 463 list_add_tail(&block_cb->driver_list, f->driver_block_list); 464 return 0; 465 case FLOW_BLOCK_UNBIND: 466 block_cb = flow_block_cb_lookup(f->block, cb, priv); 467 if (!block_cb) 468 return -ENOENT; 469 470 flow_block_cb_remove(block_cb, f); 471 list_del(&block_cb->driver_list); 472 return 0; 473 default: 474 return -EOPNOTSUPP; 475 } 476 } 477 478 static int ocelot_setup_tc(struct net_device *dev, enum tc_setup_type type, 479 void *type_data) 480 { 481 struct ocelot_port_private *priv = netdev_priv(dev); 482 483 switch (type) { 484 case TC_SETUP_BLOCK: 485 return ocelot_setup_tc_block(priv, type_data); 486 default: 487 return -EOPNOTSUPP; 488 } 489 return 0; 490 } 491 492 static int ocelot_vlan_vid_add(struct net_device *dev, u16 vid, bool pvid, 493 bool untagged) 494 { 495 struct ocelot_port_private *priv = netdev_priv(dev); 496 struct ocelot_port *ocelot_port = &priv->port; 497 struct ocelot *ocelot = ocelot_port->ocelot; 498 int port = priv->port.index; 499 int ret; 500 501 ret = ocelot_vlan_add(ocelot, port, vid, pvid, untagged); 502 if (ret) 503 return ret; 504 505 /* Add the port MAC address to with the right VLAN information */ 506 ocelot_mact_learn(ocelot, PGID_CPU, dev->dev_addr, vid, 507 ENTRYTYPE_LOCKED); 508 509 return 0; 510 } 511 512 static int ocelot_vlan_vid_del(struct net_device *dev, u16 vid) 513 { 514 struct ocelot_port_private *priv = netdev_priv(dev); 515 struct ocelot *ocelot = priv->port.ocelot; 516 int port = priv->port.index; 517 int ret; 518 519 /* 8021q removes VID 0 on module unload for all interfaces 520 * with VLAN filtering feature. We need to keep it to receive 521 * untagged traffic. 522 */ 523 if (vid == OCELOT_STANDALONE_PVID) 524 return 0; 525 526 ret = ocelot_vlan_del(ocelot, port, vid); 527 if (ret) 528 return ret; 529 530 /* Del the port MAC address to with the right VLAN information */ 531 ocelot_mact_forget(ocelot, dev->dev_addr, vid); 532 533 return 0; 534 } 535 536 static int ocelot_port_open(struct net_device *dev) 537 { 538 struct ocelot_port_private *priv = netdev_priv(dev); 539 540 phylink_start(priv->phylink); 541 542 return 0; 543 } 544 545 static int ocelot_port_stop(struct net_device *dev) 546 { 547 struct ocelot_port_private *priv = netdev_priv(dev); 548 549 phylink_stop(priv->phylink); 550 551 return 0; 552 } 553 554 static bool ocelot_xmit_timestamp(struct ocelot *ocelot, int port, 555 struct sk_buff *skb, u32 *rew_op) 556 { 557 if (ocelot->ptp && (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)) { 558 struct sk_buff *clone = NULL; 559 560 if (ocelot_port_txtstamp_request(ocelot, port, skb, &clone)) { 561 kfree_skb(skb); 562 return false; 563 } 564 565 if (clone) 566 OCELOT_SKB_CB(skb)->clone = clone; 567 568 *rew_op = ocelot_ptp_rew_op(skb); 569 } 570 571 return true; 572 } 573 574 static netdev_tx_t ocelot_port_xmit_fdma(struct sk_buff *skb, 575 struct net_device *dev) 576 { 577 struct ocelot_port_private *priv = netdev_priv(dev); 578 struct ocelot_port *ocelot_port = &priv->port; 579 struct ocelot *ocelot = ocelot_port->ocelot; 580 int port = priv->port.index; 581 u32 rew_op = 0; 582 583 if (!ocelot_xmit_timestamp(ocelot, port, skb, &rew_op)) 584 return NETDEV_TX_OK; 585 586 ocelot_fdma_inject_frame(ocelot, port, rew_op, skb, dev); 587 588 return NETDEV_TX_OK; 589 } 590 591 static netdev_tx_t ocelot_port_xmit_inj(struct sk_buff *skb, 592 struct net_device *dev) 593 { 594 struct ocelot_port_private *priv = netdev_priv(dev); 595 struct ocelot_port *ocelot_port = &priv->port; 596 struct ocelot *ocelot = ocelot_port->ocelot; 597 int port = priv->port.index; 598 u32 rew_op = 0; 599 600 ocelot_lock_inj_grp(ocelot, 0); 601 602 if (!ocelot_can_inject(ocelot, 0)) { 603 ocelot_unlock_inj_grp(ocelot, 0); 604 return NETDEV_TX_BUSY; 605 } 606 607 if (!ocelot_xmit_timestamp(ocelot, port, skb, &rew_op)) { 608 ocelot_unlock_inj_grp(ocelot, 0); 609 return NETDEV_TX_OK; 610 } 611 612 ocelot_port_inject_frame(ocelot, port, 0, rew_op, skb); 613 614 ocelot_unlock_inj_grp(ocelot, 0); 615 616 consume_skb(skb); 617 618 return NETDEV_TX_OK; 619 } 620 621 static netdev_tx_t ocelot_port_xmit(struct sk_buff *skb, struct net_device *dev) 622 { 623 if (static_branch_unlikely(&ocelot_fdma_enabled)) 624 return ocelot_port_xmit_fdma(skb, dev); 625 626 return ocelot_port_xmit_inj(skb, dev); 627 } 628 629 enum ocelot_action_type { 630 OCELOT_MACT_LEARN, 631 OCELOT_MACT_FORGET, 632 }; 633 634 struct ocelot_mact_work_ctx { 635 struct work_struct work; 636 struct ocelot *ocelot; 637 enum ocelot_action_type type; 638 union { 639 /* OCELOT_MACT_LEARN */ 640 struct { 641 unsigned char addr[ETH_ALEN]; 642 u16 vid; 643 enum macaccess_entry_type entry_type; 644 int pgid; 645 } learn; 646 /* OCELOT_MACT_FORGET */ 647 struct { 648 unsigned char addr[ETH_ALEN]; 649 u16 vid; 650 } forget; 651 }; 652 }; 653 654 #define ocelot_work_to_ctx(x) \ 655 container_of((x), struct ocelot_mact_work_ctx, work) 656 657 static void ocelot_mact_work(struct work_struct *work) 658 { 659 struct ocelot_mact_work_ctx *w = ocelot_work_to_ctx(work); 660 struct ocelot *ocelot = w->ocelot; 661 662 switch (w->type) { 663 case OCELOT_MACT_LEARN: 664 ocelot_mact_learn(ocelot, w->learn.pgid, w->learn.addr, 665 w->learn.vid, w->learn.entry_type); 666 break; 667 case OCELOT_MACT_FORGET: 668 ocelot_mact_forget(ocelot, w->forget.addr, w->forget.vid); 669 break; 670 default: 671 break; 672 } 673 674 kfree(w); 675 } 676 677 static int ocelot_enqueue_mact_action(struct ocelot *ocelot, 678 const struct ocelot_mact_work_ctx *ctx) 679 { 680 struct ocelot_mact_work_ctx *w = kmemdup(ctx, sizeof(*w), GFP_ATOMIC); 681 682 if (!w) 683 return -ENOMEM; 684 685 w->ocelot = ocelot; 686 INIT_WORK(&w->work, ocelot_mact_work); 687 queue_work(ocelot->owq, &w->work); 688 689 return 0; 690 } 691 692 static int ocelot_mc_unsync(struct net_device *dev, const unsigned char *addr) 693 { 694 struct ocelot_port_private *priv = netdev_priv(dev); 695 struct ocelot_port *ocelot_port = &priv->port; 696 struct ocelot *ocelot = ocelot_port->ocelot; 697 struct ocelot_mact_work_ctx w; 698 699 ether_addr_copy(w.forget.addr, addr); 700 w.forget.vid = OCELOT_STANDALONE_PVID; 701 w.type = OCELOT_MACT_FORGET; 702 703 return ocelot_enqueue_mact_action(ocelot, &w); 704 } 705 706 static int ocelot_mc_sync(struct net_device *dev, const unsigned char *addr) 707 { 708 struct ocelot_port_private *priv = netdev_priv(dev); 709 struct ocelot_port *ocelot_port = &priv->port; 710 struct ocelot *ocelot = ocelot_port->ocelot; 711 struct ocelot_mact_work_ctx w; 712 713 ether_addr_copy(w.learn.addr, addr); 714 w.learn.vid = OCELOT_STANDALONE_PVID; 715 w.learn.pgid = PGID_CPU; 716 w.learn.entry_type = ENTRYTYPE_LOCKED; 717 w.type = OCELOT_MACT_LEARN; 718 719 return ocelot_enqueue_mact_action(ocelot, &w); 720 } 721 722 static void ocelot_set_rx_mode(struct net_device *dev) 723 { 724 struct ocelot_port_private *priv = netdev_priv(dev); 725 struct ocelot *ocelot = priv->port.ocelot; 726 u32 val; 727 int i; 728 729 /* This doesn't handle promiscuous mode because the bridge core is 730 * setting IFF_PROMISC on all slave interfaces and all frames would be 731 * forwarded to the CPU port. 732 */ 733 val = GENMASK(ocelot->num_phys_ports - 1, 0); 734 for_each_nonreserved_multicast_dest_pgid(ocelot, i) 735 ocelot_write_rix(ocelot, val, ANA_PGID_PGID, i); 736 737 __dev_mc_sync(dev, ocelot_mc_sync, ocelot_mc_unsync); 738 } 739 740 static int ocelot_port_set_mac_address(struct net_device *dev, void *p) 741 { 742 struct ocelot_port_private *priv = netdev_priv(dev); 743 struct ocelot_port *ocelot_port = &priv->port; 744 struct ocelot *ocelot = ocelot_port->ocelot; 745 const struct sockaddr *addr = p; 746 747 /* Learn the new net device MAC address in the mac table. */ 748 ocelot_mact_learn(ocelot, PGID_CPU, addr->sa_data, 749 OCELOT_STANDALONE_PVID, ENTRYTYPE_LOCKED); 750 /* Then forget the previous one. */ 751 ocelot_mact_forget(ocelot, dev->dev_addr, OCELOT_STANDALONE_PVID); 752 753 eth_hw_addr_set(dev, addr->sa_data); 754 return 0; 755 } 756 757 static void ocelot_get_stats64(struct net_device *dev, 758 struct rtnl_link_stats64 *stats) 759 { 760 struct ocelot_port_private *priv = netdev_priv(dev); 761 struct ocelot *ocelot = priv->port.ocelot; 762 int port = priv->port.index; 763 764 return ocelot_port_get_stats64(ocelot, port, stats); 765 } 766 767 static int ocelot_port_fdb_add(struct ndmsg *ndm, struct nlattr *tb[], 768 struct net_device *dev, 769 const unsigned char *addr, 770 u16 vid, u16 flags, bool *notified, 771 struct netlink_ext_ack *extack) 772 { 773 struct ocelot_port_private *priv = netdev_priv(dev); 774 struct ocelot_port *ocelot_port = &priv->port; 775 struct ocelot *ocelot = ocelot_port->ocelot; 776 int port = priv->port.index; 777 778 return ocelot_fdb_add(ocelot, port, addr, vid, ocelot_port->bridge); 779 } 780 781 static int ocelot_port_fdb_del(struct ndmsg *ndm, struct nlattr *tb[], 782 struct net_device *dev, 783 const unsigned char *addr, u16 vid, 784 bool *notified, struct netlink_ext_ack *extack) 785 { 786 struct ocelot_port_private *priv = netdev_priv(dev); 787 struct ocelot_port *ocelot_port = &priv->port; 788 struct ocelot *ocelot = ocelot_port->ocelot; 789 int port = priv->port.index; 790 791 return ocelot_fdb_del(ocelot, port, addr, vid, ocelot_port->bridge); 792 } 793 794 static int ocelot_port_fdb_do_dump(const unsigned char *addr, u16 vid, 795 bool is_static, void *data) 796 { 797 struct ocelot_dump_ctx *dump = data; 798 struct ndo_fdb_dump_context *ctx = (void *)dump->cb->ctx; 799 u32 portid = NETLINK_CB(dump->cb->skb).portid; 800 u32 seq = dump->cb->nlh->nlmsg_seq; 801 struct nlmsghdr *nlh; 802 struct ndmsg *ndm; 803 804 if (dump->idx < ctx->fdb_idx) 805 goto skip; 806 807 nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH, 808 sizeof(*ndm), NLM_F_MULTI); 809 if (!nlh) 810 return -EMSGSIZE; 811 812 ndm = nlmsg_data(nlh); 813 ndm->ndm_family = AF_BRIDGE; 814 ndm->ndm_pad1 = 0; 815 ndm->ndm_pad2 = 0; 816 ndm->ndm_flags = NTF_SELF; 817 ndm->ndm_type = 0; 818 ndm->ndm_ifindex = dump->dev->ifindex; 819 ndm->ndm_state = is_static ? NUD_NOARP : NUD_REACHABLE; 820 821 if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, addr)) 822 goto nla_put_failure; 823 824 if (vid && nla_put_u16(dump->skb, NDA_VLAN, vid)) 825 goto nla_put_failure; 826 827 nlmsg_end(dump->skb, nlh); 828 829 skip: 830 dump->idx++; 831 return 0; 832 833 nla_put_failure: 834 nlmsg_cancel(dump->skb, nlh); 835 return -EMSGSIZE; 836 } 837 838 static int ocelot_port_fdb_dump(struct sk_buff *skb, 839 struct netlink_callback *cb, 840 struct net_device *dev, 841 struct net_device *filter_dev, int *idx) 842 { 843 struct ocelot_port_private *priv = netdev_priv(dev); 844 struct ocelot *ocelot = priv->port.ocelot; 845 struct ocelot_dump_ctx dump = { 846 .dev = dev, 847 .skb = skb, 848 .cb = cb, 849 .idx = *idx, 850 }; 851 int port = priv->port.index; 852 int ret; 853 854 ret = ocelot_fdb_dump(ocelot, port, ocelot_port_fdb_do_dump, &dump); 855 856 *idx = dump.idx; 857 858 return ret; 859 } 860 861 static int ocelot_vlan_rx_add_vid(struct net_device *dev, __be16 proto, 862 u16 vid) 863 { 864 return ocelot_vlan_vid_add(dev, vid, false, false); 865 } 866 867 static int ocelot_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, 868 u16 vid) 869 { 870 return ocelot_vlan_vid_del(dev, vid); 871 } 872 873 static void ocelot_vlan_mode(struct ocelot *ocelot, int port, 874 netdev_features_t features) 875 { 876 u32 val; 877 878 /* Filtering */ 879 val = ocelot_read(ocelot, ANA_VLANMASK); 880 if (features & NETIF_F_HW_VLAN_CTAG_FILTER) 881 val |= BIT(port); 882 else 883 val &= ~BIT(port); 884 ocelot_write(ocelot, val, ANA_VLANMASK); 885 } 886 887 static int ocelot_set_features(struct net_device *dev, 888 netdev_features_t features) 889 { 890 netdev_features_t changed = dev->features ^ features; 891 struct ocelot_port_private *priv = netdev_priv(dev); 892 struct ocelot *ocelot = priv->port.ocelot; 893 int port = priv->port.index; 894 895 if ((dev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC) && 896 priv->tc.offload_cnt) { 897 netdev_err(dev, 898 "Cannot disable HW TC offload while offloads active\n"); 899 return -EBUSY; 900 } 901 902 if (changed & NETIF_F_HW_VLAN_CTAG_FILTER) 903 ocelot_vlan_mode(ocelot, port, features); 904 905 return 0; 906 } 907 908 static int ocelot_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 909 { 910 return phy_mii_ioctl(dev->phydev, ifr, cmd); 911 } 912 913 static int ocelot_port_hwtstamp_get(struct net_device *dev, 914 struct kernel_hwtstamp_config *cfg) 915 { 916 struct ocelot_port_private *priv = netdev_priv(dev); 917 struct ocelot *ocelot = priv->port.ocelot; 918 int port = priv->port.index; 919 920 ocelot_hwstamp_get(ocelot, port, cfg); 921 922 return 0; 923 } 924 925 static int ocelot_port_hwtstamp_set(struct net_device *dev, 926 struct kernel_hwtstamp_config *cfg, 927 struct netlink_ext_ack *extack) 928 { 929 struct ocelot_port_private *priv = netdev_priv(dev); 930 struct ocelot *ocelot = priv->port.ocelot; 931 int port = priv->port.index; 932 933 return ocelot_hwstamp_set(ocelot, port, cfg, extack); 934 } 935 936 static int ocelot_change_mtu(struct net_device *dev, int new_mtu) 937 { 938 struct ocelot_port_private *priv = netdev_priv(dev); 939 struct ocelot_port *ocelot_port = &priv->port; 940 struct ocelot *ocelot = ocelot_port->ocelot; 941 942 ocelot_port_set_maxlen(ocelot, priv->port.index, new_mtu); 943 WRITE_ONCE(dev->mtu, new_mtu); 944 945 return 0; 946 } 947 948 static const struct net_device_ops ocelot_port_netdev_ops = { 949 .ndo_open = ocelot_port_open, 950 .ndo_stop = ocelot_port_stop, 951 .ndo_start_xmit = ocelot_port_xmit, 952 .ndo_change_mtu = ocelot_change_mtu, 953 .ndo_set_rx_mode = ocelot_set_rx_mode, 954 .ndo_set_mac_address = ocelot_port_set_mac_address, 955 .ndo_get_stats64 = ocelot_get_stats64, 956 .ndo_fdb_add = ocelot_port_fdb_add, 957 .ndo_fdb_del = ocelot_port_fdb_del, 958 .ndo_fdb_dump = ocelot_port_fdb_dump, 959 .ndo_vlan_rx_add_vid = ocelot_vlan_rx_add_vid, 960 .ndo_vlan_rx_kill_vid = ocelot_vlan_rx_kill_vid, 961 .ndo_set_features = ocelot_set_features, 962 .ndo_setup_tc = ocelot_setup_tc, 963 .ndo_eth_ioctl = ocelot_ioctl, 964 .ndo_hwtstamp_get = ocelot_port_hwtstamp_get, 965 .ndo_hwtstamp_set = ocelot_port_hwtstamp_set, 966 }; 967 968 struct net_device *ocelot_port_to_netdev(struct ocelot *ocelot, int port) 969 { 970 struct ocelot_port *ocelot_port = ocelot->ports[port]; 971 struct ocelot_port_private *priv; 972 973 if (!ocelot_port) 974 return NULL; 975 976 priv = container_of(ocelot_port, struct ocelot_port_private, port); 977 978 return priv->dev; 979 } 980 981 /* Checks if the net_device instance given to us originates from our driver */ 982 static bool ocelot_netdevice_dev_check(const struct net_device *dev) 983 { 984 return dev->netdev_ops == &ocelot_port_netdev_ops; 985 } 986 987 int ocelot_netdev_to_port(struct ocelot *ocelot, struct net_device *dev) 988 { 989 struct ocelot_port_private *priv; 990 991 if (!dev || !ocelot_netdevice_dev_check(dev)) 992 return -EINVAL; 993 994 priv = netdev_priv(dev); 995 if (priv->port.ocelot != ocelot) 996 return -EINVAL; 997 998 return priv->port.index; 999 } 1000 1001 static void ocelot_port_get_strings(struct net_device *netdev, u32 sset, 1002 u8 *data) 1003 { 1004 struct ocelot_port_private *priv = netdev_priv(netdev); 1005 struct ocelot *ocelot = priv->port.ocelot; 1006 int port = priv->port.index; 1007 1008 ocelot_get_strings(ocelot, port, sset, data); 1009 } 1010 1011 static void ocelot_port_get_ethtool_stats(struct net_device *dev, 1012 struct ethtool_stats *stats, 1013 u64 *data) 1014 { 1015 struct ocelot_port_private *priv = netdev_priv(dev); 1016 struct ocelot *ocelot = priv->port.ocelot; 1017 int port = priv->port.index; 1018 1019 ocelot_get_ethtool_stats(ocelot, port, data); 1020 } 1021 1022 static int ocelot_port_get_sset_count(struct net_device *dev, int sset) 1023 { 1024 struct ocelot_port_private *priv = netdev_priv(dev); 1025 struct ocelot *ocelot = priv->port.ocelot; 1026 int port = priv->port.index; 1027 1028 return ocelot_get_sset_count(ocelot, port, sset); 1029 } 1030 1031 static int ocelot_port_get_ts_info(struct net_device *dev, 1032 struct kernel_ethtool_ts_info *info) 1033 { 1034 struct ocelot_port_private *priv = netdev_priv(dev); 1035 struct ocelot *ocelot = priv->port.ocelot; 1036 int port = priv->port.index; 1037 1038 if (!ocelot->ptp) 1039 return ethtool_op_get_ts_info(dev, info); 1040 1041 return ocelot_get_ts_info(ocelot, port, info); 1042 } 1043 1044 static void ocelot_port_ts_stats(struct net_device *dev, 1045 struct ethtool_ts_stats *ts_stats) 1046 { 1047 struct ocelot_port_private *priv = netdev_priv(dev); 1048 struct ocelot *ocelot = priv->port.ocelot; 1049 int port = priv->port.index; 1050 1051 ocelot_port_get_ts_stats(ocelot, port, ts_stats); 1052 } 1053 1054 static const struct ethtool_ops ocelot_ethtool_ops = { 1055 .get_strings = ocelot_port_get_strings, 1056 .get_ethtool_stats = ocelot_port_get_ethtool_stats, 1057 .get_sset_count = ocelot_port_get_sset_count, 1058 .get_link_ksettings = phy_ethtool_get_link_ksettings, 1059 .set_link_ksettings = phy_ethtool_set_link_ksettings, 1060 .get_ts_info = ocelot_port_get_ts_info, 1061 .get_ts_stats = ocelot_port_ts_stats, 1062 }; 1063 1064 static void ocelot_port_attr_stp_state_set(struct ocelot *ocelot, int port, 1065 u8 state) 1066 { 1067 ocelot_bridge_stp_state_set(ocelot, port, state); 1068 } 1069 1070 static void ocelot_port_attr_ageing_set(struct ocelot *ocelot, int port, 1071 unsigned long ageing_clock_t) 1072 { 1073 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t); 1074 u32 ageing_time = jiffies_to_msecs(ageing_jiffies); 1075 1076 ocelot_set_ageing_time(ocelot, ageing_time); 1077 } 1078 1079 static void ocelot_port_attr_mc_set(struct ocelot *ocelot, int port, bool mc) 1080 { 1081 u32 cpu_fwd_mcast = ANA_PORT_CPU_FWD_CFG_CPU_IGMP_REDIR_ENA | 1082 ANA_PORT_CPU_FWD_CFG_CPU_MLD_REDIR_ENA | 1083 ANA_PORT_CPU_FWD_CFG_CPU_IPMC_CTRL_COPY_ENA; 1084 u32 val = 0; 1085 1086 if (mc) 1087 val = cpu_fwd_mcast; 1088 1089 ocelot_rmw_gix(ocelot, val, cpu_fwd_mcast, 1090 ANA_PORT_CPU_FWD_CFG, port); 1091 } 1092 1093 static int ocelot_port_attr_set(struct net_device *dev, const void *ctx, 1094 const struct switchdev_attr *attr, 1095 struct netlink_ext_ack *extack) 1096 { 1097 struct ocelot_port_private *priv = netdev_priv(dev); 1098 struct ocelot *ocelot = priv->port.ocelot; 1099 int port = priv->port.index; 1100 int err = 0; 1101 1102 if (ctx && ctx != priv) 1103 return 0; 1104 1105 switch (attr->id) { 1106 case SWITCHDEV_ATTR_ID_PORT_STP_STATE: 1107 ocelot_port_attr_stp_state_set(ocelot, port, attr->u.stp_state); 1108 break; 1109 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME: 1110 ocelot_port_attr_ageing_set(ocelot, port, attr->u.ageing_time); 1111 break; 1112 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING: 1113 ocelot_port_vlan_filtering(ocelot, port, attr->u.vlan_filtering, 1114 extack); 1115 break; 1116 case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED: 1117 ocelot_port_attr_mc_set(ocelot, port, !attr->u.mc_disabled); 1118 break; 1119 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS: 1120 err = ocelot_port_pre_bridge_flags(ocelot, port, 1121 attr->u.brport_flags); 1122 break; 1123 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS: 1124 ocelot_port_bridge_flags(ocelot, port, attr->u.brport_flags); 1125 break; 1126 default: 1127 err = -EOPNOTSUPP; 1128 break; 1129 } 1130 1131 return err; 1132 } 1133 1134 static int ocelot_vlan_vid_prepare(struct net_device *dev, u16 vid, bool pvid, 1135 bool untagged, struct netlink_ext_ack *extack) 1136 { 1137 struct ocelot_port_private *priv = netdev_priv(dev); 1138 struct ocelot_port *ocelot_port = &priv->port; 1139 struct ocelot *ocelot = ocelot_port->ocelot; 1140 int port = priv->port.index; 1141 1142 return ocelot_vlan_prepare(ocelot, port, vid, pvid, untagged, extack); 1143 } 1144 1145 static int ocelot_port_obj_add_vlan(struct net_device *dev, 1146 const struct switchdev_obj_port_vlan *vlan, 1147 struct netlink_ext_ack *extack) 1148 { 1149 bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED; 1150 bool pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID; 1151 int ret; 1152 1153 ret = ocelot_vlan_vid_prepare(dev, vlan->vid, pvid, untagged, extack); 1154 if (ret) 1155 return ret; 1156 1157 return ocelot_vlan_vid_add(dev, vlan->vid, pvid, untagged); 1158 } 1159 1160 static int ocelot_port_obj_add_mdb(struct net_device *dev, 1161 const struct switchdev_obj_port_mdb *mdb) 1162 { 1163 struct ocelot_port_private *priv = netdev_priv(dev); 1164 struct ocelot_port *ocelot_port = &priv->port; 1165 struct ocelot *ocelot = ocelot_port->ocelot; 1166 int port = priv->port.index; 1167 1168 return ocelot_port_mdb_add(ocelot, port, mdb, ocelot_port->bridge); 1169 } 1170 1171 static int ocelot_port_obj_del_mdb(struct net_device *dev, 1172 const struct switchdev_obj_port_mdb *mdb) 1173 { 1174 struct ocelot_port_private *priv = netdev_priv(dev); 1175 struct ocelot_port *ocelot_port = &priv->port; 1176 struct ocelot *ocelot = ocelot_port->ocelot; 1177 int port = priv->port.index; 1178 1179 return ocelot_port_mdb_del(ocelot, port, mdb, ocelot_port->bridge); 1180 } 1181 1182 static int ocelot_port_obj_mrp_add(struct net_device *dev, 1183 const struct switchdev_obj_mrp *mrp) 1184 { 1185 struct ocelot_port_private *priv = netdev_priv(dev); 1186 struct ocelot_port *ocelot_port = &priv->port; 1187 struct ocelot *ocelot = ocelot_port->ocelot; 1188 int port = priv->port.index; 1189 1190 return ocelot_mrp_add(ocelot, port, mrp); 1191 } 1192 1193 static int ocelot_port_obj_mrp_del(struct net_device *dev, 1194 const struct switchdev_obj_mrp *mrp) 1195 { 1196 struct ocelot_port_private *priv = netdev_priv(dev); 1197 struct ocelot_port *ocelot_port = &priv->port; 1198 struct ocelot *ocelot = ocelot_port->ocelot; 1199 int port = priv->port.index; 1200 1201 return ocelot_mrp_del(ocelot, port, mrp); 1202 } 1203 1204 static int 1205 ocelot_port_obj_mrp_add_ring_role(struct net_device *dev, 1206 const struct switchdev_obj_ring_role_mrp *mrp) 1207 { 1208 struct ocelot_port_private *priv = netdev_priv(dev); 1209 struct ocelot_port *ocelot_port = &priv->port; 1210 struct ocelot *ocelot = ocelot_port->ocelot; 1211 int port = priv->port.index; 1212 1213 return ocelot_mrp_add_ring_role(ocelot, port, mrp); 1214 } 1215 1216 static int 1217 ocelot_port_obj_mrp_del_ring_role(struct net_device *dev, 1218 const struct switchdev_obj_ring_role_mrp *mrp) 1219 { 1220 struct ocelot_port_private *priv = netdev_priv(dev); 1221 struct ocelot_port *ocelot_port = &priv->port; 1222 struct ocelot *ocelot = ocelot_port->ocelot; 1223 int port = priv->port.index; 1224 1225 return ocelot_mrp_del_ring_role(ocelot, port, mrp); 1226 } 1227 1228 static int ocelot_port_obj_add(struct net_device *dev, const void *ctx, 1229 const struct switchdev_obj *obj, 1230 struct netlink_ext_ack *extack) 1231 { 1232 struct ocelot_port_private *priv = netdev_priv(dev); 1233 int ret = 0; 1234 1235 if (ctx && ctx != priv) 1236 return 0; 1237 1238 switch (obj->id) { 1239 case SWITCHDEV_OBJ_ID_PORT_VLAN: 1240 ret = ocelot_port_obj_add_vlan(dev, 1241 SWITCHDEV_OBJ_PORT_VLAN(obj), 1242 extack); 1243 break; 1244 case SWITCHDEV_OBJ_ID_PORT_MDB: 1245 ret = ocelot_port_obj_add_mdb(dev, SWITCHDEV_OBJ_PORT_MDB(obj)); 1246 break; 1247 case SWITCHDEV_OBJ_ID_MRP: 1248 ret = ocelot_port_obj_mrp_add(dev, SWITCHDEV_OBJ_MRP(obj)); 1249 break; 1250 case SWITCHDEV_OBJ_ID_RING_ROLE_MRP: 1251 ret = ocelot_port_obj_mrp_add_ring_role(dev, 1252 SWITCHDEV_OBJ_RING_ROLE_MRP(obj)); 1253 break; 1254 default: 1255 return -EOPNOTSUPP; 1256 } 1257 1258 return ret; 1259 } 1260 1261 static int ocelot_port_obj_del(struct net_device *dev, const void *ctx, 1262 const struct switchdev_obj *obj) 1263 { 1264 struct ocelot_port_private *priv = netdev_priv(dev); 1265 int ret = 0; 1266 1267 if (ctx && ctx != priv) 1268 return 0; 1269 1270 switch (obj->id) { 1271 case SWITCHDEV_OBJ_ID_PORT_VLAN: 1272 ret = ocelot_vlan_vid_del(dev, 1273 SWITCHDEV_OBJ_PORT_VLAN(obj)->vid); 1274 break; 1275 case SWITCHDEV_OBJ_ID_PORT_MDB: 1276 ret = ocelot_port_obj_del_mdb(dev, SWITCHDEV_OBJ_PORT_MDB(obj)); 1277 break; 1278 case SWITCHDEV_OBJ_ID_MRP: 1279 ret = ocelot_port_obj_mrp_del(dev, SWITCHDEV_OBJ_MRP(obj)); 1280 break; 1281 case SWITCHDEV_OBJ_ID_RING_ROLE_MRP: 1282 ret = ocelot_port_obj_mrp_del_ring_role(dev, 1283 SWITCHDEV_OBJ_RING_ROLE_MRP(obj)); 1284 break; 1285 default: 1286 return -EOPNOTSUPP; 1287 } 1288 1289 return ret; 1290 } 1291 1292 static void ocelot_inherit_brport_flags(struct ocelot *ocelot, int port, 1293 struct net_device *brport_dev) 1294 { 1295 struct switchdev_brport_flags flags = {0}; 1296 int flag; 1297 1298 flags.mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD; 1299 1300 for_each_set_bit(flag, &flags.mask, 32) 1301 if (br_port_flag_is_set(brport_dev, BIT(flag))) 1302 flags.val |= BIT(flag); 1303 1304 ocelot_port_bridge_flags(ocelot, port, flags); 1305 } 1306 1307 static void ocelot_clear_brport_flags(struct ocelot *ocelot, int port) 1308 { 1309 struct switchdev_brport_flags flags; 1310 1311 flags.mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD; 1312 flags.val = flags.mask & ~BR_LEARNING; 1313 1314 ocelot_port_bridge_flags(ocelot, port, flags); 1315 } 1316 1317 static int ocelot_switchdev_sync(struct ocelot *ocelot, int port, 1318 struct net_device *brport_dev, 1319 struct net_device *bridge_dev, 1320 struct netlink_ext_ack *extack) 1321 { 1322 clock_t ageing_time; 1323 u8 stp_state; 1324 1325 ocelot_inherit_brport_flags(ocelot, port, brport_dev); 1326 1327 stp_state = br_port_get_stp_state(brport_dev); 1328 ocelot_bridge_stp_state_set(ocelot, port, stp_state); 1329 1330 ageing_time = br_get_ageing_time(bridge_dev); 1331 ocelot_port_attr_ageing_set(ocelot, port, ageing_time); 1332 1333 return ocelot_port_vlan_filtering(ocelot, port, 1334 br_vlan_enabled(bridge_dev), 1335 extack); 1336 } 1337 1338 static int ocelot_switchdev_unsync(struct ocelot *ocelot, int port) 1339 { 1340 int err; 1341 1342 err = ocelot_port_vlan_filtering(ocelot, port, false, NULL); 1343 if (err) 1344 return err; 1345 1346 ocelot_clear_brport_flags(ocelot, port); 1347 1348 ocelot_bridge_stp_state_set(ocelot, port, BR_STATE_FORWARDING); 1349 1350 return 0; 1351 } 1352 1353 static int ocelot_bridge_num_get(struct ocelot *ocelot, 1354 const struct net_device *bridge_dev) 1355 { 1356 int bridge_num = ocelot_bridge_num_find(ocelot, bridge_dev); 1357 1358 if (bridge_num < 0) { 1359 /* First port that offloads this bridge */ 1360 bridge_num = find_first_zero_bit(&ocelot->bridges, 1361 ocelot->num_phys_ports); 1362 1363 set_bit(bridge_num, &ocelot->bridges); 1364 } 1365 1366 return bridge_num; 1367 } 1368 1369 static void ocelot_bridge_num_put(struct ocelot *ocelot, 1370 const struct net_device *bridge_dev, 1371 int bridge_num) 1372 { 1373 /* Check if the bridge is still in use, otherwise it is time 1374 * to clean it up so we can reuse this bridge_num later. 1375 */ 1376 if (!ocelot_bridge_num_find(ocelot, bridge_dev)) 1377 clear_bit(bridge_num, &ocelot->bridges); 1378 } 1379 1380 static int ocelot_netdevice_bridge_join(struct net_device *dev, 1381 struct net_device *brport_dev, 1382 struct net_device *bridge, 1383 struct netlink_ext_ack *extack) 1384 { 1385 struct ocelot_port_private *priv = netdev_priv(dev); 1386 struct ocelot_port *ocelot_port = &priv->port; 1387 struct ocelot *ocelot = ocelot_port->ocelot; 1388 int port = priv->port.index; 1389 int bridge_num, err; 1390 1391 bridge_num = ocelot_bridge_num_get(ocelot, bridge); 1392 1393 err = ocelot_port_bridge_join(ocelot, port, bridge, bridge_num, 1394 extack); 1395 if (err) 1396 goto err_join; 1397 1398 err = switchdev_bridge_port_offload(brport_dev, dev, priv, 1399 &ocelot_switchdev_nb, 1400 &ocelot_switchdev_blocking_nb, 1401 false, extack); 1402 if (err) 1403 goto err_switchdev_offload; 1404 1405 err = ocelot_switchdev_sync(ocelot, port, brport_dev, bridge, extack); 1406 if (err) 1407 goto err_switchdev_sync; 1408 1409 return 0; 1410 1411 err_switchdev_sync: 1412 switchdev_bridge_port_unoffload(brport_dev, priv, 1413 &ocelot_switchdev_nb, 1414 &ocelot_switchdev_blocking_nb); 1415 err_switchdev_offload: 1416 ocelot_port_bridge_leave(ocelot, port, bridge); 1417 err_join: 1418 ocelot_bridge_num_put(ocelot, bridge, bridge_num); 1419 return err; 1420 } 1421 1422 static void ocelot_netdevice_pre_bridge_leave(struct net_device *dev, 1423 struct net_device *brport_dev) 1424 { 1425 struct ocelot_port_private *priv = netdev_priv(dev); 1426 1427 switchdev_bridge_port_unoffload(brport_dev, priv, 1428 &ocelot_switchdev_nb, 1429 &ocelot_switchdev_blocking_nb); 1430 } 1431 1432 static int ocelot_netdevice_bridge_leave(struct net_device *dev, 1433 struct net_device *brport_dev, 1434 struct net_device *bridge) 1435 { 1436 struct ocelot_port_private *priv = netdev_priv(dev); 1437 struct ocelot_port *ocelot_port = &priv->port; 1438 struct ocelot *ocelot = ocelot_port->ocelot; 1439 int bridge_num = ocelot_port->bridge_num; 1440 int port = priv->port.index; 1441 int err; 1442 1443 err = ocelot_switchdev_unsync(ocelot, port); 1444 if (err) 1445 return err; 1446 1447 ocelot_port_bridge_leave(ocelot, port, bridge); 1448 ocelot_bridge_num_put(ocelot, bridge, bridge_num); 1449 1450 return 0; 1451 } 1452 1453 static int ocelot_netdevice_lag_join(struct net_device *dev, 1454 struct net_device *bond, 1455 struct netdev_lag_upper_info *info, 1456 struct netlink_ext_ack *extack) 1457 { 1458 struct ocelot_port_private *priv = netdev_priv(dev); 1459 struct ocelot_port *ocelot_port = &priv->port; 1460 struct ocelot *ocelot = ocelot_port->ocelot; 1461 struct net_device *bridge_dev; 1462 int port = priv->port.index; 1463 int err; 1464 1465 err = ocelot_port_lag_join(ocelot, port, bond, info, extack); 1466 if (err == -EOPNOTSUPP) 1467 /* Offloading not supported, fall back to software LAG */ 1468 return 0; 1469 1470 bridge_dev = netdev_master_upper_dev_get(bond); 1471 if (!bridge_dev || !netif_is_bridge_master(bridge_dev)) 1472 return 0; 1473 1474 err = ocelot_netdevice_bridge_join(dev, bond, bridge_dev, extack); 1475 if (err) 1476 goto err_bridge_join; 1477 1478 return 0; 1479 1480 err_bridge_join: 1481 ocelot_port_lag_leave(ocelot, port, bond); 1482 return err; 1483 } 1484 1485 static void ocelot_netdevice_pre_lag_leave(struct net_device *dev, 1486 struct net_device *bond) 1487 { 1488 struct net_device *bridge_dev; 1489 1490 bridge_dev = netdev_master_upper_dev_get(bond); 1491 if (!bridge_dev || !netif_is_bridge_master(bridge_dev)) 1492 return; 1493 1494 ocelot_netdevice_pre_bridge_leave(dev, bond); 1495 } 1496 1497 static int ocelot_netdevice_lag_leave(struct net_device *dev, 1498 struct net_device *bond) 1499 { 1500 struct ocelot_port_private *priv = netdev_priv(dev); 1501 struct ocelot_port *ocelot_port = &priv->port; 1502 struct ocelot *ocelot = ocelot_port->ocelot; 1503 struct net_device *bridge_dev; 1504 int port = priv->port.index; 1505 1506 ocelot_port_lag_leave(ocelot, port, bond); 1507 1508 bridge_dev = netdev_master_upper_dev_get(bond); 1509 if (!bridge_dev || !netif_is_bridge_master(bridge_dev)) 1510 return 0; 1511 1512 return ocelot_netdevice_bridge_leave(dev, bond, bridge_dev); 1513 } 1514 1515 static int ocelot_netdevice_changeupper(struct net_device *dev, 1516 struct net_device *brport_dev, 1517 struct netdev_notifier_changeupper_info *info) 1518 { 1519 struct netlink_ext_ack *extack; 1520 int err = 0; 1521 1522 extack = netdev_notifier_info_to_extack(&info->info); 1523 1524 if (netif_is_bridge_master(info->upper_dev)) { 1525 if (info->linking) 1526 err = ocelot_netdevice_bridge_join(dev, brport_dev, 1527 info->upper_dev, 1528 extack); 1529 else 1530 err = ocelot_netdevice_bridge_leave(dev, brport_dev, 1531 info->upper_dev); 1532 } 1533 if (netif_is_lag_master(info->upper_dev)) { 1534 if (info->linking) 1535 err = ocelot_netdevice_lag_join(dev, info->upper_dev, 1536 info->upper_info, extack); 1537 else 1538 ocelot_netdevice_lag_leave(dev, info->upper_dev); 1539 } 1540 1541 return notifier_from_errno(err); 1542 } 1543 1544 /* Treat CHANGEUPPER events on an offloaded LAG as individual CHANGEUPPER 1545 * events for the lower physical ports of the LAG. 1546 * If the LAG upper isn't offloaded, ignore its CHANGEUPPER events. 1547 * In case the LAG joined a bridge, notify that we are offloading it and can do 1548 * forwarding in hardware towards it. 1549 */ 1550 static int 1551 ocelot_netdevice_lag_changeupper(struct net_device *dev, 1552 struct netdev_notifier_changeupper_info *info) 1553 { 1554 struct net_device *lower; 1555 struct list_head *iter; 1556 int err = NOTIFY_DONE; 1557 1558 netdev_for_each_lower_dev(dev, lower, iter) { 1559 struct ocelot_port_private *priv = netdev_priv(lower); 1560 struct ocelot_port *ocelot_port = &priv->port; 1561 1562 if (ocelot_port->bond != dev) 1563 return NOTIFY_OK; 1564 1565 err = ocelot_netdevice_changeupper(lower, dev, info); 1566 if (err) 1567 return notifier_from_errno(err); 1568 } 1569 1570 return NOTIFY_DONE; 1571 } 1572 1573 static int 1574 ocelot_netdevice_prechangeupper(struct net_device *dev, 1575 struct net_device *brport_dev, 1576 struct netdev_notifier_changeupper_info *info) 1577 { 1578 if (netif_is_bridge_master(info->upper_dev) && !info->linking) 1579 ocelot_netdevice_pre_bridge_leave(dev, brport_dev); 1580 1581 if (netif_is_lag_master(info->upper_dev) && !info->linking) 1582 ocelot_netdevice_pre_lag_leave(dev, info->upper_dev); 1583 1584 return NOTIFY_DONE; 1585 } 1586 1587 static int 1588 ocelot_netdevice_lag_prechangeupper(struct net_device *dev, 1589 struct netdev_notifier_changeupper_info *info) 1590 { 1591 struct net_device *lower; 1592 struct list_head *iter; 1593 int err = NOTIFY_DONE; 1594 1595 netdev_for_each_lower_dev(dev, lower, iter) { 1596 struct ocelot_port_private *priv = netdev_priv(lower); 1597 struct ocelot_port *ocelot_port = &priv->port; 1598 1599 if (ocelot_port->bond != dev) 1600 return NOTIFY_OK; 1601 1602 err = ocelot_netdevice_prechangeupper(dev, lower, info); 1603 if (err) 1604 return err; 1605 } 1606 1607 return NOTIFY_DONE; 1608 } 1609 1610 static int 1611 ocelot_netdevice_changelowerstate(struct net_device *dev, 1612 struct netdev_lag_lower_state_info *info) 1613 { 1614 struct ocelot_port_private *priv = netdev_priv(dev); 1615 bool is_active = info->link_up && info->tx_enabled; 1616 struct ocelot_port *ocelot_port = &priv->port; 1617 struct ocelot *ocelot = ocelot_port->ocelot; 1618 int port = priv->port.index; 1619 1620 if (!ocelot_port->bond) 1621 return NOTIFY_DONE; 1622 1623 if (ocelot_port->lag_tx_active == is_active) 1624 return NOTIFY_DONE; 1625 1626 ocelot_port_lag_change(ocelot, port, is_active); 1627 1628 return NOTIFY_OK; 1629 } 1630 1631 static int ocelot_netdevice_event(struct notifier_block *unused, 1632 unsigned long event, void *ptr) 1633 { 1634 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 1635 1636 switch (event) { 1637 case NETDEV_PRECHANGEUPPER: { 1638 struct netdev_notifier_changeupper_info *info = ptr; 1639 1640 if (ocelot_netdevice_dev_check(dev)) 1641 return ocelot_netdevice_prechangeupper(dev, dev, info); 1642 1643 if (netif_is_lag_master(dev)) 1644 return ocelot_netdevice_lag_prechangeupper(dev, info); 1645 1646 break; 1647 } 1648 case NETDEV_CHANGEUPPER: { 1649 struct netdev_notifier_changeupper_info *info = ptr; 1650 1651 if (ocelot_netdevice_dev_check(dev)) 1652 return ocelot_netdevice_changeupper(dev, dev, info); 1653 1654 if (netif_is_lag_master(dev)) 1655 return ocelot_netdevice_lag_changeupper(dev, info); 1656 1657 break; 1658 } 1659 case NETDEV_CHANGELOWERSTATE: { 1660 struct netdev_notifier_changelowerstate_info *info = ptr; 1661 1662 if (!ocelot_netdevice_dev_check(dev)) 1663 break; 1664 1665 return ocelot_netdevice_changelowerstate(dev, 1666 info->lower_state_info); 1667 } 1668 default: 1669 break; 1670 } 1671 1672 return NOTIFY_DONE; 1673 } 1674 1675 struct notifier_block ocelot_netdevice_nb __read_mostly = { 1676 .notifier_call = ocelot_netdevice_event, 1677 }; 1678 1679 static int ocelot_switchdev_event(struct notifier_block *unused, 1680 unsigned long event, void *ptr) 1681 { 1682 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 1683 int err; 1684 1685 switch (event) { 1686 case SWITCHDEV_PORT_ATTR_SET: 1687 err = switchdev_handle_port_attr_set(dev, ptr, 1688 ocelot_netdevice_dev_check, 1689 ocelot_port_attr_set); 1690 return notifier_from_errno(err); 1691 } 1692 1693 return NOTIFY_DONE; 1694 } 1695 1696 struct notifier_block ocelot_switchdev_nb __read_mostly = { 1697 .notifier_call = ocelot_switchdev_event, 1698 }; 1699 1700 static int ocelot_switchdev_blocking_event(struct notifier_block *unused, 1701 unsigned long event, void *ptr) 1702 { 1703 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 1704 int err; 1705 1706 switch (event) { 1707 /* Blocking events. */ 1708 case SWITCHDEV_PORT_OBJ_ADD: 1709 err = switchdev_handle_port_obj_add(dev, ptr, 1710 ocelot_netdevice_dev_check, 1711 ocelot_port_obj_add); 1712 return notifier_from_errno(err); 1713 case SWITCHDEV_PORT_OBJ_DEL: 1714 err = switchdev_handle_port_obj_del(dev, ptr, 1715 ocelot_netdevice_dev_check, 1716 ocelot_port_obj_del); 1717 return notifier_from_errno(err); 1718 case SWITCHDEV_PORT_ATTR_SET: 1719 err = switchdev_handle_port_attr_set(dev, ptr, 1720 ocelot_netdevice_dev_check, 1721 ocelot_port_attr_set); 1722 return notifier_from_errno(err); 1723 } 1724 1725 return NOTIFY_DONE; 1726 } 1727 1728 struct notifier_block ocelot_switchdev_blocking_nb __read_mostly = { 1729 .notifier_call = ocelot_switchdev_blocking_event, 1730 }; 1731 1732 static void vsc7514_phylink_mac_config(struct phylink_config *config, 1733 unsigned int link_an_mode, 1734 const struct phylink_link_state *state) 1735 { 1736 struct net_device *ndev = to_net_dev(config->dev); 1737 struct ocelot_port_private *priv = netdev_priv(ndev); 1738 struct ocelot *ocelot = priv->port.ocelot; 1739 int port = priv->port.index; 1740 1741 ocelot_phylink_mac_config(ocelot, port, link_an_mode, state); 1742 } 1743 1744 static void vsc7514_phylink_mac_link_down(struct phylink_config *config, 1745 unsigned int link_an_mode, 1746 phy_interface_t interface) 1747 { 1748 struct net_device *ndev = to_net_dev(config->dev); 1749 struct ocelot_port_private *priv = netdev_priv(ndev); 1750 struct ocelot *ocelot = priv->port.ocelot; 1751 int port = priv->port.index; 1752 1753 ocelot_phylink_mac_link_down(ocelot, port, link_an_mode, interface, 1754 OCELOT_MAC_QUIRKS); 1755 } 1756 1757 static void vsc7514_phylink_mac_link_up(struct phylink_config *config, 1758 struct phy_device *phydev, 1759 unsigned int link_an_mode, 1760 phy_interface_t interface, 1761 int speed, int duplex, 1762 bool tx_pause, bool rx_pause) 1763 { 1764 struct net_device *ndev = to_net_dev(config->dev); 1765 struct ocelot_port_private *priv = netdev_priv(ndev); 1766 struct ocelot *ocelot = priv->port.ocelot; 1767 int port = priv->port.index; 1768 1769 ocelot_phylink_mac_link_up(ocelot, port, phydev, link_an_mode, 1770 interface, speed, duplex, 1771 tx_pause, rx_pause, OCELOT_MAC_QUIRKS); 1772 } 1773 1774 static const struct phylink_mac_ops ocelot_phylink_ops = { 1775 .mac_config = vsc7514_phylink_mac_config, 1776 .mac_link_down = vsc7514_phylink_mac_link_down, 1777 .mac_link_up = vsc7514_phylink_mac_link_up, 1778 }; 1779 1780 static int ocelot_port_phylink_create(struct ocelot *ocelot, int port, 1781 struct device_node *portnp) 1782 { 1783 struct ocelot_port *ocelot_port = ocelot->ports[port]; 1784 struct ocelot_port_private *priv; 1785 struct device *dev = ocelot->dev; 1786 phy_interface_t phy_mode; 1787 struct phylink *phylink; 1788 int err; 1789 1790 of_get_phy_mode(portnp, &phy_mode); 1791 /* DT bindings of internal PHY ports are broken and don't 1792 * specify a phy-mode 1793 */ 1794 if (phy_mode == PHY_INTERFACE_MODE_NA) 1795 phy_mode = PHY_INTERFACE_MODE_INTERNAL; 1796 1797 if (phy_mode != PHY_INTERFACE_MODE_SGMII && 1798 phy_mode != PHY_INTERFACE_MODE_QSGMII && 1799 phy_mode != PHY_INTERFACE_MODE_INTERNAL) { 1800 dev_err(dev, "unsupported phy mode %s for port %d\n", 1801 phy_modes(phy_mode), port); 1802 return -EINVAL; 1803 } 1804 1805 ocelot_port->phy_mode = phy_mode; 1806 1807 err = ocelot_port_configure_serdes(ocelot, port, portnp); 1808 if (err) 1809 return err; 1810 1811 priv = container_of(ocelot_port, struct ocelot_port_private, port); 1812 1813 priv->phylink_config.dev = &priv->dev->dev; 1814 priv->phylink_config.type = PHYLINK_NETDEV; 1815 priv->phylink_config.mac_capabilities = MAC_ASYM_PAUSE | MAC_SYM_PAUSE | 1816 MAC_10 | MAC_100 | MAC_1000FD | MAC_2500FD; 1817 1818 __set_bit(ocelot_port->phy_mode, 1819 priv->phylink_config.supported_interfaces); 1820 1821 phylink = phylink_create(&priv->phylink_config, 1822 of_fwnode_handle(portnp), 1823 phy_mode, &ocelot_phylink_ops); 1824 if (IS_ERR(phylink)) { 1825 err = PTR_ERR(phylink); 1826 dev_err(dev, "Could not create phylink (%pe)\n", phylink); 1827 return err; 1828 } 1829 1830 priv->phylink = phylink; 1831 1832 err = phylink_of_phy_connect(phylink, portnp, 0); 1833 if (err) { 1834 dev_err(dev, "Could not connect to PHY: %pe\n", ERR_PTR(err)); 1835 phylink_destroy(phylink); 1836 priv->phylink = NULL; 1837 return err; 1838 } 1839 1840 return 0; 1841 } 1842 1843 int ocelot_probe_port(struct ocelot *ocelot, int port, struct regmap *target, 1844 struct device_node *portnp) 1845 { 1846 struct ocelot_port_private *priv; 1847 struct ocelot_port *ocelot_port; 1848 struct net_device *dev; 1849 int err; 1850 1851 dev = alloc_etherdev(sizeof(struct ocelot_port_private)); 1852 if (!dev) 1853 return -ENOMEM; 1854 SET_NETDEV_DEV(dev, ocelot->dev); 1855 priv = netdev_priv(dev); 1856 priv->dev = dev; 1857 ocelot_port = &priv->port; 1858 ocelot_port->ocelot = ocelot; 1859 ocelot_port->index = port; 1860 ocelot_port->target = target; 1861 ocelot->ports[port] = ocelot_port; 1862 1863 dev->netdev_ops = &ocelot_port_netdev_ops; 1864 dev->ethtool_ops = &ocelot_ethtool_ops; 1865 dev->max_mtu = OCELOT_JUMBO_MTU; 1866 1867 dev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_RXFCS | 1868 NETIF_F_HW_TC; 1869 dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_TC; 1870 1871 err = of_get_ethdev_address(portnp, dev); 1872 if (err) 1873 eth_hw_addr_gen(dev, ocelot->base_mac, port); 1874 1875 ocelot_mact_learn(ocelot, PGID_CPU, dev->dev_addr, 1876 OCELOT_STANDALONE_PVID, ENTRYTYPE_LOCKED); 1877 1878 ocelot_init_port(ocelot, port); 1879 1880 err = ocelot_port_phylink_create(ocelot, port, portnp); 1881 if (err) 1882 goto out; 1883 1884 if (ocelot->fdma) 1885 ocelot_fdma_netdev_init(ocelot, dev); 1886 1887 SET_NETDEV_DEVLINK_PORT(dev, &ocelot->devlink_ports[port]); 1888 err = register_netdev(dev); 1889 if (err) { 1890 dev_err(ocelot->dev, "register_netdev failed\n"); 1891 goto out_fdma_deinit; 1892 } 1893 1894 return 0; 1895 1896 out_fdma_deinit: 1897 if (ocelot->fdma) 1898 ocelot_fdma_netdev_deinit(ocelot, dev); 1899 out: 1900 ocelot->ports[port] = NULL; 1901 free_netdev(dev); 1902 1903 return err; 1904 } 1905 1906 void ocelot_release_port(struct ocelot_port *ocelot_port) 1907 { 1908 struct ocelot_port_private *priv = container_of(ocelot_port, 1909 struct ocelot_port_private, 1910 port); 1911 struct ocelot *ocelot = ocelot_port->ocelot; 1912 struct ocelot_fdma *fdma = ocelot->fdma; 1913 1914 unregister_netdev(priv->dev); 1915 1916 if (fdma) 1917 ocelot_fdma_netdev_deinit(ocelot, priv->dev); 1918 1919 if (priv->phylink) { 1920 rtnl_lock(); 1921 phylink_disconnect_phy(priv->phylink); 1922 rtnl_unlock(); 1923 1924 phylink_destroy(priv->phylink); 1925 } 1926 1927 free_netdev(priv->dev); 1928 } 1929