1869 lines · c
1// SPDX-License-Identifier: (GPL-2.0 OR MIT)2/* Microsemi Ocelot Switch driver3 *4 * This contains glue logic between the switchdev driver operations and the5 * mscc_ocelot_switch_lib.6 *7 * Copyright (c) 2017, 2019 Microsemi Corporation8 * Copyright 2020-2021 NXP9 */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_UP22 23struct ocelot_dump_ctx {24 struct net_device *dev;25 struct sk_buff *skb;26 struct netlink_callback *cb;27 int idx;28};29 30static bool ocelot_netdevice_dev_check(const struct net_device *dev);31 32static struct ocelot *devlink_port_to_ocelot(struct devlink_port *dlp)33{34 return devlink_priv(dlp->devlink);35}36 37static 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 44static 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 53static 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 64static 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 75static 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 87static int88ocelot_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 101static int102ocelot_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 116static 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 124static 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 132static 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 144static int145ocelot_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 158const 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 171int 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 190void 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 197int 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 219static 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 260static 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 else297 priv->tc.egress_mirred_id = f->cookie;298 priv->tc.offload_cnt++;299 300 return 0;301}302 303static 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 323static 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 else335 priv->tc.egress_mirred_id = 0;336 priv->tc.offload_cnt--;337 338 return 0;339}340 341static 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 else390 return -ENOENT;391 392 break;393 case TC_CLSMATCHALL_STATS:394 default:395 return -EOPNOTSUPP;396 }397}398 399static 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 418static 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 426static 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 434static LIST_HEAD(ocelot_block_cb_list);435 436static 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 478static 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 492static 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 512static 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 interfaces520 * with VLAN filtering feature. We need to keep it to receive521 * 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 536static 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 545static 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 554static netdev_tx_t ocelot_port_xmit(struct sk_buff *skb, struct net_device *dev)555{556 struct ocelot_port_private *priv = netdev_priv(dev);557 struct ocelot_port *ocelot_port = &priv->port;558 struct ocelot *ocelot = ocelot_port->ocelot;559 int port = priv->port.index;560 u32 rew_op = 0;561 562 if (!static_branch_unlikely(&ocelot_fdma_enabled) &&563 !ocelot_can_inject(ocelot, 0))564 return NETDEV_TX_BUSY;565 566 /* Check if timestamping is needed */567 if (ocelot->ptp && (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)) {568 struct sk_buff *clone = NULL;569 570 if (ocelot_port_txtstamp_request(ocelot, port, skb, &clone)) {571 kfree_skb(skb);572 return NETDEV_TX_OK;573 }574 575 if (clone)576 OCELOT_SKB_CB(skb)->clone = clone;577 578 rew_op = ocelot_ptp_rew_op(skb);579 }580 581 if (static_branch_unlikely(&ocelot_fdma_enabled)) {582 ocelot_fdma_inject_frame(ocelot, port, rew_op, skb, dev);583 } else {584 ocelot_port_inject_frame(ocelot, port, 0, rew_op, skb);585 586 consume_skb(skb);587 }588 589 return NETDEV_TX_OK;590}591 592enum ocelot_action_type {593 OCELOT_MACT_LEARN,594 OCELOT_MACT_FORGET,595};596 597struct ocelot_mact_work_ctx {598 struct work_struct work;599 struct ocelot *ocelot;600 enum ocelot_action_type type;601 union {602 /* OCELOT_MACT_LEARN */603 struct {604 unsigned char addr[ETH_ALEN];605 u16 vid;606 enum macaccess_entry_type entry_type;607 int pgid;608 } learn;609 /* OCELOT_MACT_FORGET */610 struct {611 unsigned char addr[ETH_ALEN];612 u16 vid;613 } forget;614 };615};616 617#define ocelot_work_to_ctx(x) \618 container_of((x), struct ocelot_mact_work_ctx, work)619 620static void ocelot_mact_work(struct work_struct *work)621{622 struct ocelot_mact_work_ctx *w = ocelot_work_to_ctx(work);623 struct ocelot *ocelot = w->ocelot;624 625 switch (w->type) {626 case OCELOT_MACT_LEARN:627 ocelot_mact_learn(ocelot, w->learn.pgid, w->learn.addr,628 w->learn.vid, w->learn.entry_type);629 break;630 case OCELOT_MACT_FORGET:631 ocelot_mact_forget(ocelot, w->forget.addr, w->forget.vid);632 break;633 default:634 break;635 }636 637 kfree(w);638}639 640static int ocelot_enqueue_mact_action(struct ocelot *ocelot,641 const struct ocelot_mact_work_ctx *ctx)642{643 struct ocelot_mact_work_ctx *w = kmemdup(ctx, sizeof(*w), GFP_ATOMIC);644 645 if (!w)646 return -ENOMEM;647 648 w->ocelot = ocelot;649 INIT_WORK(&w->work, ocelot_mact_work);650 queue_work(ocelot->owq, &w->work);651 652 return 0;653}654 655static int ocelot_mc_unsync(struct net_device *dev, const unsigned char *addr)656{657 struct ocelot_port_private *priv = netdev_priv(dev);658 struct ocelot_port *ocelot_port = &priv->port;659 struct ocelot *ocelot = ocelot_port->ocelot;660 struct ocelot_mact_work_ctx w;661 662 ether_addr_copy(w.forget.addr, addr);663 w.forget.vid = OCELOT_STANDALONE_PVID;664 w.type = OCELOT_MACT_FORGET;665 666 return ocelot_enqueue_mact_action(ocelot, &w);667}668 669static int ocelot_mc_sync(struct net_device *dev, const unsigned char *addr)670{671 struct ocelot_port_private *priv = netdev_priv(dev);672 struct ocelot_port *ocelot_port = &priv->port;673 struct ocelot *ocelot = ocelot_port->ocelot;674 struct ocelot_mact_work_ctx w;675 676 ether_addr_copy(w.learn.addr, addr);677 w.learn.vid = OCELOT_STANDALONE_PVID;678 w.learn.pgid = PGID_CPU;679 w.learn.entry_type = ENTRYTYPE_LOCKED;680 w.type = OCELOT_MACT_LEARN;681 682 return ocelot_enqueue_mact_action(ocelot, &w);683}684 685static void ocelot_set_rx_mode(struct net_device *dev)686{687 struct ocelot_port_private *priv = netdev_priv(dev);688 struct ocelot *ocelot = priv->port.ocelot;689 u32 val;690 int i;691 692 /* This doesn't handle promiscuous mode because the bridge core is693 * setting IFF_PROMISC on all slave interfaces and all frames would be694 * forwarded to the CPU port.695 */696 val = GENMASK(ocelot->num_phys_ports - 1, 0);697 for_each_nonreserved_multicast_dest_pgid(ocelot, i)698 ocelot_write_rix(ocelot, val, ANA_PGID_PGID, i);699 700 __dev_mc_sync(dev, ocelot_mc_sync, ocelot_mc_unsync);701}702 703static int ocelot_port_set_mac_address(struct net_device *dev, void *p)704{705 struct ocelot_port_private *priv = netdev_priv(dev);706 struct ocelot_port *ocelot_port = &priv->port;707 struct ocelot *ocelot = ocelot_port->ocelot;708 const struct sockaddr *addr = p;709 710 /* Learn the new net device MAC address in the mac table. */711 ocelot_mact_learn(ocelot, PGID_CPU, addr->sa_data,712 OCELOT_STANDALONE_PVID, ENTRYTYPE_LOCKED);713 /* Then forget the previous one. */714 ocelot_mact_forget(ocelot, dev->dev_addr, OCELOT_STANDALONE_PVID);715 716 eth_hw_addr_set(dev, addr->sa_data);717 return 0;718}719 720static void ocelot_get_stats64(struct net_device *dev,721 struct rtnl_link_stats64 *stats)722{723 struct ocelot_port_private *priv = netdev_priv(dev);724 struct ocelot *ocelot = priv->port.ocelot;725 int port = priv->port.index;726 727 return ocelot_port_get_stats64(ocelot, port, stats);728}729 730static int ocelot_port_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],731 struct net_device *dev,732 const unsigned char *addr,733 u16 vid, u16 flags,734 struct netlink_ext_ack *extack)735{736 struct ocelot_port_private *priv = netdev_priv(dev);737 struct ocelot_port *ocelot_port = &priv->port;738 struct ocelot *ocelot = ocelot_port->ocelot;739 int port = priv->port.index;740 741 return ocelot_fdb_add(ocelot, port, addr, vid, ocelot_port->bridge);742}743 744static int ocelot_port_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],745 struct net_device *dev,746 const unsigned char *addr, u16 vid,747 struct netlink_ext_ack *extack)748{749 struct ocelot_port_private *priv = netdev_priv(dev);750 struct ocelot_port *ocelot_port = &priv->port;751 struct ocelot *ocelot = ocelot_port->ocelot;752 int port = priv->port.index;753 754 return ocelot_fdb_del(ocelot, port, addr, vid, ocelot_port->bridge);755}756 757static int ocelot_port_fdb_do_dump(const unsigned char *addr, u16 vid,758 bool is_static, void *data)759{760 struct ocelot_dump_ctx *dump = data;761 u32 portid = NETLINK_CB(dump->cb->skb).portid;762 u32 seq = dump->cb->nlh->nlmsg_seq;763 struct nlmsghdr *nlh;764 struct ndmsg *ndm;765 766 if (dump->idx < dump->cb->args[2])767 goto skip;768 769 nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH,770 sizeof(*ndm), NLM_F_MULTI);771 if (!nlh)772 return -EMSGSIZE;773 774 ndm = nlmsg_data(nlh);775 ndm->ndm_family = AF_BRIDGE;776 ndm->ndm_pad1 = 0;777 ndm->ndm_pad2 = 0;778 ndm->ndm_flags = NTF_SELF;779 ndm->ndm_type = 0;780 ndm->ndm_ifindex = dump->dev->ifindex;781 ndm->ndm_state = is_static ? NUD_NOARP : NUD_REACHABLE;782 783 if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, addr))784 goto nla_put_failure;785 786 if (vid && nla_put_u16(dump->skb, NDA_VLAN, vid))787 goto nla_put_failure;788 789 nlmsg_end(dump->skb, nlh);790 791skip:792 dump->idx++;793 return 0;794 795nla_put_failure:796 nlmsg_cancel(dump->skb, nlh);797 return -EMSGSIZE;798}799 800static int ocelot_port_fdb_dump(struct sk_buff *skb,801 struct netlink_callback *cb,802 struct net_device *dev,803 struct net_device *filter_dev, int *idx)804{805 struct ocelot_port_private *priv = netdev_priv(dev);806 struct ocelot *ocelot = priv->port.ocelot;807 struct ocelot_dump_ctx dump = {808 .dev = dev,809 .skb = skb,810 .cb = cb,811 .idx = *idx,812 };813 int port = priv->port.index;814 int ret;815 816 ret = ocelot_fdb_dump(ocelot, port, ocelot_port_fdb_do_dump, &dump);817 818 *idx = dump.idx;819 820 return ret;821}822 823static int ocelot_vlan_rx_add_vid(struct net_device *dev, __be16 proto,824 u16 vid)825{826 return ocelot_vlan_vid_add(dev, vid, false, false);827}828 829static int ocelot_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,830 u16 vid)831{832 return ocelot_vlan_vid_del(dev, vid);833}834 835static void ocelot_vlan_mode(struct ocelot *ocelot, int port,836 netdev_features_t features)837{838 u32 val;839 840 /* Filtering */841 val = ocelot_read(ocelot, ANA_VLANMASK);842 if (features & NETIF_F_HW_VLAN_CTAG_FILTER)843 val |= BIT(port);844 else845 val &= ~BIT(port);846 ocelot_write(ocelot, val, ANA_VLANMASK);847}848 849static int ocelot_set_features(struct net_device *dev,850 netdev_features_t features)851{852 netdev_features_t changed = dev->features ^ features;853 struct ocelot_port_private *priv = netdev_priv(dev);854 struct ocelot *ocelot = priv->port.ocelot;855 int port = priv->port.index;856 857 if ((dev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC) &&858 priv->tc.offload_cnt) {859 netdev_err(dev,860 "Cannot disable HW TC offload while offloads active\n");861 return -EBUSY;862 }863 864 if (changed & NETIF_F_HW_VLAN_CTAG_FILTER)865 ocelot_vlan_mode(ocelot, port, features);866 867 return 0;868}869 870static int ocelot_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)871{872 struct ocelot_port_private *priv = netdev_priv(dev);873 struct ocelot *ocelot = priv->port.ocelot;874 int port = priv->port.index;875 876 /* If the attached PHY device isn't capable of timestamping operations,877 * use our own (when possible).878 */879 if (!phy_has_hwtstamp(dev->phydev) && ocelot->ptp) {880 switch (cmd) {881 case SIOCSHWTSTAMP:882 return ocelot_hwstamp_set(ocelot, port, ifr);883 case SIOCGHWTSTAMP:884 return ocelot_hwstamp_get(ocelot, port, ifr);885 }886 }887 888 return phy_mii_ioctl(dev->phydev, ifr, cmd);889}890 891static int ocelot_change_mtu(struct net_device *dev, int new_mtu)892{893 struct ocelot_port_private *priv = netdev_priv(dev);894 struct ocelot_port *ocelot_port = &priv->port;895 struct ocelot *ocelot = ocelot_port->ocelot;896 897 ocelot_port_set_maxlen(ocelot, priv->port.index, new_mtu);898 WRITE_ONCE(dev->mtu, new_mtu);899 900 return 0;901}902 903static const struct net_device_ops ocelot_port_netdev_ops = {904 .ndo_open = ocelot_port_open,905 .ndo_stop = ocelot_port_stop,906 .ndo_start_xmit = ocelot_port_xmit,907 .ndo_change_mtu = ocelot_change_mtu,908 .ndo_set_rx_mode = ocelot_set_rx_mode,909 .ndo_set_mac_address = ocelot_port_set_mac_address,910 .ndo_get_stats64 = ocelot_get_stats64,911 .ndo_fdb_add = ocelot_port_fdb_add,912 .ndo_fdb_del = ocelot_port_fdb_del,913 .ndo_fdb_dump = ocelot_port_fdb_dump,914 .ndo_vlan_rx_add_vid = ocelot_vlan_rx_add_vid,915 .ndo_vlan_rx_kill_vid = ocelot_vlan_rx_kill_vid,916 .ndo_set_features = ocelot_set_features,917 .ndo_setup_tc = ocelot_setup_tc,918 .ndo_eth_ioctl = ocelot_ioctl,919};920 921struct net_device *ocelot_port_to_netdev(struct ocelot *ocelot, int port)922{923 struct ocelot_port *ocelot_port = ocelot->ports[port];924 struct ocelot_port_private *priv;925 926 if (!ocelot_port)927 return NULL;928 929 priv = container_of(ocelot_port, struct ocelot_port_private, port);930 931 return priv->dev;932}933 934/* Checks if the net_device instance given to us originates from our driver */935static bool ocelot_netdevice_dev_check(const struct net_device *dev)936{937 return dev->netdev_ops == &ocelot_port_netdev_ops;938}939 940int ocelot_netdev_to_port(struct net_device *dev)941{942 struct ocelot_port_private *priv;943 944 if (!dev || !ocelot_netdevice_dev_check(dev))945 return -EINVAL;946 947 priv = netdev_priv(dev);948 949 return priv->port.index;950}951 952static void ocelot_port_get_strings(struct net_device *netdev, u32 sset,953 u8 *data)954{955 struct ocelot_port_private *priv = netdev_priv(netdev);956 struct ocelot *ocelot = priv->port.ocelot;957 int port = priv->port.index;958 959 ocelot_get_strings(ocelot, port, sset, data);960}961 962static void ocelot_port_get_ethtool_stats(struct net_device *dev,963 struct ethtool_stats *stats,964 u64 *data)965{966 struct ocelot_port_private *priv = netdev_priv(dev);967 struct ocelot *ocelot = priv->port.ocelot;968 int port = priv->port.index;969 970 ocelot_get_ethtool_stats(ocelot, port, data);971}972 973static int ocelot_port_get_sset_count(struct net_device *dev, int sset)974{975 struct ocelot_port_private *priv = netdev_priv(dev);976 struct ocelot *ocelot = priv->port.ocelot;977 int port = priv->port.index;978 979 return ocelot_get_sset_count(ocelot, port, sset);980}981 982static int ocelot_port_get_ts_info(struct net_device *dev,983 struct kernel_ethtool_ts_info *info)984{985 struct ocelot_port_private *priv = netdev_priv(dev);986 struct ocelot *ocelot = priv->port.ocelot;987 int port = priv->port.index;988 989 if (!ocelot->ptp)990 return ethtool_op_get_ts_info(dev, info);991 992 return ocelot_get_ts_info(ocelot, port, info);993}994 995static const struct ethtool_ops ocelot_ethtool_ops = {996 .get_strings = ocelot_port_get_strings,997 .get_ethtool_stats = ocelot_port_get_ethtool_stats,998 .get_sset_count = ocelot_port_get_sset_count,999 .get_link_ksettings = phy_ethtool_get_link_ksettings,1000 .set_link_ksettings = phy_ethtool_set_link_ksettings,1001 .get_ts_info = ocelot_port_get_ts_info,1002};1003 1004static void ocelot_port_attr_stp_state_set(struct ocelot *ocelot, int port,1005 u8 state)1006{1007 ocelot_bridge_stp_state_set(ocelot, port, state);1008}1009 1010static void ocelot_port_attr_ageing_set(struct ocelot *ocelot, int port,1011 unsigned long ageing_clock_t)1012{1013 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t);1014 u32 ageing_time = jiffies_to_msecs(ageing_jiffies);1015 1016 ocelot_set_ageing_time(ocelot, ageing_time);1017}1018 1019static void ocelot_port_attr_mc_set(struct ocelot *ocelot, int port, bool mc)1020{1021 u32 cpu_fwd_mcast = ANA_PORT_CPU_FWD_CFG_CPU_IGMP_REDIR_ENA |1022 ANA_PORT_CPU_FWD_CFG_CPU_MLD_REDIR_ENA |1023 ANA_PORT_CPU_FWD_CFG_CPU_IPMC_CTRL_COPY_ENA;1024 u32 val = 0;1025 1026 if (mc)1027 val = cpu_fwd_mcast;1028 1029 ocelot_rmw_gix(ocelot, val, cpu_fwd_mcast,1030 ANA_PORT_CPU_FWD_CFG, port);1031}1032 1033static int ocelot_port_attr_set(struct net_device *dev, const void *ctx,1034 const struct switchdev_attr *attr,1035 struct netlink_ext_ack *extack)1036{1037 struct ocelot_port_private *priv = netdev_priv(dev);1038 struct ocelot *ocelot = priv->port.ocelot;1039 int port = priv->port.index;1040 int err = 0;1041 1042 if (ctx && ctx != priv)1043 return 0;1044 1045 switch (attr->id) {1046 case SWITCHDEV_ATTR_ID_PORT_STP_STATE:1047 ocelot_port_attr_stp_state_set(ocelot, port, attr->u.stp_state);1048 break;1049 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:1050 ocelot_port_attr_ageing_set(ocelot, port, attr->u.ageing_time);1051 break;1052 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:1053 ocelot_port_vlan_filtering(ocelot, port, attr->u.vlan_filtering,1054 extack);1055 break;1056 case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED:1057 ocelot_port_attr_mc_set(ocelot, port, !attr->u.mc_disabled);1058 break;1059 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:1060 err = ocelot_port_pre_bridge_flags(ocelot, port,1061 attr->u.brport_flags);1062 break;1063 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:1064 ocelot_port_bridge_flags(ocelot, port, attr->u.brport_flags);1065 break;1066 default:1067 err = -EOPNOTSUPP;1068 break;1069 }1070 1071 return err;1072}1073 1074static int ocelot_vlan_vid_prepare(struct net_device *dev, u16 vid, bool pvid,1075 bool untagged, struct netlink_ext_ack *extack)1076{1077 struct ocelot_port_private *priv = netdev_priv(dev);1078 struct ocelot_port *ocelot_port = &priv->port;1079 struct ocelot *ocelot = ocelot_port->ocelot;1080 int port = priv->port.index;1081 1082 return ocelot_vlan_prepare(ocelot, port, vid, pvid, untagged, extack);1083}1084 1085static int ocelot_port_obj_add_vlan(struct net_device *dev,1086 const struct switchdev_obj_port_vlan *vlan,1087 struct netlink_ext_ack *extack)1088{1089 bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;1090 bool pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;1091 int ret;1092 1093 ret = ocelot_vlan_vid_prepare(dev, vlan->vid, pvid, untagged, extack);1094 if (ret)1095 return ret;1096 1097 return ocelot_vlan_vid_add(dev, vlan->vid, pvid, untagged);1098}1099 1100static int ocelot_port_obj_add_mdb(struct net_device *dev,1101 const struct switchdev_obj_port_mdb *mdb)1102{1103 struct ocelot_port_private *priv = netdev_priv(dev);1104 struct ocelot_port *ocelot_port = &priv->port;1105 struct ocelot *ocelot = ocelot_port->ocelot;1106 int port = priv->port.index;1107 1108 return ocelot_port_mdb_add(ocelot, port, mdb, ocelot_port->bridge);1109}1110 1111static int ocelot_port_obj_del_mdb(struct net_device *dev,1112 const struct switchdev_obj_port_mdb *mdb)1113{1114 struct ocelot_port_private *priv = netdev_priv(dev);1115 struct ocelot_port *ocelot_port = &priv->port;1116 struct ocelot *ocelot = ocelot_port->ocelot;1117 int port = priv->port.index;1118 1119 return ocelot_port_mdb_del(ocelot, port, mdb, ocelot_port->bridge);1120}1121 1122static int ocelot_port_obj_mrp_add(struct net_device *dev,1123 const struct switchdev_obj_mrp *mrp)1124{1125 struct ocelot_port_private *priv = netdev_priv(dev);1126 struct ocelot_port *ocelot_port = &priv->port;1127 struct ocelot *ocelot = ocelot_port->ocelot;1128 int port = priv->port.index;1129 1130 return ocelot_mrp_add(ocelot, port, mrp);1131}1132 1133static int ocelot_port_obj_mrp_del(struct net_device *dev,1134 const struct switchdev_obj_mrp *mrp)1135{1136 struct ocelot_port_private *priv = netdev_priv(dev);1137 struct ocelot_port *ocelot_port = &priv->port;1138 struct ocelot *ocelot = ocelot_port->ocelot;1139 int port = priv->port.index;1140 1141 return ocelot_mrp_del(ocelot, port, mrp);1142}1143 1144static int1145ocelot_port_obj_mrp_add_ring_role(struct net_device *dev,1146 const struct switchdev_obj_ring_role_mrp *mrp)1147{1148 struct ocelot_port_private *priv = netdev_priv(dev);1149 struct ocelot_port *ocelot_port = &priv->port;1150 struct ocelot *ocelot = ocelot_port->ocelot;1151 int port = priv->port.index;1152 1153 return ocelot_mrp_add_ring_role(ocelot, port, mrp);1154}1155 1156static int1157ocelot_port_obj_mrp_del_ring_role(struct net_device *dev,1158 const struct switchdev_obj_ring_role_mrp *mrp)1159{1160 struct ocelot_port_private *priv = netdev_priv(dev);1161 struct ocelot_port *ocelot_port = &priv->port;1162 struct ocelot *ocelot = ocelot_port->ocelot;1163 int port = priv->port.index;1164 1165 return ocelot_mrp_del_ring_role(ocelot, port, mrp);1166}1167 1168static int ocelot_port_obj_add(struct net_device *dev, const void *ctx,1169 const struct switchdev_obj *obj,1170 struct netlink_ext_ack *extack)1171{1172 struct ocelot_port_private *priv = netdev_priv(dev);1173 int ret = 0;1174 1175 if (ctx && ctx != priv)1176 return 0;1177 1178 switch (obj->id) {1179 case SWITCHDEV_OBJ_ID_PORT_VLAN:1180 ret = ocelot_port_obj_add_vlan(dev,1181 SWITCHDEV_OBJ_PORT_VLAN(obj),1182 extack);1183 break;1184 case SWITCHDEV_OBJ_ID_PORT_MDB:1185 ret = ocelot_port_obj_add_mdb(dev, SWITCHDEV_OBJ_PORT_MDB(obj));1186 break;1187 case SWITCHDEV_OBJ_ID_MRP:1188 ret = ocelot_port_obj_mrp_add(dev, SWITCHDEV_OBJ_MRP(obj));1189 break;1190 case SWITCHDEV_OBJ_ID_RING_ROLE_MRP:1191 ret = ocelot_port_obj_mrp_add_ring_role(dev,1192 SWITCHDEV_OBJ_RING_ROLE_MRP(obj));1193 break;1194 default:1195 return -EOPNOTSUPP;1196 }1197 1198 return ret;1199}1200 1201static int ocelot_port_obj_del(struct net_device *dev, const void *ctx,1202 const struct switchdev_obj *obj)1203{1204 struct ocelot_port_private *priv = netdev_priv(dev);1205 int ret = 0;1206 1207 if (ctx && ctx != priv)1208 return 0;1209 1210 switch (obj->id) {1211 case SWITCHDEV_OBJ_ID_PORT_VLAN:1212 ret = ocelot_vlan_vid_del(dev,1213 SWITCHDEV_OBJ_PORT_VLAN(obj)->vid);1214 break;1215 case SWITCHDEV_OBJ_ID_PORT_MDB:1216 ret = ocelot_port_obj_del_mdb(dev, SWITCHDEV_OBJ_PORT_MDB(obj));1217 break;1218 case SWITCHDEV_OBJ_ID_MRP:1219 ret = ocelot_port_obj_mrp_del(dev, SWITCHDEV_OBJ_MRP(obj));1220 break;1221 case SWITCHDEV_OBJ_ID_RING_ROLE_MRP:1222 ret = ocelot_port_obj_mrp_del_ring_role(dev,1223 SWITCHDEV_OBJ_RING_ROLE_MRP(obj));1224 break;1225 default:1226 return -EOPNOTSUPP;1227 }1228 1229 return ret;1230}1231 1232static void ocelot_inherit_brport_flags(struct ocelot *ocelot, int port,1233 struct net_device *brport_dev)1234{1235 struct switchdev_brport_flags flags = {0};1236 int flag;1237 1238 flags.mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;1239 1240 for_each_set_bit(flag, &flags.mask, 32)1241 if (br_port_flag_is_set(brport_dev, BIT(flag)))1242 flags.val |= BIT(flag);1243 1244 ocelot_port_bridge_flags(ocelot, port, flags);1245}1246 1247static void ocelot_clear_brport_flags(struct ocelot *ocelot, int port)1248{1249 struct switchdev_brport_flags flags;1250 1251 flags.mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;1252 flags.val = flags.mask & ~BR_LEARNING;1253 1254 ocelot_port_bridge_flags(ocelot, port, flags);1255}1256 1257static int ocelot_switchdev_sync(struct ocelot *ocelot, int port,1258 struct net_device *brport_dev,1259 struct net_device *bridge_dev,1260 struct netlink_ext_ack *extack)1261{1262 clock_t ageing_time;1263 u8 stp_state;1264 1265 ocelot_inherit_brport_flags(ocelot, port, brport_dev);1266 1267 stp_state = br_port_get_stp_state(brport_dev);1268 ocelot_bridge_stp_state_set(ocelot, port, stp_state);1269 1270 ageing_time = br_get_ageing_time(bridge_dev);1271 ocelot_port_attr_ageing_set(ocelot, port, ageing_time);1272 1273 return ocelot_port_vlan_filtering(ocelot, port,1274 br_vlan_enabled(bridge_dev),1275 extack);1276}1277 1278static int ocelot_switchdev_unsync(struct ocelot *ocelot, int port)1279{1280 int err;1281 1282 err = ocelot_port_vlan_filtering(ocelot, port, false, NULL);1283 if (err)1284 return err;1285 1286 ocelot_clear_brport_flags(ocelot, port);1287 1288 ocelot_bridge_stp_state_set(ocelot, port, BR_STATE_FORWARDING);1289 1290 return 0;1291}1292 1293static int ocelot_bridge_num_get(struct ocelot *ocelot,1294 const struct net_device *bridge_dev)1295{1296 int bridge_num = ocelot_bridge_num_find(ocelot, bridge_dev);1297 1298 if (bridge_num < 0) {1299 /* First port that offloads this bridge */1300 bridge_num = find_first_zero_bit(&ocelot->bridges,1301 ocelot->num_phys_ports);1302 1303 set_bit(bridge_num, &ocelot->bridges);1304 }1305 1306 return bridge_num;1307}1308 1309static void ocelot_bridge_num_put(struct ocelot *ocelot,1310 const struct net_device *bridge_dev,1311 int bridge_num)1312{1313 /* Check if the bridge is still in use, otherwise it is time1314 * to clean it up so we can reuse this bridge_num later.1315 */1316 if (!ocelot_bridge_num_find(ocelot, bridge_dev))1317 clear_bit(bridge_num, &ocelot->bridges);1318}1319 1320static int ocelot_netdevice_bridge_join(struct net_device *dev,1321 struct net_device *brport_dev,1322 struct net_device *bridge,1323 struct netlink_ext_ack *extack)1324{1325 struct ocelot_port_private *priv = netdev_priv(dev);1326 struct ocelot_port *ocelot_port = &priv->port;1327 struct ocelot *ocelot = ocelot_port->ocelot;1328 int port = priv->port.index;1329 int bridge_num, err;1330 1331 bridge_num = ocelot_bridge_num_get(ocelot, bridge);1332 1333 err = ocelot_port_bridge_join(ocelot, port, bridge, bridge_num,1334 extack);1335 if (err)1336 goto err_join;1337 1338 err = switchdev_bridge_port_offload(brport_dev, dev, priv,1339 &ocelot_switchdev_nb,1340 &ocelot_switchdev_blocking_nb,1341 false, extack);1342 if (err)1343 goto err_switchdev_offload;1344 1345 err = ocelot_switchdev_sync(ocelot, port, brport_dev, bridge, extack);1346 if (err)1347 goto err_switchdev_sync;1348 1349 return 0;1350 1351err_switchdev_sync:1352 switchdev_bridge_port_unoffload(brport_dev, priv,1353 &ocelot_switchdev_nb,1354 &ocelot_switchdev_blocking_nb);1355err_switchdev_offload:1356 ocelot_port_bridge_leave(ocelot, port, bridge);1357err_join:1358 ocelot_bridge_num_put(ocelot, bridge, bridge_num);1359 return err;1360}1361 1362static void ocelot_netdevice_pre_bridge_leave(struct net_device *dev,1363 struct net_device *brport_dev)1364{1365 struct ocelot_port_private *priv = netdev_priv(dev);1366 1367 switchdev_bridge_port_unoffload(brport_dev, priv,1368 &ocelot_switchdev_nb,1369 &ocelot_switchdev_blocking_nb);1370}1371 1372static int ocelot_netdevice_bridge_leave(struct net_device *dev,1373 struct net_device *brport_dev,1374 struct net_device *bridge)1375{1376 struct ocelot_port_private *priv = netdev_priv(dev);1377 struct ocelot_port *ocelot_port = &priv->port;1378 struct ocelot *ocelot = ocelot_port->ocelot;1379 int bridge_num = ocelot_port->bridge_num;1380 int port = priv->port.index;1381 int err;1382 1383 err = ocelot_switchdev_unsync(ocelot, port);1384 if (err)1385 return err;1386 1387 ocelot_port_bridge_leave(ocelot, port, bridge);1388 ocelot_bridge_num_put(ocelot, bridge, bridge_num);1389 1390 return 0;1391}1392 1393static int ocelot_netdevice_lag_join(struct net_device *dev,1394 struct net_device *bond,1395 struct netdev_lag_upper_info *info,1396 struct netlink_ext_ack *extack)1397{1398 struct ocelot_port_private *priv = netdev_priv(dev);1399 struct ocelot_port *ocelot_port = &priv->port;1400 struct ocelot *ocelot = ocelot_port->ocelot;1401 struct net_device *bridge_dev;1402 int port = priv->port.index;1403 int err;1404 1405 err = ocelot_port_lag_join(ocelot, port, bond, info, extack);1406 if (err == -EOPNOTSUPP)1407 /* Offloading not supported, fall back to software LAG */1408 return 0;1409 1410 bridge_dev = netdev_master_upper_dev_get(bond);1411 if (!bridge_dev || !netif_is_bridge_master(bridge_dev))1412 return 0;1413 1414 err = ocelot_netdevice_bridge_join(dev, bond, bridge_dev, extack);1415 if (err)1416 goto err_bridge_join;1417 1418 return 0;1419 1420err_bridge_join:1421 ocelot_port_lag_leave(ocelot, port, bond);1422 return err;1423}1424 1425static void ocelot_netdevice_pre_lag_leave(struct net_device *dev,1426 struct net_device *bond)1427{1428 struct net_device *bridge_dev;1429 1430 bridge_dev = netdev_master_upper_dev_get(bond);1431 if (!bridge_dev || !netif_is_bridge_master(bridge_dev))1432 return;1433 1434 ocelot_netdevice_pre_bridge_leave(dev, bond);1435}1436 1437static int ocelot_netdevice_lag_leave(struct net_device *dev,1438 struct net_device *bond)1439{1440 struct ocelot_port_private *priv = netdev_priv(dev);1441 struct ocelot_port *ocelot_port = &priv->port;1442 struct ocelot *ocelot = ocelot_port->ocelot;1443 struct net_device *bridge_dev;1444 int port = priv->port.index;1445 1446 ocelot_port_lag_leave(ocelot, port, bond);1447 1448 bridge_dev = netdev_master_upper_dev_get(bond);1449 if (!bridge_dev || !netif_is_bridge_master(bridge_dev))1450 return 0;1451 1452 return ocelot_netdevice_bridge_leave(dev, bond, bridge_dev);1453}1454 1455static int ocelot_netdevice_changeupper(struct net_device *dev,1456 struct net_device *brport_dev,1457 struct netdev_notifier_changeupper_info *info)1458{1459 struct netlink_ext_ack *extack;1460 int err = 0;1461 1462 extack = netdev_notifier_info_to_extack(&info->info);1463 1464 if (netif_is_bridge_master(info->upper_dev)) {1465 if (info->linking)1466 err = ocelot_netdevice_bridge_join(dev, brport_dev,1467 info->upper_dev,1468 extack);1469 else1470 err = ocelot_netdevice_bridge_leave(dev, brport_dev,1471 info->upper_dev);1472 }1473 if (netif_is_lag_master(info->upper_dev)) {1474 if (info->linking)1475 err = ocelot_netdevice_lag_join(dev, info->upper_dev,1476 info->upper_info, extack);1477 else1478 ocelot_netdevice_lag_leave(dev, info->upper_dev);1479 }1480 1481 return notifier_from_errno(err);1482}1483 1484/* Treat CHANGEUPPER events on an offloaded LAG as individual CHANGEUPPER1485 * events for the lower physical ports of the LAG.1486 * If the LAG upper isn't offloaded, ignore its CHANGEUPPER events.1487 * In case the LAG joined a bridge, notify that we are offloading it and can do1488 * forwarding in hardware towards it.1489 */1490static int1491ocelot_netdevice_lag_changeupper(struct net_device *dev,1492 struct netdev_notifier_changeupper_info *info)1493{1494 struct net_device *lower;1495 struct list_head *iter;1496 int err = NOTIFY_DONE;1497 1498 netdev_for_each_lower_dev(dev, lower, iter) {1499 struct ocelot_port_private *priv = netdev_priv(lower);1500 struct ocelot_port *ocelot_port = &priv->port;1501 1502 if (ocelot_port->bond != dev)1503 return NOTIFY_OK;1504 1505 err = ocelot_netdevice_changeupper(lower, dev, info);1506 if (err)1507 return notifier_from_errno(err);1508 }1509 1510 return NOTIFY_DONE;1511}1512 1513static int1514ocelot_netdevice_prechangeupper(struct net_device *dev,1515 struct net_device *brport_dev,1516 struct netdev_notifier_changeupper_info *info)1517{1518 if (netif_is_bridge_master(info->upper_dev) && !info->linking)1519 ocelot_netdevice_pre_bridge_leave(dev, brport_dev);1520 1521 if (netif_is_lag_master(info->upper_dev) && !info->linking)1522 ocelot_netdevice_pre_lag_leave(dev, info->upper_dev);1523 1524 return NOTIFY_DONE;1525}1526 1527static int1528ocelot_netdevice_lag_prechangeupper(struct net_device *dev,1529 struct netdev_notifier_changeupper_info *info)1530{1531 struct net_device *lower;1532 struct list_head *iter;1533 int err = NOTIFY_DONE;1534 1535 netdev_for_each_lower_dev(dev, lower, iter) {1536 struct ocelot_port_private *priv = netdev_priv(lower);1537 struct ocelot_port *ocelot_port = &priv->port;1538 1539 if (ocelot_port->bond != dev)1540 return NOTIFY_OK;1541 1542 err = ocelot_netdevice_prechangeupper(dev, lower, info);1543 if (err)1544 return err;1545 }1546 1547 return NOTIFY_DONE;1548}1549 1550static int1551ocelot_netdevice_changelowerstate(struct net_device *dev,1552 struct netdev_lag_lower_state_info *info)1553{1554 struct ocelot_port_private *priv = netdev_priv(dev);1555 bool is_active = info->link_up && info->tx_enabled;1556 struct ocelot_port *ocelot_port = &priv->port;1557 struct ocelot *ocelot = ocelot_port->ocelot;1558 int port = priv->port.index;1559 1560 if (!ocelot_port->bond)1561 return NOTIFY_DONE;1562 1563 if (ocelot_port->lag_tx_active == is_active)1564 return NOTIFY_DONE;1565 1566 ocelot_port_lag_change(ocelot, port, is_active);1567 1568 return NOTIFY_OK;1569}1570 1571static int ocelot_netdevice_event(struct notifier_block *unused,1572 unsigned long event, void *ptr)1573{1574 struct net_device *dev = netdev_notifier_info_to_dev(ptr);1575 1576 switch (event) {1577 case NETDEV_PRECHANGEUPPER: {1578 struct netdev_notifier_changeupper_info *info = ptr;1579 1580 if (ocelot_netdevice_dev_check(dev))1581 return ocelot_netdevice_prechangeupper(dev, dev, info);1582 1583 if (netif_is_lag_master(dev))1584 return ocelot_netdevice_lag_prechangeupper(dev, info);1585 1586 break;1587 }1588 case NETDEV_CHANGEUPPER: {1589 struct netdev_notifier_changeupper_info *info = ptr;1590 1591 if (ocelot_netdevice_dev_check(dev))1592 return ocelot_netdevice_changeupper(dev, dev, info);1593 1594 if (netif_is_lag_master(dev))1595 return ocelot_netdevice_lag_changeupper(dev, info);1596 1597 break;1598 }1599 case NETDEV_CHANGELOWERSTATE: {1600 struct netdev_notifier_changelowerstate_info *info = ptr;1601 1602 if (!ocelot_netdevice_dev_check(dev))1603 break;1604 1605 return ocelot_netdevice_changelowerstate(dev,1606 info->lower_state_info);1607 }1608 default:1609 break;1610 }1611 1612 return NOTIFY_DONE;1613}1614 1615struct notifier_block ocelot_netdevice_nb __read_mostly = {1616 .notifier_call = ocelot_netdevice_event,1617};1618 1619static int ocelot_switchdev_event(struct notifier_block *unused,1620 unsigned long event, void *ptr)1621{1622 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);1623 int err;1624 1625 switch (event) {1626 case SWITCHDEV_PORT_ATTR_SET:1627 err = switchdev_handle_port_attr_set(dev, ptr,1628 ocelot_netdevice_dev_check,1629 ocelot_port_attr_set);1630 return notifier_from_errno(err);1631 }1632 1633 return NOTIFY_DONE;1634}1635 1636struct notifier_block ocelot_switchdev_nb __read_mostly = {1637 .notifier_call = ocelot_switchdev_event,1638};1639 1640static int ocelot_switchdev_blocking_event(struct notifier_block *unused,1641 unsigned long event, void *ptr)1642{1643 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);1644 int err;1645 1646 switch (event) {1647 /* Blocking events. */1648 case SWITCHDEV_PORT_OBJ_ADD:1649 err = switchdev_handle_port_obj_add(dev, ptr,1650 ocelot_netdevice_dev_check,1651 ocelot_port_obj_add);1652 return notifier_from_errno(err);1653 case SWITCHDEV_PORT_OBJ_DEL:1654 err = switchdev_handle_port_obj_del(dev, ptr,1655 ocelot_netdevice_dev_check,1656 ocelot_port_obj_del);1657 return notifier_from_errno(err);1658 case SWITCHDEV_PORT_ATTR_SET:1659 err = switchdev_handle_port_attr_set(dev, ptr,1660 ocelot_netdevice_dev_check,1661 ocelot_port_attr_set);1662 return notifier_from_errno(err);1663 }1664 1665 return NOTIFY_DONE;1666}1667 1668struct notifier_block ocelot_switchdev_blocking_nb __read_mostly = {1669 .notifier_call = ocelot_switchdev_blocking_event,1670};1671 1672static void vsc7514_phylink_mac_config(struct phylink_config *config,1673 unsigned int link_an_mode,1674 const struct phylink_link_state *state)1675{1676 struct net_device *ndev = to_net_dev(config->dev);1677 struct ocelot_port_private *priv = netdev_priv(ndev);1678 struct ocelot *ocelot = priv->port.ocelot;1679 int port = priv->port.index;1680 1681 ocelot_phylink_mac_config(ocelot, port, link_an_mode, state);1682}1683 1684static void vsc7514_phylink_mac_link_down(struct phylink_config *config,1685 unsigned int link_an_mode,1686 phy_interface_t interface)1687{1688 struct net_device *ndev = to_net_dev(config->dev);1689 struct ocelot_port_private *priv = netdev_priv(ndev);1690 struct ocelot *ocelot = priv->port.ocelot;1691 int port = priv->port.index;1692 1693 ocelot_phylink_mac_link_down(ocelot, port, link_an_mode, interface,1694 OCELOT_MAC_QUIRKS);1695}1696 1697static void vsc7514_phylink_mac_link_up(struct phylink_config *config,1698 struct phy_device *phydev,1699 unsigned int link_an_mode,1700 phy_interface_t interface,1701 int speed, int duplex,1702 bool tx_pause, bool rx_pause)1703{1704 struct net_device *ndev = to_net_dev(config->dev);1705 struct ocelot_port_private *priv = netdev_priv(ndev);1706 struct ocelot *ocelot = priv->port.ocelot;1707 int port = priv->port.index;1708 1709 ocelot_phylink_mac_link_up(ocelot, port, phydev, link_an_mode,1710 interface, speed, duplex,1711 tx_pause, rx_pause, OCELOT_MAC_QUIRKS);1712}1713 1714static const struct phylink_mac_ops ocelot_phylink_ops = {1715 .mac_config = vsc7514_phylink_mac_config,1716 .mac_link_down = vsc7514_phylink_mac_link_down,1717 .mac_link_up = vsc7514_phylink_mac_link_up,1718};1719 1720static int ocelot_port_phylink_create(struct ocelot *ocelot, int port,1721 struct device_node *portnp)1722{1723 struct ocelot_port *ocelot_port = ocelot->ports[port];1724 struct ocelot_port_private *priv;1725 struct device *dev = ocelot->dev;1726 phy_interface_t phy_mode;1727 struct phylink *phylink;1728 int err;1729 1730 of_get_phy_mode(portnp, &phy_mode);1731 /* DT bindings of internal PHY ports are broken and don't1732 * specify a phy-mode1733 */1734 if (phy_mode == PHY_INTERFACE_MODE_NA)1735 phy_mode = PHY_INTERFACE_MODE_INTERNAL;1736 1737 if (phy_mode != PHY_INTERFACE_MODE_SGMII &&1738 phy_mode != PHY_INTERFACE_MODE_QSGMII &&1739 phy_mode != PHY_INTERFACE_MODE_INTERNAL) {1740 dev_err(dev, "unsupported phy mode %s for port %d\n",1741 phy_modes(phy_mode), port);1742 return -EINVAL;1743 }1744 1745 ocelot_port->phy_mode = phy_mode;1746 1747 err = ocelot_port_configure_serdes(ocelot, port, portnp);1748 if (err)1749 return err;1750 1751 priv = container_of(ocelot_port, struct ocelot_port_private, port);1752 1753 priv->phylink_config.dev = &priv->dev->dev;1754 priv->phylink_config.type = PHYLINK_NETDEV;1755 priv->phylink_config.mac_capabilities = MAC_ASYM_PAUSE | MAC_SYM_PAUSE |1756 MAC_10 | MAC_100 | MAC_1000FD | MAC_2500FD;1757 1758 __set_bit(ocelot_port->phy_mode,1759 priv->phylink_config.supported_interfaces);1760 1761 phylink = phylink_create(&priv->phylink_config,1762 of_fwnode_handle(portnp),1763 phy_mode, &ocelot_phylink_ops);1764 if (IS_ERR(phylink)) {1765 err = PTR_ERR(phylink);1766 dev_err(dev, "Could not create phylink (%pe)\n", phylink);1767 return err;1768 }1769 1770 priv->phylink = phylink;1771 1772 err = phylink_of_phy_connect(phylink, portnp, 0);1773 if (err) {1774 dev_err(dev, "Could not connect to PHY: %pe\n", ERR_PTR(err));1775 phylink_destroy(phylink);1776 priv->phylink = NULL;1777 return err;1778 }1779 1780 return 0;1781}1782 1783int ocelot_probe_port(struct ocelot *ocelot, int port, struct regmap *target,1784 struct device_node *portnp)1785{1786 struct ocelot_port_private *priv;1787 struct ocelot_port *ocelot_port;1788 struct net_device *dev;1789 int err;1790 1791 dev = alloc_etherdev(sizeof(struct ocelot_port_private));1792 if (!dev)1793 return -ENOMEM;1794 SET_NETDEV_DEV(dev, ocelot->dev);1795 priv = netdev_priv(dev);1796 priv->dev = dev;1797 ocelot_port = &priv->port;1798 ocelot_port->ocelot = ocelot;1799 ocelot_port->index = port;1800 ocelot_port->target = target;1801 ocelot->ports[port] = ocelot_port;1802 1803 dev->netdev_ops = &ocelot_port_netdev_ops;1804 dev->ethtool_ops = &ocelot_ethtool_ops;1805 dev->max_mtu = OCELOT_JUMBO_MTU;1806 1807 dev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_RXFCS |1808 NETIF_F_HW_TC;1809 dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_TC;1810 1811 err = of_get_ethdev_address(portnp, dev);1812 if (err)1813 eth_hw_addr_gen(dev, ocelot->base_mac, port);1814 1815 ocelot_mact_learn(ocelot, PGID_CPU, dev->dev_addr,1816 OCELOT_STANDALONE_PVID, ENTRYTYPE_LOCKED);1817 1818 ocelot_init_port(ocelot, port);1819 1820 err = ocelot_port_phylink_create(ocelot, port, portnp);1821 if (err)1822 goto out;1823 1824 if (ocelot->fdma)1825 ocelot_fdma_netdev_init(ocelot, dev);1826 1827 SET_NETDEV_DEVLINK_PORT(dev, &ocelot->devlink_ports[port]);1828 err = register_netdev(dev);1829 if (err) {1830 dev_err(ocelot->dev, "register_netdev failed\n");1831 goto out_fdma_deinit;1832 }1833 1834 return 0;1835 1836out_fdma_deinit:1837 if (ocelot->fdma)1838 ocelot_fdma_netdev_deinit(ocelot, dev);1839out:1840 ocelot->ports[port] = NULL;1841 free_netdev(dev);1842 1843 return err;1844}1845 1846void ocelot_release_port(struct ocelot_port *ocelot_port)1847{1848 struct ocelot_port_private *priv = container_of(ocelot_port,1849 struct ocelot_port_private,1850 port);1851 struct ocelot *ocelot = ocelot_port->ocelot;1852 struct ocelot_fdma *fdma = ocelot->fdma;1853 1854 unregister_netdev(priv->dev);1855 1856 if (fdma)1857 ocelot_fdma_netdev_deinit(ocelot, priv->dev);1858 1859 if (priv->phylink) {1860 rtnl_lock();1861 phylink_disconnect_phy(priv->phylink);1862 rtnl_unlock();1863 1864 phylink_destroy(priv->phylink);1865 }1866 1867 free_netdev(priv->dev);1868}1869