| // SPDX-License-Identifier: GPL-2.0-or-later | |
| /* | |
| * Copyright (c) 2026 David Yang | |
| */ | |
| #include "chip.h" | |
| #include "mib.h" | |
| #include "smi.h" | |
| struct yt921x_mib_desc { | |
| unsigned int size; | |
| unsigned int offset; | |
| const char *name; | |
| }; | |
| #define MIB_DESC(_size, _offset, _name) \ | |
| {_size, _offset, _name} | |
| /* Must agree with yt921x_mib_stats | |
| * | |
| * Unstructured fields (name != NULL) will appear in get_ethtool_stats(), | |
| * structured go to their *_stats() methods, but we need their sizes and offsets | |
| * to perform 32bit MIB overflow wraparound. | |
| */ | |
| static const struct yt921x_mib_desc yt921x_mib_descs[] = { | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_BROADCAST, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_PAUSE, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_MULTICAST, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_CRC_ERR, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_ALIGN_ERR, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_UNDERSIZE_ERR, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_FRAG_ERR, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_PKT_SZ_64, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_PKT_SZ_65_TO_127, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_PKT_SZ_128_TO_255, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_PKT_SZ_256_TO_511, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_PKT_SZ_512_TO_1023, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_PKT_SZ_1024_TO_1518, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_PKT_SZ_1519_TO_MAX, NULL), | |
| MIB_DESC(2, YT921X_MIB_DATA_RX_GOOD_BYTES, NULL), | |
| MIB_DESC(2, YT921X_MIB_DATA_RX_BAD_BYTES, "RxBadBytes"), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_OVERSIZE_ERR, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_DROPPED, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_BROADCAST, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_PAUSE, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_MULTICAST, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_UNDERSIZE_ERR, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_PKT_SZ_64, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_PKT_SZ_65_TO_127, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_PKT_SZ_128_TO_255, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_PKT_SZ_256_TO_511, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_PKT_SZ_512_TO_1023, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_PKT_SZ_1024_TO_1518, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_PKT_SZ_1519_TO_MAX, NULL), | |
| MIB_DESC(2, YT921X_MIB_DATA_TX_GOOD_BYTES, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_COLLISION, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_EXCESSIVE_COLLISION, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_MULTIPLE_COLLISION, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_SINGLE_COLLISION, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_PKT, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_DEFERRED, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_LATE_COLLISION, NULL), | |
| MIB_DESC(1, YT921X_MIB_DATA_RX_OAM, "RxOAM"), | |
| MIB_DESC(1, YT921X_MIB_DATA_TX_OAM, "TxOAM"), | |
| }; | |
| static_assert(ARRAY_SIZE(yt921x_mib_descs) == YT921X_MIB_STAT_NUM); | |
| /* The interval should be small enough to avoid overflow of 32bit MIBs. | |
| * | |
| * Until we can read MIBs from stats64 call directly (i.e. sleep | |
| * there), we have to poll stats more frequently then it is actually needed. | |
| * For overflow protection, normally, 100 sec interval should have been OK. | |
| */ | |
| #define YT921X_STATS_INTERVAL_JIFFIES (3 * HZ) | |
| /* Read and handle overflow of 32bit MIBs. MIB buffer must be zeroed before. */ | |
| static int yt921x_mib_read(struct yt921x_priv *priv, int port) | |
| { | |
| struct device *dev = yt921x_priv_to_device(priv); | |
| struct yt921x_port *pp = &priv->ports[port]; | |
| struct yt921x_mib *pm = pp->mib; | |
| struct yt921x_mib_stats *mib; | |
| u64 *buf = pm->data; | |
| unsigned long flags; | |
| u64 rx_frames; | |
| u64 tx_frames; | |
| int res = 0; | |
| mib = &pm->stats; | |
| for (size_t i = 0; i < ARRAY_SIZE(yt921x_mib_descs); i++) { | |
| const struct yt921x_mib_desc *desc = &yt921x_mib_descs[i]; | |
| u32 reg = YT921X_MIBn_DATA0(port) + desc->offset; | |
| u32 val0; | |
| u64 val; | |
| res = yt921x_reg_read(priv, reg, &val0); | |
| if (res) | |
| break; | |
| if (desc->size <= 1) { | |
| u64 old_val = buf[i]; | |
| val = (old_val & ~(u64)U32_MAX) | val0; | |
| if (val < old_val) | |
| val += 1ull << 32; | |
| } else { | |
| u32 val1; | |
| res = yt921x_reg_read(priv, reg + 4, &val1); | |
| if (res) | |
| break; | |
| val = ((u64)val1 << 32) | val0; | |
| } | |
| buf[i] = val; | |
| } | |
| flags = u64_stats_update_begin_irqsave(&pm->syncp); | |
| for (size_t i = 0; i < ARRAY_SIZE(yt921x_mib_descs); i++) | |
| u64_stats_set(&((u64_stats_t *)mib)[i], buf[i]); | |
| rx_frames = u64_stats_read(&mib->rx_64byte) + | |
| u64_stats_read(&mib->rx_65_127byte) + | |
| u64_stats_read(&mib->rx_128_255byte) + | |
| u64_stats_read(&mib->rx_256_511byte) + | |
| u64_stats_read(&mib->rx_512_1023byte) + | |
| u64_stats_read(&mib->rx_1024_1518byte) + | |
| u64_stats_read(&mib->rx_jumbo); | |
| tx_frames = u64_stats_read(&mib->tx_64byte) + | |
| u64_stats_read(&mib->tx_65_127byte) + | |
| u64_stats_read(&mib->tx_128_255byte) + | |
| u64_stats_read(&mib->tx_256_511byte) + | |
| u64_stats_read(&mib->tx_512_1023byte) + | |
| u64_stats_read(&mib->tx_1024_1518byte) + | |
| u64_stats_read(&mib->tx_jumbo); | |
| u64_stats_set(&pm->rx_frames, rx_frames); | |
| u64_stats_set(&pm->tx_frames, tx_frames); | |
| u64_stats_update_end_irqrestore(&pm->syncp, flags); | |
| if (res) | |
| dev_err(dev, "Failed to %s port %d: %i\n", "read stats for", | |
| port, res); | |
| return res; | |
| } | |
| void yt921x_mib_poll(struct work_struct *work) | |
| { | |
| struct yt921x_mib *pm = container_of_const(work, struct yt921x_mib, | |
| work.work); | |
| struct yt921x_port *pp = pm->port; | |
| unsigned long delay = YT921X_STATS_INTERVAL_JIFFIES; | |
| struct yt921x_priv *priv = yt921x_port_to_priv(pp); | |
| int port = pp->index; | |
| int res; | |
| mutex_lock(&priv->reg_lock); | |
| res = yt921x_mib_read(priv, port); | |
| mutex_unlock(&priv->reg_lock); | |
| if (res) | |
| delay *= 4; | |
| schedule_delayed_work(&pm->work, delay); | |
| } | |
| void | |
| yt921x_dsa_get_strings(struct dsa_switch *ds, int port, u32 stringset, | |
| uint8_t *data) | |
| { | |
| if (stringset != ETH_SS_STATS) | |
| return; | |
| for (size_t i = 0; i < ARRAY_SIZE(yt921x_mib_descs); i++) { | |
| const struct yt921x_mib_desc *desc = &yt921x_mib_descs[i]; | |
| if (desc->name) | |
| ethtool_puts(&data, desc->name); | |
| } | |
| } | |
| void | |
| yt921x_dsa_get_ethtool_stats(struct dsa_switch *ds, int port, uint64_t *data) | |
| { | |
| struct yt921x_priv *priv = dsa_to_yt921x_priv(ds); | |
| struct yt921x_port *pp = &priv->ports[port]; | |
| struct yt921x_mib *pm = pp->mib; | |
| u64 *buf; | |
| size_t j; | |
| if (!pm) | |
| return; | |
| buf = pm->data; | |
| mutex_lock(&priv->reg_lock); | |
| yt921x_mib_read(priv, port); | |
| j = 0; | |
| for (size_t i = 0; i < ARRAY_SIZE(yt921x_mib_descs); i++) { | |
| const struct yt921x_mib_desc *desc = &yt921x_mib_descs[i]; | |
| if (!desc->name) | |
| continue; | |
| data[j] = buf[i]; | |
| j++; | |
| } | |
| mutex_unlock(&priv->reg_lock); | |
| } | |
| int yt921x_dsa_get_sset_count(struct dsa_switch *ds, int port, int sset) | |
| { | |
| int cnt = 0; | |
| if (sset != ETH_SS_STATS) | |
| return 0; | |
| for (size_t i = 0; i < ARRAY_SIZE(yt921x_mib_descs); i++) { | |
| const struct yt921x_mib_desc *desc = &yt921x_mib_descs[i]; | |
| if (desc->name) | |
| cnt++; | |
| } | |
| return cnt; | |
| } | |
| void | |
| yt921x_dsa_get_eth_mac_stats(struct dsa_switch *ds, int port, | |
| struct ethtool_eth_mac_stats *mac_stats) | |
| { | |
| struct yt921x_priv *priv = dsa_to_yt921x_priv(ds); | |
| struct yt921x_port *pp = &priv->ports[port]; | |
| struct yt921x_mib *pm = pp->mib; | |
| struct yt921x_mib_stats *mib; | |
| if (!pm) | |
| return; | |
| mib = &pm->stats; | |
| mutex_lock(&priv->reg_lock); | |
| yt921x_mib_read(priv, port); | |
| mac_stats->FramesTransmittedOK = u64_stats_read(&pm->tx_frames); | |
| mac_stats->SingleCollisionFrames = u64_stats_read(&mib->tx_single_collisions); | |
| mac_stats->MultipleCollisionFrames = u64_stats_read(&mib->tx_multiple_collisions); | |
| mac_stats->FramesReceivedOK = u64_stats_read(&pm->rx_frames); | |
| mac_stats->FrameCheckSequenceErrors = u64_stats_read(&mib->rx_crc_errors); | |
| mac_stats->AlignmentErrors = u64_stats_read(&mib->rx_alignment_errors); | |
| mac_stats->OctetsTransmittedOK = u64_stats_read(&mib->tx_good_bytes); | |
| mac_stats->FramesWithDeferredXmissions = u64_stats_read(&mib->tx_deferred); | |
| mac_stats->LateCollisions = u64_stats_read(&mib->tx_late_collisions); | |
| mac_stats->FramesAbortedDueToXSColls = u64_stats_read(&mib->tx_aborted_errors); | |
| /* mac_stats->FramesLostDueToIntMACXmitError */ | |
| /* mac_stats->CarrierSenseErrors */ | |
| mac_stats->OctetsReceivedOK = u64_stats_read(&mib->rx_good_bytes); | |
| /* mac_stats->FramesLostDueToIntMACRcvError */ | |
| mac_stats->MulticastFramesXmittedOK = u64_stats_read(&mib->tx_multicast); | |
| mac_stats->BroadcastFramesXmittedOK = u64_stats_read(&mib->tx_broadcast); | |
| /* mac_stats->FramesWithExcessiveDeferral */ | |
| mac_stats->MulticastFramesReceivedOK = u64_stats_read(&mib->rx_multicast); | |
| mac_stats->BroadcastFramesReceivedOK = u64_stats_read(&mib->rx_broadcast); | |
| /* mac_stats->InRangeLengthErrors */ | |
| /* mac_stats->OutOfRangeLengthField */ | |
| mac_stats->FrameTooLongErrors = u64_stats_read(&mib->rx_oversize_errors); | |
| mutex_unlock(&priv->reg_lock); | |
| } | |
| void | |
| yt921x_dsa_get_eth_ctrl_stats(struct dsa_switch *ds, int port, | |
| struct ethtool_eth_ctrl_stats *ctrl_stats) | |
| { | |
| struct yt921x_priv *priv = dsa_to_yt921x_priv(ds); | |
| struct yt921x_port *pp = &priv->ports[port]; | |
| struct yt921x_mib *pm = pp->mib; | |
| struct yt921x_mib_stats *mib; | |
| if (!pm) | |
| return; | |
| mib = &pm->stats; | |
| mutex_lock(&priv->reg_lock); | |
| yt921x_mib_read(priv, port); | |
| ctrl_stats->MACControlFramesTransmitted = u64_stats_read(&mib->tx_pause); | |
| ctrl_stats->MACControlFramesReceived = u64_stats_read(&mib->rx_pause); | |
| /* ctrl_stats->UnsupportedOpcodesReceived */ | |
| mutex_unlock(&priv->reg_lock); | |
| } | |
| static const struct ethtool_rmon_hist_range yt921x_rmon_ranges[] = { | |
| { 0, 64 }, | |
| { 65, 127 }, | |
| { 128, 255 }, | |
| { 256, 511 }, | |
| { 512, 1023 }, | |
| { 1024, 1518 }, | |
| { 1519, YT921X_FRAME_SIZE_MAX }, | |
| {} | |
| }; | |
| void | |
| yt921x_dsa_get_rmon_stats(struct dsa_switch *ds, int port, | |
| struct ethtool_rmon_stats *rmon_stats, | |
| const struct ethtool_rmon_hist_range **ranges) | |
| { | |
| struct yt921x_priv *priv = dsa_to_yt921x_priv(ds); | |
| struct yt921x_port *pp = &priv->ports[port]; | |
| struct yt921x_mib *pm = pp->mib; | |
| struct yt921x_mib_stats *mib; | |
| if (!pm) | |
| return; | |
| mib = &pm->stats; | |
| mutex_lock(&priv->reg_lock); | |
| yt921x_mib_read(priv, port); | |
| *ranges = yt921x_rmon_ranges; | |
| rmon_stats->undersize_pkts = u64_stats_read(&mib->rx_undersize_errors); | |
| rmon_stats->oversize_pkts = u64_stats_read(&mib->rx_oversize_errors); | |
| rmon_stats->fragments = u64_stats_read(&mib->rx_alignment_errors); | |
| /* rmon_stats->jabbers */ | |
| rmon_stats->hist[0] = u64_stats_read(&mib->rx_64byte); | |
| rmon_stats->hist[1] = u64_stats_read(&mib->rx_65_127byte); | |
| rmon_stats->hist[2] = u64_stats_read(&mib->rx_128_255byte); | |
| rmon_stats->hist[3] = u64_stats_read(&mib->rx_256_511byte); | |
| rmon_stats->hist[4] = u64_stats_read(&mib->rx_512_1023byte); | |
| rmon_stats->hist[5] = u64_stats_read(&mib->rx_1024_1518byte); | |
| rmon_stats->hist[6] = u64_stats_read(&mib->rx_jumbo); | |
| rmon_stats->hist_tx[0] = u64_stats_read(&mib->tx_64byte); | |
| rmon_stats->hist_tx[1] = u64_stats_read(&mib->tx_65_127byte); | |
| rmon_stats->hist_tx[2] = u64_stats_read(&mib->tx_128_255byte); | |
| rmon_stats->hist_tx[3] = u64_stats_read(&mib->tx_256_511byte); | |
| rmon_stats->hist_tx[4] = u64_stats_read(&mib->tx_512_1023byte); | |
| rmon_stats->hist_tx[5] = u64_stats_read(&mib->tx_1024_1518byte); | |
| rmon_stats->hist_tx[6] = u64_stats_read(&mib->tx_jumbo); | |
| mutex_unlock(&priv->reg_lock); | |
| } | |
| void | |
| yt921x_dsa_get_stats64(struct dsa_switch *ds, int port, | |
| struct rtnl_link_stats64 *stats) | |
| { | |
| struct yt921x_priv *priv = dsa_to_yt921x_priv(ds); | |
| struct yt921x_port *pp = &priv->ports[port]; | |
| struct yt921x_mib *pm = pp->mib; | |
| struct yt921x_mib_stats *mib; | |
| unsigned int start; | |
| if (!pm) | |
| return; | |
| mib = &pm->stats; | |
| do { | |
| start = u64_stats_fetch_begin(&pm->syncp); | |
| stats->rx_length_errors = u64_stats_read(&mib->rx_undersize_errors) + | |
| u64_stats_read(&mib->rx_fragment_errors); | |
| stats->rx_over_errors = u64_stats_read(&mib->rx_oversize_errors); | |
| stats->rx_crc_errors = u64_stats_read(&mib->rx_crc_errors); | |
| stats->rx_frame_errors = u64_stats_read(&mib->rx_alignment_errors); | |
| /* stats->rx_fifo_errors */ | |
| /* stats->rx_missed_errors */ | |
| stats->tx_aborted_errors = u64_stats_read(&mib->tx_aborted_errors); | |
| /* stats->tx_carrier_errors */ | |
| stats->tx_fifo_errors = u64_stats_read(&mib->tx_undersize_errors); | |
| /* stats->tx_heartbeat_errors */ | |
| stats->tx_window_errors = u64_stats_read(&mib->tx_late_collisions); | |
| stats->rx_packets = u64_stats_read(&pm->rx_frames); | |
| stats->tx_packets = u64_stats_read(&pm->tx_frames); | |
| stats->rx_bytes = u64_stats_read(&mib->rx_good_bytes) - | |
| ETH_FCS_LEN * stats->rx_packets; | |
| stats->tx_bytes = u64_stats_read(&mib->tx_good_bytes) - | |
| ETH_FCS_LEN * stats->tx_packets; | |
| stats->rx_dropped = u64_stats_read(&mib->rx_dropped); | |
| /* stats->tx_dropped */ | |
| stats->multicast = u64_stats_read(&mib->rx_multicast); | |
| stats->collisions = u64_stats_read(&mib->tx_collisions); | |
| } while (u64_stats_fetch_retry(&pm->syncp, start)); | |
| stats->rx_errors = stats->rx_length_errors + stats->rx_over_errors + | |
| stats->rx_crc_errors + stats->rx_frame_errors; | |
| stats->tx_errors = stats->tx_aborted_errors + stats->tx_fifo_errors + | |
| stats->tx_window_errors; | |
| } | |
| void | |
| yt921x_dsa_get_pause_stats(struct dsa_switch *ds, int port, | |
| struct ethtool_pause_stats *pause_stats) | |
| { | |
| struct yt921x_priv *priv = dsa_to_yt921x_priv(ds); | |
| struct yt921x_port *pp = &priv->ports[port]; | |
| struct yt921x_mib *pm = pp->mib; | |
| struct yt921x_mib_stats *mib; | |
| if (!pm) | |
| return; | |
| mib = &pm->stats; | |
| mutex_lock(&priv->reg_lock); | |
| yt921x_mib_read(priv, port); | |
| pause_stats->tx_pause_frames = u64_stats_read(&mib->tx_pause); | |
| pause_stats->rx_pause_frames = u64_stats_read(&mib->rx_pause); | |
| mutex_unlock(&priv->reg_lock); | |
| } |