drivers/net/ethernet/mscc/ocelot_net.c

   1 // SPDX-License-Identifier: (GPL-2.0 OR MIT)
   2 /* Microsemi Ocelot Switch driver
   3  *
   4  * Copyright (c) 2017, 2019 Microsemi Corporation
   5  */
   6
   7 #include <linux/if_bridge.h>
   8 #include "ocelot.h"
   9 #include "ocelot_vcap.h"
  10
  11 int ocelot_setup_tc_cls_flower(struct ocelot_port_private *priv,
  12                                struct flow_cls_offload *f,
  13                                bool ingress)
  14 {
  15         struct ocelot *ocelot = priv->port.ocelot;
  16         int port = priv->chip_port;
  17
  18         if (!ingress)
  19                 return -EOPNOTSUPP;
  20
  21         switch (f->command) {
  22         case FLOW_CLS_REPLACE:
  23                 return ocelot_cls_flower_replace(ocelot, port, f, ingress);
  24         case FLOW_CLS_DESTROY:
  25                 return ocelot_cls_flower_destroy(ocelot, port, f, ingress);
  26         case FLOW_CLS_STATS:
  27                 return ocelot_cls_flower_stats(ocelot, port, f, ingress);
  28         default:
  29                 return -EOPNOTSUPP;
  30         }
  31 }
  32
  33 static int ocelot_setup_tc_cls_matchall(struct ocelot_port_private *priv,
  34                                         struct tc_cls_matchall_offload *f,
  35                                         bool ingress)
  36 {
  37         struct netlink_ext_ack *extack = f->common.extack;
  38         struct ocelot *ocelot = priv->port.ocelot;
  39         struct ocelot_policer pol = { 0 };
  40         struct flow_action_entry *action;
  41         int port = priv->chip_port;
  42         int err;
  43
  44         if (!ingress) {
  45                 NL_SET_ERR_MSG_MOD(extack, "Only ingress is supported");
  46                 return -EOPNOTSUPP;
  47         }
  48
  49         switch (f->command) {
  50         case TC_CLSMATCHALL_REPLACE:
  51                 if (!flow_offload_has_one_action(&f->rule->action)) {
  52                         NL_SET_ERR_MSG_MOD(extack,
  53                                            "Only one action is supported");
  54                         return -EOPNOTSUPP;
  55                 }
  56
  57                 if (priv->tc.block_shared) {
  58                         NL_SET_ERR_MSG_MOD(extack,
  59                                            "Rate limit is not supported on shared blocks");
  60                         return -EOPNOTSUPP;
  61                 }
  62
  63                 action = &f->rule->action.entries[0];
  64
  65                 if (action->id != FLOW_ACTION_POLICE) {
  66                         NL_SET_ERR_MSG_MOD(extack, "Unsupported action");
  67                         return -EOPNOTSUPP;
  68                 }
  69
  70                 if (priv->tc.police_id && priv->tc.police_id != f->cookie) {
  71                         NL_SET_ERR_MSG_MOD(extack,
  72                                            "Only one policer per port is supported");
  73                         return -EEXIST;
  74                 }
  75
  76                 pol.rate = (u32)div_u64(action->police.rate_bytes_ps, 1000) * 8;
  77                 pol.burst = action->police.burst;
  78
  79                 err = ocelot_port_policer_add(ocelot, port, &pol);
  80                 if (err) {
  81                         NL_SET_ERR_MSG_MOD(extack, "Could not add policer");
  82                         return err;
  83                 }
  84
  85                 priv->tc.police_id = f->cookie;
  86                 priv->tc.offload_cnt++;
  87                 return 0;
  88         case TC_CLSMATCHALL_DESTROY:
  89                 if (priv->tc.police_id != f->cookie)
  90                         return -ENOENT;
  91
  92                 err = ocelot_port_policer_del(ocelot, port);
  93                 if (err) {
  94                         NL_SET_ERR_MSG_MOD(extack,
  95                                            "Could not delete policer");
  96                         return err;
  97                 }
  98                 priv->tc.police_id = 0;
  99                 priv->tc.offload_cnt--;
 100                 return 0;
 101         case TC_CLSMATCHALL_STATS:
 102         default:
 103                 return -EOPNOTSUPP;
 104         }
 105 }
 106
 107 static int ocelot_setup_tc_block_cb(enum tc_setup_type type,
 108                                     void *type_data,
 109                                     void *cb_priv, bool ingress)
 110 {
 111         struct ocelot_port_private *priv = cb_priv;
 112
 113         if (!tc_cls_can_offload_and_chain0(priv->dev, type_data))
 114                 return -EOPNOTSUPP;
 115
 116         switch (type) {
 117         case TC_SETUP_CLSMATCHALL:
 118                 return ocelot_setup_tc_cls_matchall(priv, type_data, ingress);
 119         case TC_SETUP_CLSFLOWER:
 120                 return ocelot_setup_tc_cls_flower(priv, type_data, ingress);
 121         default:
 122                 return -EOPNOTSUPP;
 123         }
 124 }
 125
 126 static int ocelot_setup_tc_block_cb_ig(enum tc_setup_type type,
 127                                        void *type_data,
 128                                        void *cb_priv)
 129 {
 130         return ocelot_setup_tc_block_cb(type, type_data,
 131                                         cb_priv, true);
 132 }
 133
 134 static int ocelot_setup_tc_block_cb_eg(enum tc_setup_type type,
 135                                        void *type_data,
 136                                        void *cb_priv)
 137 {
 138         return ocelot_setup_tc_block_cb(type, type_data,
 139                                         cb_priv, false);
 140 }
 141
 142 static LIST_HEAD(ocelot_block_cb_list);
 143
 144 static int ocelot_setup_tc_block(struct ocelot_port_private *priv,
 145                                  struct flow_block_offload *f)
 146 {
 147         struct flow_block_cb *block_cb;
 148         flow_setup_cb_t *cb;
 149
 150         if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS) {
 151                 cb = ocelot_setup_tc_block_cb_ig;
 152                 priv->tc.block_shared = f->block_shared;
 153         } else if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS) {
 154                 cb = ocelot_setup_tc_block_cb_eg;
 155         } else {
 156                 return -EOPNOTSUPP;
 157         }
 158
 159         f->driver_block_list = &ocelot_block_cb_list;
 160
 161         switch (f->command) {
 162         case FLOW_BLOCK_BIND:
 163                 if (flow_block_cb_is_busy(cb, priv, &ocelot_block_cb_list))
 164                         return -EBUSY;
 165
 166                 block_cb = flow_block_cb_alloc(cb, priv, priv, NULL);
 167                 if (IS_ERR(block_cb))
 168                         return PTR_ERR(block_cb);
 169
 170                 flow_block_cb_add(block_cb, f);
 171                 list_add_tail(&block_cb->driver_list, f->driver_block_list);
 172                 return 0;
 173         case FLOW_BLOCK_UNBIND:
 174                 block_cb = flow_block_cb_lookup(f->block, cb, priv);
 175                 if (!block_cb)
 176                         return -ENOENT;
 177
 178                 flow_block_cb_remove(block_cb, f);
 179                 list_del(&block_cb->driver_list);
 180                 return 0;
 181         default:
 182                 return -EOPNOTSUPP;
 183         }
 184 }
 185
 186 static int ocelot_setup_tc(struct net_device *dev, enum tc_setup_type type,
 187                            void *type_data)
 188 {
 189         struct ocelot_port_private *priv = netdev_priv(dev);
 190
 191         switch (type) {
 192         case TC_SETUP_BLOCK:
 193                 return ocelot_setup_tc_block(priv, type_data);
 194         default:
 195                 return -EOPNOTSUPP;
 196         }
 197         return 0;
 198 }
 199
 200 static void ocelot_port_adjust_link(struct net_device *dev)
 201 {
 202         struct ocelot_port_private *priv = netdev_priv(dev);
 203         struct ocelot *ocelot = priv->port.ocelot;
 204         int port = priv->chip_port;
 205
 206         ocelot_adjust_link(ocelot, port, dev->phydev);
 207 }
 208
 209 static int ocelot_vlan_vid_add(struct net_device *dev, u16 vid, bool pvid,
 210                                bool untagged)
 211 {
 212         struct ocelot_port_private *priv = netdev_priv(dev);
 213         struct ocelot_port *ocelot_port = &priv->port;
 214         struct ocelot *ocelot = ocelot_port->ocelot;
 215         int port = priv->chip_port;
 216         int ret;
 217
 218         ret = ocelot_vlan_add(ocelot, port, vid, pvid, untagged);
 219         if (ret)
 220                 return ret;
 221
 222         /* Add the port MAC address to with the right VLAN information */
 223         ocelot_mact_learn(ocelot, PGID_CPU, dev->dev_addr, vid,
 224                           ENTRYTYPE_LOCKED);
 225
 226         return 0;
 227 }
 228
 229 static int ocelot_vlan_vid_del(struct net_device *dev, u16 vid)
 230 {
 231         struct ocelot_port_private *priv = netdev_priv(dev);
 232         struct ocelot *ocelot = priv->port.ocelot;
 233         int port = priv->chip_port;
 234         int ret;
 235
 236         /* 8021q removes VID 0 on module unload for all interfaces
 237          * with VLAN filtering feature. We need to keep it to receive
 238          * untagged traffic.
 239          */
 240         if (vid == 0)
 241                 return 0;
 242
 243         ret = ocelot_vlan_del(ocelot, port, vid);
 244         if (ret)
 245                 return ret;
 246
 247         /* Del the port MAC address to with the right VLAN information */
 248         ocelot_mact_forget(ocelot, dev->dev_addr, vid);
 249
 250         return 0;
 251 }
 252
 253 static int ocelot_port_open(struct net_device *dev)
 254 {
 255         struct ocelot_port_private *priv = netdev_priv(dev);
 256         struct ocelot_port *ocelot_port = &priv->port;
 257         struct ocelot *ocelot = ocelot_port->ocelot;
 258         int port = priv->chip_port;
 259         int err;
 260
 261         if (priv->serdes) {
 262                 err = phy_set_mode_ext(priv->serdes, PHY_MODE_ETHERNET,
 263                                        ocelot_port->phy_mode);
 264                 if (err) {
 265                         netdev_err(dev, "Could not set mode of SerDes\n");
 266                         return err;
 267                 }
 268         }
 269
 270         err = phy_connect_direct(dev, priv->phy, &ocelot_port_adjust_link,
 271                                  ocelot_port->phy_mode);
 272         if (err) {
 273                 netdev_err(dev, "Could not attach to PHY\n");
 274                 return err;
 275         }
 276
 277         dev->phydev = priv->phy;
 278
 279         phy_attached_info(priv->phy);
 280         phy_start(priv->phy);
 281
 282         ocelot_port_enable(ocelot, port, priv->phy);
 283
 284         return 0;
 285 }
 286
 287 static int ocelot_port_stop(struct net_device *dev)
 288 {
 289         struct ocelot_port_private *priv = netdev_priv(dev);
 290         struct ocelot *ocelot = priv->port.ocelot;
 291         int port = priv->chip_port;
 292
 293         phy_disconnect(priv->phy);
 294
 295         dev->phydev = NULL;
 296
 297         ocelot_port_disable(ocelot, port);
 298
 299         return 0;
 300 }
 301
 302 /* Generate the IFH for frame injection
 303  *
 304  * The IFH is a 128bit-value
 305  * bit 127: bypass the analyzer processing
 306  * bit 56-67: destination mask
 307  * bit 28-29: pop_cnt: 3 disables all rewriting of the frame
 308  * bit 20-27: cpu extraction queue mask
 309  * bit 16: tag type 0: C-tag, 1: S-tag
 310  * bit 0-11: VID
 311  */
 312 static int ocelot_gen_ifh(u32 *ifh, struct frame_info *info)
 313 {
 314         ifh[0] = IFH_INJ_BYPASS | ((0x1ff & info->rew_op) << 21);
 315         ifh[1] = (0xf00 & info->port) >> 8;
 316         ifh[2] = (0xff & info->port) << 24;
 317         ifh[3] = (info->tag_type << 16) | info->vid;
 318
 319         return 0;
 320 }
 321
 322 static int ocelot_port_xmit(struct sk_buff *skb, struct net_device *dev)
 323 {
 324         struct ocelot_port_private *priv = netdev_priv(dev);
 325         struct skb_shared_info *shinfo = skb_shinfo(skb);
 326         struct ocelot_port *ocelot_port = &priv->port;
 327         struct ocelot *ocelot = ocelot_port->ocelot;
 328         u32 val, ifh[OCELOT_TAG_LEN / 4];
 329         struct frame_info info = {};
 330         u8 grp = 0; /* Send everything on CPU group 0 */
 331         unsigned int i, count, last;
 332         int port = priv->chip_port;
 333         bool do_tstamp;
 334
 335         val = ocelot_read(ocelot, QS_INJ_STATUS);
 336         if (!(val & QS_INJ_STATUS_FIFO_RDY(BIT(grp))) ||
 337             (val & QS_INJ_STATUS_WMARK_REACHED(BIT(grp))))
 338                 return NETDEV_TX_BUSY;
 339
 340         ocelot_write_rix(ocelot, QS_INJ_CTRL_GAP_SIZE(1) |
 341                          QS_INJ_CTRL_SOF, QS_INJ_CTRL, grp);
 342
 343         info.port = BIT(port);
 344         info.tag_type = IFH_TAG_TYPE_C;
 345         info.vid = skb_vlan_tag_get(skb);
 346
 347         /* Check if timestamping is needed */
 348         do_tstamp = (ocelot_port_add_txtstamp_skb(ocelot_port, skb) == 0);
 349
 350         if (ocelot->ptp && shinfo->tx_flags & SKBTX_HW_TSTAMP) {
 351                 info.rew_op = ocelot_port->ptp_cmd;
 352                 if (ocelot_port->ptp_cmd == IFH_REW_OP_TWO_STEP_PTP) {
 353                         info.rew_op |= (ocelot_port->ts_id  % 4) << 3;
 354                         ocelot_port->ts_id++;
 355                 }
 356         }
 357
 358         ocelot_gen_ifh(ifh, &info);
 359
 360         for (i = 0; i < OCELOT_TAG_LEN / 4; i++)
 361                 ocelot_write_rix(ocelot, (__force u32)cpu_to_be32(ifh[i]),
 362                                  QS_INJ_WR, grp);
 363
 364         count = (skb->len + 3) / 4;
 365         last = skb->len % 4;
 366         for (i = 0; i < count; i++)
 367                 ocelot_write_rix(ocelot, ((u32 *)skb->data)[i], QS_INJ_WR, grp);
 368
 369         /* Add padding */
 370         while (i < (OCELOT_BUFFER_CELL_SZ / 4)) {
 371                 ocelot_write_rix(ocelot, 0, QS_INJ_WR, grp);
 372                 i++;
 373         }
 374
 375         /* Indicate EOF and valid bytes in last word */
 376         ocelot_write_rix(ocelot, QS_INJ_CTRL_GAP_SIZE(1) |
 377                          QS_INJ_CTRL_VLD_BYTES(skb->len < OCELOT_BUFFER_CELL_SZ ? 0 : last) |
 378                          QS_INJ_CTRL_EOF,
 379                          QS_INJ_CTRL, grp);
 380
 381         /* Add dummy CRC */
 382         ocelot_write_rix(ocelot, 0, QS_INJ_WR, grp);
 383         skb_tx_timestamp(skb);
 384
 385         dev->stats.tx_packets++;
 386         dev->stats.tx_bytes += skb->len;
 387
 388         if (!do_tstamp)
 389                 dev_kfree_skb_any(skb);
 390
 391         return NETDEV_TX_OK;
 392 }
 393
 394 static int ocelot_mc_unsync(struct net_device *dev, const unsigned char *addr)
 395 {
 396         struct ocelot_port_private *priv = netdev_priv(dev);
 397         struct ocelot_port *ocelot_port = &priv->port;
 398         struct ocelot *ocelot = ocelot_port->ocelot;
 399
 400         return ocelot_mact_forget(ocelot, addr, ocelot_port->pvid);
 401 }
 402
 403 static int ocelot_mc_sync(struct net_device *dev, const unsigned char *addr)
 404 {
 405         struct ocelot_port_private *priv = netdev_priv(dev);
 406         struct ocelot_port *ocelot_port = &priv->port;
 407         struct ocelot *ocelot = ocelot_port->ocelot;
 408
 409         return ocelot_mact_learn(ocelot, PGID_CPU, addr, ocelot_port->pvid,
 410                                  ENTRYTYPE_LOCKED);
 411 }
 412
 413 static void ocelot_set_rx_mode(struct net_device *dev)
 414 {
 415         struct ocelot_port_private *priv = netdev_priv(dev);
 416         struct ocelot *ocelot = priv->port.ocelot;
 417         u32 val;
 418         int i;
 419
 420         /* This doesn't handle promiscuous mode because the bridge core is
 421          * setting IFF_PROMISC on all slave interfaces and all frames would be
 422          * forwarded to the CPU port.
 423          */
 424         val = GENMASK(ocelot->num_phys_ports - 1, 0);
 425         for_each_nonreserved_multicast_dest_pgid(ocelot, i)
 426                 ocelot_write_rix(ocelot, val, ANA_PGID_PGID, i);
 427
 428         __dev_mc_sync(dev, ocelot_mc_sync, ocelot_mc_unsync);
 429 }
 430
 431 static int ocelot_port_get_phys_port_name(struct net_device *dev,
 432                                           char *buf, size_t len)
 433 {
 434         struct ocelot_port_private *priv = netdev_priv(dev);
 435         int port = priv->chip_port;
 436         int ret;
 437
 438         ret = snprintf(buf, len, "p%d", port);
 439         if (ret >= len)
 440                 return -EINVAL;
 441
 442         return 0;
 443 }
 444
 445 static int ocelot_port_set_mac_address(struct net_device *dev, void *p)
 446 {
 447         struct ocelot_port_private *priv = netdev_priv(dev);
 448         struct ocelot_port *ocelot_port = &priv->port;
 449         struct ocelot *ocelot = ocelot_port->ocelot;
 450         const struct sockaddr *addr = p;
 451
 452         /* Learn the new net device MAC address in the mac table. */
 453         ocelot_mact_learn(ocelot, PGID_CPU, addr->sa_data, ocelot_port->pvid,
 454                           ENTRYTYPE_LOCKED);
 455         /* Then forget the previous one. */
 456         ocelot_mact_forget(ocelot, dev->dev_addr, ocelot_port->pvid);
 457
 458         ether_addr_copy(dev->dev_addr, addr->sa_data);
 459         return 0;
 460 }
 461
 462 static void ocelot_get_stats64(struct net_device *dev,
 463                                struct rtnl_link_stats64 *stats)
 464 {
 465         struct ocelot_port_private *priv = netdev_priv(dev);
 466         struct ocelot *ocelot = priv->port.ocelot;
 467         int port = priv->chip_port;
 468
 469         /* Configure the port to read the stats from */
 470         ocelot_write(ocelot, SYS_STAT_CFG_STAT_VIEW(port),
 471                      SYS_STAT_CFG);
 472
 473         /* Get Rx stats */
 474         stats->rx_bytes = ocelot_read(ocelot, SYS_COUNT_RX_OCTETS);
 475         stats->rx_packets = ocelot_read(ocelot, SYS_COUNT_RX_SHORTS) +
 476                             ocelot_read(ocelot, SYS_COUNT_RX_FRAGMENTS) +
 477                             ocelot_read(ocelot, SYS_COUNT_RX_JABBERS) +
 478                             ocelot_read(ocelot, SYS_COUNT_RX_LONGS) +
 479                             ocelot_read(ocelot, SYS_COUNT_RX_64) +
 480                             ocelot_read(ocelot, SYS_COUNT_RX_65_127) +
 481                             ocelot_read(ocelot, SYS_COUNT_RX_128_255) +
 482                             ocelot_read(ocelot, SYS_COUNT_RX_256_1023) +
 483                             ocelot_read(ocelot, SYS_COUNT_RX_1024_1526) +
 484                             ocelot_read(ocelot, SYS_COUNT_RX_1527_MAX);
 485         stats->multicast = ocelot_read(ocelot, SYS_COUNT_RX_MULTICAST);
 486         stats->rx_dropped = dev->stats.rx_dropped;
 487
 488         /* Get Tx stats */
 489         stats->tx_bytes = ocelot_read(ocelot, SYS_COUNT_TX_OCTETS);
 490         stats->tx_packets = ocelot_read(ocelot, SYS_COUNT_TX_64) +
 491                             ocelot_read(ocelot, SYS_COUNT_TX_65_127) +
 492                             ocelot_read(ocelot, SYS_COUNT_TX_128_511) +
 493                             ocelot_read(ocelot, SYS_COUNT_TX_512_1023) +
 494                             ocelot_read(ocelot, SYS_COUNT_TX_1024_1526) +
 495                             ocelot_read(ocelot, SYS_COUNT_TX_1527_MAX);
 496         stats->tx_dropped = ocelot_read(ocelot, SYS_COUNT_TX_DROPS) +
 497                             ocelot_read(ocelot, SYS_COUNT_TX_AGING);
 498         stats->collisions = ocelot_read(ocelot, SYS_COUNT_TX_COLLISION);
 499 }
 500
 501 static int ocelot_port_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
 502                                struct net_device *dev,
 503                                const unsigned char *addr,
 504                                u16 vid, u16 flags,
 505                                struct netlink_ext_ack *extack)
 506 {
 507         struct ocelot_port_private *priv = netdev_priv(dev);
 508         struct ocelot *ocelot = priv->port.ocelot;
 509         int port = priv->chip_port;
 510
 511         return ocelot_fdb_add(ocelot, port, addr, vid);
 512 }
 513
 514 static int ocelot_port_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
 515                                struct net_device *dev,
 516                                const unsigned char *addr, u16 vid)
 517 {
 518         struct ocelot_port_private *priv = netdev_priv(dev);
 519         struct ocelot *ocelot = priv->port.ocelot;
 520         int port = priv->chip_port;
 521
 522         return ocelot_fdb_del(ocelot, port, addr, vid);
 523 }
 524
 525 static int ocelot_port_fdb_dump(struct sk_buff *skb,
 526                                 struct netlink_callback *cb,
 527                                 struct net_device *dev,
 528                                 struct net_device *filter_dev, int *idx)
 529 {
 530         struct ocelot_port_private *priv = netdev_priv(dev);
 531         struct ocelot *ocelot = priv->port.ocelot;
 532         struct ocelot_dump_ctx dump = {
 533                 .dev = dev,
 534                 .skb = skb,
 535                 .cb = cb,
 536                 .idx = *idx,
 537         };
 538         int port = priv->chip_port;
 539         int ret;
 540
 541         ret = ocelot_fdb_dump(ocelot, port, ocelot_port_fdb_do_dump, &dump);
 542
 543         *idx = dump.idx;
 544
 545         return ret;
 546 }
 547
 548 static int ocelot_vlan_rx_add_vid(struct net_device *dev, __be16 proto,
 549                                   u16 vid)
 550 {
 551         return ocelot_vlan_vid_add(dev, vid, false, false);
 552 }
 553
 554 static int ocelot_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,
 555                                    u16 vid)
 556 {
 557         return ocelot_vlan_vid_del(dev, vid);
 558 }
 559
 560 static void ocelot_vlan_mode(struct ocelot *ocelot, int port,
 561                              netdev_features_t features)
 562 {
 563         u32 val;
 564
 565         /* Filtering */
 566         val = ocelot_read(ocelot, ANA_VLANMASK);
 567         if (features & NETIF_F_HW_VLAN_CTAG_FILTER)
 568                 val |= BIT(port);
 569         else
 570                 val &= ~BIT(port);
 571         ocelot_write(ocelot, val, ANA_VLANMASK);
 572 }
 573
 574 static int ocelot_set_features(struct net_device *dev,
 575                                netdev_features_t features)
 576 {
 577         netdev_features_t changed = dev->features ^ features;
 578         struct ocelot_port_private *priv = netdev_priv(dev);
 579         struct ocelot *ocelot = priv->port.ocelot;
 580         int port = priv->chip_port;
 581
 582         if ((dev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC) &&
 583             priv->tc.offload_cnt) {
 584                 netdev_err(dev,
 585                            "Cannot disable HW TC offload while offloads active\n");
 586                 return -EBUSY;
 587         }
 588
 589         if (changed & NETIF_F_HW_VLAN_CTAG_FILTER)
 590                 ocelot_vlan_mode(ocelot, port, features);
 591
 592         return 0;
 593 }
 594
 595 static int ocelot_get_port_parent_id(struct net_device *dev,
 596                                      struct netdev_phys_item_id *ppid)
 597 {
 598         struct ocelot_port_private *priv = netdev_priv(dev);
 599         struct ocelot *ocelot = priv->port.ocelot;
 600
 601         ppid->id_len = sizeof(ocelot->base_mac);
 602         memcpy(&ppid->id, &ocelot->base_mac, ppid->id_len);
 603
 604         return 0;
 605 }
 606
 607 static int ocelot_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 608 {
 609         struct ocelot_port_private *priv = netdev_priv(dev);
 610         struct ocelot *ocelot = priv->port.ocelot;
 611         int port = priv->chip_port;
 612
 613         /* If the attached PHY device isn't capable of timestamping operations,
 614          * use our own (when possible).
 615          */
 616         if (!phy_has_hwtstamp(dev->phydev) && ocelot->ptp) {
 617                 switch (cmd) {
 618                 case SIOCSHWTSTAMP:
 619                         return ocelot_hwstamp_set(ocelot, port, ifr);
 620                 case SIOCGHWTSTAMP:
 621                         return ocelot_hwstamp_get(ocelot, port, ifr);
 622                 }
 623         }
 624
 625         return phy_mii_ioctl(dev->phydev, ifr, cmd);
 626 }
 627
 628 static const struct net_device_ops ocelot_port_netdev_ops = {
 629         .ndo_open                       = ocelot_port_open,
 630         .ndo_stop                       = ocelot_port_stop,
 631         .ndo_start_xmit                 = ocelot_port_xmit,
 632         .ndo_set_rx_mode                = ocelot_set_rx_mode,
 633         .ndo_get_phys_port_name         = ocelot_port_get_phys_port_name,
 634         .ndo_set_mac_address            = ocelot_port_set_mac_address,
 635         .ndo_get_stats64                = ocelot_get_stats64,
 636         .ndo_fdb_add                    = ocelot_port_fdb_add,
 637         .ndo_fdb_del                    = ocelot_port_fdb_del,
 638         .ndo_fdb_dump                   = ocelot_port_fdb_dump,
 639         .ndo_vlan_rx_add_vid            = ocelot_vlan_rx_add_vid,
 640         .ndo_vlan_rx_kill_vid           = ocelot_vlan_rx_kill_vid,
 641         .ndo_set_features               = ocelot_set_features,
 642         .ndo_get_port_parent_id         = ocelot_get_port_parent_id,
 643         .ndo_setup_tc                   = ocelot_setup_tc,
 644         .ndo_do_ioctl                   = ocelot_ioctl,
 645 };
 646
 647 static void ocelot_port_get_strings(struct net_device *netdev, u32 sset,
 648                                     u8 *data)
 649 {
 650         struct ocelot_port_private *priv = netdev_priv(netdev);
 651         struct ocelot *ocelot = priv->port.ocelot;
 652         int port = priv->chip_port;
 653
 654         ocelot_get_strings(ocelot, port, sset, data);
 655 }
 656
 657 static void ocelot_port_get_ethtool_stats(struct net_device *dev,
 658                                           struct ethtool_stats *stats,
 659                                           u64 *data)
 660 {
 661         struct ocelot_port_private *priv = netdev_priv(dev);
 662         struct ocelot *ocelot = priv->port.ocelot;
 663         int port = priv->chip_port;
 664
 665         ocelot_get_ethtool_stats(ocelot, port, data);
 666 }
 667
 668 static int ocelot_port_get_sset_count(struct net_device *dev, int sset)
 669 {
 670         struct ocelot_port_private *priv = netdev_priv(dev);
 671         struct ocelot *ocelot = priv->port.ocelot;
 672         int port = priv->chip_port;
 673
 674         return ocelot_get_sset_count(ocelot, port, sset);
 675 }
 676
 677 static int ocelot_port_get_ts_info(struct net_device *dev,
 678                                    struct ethtool_ts_info *info)
 679 {
 680         struct ocelot_port_private *priv = netdev_priv(dev);
 681         struct ocelot *ocelot = priv->port.ocelot;
 682         int port = priv->chip_port;
 683
 684         if (!ocelot->ptp)
 685                 return ethtool_op_get_ts_info(dev, info);
 686
 687         return ocelot_get_ts_info(ocelot, port, info);
 688 }
 689
 690 static const struct ethtool_ops ocelot_ethtool_ops = {
 691         .get_strings            = ocelot_port_get_strings,
 692         .get_ethtool_stats      = ocelot_port_get_ethtool_stats,
 693         .get_sset_count         = ocelot_port_get_sset_count,
 694         .get_link_ksettings     = phy_ethtool_get_link_ksettings,
 695         .set_link_ksettings     = phy_ethtool_set_link_ksettings,
 696         .get_ts_info            = ocelot_port_get_ts_info,
 697 };
 698
 699 static void ocelot_port_attr_stp_state_set(struct ocelot *ocelot, int port,
 700                                            struct switchdev_trans *trans,
 701                                            u8 state)
 702 {
 703         if (switchdev_trans_ph_prepare(trans))
 704                 return;
 705
 706         ocelot_bridge_stp_state_set(ocelot, port, state);
 707 }
 708
 709 static void ocelot_port_attr_ageing_set(struct ocelot *ocelot, int port,
 710                                         unsigned long ageing_clock_t)
 711 {
 712         unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t);
 713         u32 ageing_time = jiffies_to_msecs(ageing_jiffies);
 714
 715         ocelot_set_ageing_time(ocelot, ageing_time);
 716 }
 717
 718 static void ocelot_port_attr_mc_set(struct ocelot *ocelot, int port, bool mc)
 719 {
 720         u32 cpu_fwd_mcast = ANA_PORT_CPU_FWD_CFG_CPU_IGMP_REDIR_ENA |
 721                             ANA_PORT_CPU_FWD_CFG_CPU_MLD_REDIR_ENA |
 722                             ANA_PORT_CPU_FWD_CFG_CPU_IPMC_CTRL_COPY_ENA;
 723         u32 val = 0;
 724
 725         if (mc)
 726                 val = cpu_fwd_mcast;
 727
 728         ocelot_rmw_gix(ocelot, val, cpu_fwd_mcast,
 729                        ANA_PORT_CPU_FWD_CFG, port);
 730 }
 731
 732 static int ocelot_port_attr_set(struct net_device *dev,
 733                                 const struct switchdev_attr *attr,
 734                                 struct switchdev_trans *trans)
 735 {
 736         struct ocelot_port_private *priv = netdev_priv(dev);
 737         struct ocelot *ocelot = priv->port.ocelot;
 738         int port = priv->chip_port;
 739         int err = 0;
 740
 741         switch (attr->id) {
 742         case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
 743                 ocelot_port_attr_stp_state_set(ocelot, port, trans,
 744                                                attr->u.stp_state);
 745                 break;
 746         case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
 747                 ocelot_port_attr_ageing_set(ocelot, port, attr->u.ageing_time);
 748                 break;
 749         case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
 750                 ocelot_port_vlan_filtering(ocelot, port,
 751                                            attr->u.vlan_filtering);
 752                 break;
 753         case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED:
 754                 ocelot_port_attr_mc_set(ocelot, port, !attr->u.mc_disabled);
 755                 break;
 756         default:
 757                 err = -EOPNOTSUPP;
 758                 break;
 759         }
 760
 761         return err;
 762 }
 763
 764 static int ocelot_port_obj_add_vlan(struct net_device *dev,
 765                                     const struct switchdev_obj_port_vlan *vlan,
 766                                     struct switchdev_trans *trans)
 767 {
 768         int ret;
 769         u16 vid;
 770
 771         for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
 772                 ret = ocelot_vlan_vid_add(dev, vid,
 773                                           vlan->flags & BRIDGE_VLAN_INFO_PVID,
 774                                           vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED);
 775                 if (ret)
 776                         return ret;
 777         }
 778
 779         return 0;
 780 }
 781
 782 static int ocelot_port_vlan_del_vlan(struct net_device *dev,
 783                                      const struct switchdev_obj_port_vlan *vlan)
 784 {
 785         int ret;
 786         u16 vid;
 787
 788         for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
 789                 ret = ocelot_vlan_vid_del(dev, vid);
 790
 791                 if (ret)
 792                         return ret;
 793         }
 794
 795         return 0;
 796 }
 797
 798 static int ocelot_port_obj_add_mdb(struct net_device *dev,
 799                                    const struct switchdev_obj_port_mdb *mdb,
 800                                    struct switchdev_trans *trans)
 801 {
 802         struct ocelot_port_private *priv = netdev_priv(dev);
 803         struct ocelot_port *ocelot_port = &priv->port;
 804         struct ocelot *ocelot = ocelot_port->ocelot;
 805         int port = priv->chip_port;
 806
 807         if (switchdev_trans_ph_prepare(trans))
 808                 return 0;
 809
 810         return ocelot_port_mdb_add(ocelot, port, mdb);
 811 }
 812
 813 static int ocelot_port_obj_del_mdb(struct net_device *dev,
 814                                    const struct switchdev_obj_port_mdb *mdb)
 815 {
 816         struct ocelot_port_private *priv = netdev_priv(dev);
 817         struct ocelot_port *ocelot_port = &priv->port;
 818         struct ocelot *ocelot = ocelot_port->ocelot;
 819         int port = priv->chip_port;
 820
 821         return ocelot_port_mdb_del(ocelot, port, mdb);
 822 }
 823
 824 static int ocelot_port_obj_add(struct net_device *dev,
 825                                const struct switchdev_obj *obj,
 826                                struct switchdev_trans *trans,
 827                                struct netlink_ext_ack *extack)
 828 {
 829         int ret = 0;
 830
 831         switch (obj->id) {
 832         case SWITCHDEV_OBJ_ID_PORT_VLAN:
 833                 ret = ocelot_port_obj_add_vlan(dev,
 834                                                SWITCHDEV_OBJ_PORT_VLAN(obj),
 835                                                trans);
 836                 break;
 837         case SWITCHDEV_OBJ_ID_PORT_MDB:
 838                 ret = ocelot_port_obj_add_mdb(dev, SWITCHDEV_OBJ_PORT_MDB(obj),
 839                                               trans);
 840                 break;
 841         default:
 842                 return -EOPNOTSUPP;
 843         }
 844
 845         return ret;
 846 }
 847
 848 static int ocelot_port_obj_del(struct net_device *dev,
 849                                const struct switchdev_obj *obj)
 850 {
 851         int ret = 0;
 852
 853         switch (obj->id) {
 854         case SWITCHDEV_OBJ_ID_PORT_VLAN:
 855                 ret = ocelot_port_vlan_del_vlan(dev,
 856                                                 SWITCHDEV_OBJ_PORT_VLAN(obj));
 857                 break;
 858         case SWITCHDEV_OBJ_ID_PORT_MDB:
 859                 ret = ocelot_port_obj_del_mdb(dev, SWITCHDEV_OBJ_PORT_MDB(obj));
 860                 break;
 861         default:
 862                 return -EOPNOTSUPP;
 863         }
 864
 865         return ret;
 866 }
 867
 868 /* Checks if the net_device instance given to us originate from our driver. */
 869 static bool ocelot_netdevice_dev_check(const struct net_device *dev)
 870 {
 871         return dev->netdev_ops == &ocelot_port_netdev_ops;
 872 }
 873
 874 static int ocelot_netdevice_port_event(struct net_device *dev,
 875                                        unsigned long event,
 876                                        struct netdev_notifier_changeupper_info *info)
 877 {
 878         struct ocelot_port_private *priv = netdev_priv(dev);
 879         struct ocelot_port *ocelot_port = &priv->port;
 880         struct ocelot *ocelot = ocelot_port->ocelot;
 881         int port = priv->chip_port;
 882         int err = 0;
 883
 884         switch (event) {
 885         case NETDEV_CHANGEUPPER:
 886                 if (netif_is_bridge_master(info->upper_dev)) {
 887                         if (info->linking) {
 888                                 err = ocelot_port_bridge_join(ocelot, port,
 889                                                               info->upper_dev);
 890                         } else {
 891                                 err = ocelot_port_bridge_leave(ocelot, port,
 892                                                                info->upper_dev);
 893                         }
 894                 }
 895                 if (netif_is_lag_master(info->upper_dev)) {
 896                         if (info->linking)
 897                                 err = ocelot_port_lag_join(ocelot, port,
 898                                                            info->upper_dev);
 899                         else
 900                                 ocelot_port_lag_leave(ocelot, port,
 901                                                       info->upper_dev);
 902                 }
 903                 break;
 904         default:
 905                 break;
 906         }
 907
 908         return err;
 909 }
 910
 911 static int ocelot_netdevice_event(struct notifier_block *unused,
 912                                   unsigned long event, void *ptr)
 913 {
 914         struct netdev_notifier_changeupper_info *info = ptr;
 915         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 916         int ret = 0;
 917
 918         if (!ocelot_netdevice_dev_check(dev))
 919                 return 0;
 920
 921         if (event == NETDEV_PRECHANGEUPPER &&
 922             netif_is_lag_master(info->upper_dev)) {
 923                 struct netdev_lag_upper_info *lag_upper_info = info->upper_info;
 924                 struct netlink_ext_ack *extack;
 925
 926                 if (lag_upper_info &&
 927                     lag_upper_info->tx_type != NETDEV_LAG_TX_TYPE_HASH) {
 928                         extack = netdev_notifier_info_to_extack(&info->info);
 929                         NL_SET_ERR_MSG_MOD(extack, "LAG device using unsupported Tx type");
 930
 931                         ret = -EINVAL;
 932                         goto notify;
 933                 }
 934         }
 935
 936         if (netif_is_lag_master(dev)) {
 937                 struct net_device *slave;
 938                 struct list_head *iter;
 939
 940                 netdev_for_each_lower_dev(dev, slave, iter) {
 941                         ret = ocelot_netdevice_port_event(slave, event, info);
 942                         if (ret)
 943                                 goto notify;
 944                 }
 945         } else {
 946                 ret = ocelot_netdevice_port_event(dev, event, info);
 947         }
 948
 949 notify:
 950         return notifier_from_errno(ret);
 951 }
 952
 953 struct notifier_block ocelot_netdevice_nb __read_mostly = {
 954         .notifier_call = ocelot_netdevice_event,
 955 };
 956
 957 static int ocelot_switchdev_event(struct notifier_block *unused,
 958                                   unsigned long event, void *ptr)
 959 {
 960         struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
 961         int err;
 962
 963         switch (event) {
 964         case SWITCHDEV_PORT_ATTR_SET:
 965                 err = switchdev_handle_port_attr_set(dev, ptr,
 966                                                      ocelot_netdevice_dev_check,
 967                                                      ocelot_port_attr_set);
 968                 return notifier_from_errno(err);
 969         }
 970
 971         return NOTIFY_DONE;
 972 }
 973
 974 struct notifier_block ocelot_switchdev_nb __read_mostly = {
 975         .notifier_call = ocelot_switchdev_event,
 976 };
 977
 978 static int ocelot_switchdev_blocking_event(struct notifier_block *unused,
 979                                            unsigned long event, void *ptr)
 980 {
 981         struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
 982         int err;
 983
 984         switch (event) {
 985                 /* Blocking events. */
 986         case SWITCHDEV_PORT_OBJ_ADD:
 987                 err = switchdev_handle_port_obj_add(dev, ptr,
 988                                                     ocelot_netdevice_dev_check,
 989                                                     ocelot_port_obj_add);
 990                 return notifier_from_errno(err);
 991         case SWITCHDEV_PORT_OBJ_DEL:
 992                 err = switchdev_handle_port_obj_del(dev, ptr,
 993                                                     ocelot_netdevice_dev_check,
 994                                                     ocelot_port_obj_del);
 995                 return notifier_from_errno(err);
 996         case SWITCHDEV_PORT_ATTR_SET:
 997                 err = switchdev_handle_port_attr_set(dev, ptr,
 998                                                      ocelot_netdevice_dev_check,
 999                                                      ocelot_port_attr_set);
1000                 return notifier_from_errno(err);
1001         }
1002
1003         return NOTIFY_DONE;
1004 }
1005
1006 struct notifier_block ocelot_switchdev_blocking_nb __read_mostly = {
1007         .notifier_call = ocelot_switchdev_blocking_event,
1008 };
1009
1010 int ocelot_probe_port(struct ocelot *ocelot, int port, struct regmap *target,
1011                       struct phy_device *phy)
1012 {
1013         struct ocelot_port_private *priv;
1014         struct ocelot_port *ocelot_port;
1015         struct net_device *dev;
1016         int err;
1017
1018         dev = alloc_etherdev(sizeof(struct ocelot_port_private));
1019         if (!dev)
1020                 return -ENOMEM;
1021         SET_NETDEV_DEV(dev, ocelot->dev);
1022         priv = netdev_priv(dev);
1023         priv->dev = dev;
1024         priv->phy = phy;
1025         priv->chip_port = port;
1026         ocelot_port = &priv->port;
1027         ocelot_port->ocelot = ocelot;
1028         ocelot_port->target = target;
1029         ocelot->ports[port] = ocelot_port;
1030
1031         dev->netdev_ops = &ocelot_port_netdev_ops;
1032         dev->ethtool_ops = &ocelot_ethtool_ops;
1033
1034         dev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_RXFCS |
1035                 NETIF_F_HW_TC;
1036         dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_TC;
1037
1038         memcpy(dev->dev_addr, ocelot->base_mac, ETH_ALEN);
1039         dev->dev_addr[ETH_ALEN - 1] += port;
1040         ocelot_mact_learn(ocelot, PGID_CPU, dev->dev_addr, ocelot_port->pvid,
1041                           ENTRYTYPE_LOCKED);
1042
1043         ocelot_init_port(ocelot, port);
1044
1045         err = register_netdev(dev);
1046         if (err) {
1047                 dev_err(ocelot->dev, "register_netdev failed\n");
1048                 free_netdev(dev);
1049         }
1050
1051         return err;
1052 }