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 25static struct workqueue_struct *prestera_wq; 26 27int 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 50struct 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 67struct 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 83static 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 97static 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 111static 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 117static 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 131static 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 150static 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 164static 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 194static 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 199static 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 211static 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 221int 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 251set_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 265static 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 272static 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 279static 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 375err_register_netdev: 376 prestera_port_list_del(port); 377err_port_init: 378 prestera_devlink_port_unregister(port); 379err_dl_port_register: 380err_port_info_get: 381 free_netdev(dev); 382 return err; 383} 384 385static 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 397static 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 405static 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 419err_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 426static 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 452static 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 459static 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 465static 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 487bool prestera_netdev_check(const struct net_device *dev) 488{ 489 return dev->netdev_ops == &prestera_netdev_ops; 490} 491 492static 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 505struct 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 520static 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 532static 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 544static 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 551static void prestera_netdev_event_handler_unregister(struct prestera_switch *sw) 552{ 553 unregister_netdevice_notifier(&sw->netdev_nb); 554} 555 556static 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 599err_ports_create: 600 prestera_devlink_unregister(sw); 601err_dl_register: 602 prestera_event_handlers_unregister(sw); 603err_handlers_register: 604 prestera_rxtx_switch_fini(sw); 605err_rxtx_register: 606 prestera_switchdev_fini(sw); 607err_swdev_register: 608 prestera_netdev_event_handler_unregister(sw); 609 prestera_hw_switch_fini(sw); 610 611 return err; 612} 613 614static 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 625int 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} 645EXPORT_SYMBOL(prestera_device_register); 646 647void 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} 654EXPORT_SYMBOL(prestera_device_unregister); 655 656static 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 665static void __exit prestera_module_exit(void) 666{ 667 destroy_workqueue(prestera_wq); 668} 669 670module_init(prestera_module_init); 671module_exit(prestera_module_exit); 672 673MODULE_LICENSE("Dual BSD/GPL"); 674MODULE_DESCRIPTION("Marvell Prestera switch driver"); 675