drivers/net/ethernet/marvell/prestera/prestera_main.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved */
   3
   4 #include <linux/etherdevice.h>
   5 #include <linux/jiffies.h>
   6 #include <linux/list.h>
   7 #include <linux/module.h>
   8 #include <linux/netdev_features.h>
   9 #include <linux/of.h>
  10 #include <linux/of_net.h>
  11
  12 #include "prestera.h"
  13 #include "prestera_hw.h"
  14 #include "prestera_rxtx.h"
  15 #include "prestera_devlink.h"
  16 #include "prestera_ethtool.h"
  17 #include "prestera_switchdev.h"
  18
  19 #define PRESTERA_MTU_DEFAULT    1536
  20
  21 #define PRESTERA_STATS_DELAY_MS 1000
  22
  23 #define PRESTERA_MAC_ADDR_NUM_MAX       255
  24
  25 static struct workqueue_struct *prestera_wq;
  26
  27 int prestera_port_pvid_set(struct prestera_port *port, u16 vid)
  28 {
  29         enum prestera_accept_frm_type frm_type;
  30         int err;
  31
  32         frm_type = PRESTERA_ACCEPT_FRAME_TYPE_TAGGED;
  33
  34         if (vid) {
  35                 err = prestera_hw_vlan_port_vid_set(port, vid);
  36                 if (err)
  37                         return err;
  38
  39                 frm_type = PRESTERA_ACCEPT_FRAME_TYPE_ALL;
  40         }
  41
  42         err = prestera_hw_port_accept_frm_type(port, frm_type);
  43         if (err && frm_type == PRESTERA_ACCEPT_FRAME_TYPE_ALL)
  44                 prestera_hw_vlan_port_vid_set(port, port->pvid);
  45
  46         port->pvid = vid;
  47         return 0;
  48 }
  49
  50 struct prestera_port *prestera_port_find_by_hwid(struct prestera_switch *sw,
  51                                                  u32 dev_id, u32 hw_id)
  52 {
  53         struct prestera_port *port = NULL, *tmp;
  54
  55         read_lock(&sw->port_list_lock);
  56         list_for_each_entry(tmp, &sw->port_list, list) {
  57                 if (tmp->dev_id == dev_id && tmp->hw_id == hw_id) {
  58                         port = tmp;
  59                         break;
  60                 }
  61         }
  62         read_unlock(&sw->port_list_lock);
  63
  64         return port;
  65 }
  66
  67 struct prestera_port *prestera_find_port(struct prestera_switch *sw, u32 id)
  68 {
  69         struct prestera_port *port = NULL, *tmp;
  70
  71         read_lock(&sw->port_list_lock);
  72         list_for_each_entry(tmp, &sw->port_list, list) {
  73                 if (tmp->id == id) {
  74                         port = tmp;
  75                         break;
  76                 }
  77         }
  78         read_unlock(&sw->port_list_lock);
  79
  80         return port;
  81 }
  82
  83 static int prestera_port_open(struct net_device *dev)
  84 {
  85         struct prestera_port *port = netdev_priv(dev);
  86         int err;
  87
  88         err = prestera_hw_port_state_set(port, true);
  89         if (err)
  90                 return err;
  91
  92         netif_start_queue(dev);
  93
  94         return 0;
  95 }
  96
  97 static int prestera_port_close(struct net_device *dev)
  98 {
  99         struct prestera_port *port = netdev_priv(dev);
 100         int err;
 101
 102         netif_stop_queue(dev);
 103
 104         err = prestera_hw_port_state_set(port, false);
 105         if (err)
 106                 return err;
 107
 108         return 0;
 109 }
 110
 111 static netdev_tx_t prestera_port_xmit(struct sk_buff *skb,
 112                                       struct net_device *dev)
 113 {
 114         return prestera_rxtx_xmit(netdev_priv(dev), skb);
 115 }
 116
 117 static int prestera_is_valid_mac_addr(struct prestera_port *port, u8 *addr)
 118 {
 119         if (!is_valid_ether_addr(addr))
 120                 return -EADDRNOTAVAIL;
 121
 122         /* firmware requires that port's MAC address contains first 5 bytes
 123          * of the base MAC address
 124          */
 125         if (memcmp(port->sw->base_mac, addr, ETH_ALEN - 1))
 126                 return -EINVAL;
 127
 128         return 0;
 129 }
 130
 131 static int prestera_port_set_mac_address(struct net_device *dev, void *p)
 132 {
 133         struct prestera_port *port = netdev_priv(dev);
 134         struct sockaddr *addr = p;
 135         int err;
 136
 137         err = prestera_is_valid_mac_addr(port, addr->sa_data);
 138         if (err)
 139                 return err;
 140
 141         err = prestera_hw_port_mac_set(port, addr->sa_data);
 142         if (err)
 143                 return err;
 144
 145         ether_addr_copy(dev->dev_addr, addr->sa_data);
 146
 147         return 0;
 148 }
 149
 150 static int prestera_port_change_mtu(struct net_device *dev, int mtu)
 151 {
 152         struct prestera_port *port = netdev_priv(dev);
 153         int err;
 154
 155         err = prestera_hw_port_mtu_set(port, mtu);
 156         if (err)
 157                 return err;
 158
 159         dev->mtu = mtu;
 160
 161         return 0;
 162 }
 163
 164 static void prestera_port_get_stats64(struct net_device *dev,
 165                                       struct rtnl_link_stats64 *stats)
 166 {
 167         struct prestera_port *port = netdev_priv(dev);
 168         struct prestera_port_stats *port_stats = &port->cached_hw_stats.stats;
 169
 170         stats->rx_packets = port_stats->broadcast_frames_received +
 171                                 port_stats->multicast_frames_received +
 172                                 port_stats->unicast_frames_received;
 173
 174         stats->tx_packets = port_stats->broadcast_frames_sent +
 175                                 port_stats->multicast_frames_sent +
 176                                 port_stats->unicast_frames_sent;
 177
 178         stats->rx_bytes = port_stats->good_octets_received;
 179
 180         stats->tx_bytes = port_stats->good_octets_sent;
 181
 182         stats->rx_errors = port_stats->rx_error_frame_received;
 183         stats->tx_errors = port_stats->mac_trans_error;
 184
 185         stats->rx_dropped = port_stats->buffer_overrun;
 186         stats->tx_dropped = 0;
 187
 188         stats->multicast = port_stats->multicast_frames_received;
 189         stats->collisions = port_stats->excessive_collision;
 190
 191         stats->rx_crc_errors = port_stats->bad_crc;
 192 }
 193
 194 static void prestera_port_get_hw_stats(struct prestera_port *port)
 195 {
 196         prestera_hw_port_stats_get(port, &port->cached_hw_stats.stats);
 197 }
 198
 199 static void prestera_port_stats_update(struct work_struct *work)
 200 {
 201         struct prestera_port *port =
 202                 container_of(work, struct prestera_port,
 203                              cached_hw_stats.caching_dw.work);
 204
 205         prestera_port_get_hw_stats(port);
 206
 207         queue_delayed_work(prestera_wq, &port->cached_hw_stats.caching_dw,
 208                            msecs_to_jiffies(PRESTERA_STATS_DELAY_MS));
 209 }
 210
 211 static const struct net_device_ops prestera_netdev_ops = {
 212         .ndo_open = prestera_port_open,
 213         .ndo_stop = prestera_port_close,
 214         .ndo_start_xmit = prestera_port_xmit,
 215         .ndo_change_mtu = prestera_port_change_mtu,
 216         .ndo_get_stats64 = prestera_port_get_stats64,
 217         .ndo_set_mac_address = prestera_port_set_mac_address,
 218         .ndo_get_devlink_port = prestera_devlink_get_port,
 219 };
 220
 221 int prestera_port_autoneg_set(struct prestera_port *port, bool enable,
 222                               u64 adver_link_modes, u8 adver_fec)
 223 {
 224         bool refresh = false;
 225         u64 link_modes;
 226         int err;
 227         u8 fec;
 228
 229         if (port->caps.type != PRESTERA_PORT_TYPE_TP)
 230                 return enable ? -EINVAL : 0;
 231
 232         if (!enable)
 233                 goto set_autoneg;
 234
 235         link_modes = port->caps.supp_link_modes & adver_link_modes;
 236         fec = port->caps.supp_fec & adver_fec;
 237
 238         if (!link_modes && !fec)
 239                 return -EOPNOTSUPP;
 240
 241         if (link_modes && port->adver_link_modes != link_modes) {
 242                 port->adver_link_modes = link_modes;
 243                 refresh = true;
 244         }
 245
 246         if (fec && port->adver_fec != fec) {
 247                 port->adver_fec = fec;
 248                 refresh = true;
 249         }
 250
 251 set_autoneg:
 252         if (port->autoneg == enable && !refresh)
 253                 return 0;
 254
 255         err = prestera_hw_port_autoneg_set(port, enable, port->adver_link_modes,
 256                                            port->adver_fec);
 257         if (err)
 258                 return err;
 259
 260         port->autoneg = enable;
 261
 262         return 0;
 263 }
 264
 265 static void prestera_port_list_add(struct prestera_port *port)
 266 {
 267         write_lock(&port->sw->port_list_lock);
 268         list_add(&port->list, &port->sw->port_list);
 269         write_unlock(&port->sw->port_list_lock);
 270 }
 271
 272 static void prestera_port_list_del(struct prestera_port *port)
 273 {
 274         write_lock(&port->sw->port_list_lock);
 275         list_del(&port->list);
 276         write_unlock(&port->sw->port_list_lock);
 277 }
 278
 279 static int prestera_port_create(struct prestera_switch *sw, u32 id)
 280 {
 281         struct prestera_port *port;
 282         struct net_device *dev;
 283         int err;
 284
 285         dev = alloc_etherdev(sizeof(*port));
 286         if (!dev)
 287                 return -ENOMEM;
 288
 289         port = netdev_priv(dev);
 290
 291         INIT_LIST_HEAD(&port->vlans_list);
 292         port->pvid = PRESTERA_DEFAULT_VID;
 293         port->dev = dev;
 294         port->id = id;
 295         port->sw = sw;
 296
 297         err = prestera_hw_port_info_get(port, &port->dev_id, &port->hw_id,
 298                                         &port->fp_id);
 299         if (err) {
 300                 dev_err(prestera_dev(sw), "Failed to get port(%u) info\n", id);
 301                 goto err_port_info_get;
 302         }
 303
 304         err = prestera_devlink_port_register(port);
 305         if (err)
 306                 goto err_dl_port_register;
 307
 308         dev->features |= NETIF_F_NETNS_LOCAL;
 309         dev->netdev_ops = &prestera_netdev_ops;
 310         dev->ethtool_ops = &prestera_ethtool_ops;
 311
 312         netif_carrier_off(dev);
 313
 314         dev->mtu = min_t(unsigned int, sw->mtu_max, PRESTERA_MTU_DEFAULT);
 315         dev->min_mtu = sw->mtu_min;
 316         dev->max_mtu = sw->mtu_max;
 317
 318         err = prestera_hw_port_mtu_set(port, dev->mtu);
 319         if (err) {
 320                 dev_err(prestera_dev(sw), "Failed to set port(%u) mtu(%d)\n",
 321                         id, dev->mtu);
 322                 goto err_port_init;
 323         }
 324
 325         if (port->fp_id >= PRESTERA_MAC_ADDR_NUM_MAX) {
 326                 err = -EINVAL;
 327                 goto err_port_init;
 328         }
 329
 330         /* firmware requires that port's MAC address consist of the first
 331          * 5 bytes of the base MAC address
 332          */
 333         memcpy(dev->dev_addr, sw->base_mac, dev->addr_len - 1);
 334         dev->dev_addr[dev->addr_len - 1] = port->fp_id;
 335
 336         err = prestera_hw_port_mac_set(port, dev->dev_addr);
 337         if (err) {
 338                 dev_err(prestera_dev(sw), "Failed to set port(%u) mac addr\n", id);
 339                 goto err_port_init;
 340         }
 341
 342         err = prestera_hw_port_cap_get(port, &port->caps);
 343         if (err) {
 344                 dev_err(prestera_dev(sw), "Failed to get port(%u) caps\n", id);
 345                 goto err_port_init;
 346         }
 347
 348         port->adver_fec = BIT(PRESTERA_PORT_FEC_OFF);
 349         prestera_port_autoneg_set(port, true, port->caps.supp_link_modes,
 350                                   port->caps.supp_fec);
 351
 352         err = prestera_hw_port_state_set(port, false);
 353         if (err) {
 354                 dev_err(prestera_dev(sw), "Failed to set port(%u) down\n", id);
 355                 goto err_port_init;
 356         }
 357
 358         err = prestera_rxtx_port_init(port);
 359         if (err)
 360                 goto err_port_init;
 361
 362         INIT_DELAYED_WORK(&port->cached_hw_stats.caching_dw,
 363                           &prestera_port_stats_update);
 364
 365         prestera_port_list_add(port);
 366
 367         err = register_netdev(dev);
 368         if (err)
 369                 goto err_register_netdev;
 370
 371         prestera_devlink_port_set(port);
 372
 373         return 0;
 374
 375 err_register_netdev:
 376         prestera_port_list_del(port);
 377 err_port_init:
 378         prestera_devlink_port_unregister(port);
 379 err_dl_port_register:
 380 err_port_info_get:
 381         free_netdev(dev);
 382         return err;
 383 }
 384
 385 static void prestera_port_destroy(struct prestera_port *port)
 386 {
 387         struct net_device *dev = port->dev;
 388
 389         cancel_delayed_work_sync(&port->cached_hw_stats.caching_dw);
 390         prestera_devlink_port_clear(port);
 391         unregister_netdev(dev);
 392         prestera_port_list_del(port);
 393         prestera_devlink_port_unregister(port);
 394         free_netdev(dev);
 395 }
 396
 397 static void prestera_destroy_ports(struct prestera_switch *sw)
 398 {
 399         struct prestera_port *port, *tmp;
 400
 401         list_for_each_entry_safe(port, tmp, &sw->port_list, list)
 402                 prestera_port_destroy(port);
 403 }
 404
 405 static int prestera_create_ports(struct prestera_switch *sw)
 406 {
 407         struct prestera_port *port, *tmp;
 408         u32 port_idx;
 409         int err;
 410
 411         for (port_idx = 0; port_idx < sw->port_count; port_idx++) {
 412                 err = prestera_port_create(sw, port_idx);
 413                 if (err)
 414                         goto err_port_create;
 415         }
 416
 417         return 0;
 418
 419 err_port_create:
 420         list_for_each_entry_safe(port, tmp, &sw->port_list, list)
 421                 prestera_port_destroy(port);
 422
 423         return err;
 424 }
 425
 426 static void prestera_port_handle_event(struct prestera_switch *sw,
 427                                        struct prestera_event *evt, void *arg)
 428 {
 429         struct delayed_work *caching_dw;
 430         struct prestera_port *port;
 431
 432         port = prestera_find_port(sw, evt->port_evt.port_id);
 433         if (!port || !port->dev)
 434                 return;
 435
 436         caching_dw = &port->cached_hw_stats.caching_dw;
 437
 438         if (evt->id == PRESTERA_PORT_EVENT_STATE_CHANGED) {
 439                 if (evt->port_evt.data.oper_state) {
 440                         netif_carrier_on(port->dev);
 441                         if (!delayed_work_pending(caching_dw))
 442                                 queue_delayed_work(prestera_wq, caching_dw, 0);
 443                 } else if (netif_running(port->dev) &&
 444                            netif_carrier_ok(port->dev)) {
 445                         netif_carrier_off(port->dev);
 446                         if (delayed_work_pending(caching_dw))
 447                                 cancel_delayed_work(caching_dw);
 448                 }
 449         }
 450 }
 451
 452 static int prestera_event_handlers_register(struct prestera_switch *sw)
 453 {
 454         return prestera_hw_event_handler_register(sw, PRESTERA_EVENT_TYPE_PORT,
 455                                                   prestera_port_handle_event,
 456                                                   NULL);
 457 }
 458
 459 static void prestera_event_handlers_unregister(struct prestera_switch *sw)
 460 {
 461         prestera_hw_event_handler_unregister(sw, PRESTERA_EVENT_TYPE_PORT,
 462                                              prestera_port_handle_event);
 463 }
 464
 465 static int prestera_switch_set_base_mac_addr(struct prestera_switch *sw)
 466 {
 467         struct device_node *base_mac_np;
 468         struct device_node *np;
 469         const char *base_mac;
 470
 471         np = of_find_compatible_node(NULL, NULL, "marvell,prestera");
 472         base_mac_np = of_parse_phandle(np, "base-mac-provider", 0);
 473
 474         base_mac = of_get_mac_address(base_mac_np);
 475         of_node_put(base_mac_np);
 476         if (!IS_ERR(base_mac))
 477                 ether_addr_copy(sw->base_mac, base_mac);
 478
 479         if (!is_valid_ether_addr(sw->base_mac)) {
 480                 eth_random_addr(sw->base_mac);
 481                 dev_info(prestera_dev(sw), "using random base mac address\n");
 482         }
 483
 484         return prestera_hw_switch_mac_set(sw, sw->base_mac);
 485 }
 486
 487 bool prestera_netdev_check(const struct net_device *dev)
 488 {
 489         return dev->netdev_ops == &prestera_netdev_ops;
 490 }
 491
 492 static int prestera_lower_dev_walk(struct net_device *dev,
 493                                    struct netdev_nested_priv *priv)
 494 {
 495         struct prestera_port **pport = (struct prestera_port **)priv->data;
 496
 497         if (prestera_netdev_check(dev)) {
 498                 *pport = netdev_priv(dev);
 499                 return 1;
 500         }
 501
 502         return 0;
 503 }
 504
 505 struct prestera_port *prestera_port_dev_lower_find(struct net_device *dev)
 506 {
 507         struct prestera_port *port = NULL;
 508         struct netdev_nested_priv priv = {
 509                 .data = (void *)&port,
 510         };
 511
 512         if (prestera_netdev_check(dev))
 513                 return netdev_priv(dev);
 514
 515         netdev_walk_all_lower_dev(dev, prestera_lower_dev_walk, &priv);
 516
 517         return port;
 518 }
 519
 520 static int prestera_netdev_port_event(struct net_device *dev,
 521                                       unsigned long event, void *ptr)
 522 {
 523         switch (event) {
 524         case NETDEV_PRECHANGEUPPER:
 525         case NETDEV_CHANGEUPPER:
 526                 return prestera_bridge_port_event(dev, event, ptr);
 527         default:
 528                 return 0;
 529         }
 530 }
 531
 532 static int prestera_netdev_event_handler(struct notifier_block *nb,
 533                                          unsigned long event, void *ptr)
 534 {
 535         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 536         int err = 0;
 537
 538         if (prestera_netdev_check(dev))
 539                 err = prestera_netdev_port_event(dev, event, ptr);
 540
 541         return notifier_from_errno(err);
 542 }
 543
 544 static int prestera_netdev_event_handler_register(struct prestera_switch *sw)
 545 {
 546         sw->netdev_nb.notifier_call = prestera_netdev_event_handler;
 547
 548         return register_netdevice_notifier(&sw->netdev_nb);
 549 }
 550
 551 static void prestera_netdev_event_handler_unregister(struct prestera_switch *sw)
 552 {
 553         unregister_netdevice_notifier(&sw->netdev_nb);
 554 }
 555
 556 static int prestera_switch_init(struct prestera_switch *sw)
 557 {
 558         int err;
 559
 560         err = prestera_hw_switch_init(sw);
 561         if (err) {
 562                 dev_err(prestera_dev(sw), "Failed to init Switch device\n");
 563                 return err;
 564         }
 565
 566         rwlock_init(&sw->port_list_lock);
 567         INIT_LIST_HEAD(&sw->port_list);
 568
 569         err = prestera_switch_set_base_mac_addr(sw);
 570         if (err)
 571                 return err;
 572
 573         err = prestera_netdev_event_handler_register(sw);
 574         if (err)
 575                 return err;
 576
 577         err = prestera_switchdev_init(sw);
 578         if (err)
 579                 goto err_swdev_register;
 580
 581         err = prestera_rxtx_switch_init(sw);
 582         if (err)
 583                 goto err_rxtx_register;
 584
 585         err = prestera_event_handlers_register(sw);
 586         if (err)
 587                 goto err_handlers_register;
 588
 589         err = prestera_devlink_register(sw);
 590         if (err)
 591                 goto err_dl_register;
 592
 593         err = prestera_create_ports(sw);
 594         if (err)
 595                 goto err_ports_create;
 596
 597         return 0;
 598
 599 err_ports_create:
 600         prestera_devlink_unregister(sw);
 601 err_dl_register:
 602         prestera_event_handlers_unregister(sw);
 603 err_handlers_register:
 604         prestera_rxtx_switch_fini(sw);
 605 err_rxtx_register:
 606         prestera_switchdev_fini(sw);
 607 err_swdev_register:
 608         prestera_netdev_event_handler_unregister(sw);
 609         prestera_hw_switch_fini(sw);
 610
 611         return err;
 612 }
 613
 614 static void prestera_switch_fini(struct prestera_switch *sw)
 615 {
 616         prestera_destroy_ports(sw);
 617         prestera_devlink_unregister(sw);
 618         prestera_event_handlers_unregister(sw);
 619         prestera_rxtx_switch_fini(sw);
 620         prestera_switchdev_fini(sw);
 621         prestera_netdev_event_handler_unregister(sw);
 622         prestera_hw_switch_fini(sw);
 623 }
 624
 625 int prestera_device_register(struct prestera_device *dev)
 626 {
 627         struct prestera_switch *sw;
 628         int err;
 629
 630         sw = prestera_devlink_alloc();
 631         if (!sw)
 632                 return -ENOMEM;
 633
 634         dev->priv = sw;
 635         sw->dev = dev;
 636
 637         err = prestera_switch_init(sw);
 638         if (err) {
 639                 prestera_devlink_free(sw);
 640                 return err;
 641         }
 642
 643         return 0;
 644 }
 645 EXPORT_SYMBOL(prestera_device_register);
 646
 647 void prestera_device_unregister(struct prestera_device *dev)
 648 {
 649         struct prestera_switch *sw = dev->priv;
 650
 651         prestera_switch_fini(sw);
 652         prestera_devlink_free(sw);
 653 }
 654 EXPORT_SYMBOL(prestera_device_unregister);
 655
 656 static int __init prestera_module_init(void)
 657 {
 658         prestera_wq = alloc_workqueue("prestera", 0, 0);
 659         if (!prestera_wq)
 660                 return -ENOMEM;
 661
 662         return 0;
 663 }
 664
 665 static void __exit prestera_module_exit(void)
 666 {
 667         destroy_workqueue(prestera_wq);
 668 }
 669
 670 module_init(prestera_module_init);
 671 module_exit(prestera_module_exit);
 672
 673 MODULE_LICENSE("Dual BSD/GPL");
 674 MODULE_DESCRIPTION("Marvell Prestera switch driver");