1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved */
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>
10 #include <linux/of_net.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"
19 #define PRESTERA_MTU_DEFAULT 1536
21 #define PRESTERA_STATS_DELAY_MS 1000
23 #define PRESTERA_MAC_ADDR_NUM_MAX 255
25 static struct workqueue_struct *prestera_wq;
27 int prestera_port_pvid_set(struct prestera_port *port, u16 vid)
29 enum prestera_accept_frm_type frm_type;
32 frm_type = PRESTERA_ACCEPT_FRAME_TYPE_TAGGED;
35 err = prestera_hw_vlan_port_vid_set(port, vid);
39 frm_type = PRESTERA_ACCEPT_FRAME_TYPE_ALL;
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);
50 struct prestera_port *prestera_port_find_by_hwid(struct prestera_switch *sw,
51 u32 dev_id, u32 hw_id)
53 struct prestera_port *port = NULL, *tmp;
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) {
62 read_unlock(&sw->port_list_lock);
67 struct prestera_port *prestera_find_port(struct prestera_switch *sw, u32 id)
69 struct prestera_port *port = NULL, *tmp;
71 read_lock(&sw->port_list_lock);
72 list_for_each_entry(tmp, &sw->port_list, list) {
78 read_unlock(&sw->port_list_lock);
83 static int prestera_port_open(struct net_device *dev)
85 struct prestera_port *port = netdev_priv(dev);
88 err = prestera_hw_port_state_set(port, true);
92 netif_start_queue(dev);
97 static int prestera_port_close(struct net_device *dev)
99 struct prestera_port *port = netdev_priv(dev);
102 netif_stop_queue(dev);
104 err = prestera_hw_port_state_set(port, false);
111 static netdev_tx_t prestera_port_xmit(struct sk_buff *skb,
112 struct net_device *dev)
114 return prestera_rxtx_xmit(netdev_priv(dev), skb);
117 static int prestera_is_valid_mac_addr(struct prestera_port *port, u8 *addr)
119 if (!is_valid_ether_addr(addr))
120 return -EADDRNOTAVAIL;
122 /* firmware requires that port's MAC address contains first 5 bytes
123 * of the base MAC address
125 if (memcmp(port->sw->base_mac, addr, ETH_ALEN - 1))
131 static int prestera_port_set_mac_address(struct net_device *dev, void *p)
133 struct prestera_port *port = netdev_priv(dev);
134 struct sockaddr *addr = p;
137 err = prestera_is_valid_mac_addr(port, addr->sa_data);
141 err = prestera_hw_port_mac_set(port, addr->sa_data);
145 ether_addr_copy(dev->dev_addr, addr->sa_data);
150 static int prestera_port_change_mtu(struct net_device *dev, int mtu)
152 struct prestera_port *port = netdev_priv(dev);
155 err = prestera_hw_port_mtu_set(port, mtu);
164 static void prestera_port_get_stats64(struct net_device *dev,
165 struct rtnl_link_stats64 *stats)
167 struct prestera_port *port = netdev_priv(dev);
168 struct prestera_port_stats *port_stats = &port->cached_hw_stats.stats;
170 stats->rx_packets = port_stats->broadcast_frames_received +
171 port_stats->multicast_frames_received +
172 port_stats->unicast_frames_received;
174 stats->tx_packets = port_stats->broadcast_frames_sent +
175 port_stats->multicast_frames_sent +
176 port_stats->unicast_frames_sent;
178 stats->rx_bytes = port_stats->good_octets_received;
180 stats->tx_bytes = port_stats->good_octets_sent;
182 stats->rx_errors = port_stats->rx_error_frame_received;
183 stats->tx_errors = port_stats->mac_trans_error;
185 stats->rx_dropped = port_stats->buffer_overrun;
186 stats->tx_dropped = 0;
188 stats->multicast = port_stats->multicast_frames_received;
189 stats->collisions = port_stats->excessive_collision;
191 stats->rx_crc_errors = port_stats->bad_crc;
194 static void prestera_port_get_hw_stats(struct prestera_port *port)
196 prestera_hw_port_stats_get(port, &port->cached_hw_stats.stats);
199 static void prestera_port_stats_update(struct work_struct *work)
201 struct prestera_port *port =
202 container_of(work, struct prestera_port,
203 cached_hw_stats.caching_dw.work);
205 prestera_port_get_hw_stats(port);
207 queue_delayed_work(prestera_wq, &port->cached_hw_stats.caching_dw,
208 msecs_to_jiffies(PRESTERA_STATS_DELAY_MS));
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,
221 int prestera_port_autoneg_set(struct prestera_port *port, bool enable,
222 u64 adver_link_modes, u8 adver_fec)
224 bool refresh = false;
229 if (port->caps.type != PRESTERA_PORT_TYPE_TP)
230 return enable ? -EINVAL : 0;
235 link_modes = port->caps.supp_link_modes & adver_link_modes;
236 fec = port->caps.supp_fec & adver_fec;
238 if (!link_modes && !fec)
241 if (link_modes && port->adver_link_modes != link_modes) {
242 port->adver_link_modes = link_modes;
246 if (fec && port->adver_fec != fec) {
247 port->adver_fec = fec;
252 if (port->autoneg == enable && !refresh)
255 err = prestera_hw_port_autoneg_set(port, enable, port->adver_link_modes,
260 port->autoneg = enable;
265 static void prestera_port_list_add(struct prestera_port *port)
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);
272 static void prestera_port_list_del(struct prestera_port *port)
274 write_lock(&port->sw->port_list_lock);
275 list_del(&port->list);
276 write_unlock(&port->sw->port_list_lock);
279 static int prestera_port_create(struct prestera_switch *sw, u32 id)
281 struct prestera_port *port;
282 struct net_device *dev;
285 dev = alloc_etherdev(sizeof(*port));
289 port = netdev_priv(dev);
291 INIT_LIST_HEAD(&port->vlans_list);
292 port->pvid = PRESTERA_DEFAULT_VID;
297 err = prestera_hw_port_info_get(port, &port->dev_id, &port->hw_id,
300 dev_err(prestera_dev(sw), "Failed to get port(%u) info\n", id);
301 goto err_port_info_get;
304 err = prestera_devlink_port_register(port);
306 goto err_dl_port_register;
308 dev->features |= NETIF_F_NETNS_LOCAL;
309 dev->netdev_ops = &prestera_netdev_ops;
310 dev->ethtool_ops = &prestera_ethtool_ops;
312 netif_carrier_off(dev);
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;
318 err = prestera_hw_port_mtu_set(port, dev->mtu);
320 dev_err(prestera_dev(sw), "Failed to set port(%u) mtu(%d)\n",
325 if (port->fp_id >= PRESTERA_MAC_ADDR_NUM_MAX) {
330 /* firmware requires that port's MAC address consist of the first
331 * 5 bytes of the base MAC address
333 memcpy(dev->dev_addr, sw->base_mac, dev->addr_len - 1);
334 dev->dev_addr[dev->addr_len - 1] = port->fp_id;
336 err = prestera_hw_port_mac_set(port, dev->dev_addr);
338 dev_err(prestera_dev(sw), "Failed to set port(%u) mac addr\n", id);
342 err = prestera_hw_port_cap_get(port, &port->caps);
344 dev_err(prestera_dev(sw), "Failed to get port(%u) caps\n", id);
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);
352 err = prestera_hw_port_state_set(port, false);
354 dev_err(prestera_dev(sw), "Failed to set port(%u) down\n", id);
358 err = prestera_rxtx_port_init(port);
362 INIT_DELAYED_WORK(&port->cached_hw_stats.caching_dw,
363 &prestera_port_stats_update);
365 prestera_port_list_add(port);
367 err = register_netdev(dev);
369 goto err_register_netdev;
371 prestera_devlink_port_set(port);
376 prestera_port_list_del(port);
378 prestera_devlink_port_unregister(port);
379 err_dl_port_register:
385 static void prestera_port_destroy(struct prestera_port *port)
387 struct net_device *dev = port->dev;
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);
397 static void prestera_destroy_ports(struct prestera_switch *sw)
399 struct prestera_port *port, *tmp;
401 list_for_each_entry_safe(port, tmp, &sw->port_list, list)
402 prestera_port_destroy(port);
405 static int prestera_create_ports(struct prestera_switch *sw)
407 struct prestera_port *port, *tmp;
411 for (port_idx = 0; port_idx < sw->port_count; port_idx++) {
412 err = prestera_port_create(sw, port_idx);
414 goto err_port_create;
420 list_for_each_entry_safe(port, tmp, &sw->port_list, list)
421 prestera_port_destroy(port);
426 static void prestera_port_handle_event(struct prestera_switch *sw,
427 struct prestera_event *evt, void *arg)
429 struct delayed_work *caching_dw;
430 struct prestera_port *port;
432 port = prestera_find_port(sw, evt->port_evt.port_id);
433 if (!port || !port->dev)
436 caching_dw = &port->cached_hw_stats.caching_dw;
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);
452 static int prestera_event_handlers_register(struct prestera_switch *sw)
454 return prestera_hw_event_handler_register(sw, PRESTERA_EVENT_TYPE_PORT,
455 prestera_port_handle_event,
459 static void prestera_event_handlers_unregister(struct prestera_switch *sw)
461 prestera_hw_event_handler_unregister(sw, PRESTERA_EVENT_TYPE_PORT,
462 prestera_port_handle_event);
465 static int prestera_switch_set_base_mac_addr(struct prestera_switch *sw)
467 struct device_node *base_mac_np;
468 struct device_node *np;
469 const char *base_mac;
471 np = of_find_compatible_node(NULL, NULL, "marvell,prestera");
472 base_mac_np = of_parse_phandle(np, "base-mac-provider", 0);
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);
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");
484 return prestera_hw_switch_mac_set(sw, sw->base_mac);
487 bool prestera_netdev_check(const struct net_device *dev)
489 return dev->netdev_ops == &prestera_netdev_ops;
492 static int prestera_lower_dev_walk(struct net_device *dev,
493 struct netdev_nested_priv *priv)
495 struct prestera_port **pport = (struct prestera_port **)priv->data;
497 if (prestera_netdev_check(dev)) {
498 *pport = netdev_priv(dev);
505 struct prestera_port *prestera_port_dev_lower_find(struct net_device *dev)
507 struct prestera_port *port = NULL;
508 struct netdev_nested_priv priv = {
509 .data = (void *)&port,
512 if (prestera_netdev_check(dev))
513 return netdev_priv(dev);
515 netdev_walk_all_lower_dev(dev, prestera_lower_dev_walk, &priv);
520 static int prestera_netdev_port_event(struct net_device *dev,
521 unsigned long event, void *ptr)
524 case NETDEV_PRECHANGEUPPER:
525 case NETDEV_CHANGEUPPER:
526 return prestera_bridge_port_event(dev, event, ptr);
532 static int prestera_netdev_event_handler(struct notifier_block *nb,
533 unsigned long event, void *ptr)
535 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
538 if (prestera_netdev_check(dev))
539 err = prestera_netdev_port_event(dev, event, ptr);
541 return notifier_from_errno(err);
544 static int prestera_netdev_event_handler_register(struct prestera_switch *sw)
546 sw->netdev_nb.notifier_call = prestera_netdev_event_handler;
548 return register_netdevice_notifier(&sw->netdev_nb);
551 static void prestera_netdev_event_handler_unregister(struct prestera_switch *sw)
553 unregister_netdevice_notifier(&sw->netdev_nb);
556 static int prestera_switch_init(struct prestera_switch *sw)
560 err = prestera_hw_switch_init(sw);
562 dev_err(prestera_dev(sw), "Failed to init Switch device\n");
566 rwlock_init(&sw->port_list_lock);
567 INIT_LIST_HEAD(&sw->port_list);
569 err = prestera_switch_set_base_mac_addr(sw);
573 err = prestera_netdev_event_handler_register(sw);
577 err = prestera_switchdev_init(sw);
579 goto err_swdev_register;
581 err = prestera_rxtx_switch_init(sw);
583 goto err_rxtx_register;
585 err = prestera_event_handlers_register(sw);
587 goto err_handlers_register;
589 err = prestera_devlink_register(sw);
591 goto err_dl_register;
593 err = prestera_create_ports(sw);
595 goto err_ports_create;
600 prestera_devlink_unregister(sw);
602 prestera_event_handlers_unregister(sw);
603 err_handlers_register:
604 prestera_rxtx_switch_fini(sw);
606 prestera_switchdev_fini(sw);
608 prestera_netdev_event_handler_unregister(sw);
609 prestera_hw_switch_fini(sw);
614 static void prestera_switch_fini(struct prestera_switch *sw)
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);
625 int prestera_device_register(struct prestera_device *dev)
627 struct prestera_switch *sw;
630 sw = prestera_devlink_alloc();
637 err = prestera_switch_init(sw);
639 prestera_devlink_free(sw);
645 EXPORT_SYMBOL(prestera_device_register);
647 void prestera_device_unregister(struct prestera_device *dev)
649 struct prestera_switch *sw = dev->priv;
651 prestera_switch_fini(sw);
652 prestera_devlink_free(sw);
654 EXPORT_SYMBOL(prestera_device_unregister);
656 static int __init prestera_module_init(void)
658 prestera_wq = alloc_workqueue("prestera", 0, 0);
665 static void __exit prestera_module_exit(void)
667 destroy_workqueue(prestera_wq);
670 module_init(prestera_module_init);
671 module_exit(prestera_module_exit);
673 MODULE_LICENSE("Dual BSD/GPL");
674 MODULE_DESCRIPTION("Marvell Prestera switch driver");