292 lines
8.9 KiB
C
292 lines
8.9 KiB
C
// SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
|
|
/*
|
|
* NXP NETC switch driver
|
|
* Copyright 2025-2026 NXP
|
|
*/
|
|
|
|
#include <linux/ethtool_netlink.h>
|
|
|
|
#include "netc_switch.h"
|
|
|
|
static const struct ethtool_rmon_hist_range netc_rmon_ranges[] = {
|
|
{ 64, 64 },
|
|
{ 65, 127 },
|
|
{ 128, 255 },
|
|
{ 256, 511 },
|
|
{ 512, 1023 },
|
|
{ 1024, 1522 },
|
|
{ 1523, NETC_MAX_FRAME_LEN },
|
|
{ }
|
|
};
|
|
|
|
static const struct netc_port_stat netc_port_counters[] = {
|
|
{ NETC_PTGSLACR, "port gate late arrival frames" },
|
|
{ NETC_PSDFTCR, "port SDF transmit frames" },
|
|
{ NETC_PSDFDDCR, "port SDF drop duplicate frames" },
|
|
{ NETC_PRXDCR, "port rx discard frames" },
|
|
{ NETC_PRXDCRRR, "port rx discard read-reset" },
|
|
{ NETC_PRXDCRR0, "port rx discard reason 0" },
|
|
{ NETC_PRXDCRR1, "port rx discard reason 1" },
|
|
{ NETC_PTXDCR, "port tx discard frames" },
|
|
{ NETC_BPDCR, "bridge port discard frames" },
|
|
};
|
|
|
|
static const struct netc_port_stat netc_emac_counters[] = {
|
|
{ NETC_PM_ROCT(0), "eMAC rx octets" },
|
|
{ NETC_PM_RVLAN(0), "eMAC rx VLAN frames" },
|
|
{ NETC_PM_RERR(0), "eMAC rx frame errors" },
|
|
{ NETC_PM_RUCA(0), "eMAC rx unicast frames" },
|
|
{ NETC_PM_RDRP(0), "eMAC rx dropped packets" },
|
|
{ NETC_PM_RPKT(0), "eMAC rx packets" },
|
|
{ NETC_PM_TOCT(0), "eMAC tx octets" },
|
|
{ NETC_PM_TVLAN(0), "eMAC tx VLAN frames" },
|
|
{ NETC_PM_TFCS(0), "eMAC tx FCS errors" },
|
|
{ NETC_PM_TUCA(0), "eMAC tx unicast frames" },
|
|
{ NETC_PM_TPKT(0), "eMAC tx packets" },
|
|
{ NETC_PM_TUND(0), "eMAC tx undersized packets" },
|
|
{ NETC_PM_TIOCT(0), "eMAC tx invalid octets" },
|
|
};
|
|
|
|
static const struct netc_port_stat netc_pmac_counters[] = {
|
|
{ NETC_PM_ROCT(1), "pMAC rx octets" },
|
|
{ NETC_PM_RVLAN(1), "pMAC rx VLAN frames" },
|
|
{ NETC_PM_RERR(1), "pMAC rx frame errors" },
|
|
{ NETC_PM_RUCA(1), "pMAC rx unicast frames" },
|
|
{ NETC_PM_RDRP(1), "pMAC rx dropped packets" },
|
|
{ NETC_PM_RPKT(1), "pMAC rx packets" },
|
|
{ NETC_PM_TOCT(1), "pMAC tx octets" },
|
|
{ NETC_PM_TVLAN(1), "pMAC tx VLAN frames" },
|
|
{ NETC_PM_TFCS(1), "pMAC tx FCS errors" },
|
|
{ NETC_PM_TUCA(1), "pMAC tx unicast frames" },
|
|
{ NETC_PM_TPKT(1), "pMAC tx packets" },
|
|
{ NETC_PM_TUND(1), "pMAC tx undersized packets" },
|
|
{ NETC_PM_TIOCT(1), "pMAC tx invalid octets" },
|
|
};
|
|
|
|
static void netc_port_pause_stats(struct netc_port *np, int mac,
|
|
struct ethtool_pause_stats *stats)
|
|
{
|
|
if (mac && !np->caps.pmac)
|
|
return;
|
|
|
|
stats->tx_pause_frames = netc_port_rd64(np, NETC_PM_TXPF(mac));
|
|
stats->rx_pause_frames = netc_port_rd64(np, NETC_PM_RXPF(mac));
|
|
}
|
|
|
|
void netc_port_get_pause_stats(struct dsa_switch *ds, int port,
|
|
struct ethtool_pause_stats *pause_stats)
|
|
{
|
|
struct netc_port *np = NETC_PORT(ds, port);
|
|
struct net_device *ndev;
|
|
|
|
switch (pause_stats->src) {
|
|
case ETHTOOL_MAC_STATS_SRC_EMAC:
|
|
netc_port_pause_stats(np, 0, pause_stats);
|
|
break;
|
|
case ETHTOOL_MAC_STATS_SRC_PMAC:
|
|
netc_port_pause_stats(np, 1, pause_stats);
|
|
break;
|
|
case ETHTOOL_MAC_STATS_SRC_AGGREGATE:
|
|
ndev = dsa_to_port(ds, port)->user;
|
|
ethtool_aggregate_pause_stats(ndev, pause_stats);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void netc_port_rmon_stats(struct netc_port *np, int mac,
|
|
struct ethtool_rmon_stats *stats)
|
|
{
|
|
if (mac && !np->caps.pmac)
|
|
return;
|
|
|
|
stats->undersize_pkts = netc_port_rd64(np, NETC_PM_RUND(mac));
|
|
stats->oversize_pkts = netc_port_rd64(np, NETC_PM_ROVR(mac));
|
|
stats->fragments = netc_port_rd64(np, NETC_PM_RFRG(mac));
|
|
stats->jabbers = netc_port_rd64(np, NETC_PM_RJBR(mac));
|
|
|
|
stats->hist[0] = netc_port_rd64(np, NETC_PM_R64(mac));
|
|
stats->hist[1] = netc_port_rd64(np, NETC_PM_R127(mac));
|
|
stats->hist[2] = netc_port_rd64(np, NETC_PM_R255(mac));
|
|
stats->hist[3] = netc_port_rd64(np, NETC_PM_R511(mac));
|
|
stats->hist[4] = netc_port_rd64(np, NETC_PM_R1023(mac));
|
|
stats->hist[5] = netc_port_rd64(np, NETC_PM_R1522(mac));
|
|
stats->hist[6] = netc_port_rd64(np, NETC_PM_R1523X(mac));
|
|
|
|
stats->hist_tx[0] = netc_port_rd64(np, NETC_PM_T64(mac));
|
|
stats->hist_tx[1] = netc_port_rd64(np, NETC_PM_T127(mac));
|
|
stats->hist_tx[2] = netc_port_rd64(np, NETC_PM_T255(mac));
|
|
stats->hist_tx[3] = netc_port_rd64(np, NETC_PM_T511(mac));
|
|
stats->hist_tx[4] = netc_port_rd64(np, NETC_PM_T1023(mac));
|
|
stats->hist_tx[5] = netc_port_rd64(np, NETC_PM_T1522(mac));
|
|
stats->hist_tx[6] = netc_port_rd64(np, NETC_PM_T1523X(mac));
|
|
}
|
|
|
|
void netc_port_get_rmon_stats(struct dsa_switch *ds, int port,
|
|
struct ethtool_rmon_stats *rmon_stats,
|
|
const struct ethtool_rmon_hist_range **ranges)
|
|
{
|
|
struct netc_port *np = NETC_PORT(ds, port);
|
|
struct net_device *ndev;
|
|
|
|
*ranges = netc_rmon_ranges;
|
|
|
|
switch (rmon_stats->src) {
|
|
case ETHTOOL_MAC_STATS_SRC_EMAC:
|
|
netc_port_rmon_stats(np, 0, rmon_stats);
|
|
break;
|
|
case ETHTOOL_MAC_STATS_SRC_PMAC:
|
|
netc_port_rmon_stats(np, 1, rmon_stats);
|
|
break;
|
|
case ETHTOOL_MAC_STATS_SRC_AGGREGATE:
|
|
ndev = dsa_to_port(ds, port)->user;
|
|
ethtool_aggregate_rmon_stats(ndev, rmon_stats);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void netc_port_ctrl_stats(struct netc_port *np, int mac,
|
|
struct ethtool_eth_ctrl_stats *stats)
|
|
{
|
|
if (mac && !np->caps.pmac)
|
|
return;
|
|
|
|
stats->MACControlFramesTransmitted =
|
|
netc_port_rd64(np, NETC_PM_TCNP(mac));
|
|
stats->MACControlFramesReceived =
|
|
netc_port_rd64(np, NETC_PM_RCNP(mac));
|
|
}
|
|
|
|
void netc_port_get_eth_ctrl_stats(struct dsa_switch *ds, int port,
|
|
struct ethtool_eth_ctrl_stats *ctrl_stats)
|
|
{
|
|
struct netc_port *np = NETC_PORT(ds, port);
|
|
struct net_device *ndev;
|
|
|
|
switch (ctrl_stats->src) {
|
|
case ETHTOOL_MAC_STATS_SRC_EMAC:
|
|
netc_port_ctrl_stats(np, 0, ctrl_stats);
|
|
break;
|
|
case ETHTOOL_MAC_STATS_SRC_PMAC:
|
|
netc_port_ctrl_stats(np, 1, ctrl_stats);
|
|
break;
|
|
case ETHTOOL_MAC_STATS_SRC_AGGREGATE:
|
|
ndev = dsa_to_port(ds, port)->user;
|
|
ethtool_aggregate_ctrl_stats(ndev, ctrl_stats);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void netc_port_mac_stats(struct netc_port *np, int mac,
|
|
struct ethtool_eth_mac_stats *stats)
|
|
{
|
|
if (mac && !np->caps.pmac)
|
|
return;
|
|
|
|
stats->FramesTransmittedOK = netc_port_rd64(np, NETC_PM_TFRM(mac));
|
|
stats->SingleCollisionFrames = netc_port_rd64(np, NETC_PM_TSCOL(mac));
|
|
stats->MultipleCollisionFrames =
|
|
netc_port_rd64(np, NETC_PM_TMCOL(mac));
|
|
stats->FramesReceivedOK = netc_port_rd64(np, NETC_PM_RFRM(mac));
|
|
stats->FrameCheckSequenceErrors =
|
|
netc_port_rd64(np, NETC_PM_RFCS(mac));
|
|
stats->AlignmentErrors = netc_port_rd64(np, NETC_PM_RALN(mac));
|
|
stats->OctetsTransmittedOK = netc_port_rd64(np, NETC_PM_TEOCT(mac));
|
|
stats->FramesWithDeferredXmissions =
|
|
netc_port_rd64(np, NETC_PM_TDFR(mac));
|
|
stats->LateCollisions = netc_port_rd64(np, NETC_PM_TLCOL(mac));
|
|
stats->FramesAbortedDueToXSColls =
|
|
netc_port_rd64(np, NETC_PM_TECOL(mac));
|
|
stats->FramesLostDueToIntMACXmitError =
|
|
netc_port_rd64(np, NETC_PM_TERR(mac));
|
|
stats->OctetsReceivedOK = netc_port_rd64(np, NETC_PM_REOCT(mac));
|
|
stats->FramesLostDueToIntMACRcvError =
|
|
netc_port_rd64(np, NETC_PM_RDRNTP(mac));
|
|
stats->MulticastFramesXmittedOK =
|
|
netc_port_rd64(np, NETC_PM_TMCA(mac));
|
|
stats->BroadcastFramesXmittedOK =
|
|
netc_port_rd64(np, NETC_PM_TBCA(mac));
|
|
stats->MulticastFramesReceivedOK =
|
|
netc_port_rd64(np, NETC_PM_RMCA(mac));
|
|
stats->BroadcastFramesReceivedOK =
|
|
netc_port_rd64(np, NETC_PM_RBCA(mac));
|
|
stats->FramesWithExcessiveDeferral =
|
|
netc_port_rd64(np, NETC_PM_TEDFR(mac));
|
|
}
|
|
|
|
void netc_port_get_eth_mac_stats(struct dsa_switch *ds, int port,
|
|
struct ethtool_eth_mac_stats *mac_stats)
|
|
{
|
|
struct netc_port *np = NETC_PORT(ds, port);
|
|
struct net_device *ndev;
|
|
|
|
switch (mac_stats->src) {
|
|
case ETHTOOL_MAC_STATS_SRC_EMAC:
|
|
netc_port_mac_stats(np, 0, mac_stats);
|
|
break;
|
|
case ETHTOOL_MAC_STATS_SRC_PMAC:
|
|
netc_port_mac_stats(np, 1, mac_stats);
|
|
break;
|
|
case ETHTOOL_MAC_STATS_SRC_AGGREGATE:
|
|
ndev = dsa_to_port(ds, port)->user;
|
|
ethtool_aggregate_mac_stats(ndev, mac_stats);
|
|
break;
|
|
}
|
|
}
|
|
|
|
int netc_port_get_sset_count(struct dsa_switch *ds, int port, int sset)
|
|
{
|
|
struct netc_port *np = NETC_PORT(ds, port);
|
|
int size;
|
|
|
|
if (sset != ETH_SS_STATS)
|
|
return -EOPNOTSUPP;
|
|
|
|
size = ARRAY_SIZE(netc_port_counters) +
|
|
ARRAY_SIZE(netc_emac_counters);
|
|
|
|
if (np->caps.pmac)
|
|
size += ARRAY_SIZE(netc_pmac_counters);
|
|
|
|
return size;
|
|
}
|
|
|
|
void netc_port_get_strings(struct dsa_switch *ds, int port,
|
|
u32 sset, u8 *data)
|
|
{
|
|
struct netc_port *np = NETC_PORT(ds, port);
|
|
int i;
|
|
|
|
if (sset != ETH_SS_STATS)
|
|
return;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(netc_port_counters); i++)
|
|
ethtool_cpy(&data, netc_port_counters[i].name);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(netc_emac_counters); i++)
|
|
ethtool_cpy(&data, netc_emac_counters[i].name);
|
|
|
|
if (!np->caps.pmac)
|
|
return;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(netc_pmac_counters); i++)
|
|
ethtool_cpy(&data, netc_pmac_counters[i].name);
|
|
}
|
|
|
|
void netc_port_get_ethtool_stats(struct dsa_switch *ds, int port, u64 *data)
|
|
{
|
|
struct netc_port *np = NETC_PORT(ds, port);
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(netc_port_counters); i++)
|
|
*data++ = netc_port_rd(np, netc_port_counters[i].reg);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(netc_emac_counters); i++)
|
|
*data++ = netc_port_rd64(np, netc_emac_counters[i].reg);
|
|
|
|
if (!np->caps.pmac)
|
|
return;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(netc_pmac_counters); i++)
|
|
*data++ = netc_port_rd64(np, netc_pmac_counters[i].reg);
|
|
}
|