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