| // SPDX-License-Identifier: GPL-2.0 | |
| #define pr_fmt(fmt) "bcmasp_ethtool: " fmt | |
| #include <linux/unaligned.h> | |
| #include <linux/ethtool.h> | |
| #include <linux/netdevice.h> | |
| #include <linux/platform_device.h> | |
| #include "bcmasp.h" | |
| #include "bcmasp_intf_defs.h" | |
| enum bcmasp_stat_type { | |
| BCMASP_STAT_RX_CTRL, | |
| BCMASP_STAT_RX_CTRL_PER_INTF, | |
| BCMASP_STAT_SOFT, | |
| }; | |
| struct bcmasp_stats { | |
| char stat_string[ETH_GSTRING_LEN]; | |
| enum bcmasp_stat_type type; | |
| u32 reg_offset; | |
| }; | |
| #define STAT_BCMASP_SOFT_MIB(str) { \ | |
| .stat_string = str, \ | |
| .type = BCMASP_STAT_SOFT, \ | |
| } | |
| #define STAT_BCMASP_OFFSET(str, _type, offset) { \ | |
| .stat_string = str, \ | |
| .type = _type, \ | |
| .reg_offset = offset, \ | |
| } | |
| #define STAT_BCMASP_RX_CTRL(str, offset) \ | |
| STAT_BCMASP_OFFSET(str, BCMASP_STAT_RX_CTRL, offset) | |
| #define STAT_BCMASP_RX_CTRL_PER_INTF(str, offset) \ | |
| STAT_BCMASP_OFFSET(str, BCMASP_STAT_RX_CTRL_PER_INTF, offset) | |
| /* Must match the order of struct bcmasp_mib_counters */ | |
| static const struct bcmasp_stats bcmasp_gstrings_stats[] = { | |
| /* ASP RX control */ | |
| STAT_BCMASP_RX_CTRL_PER_INTF("Frames From Unimac", | |
| ASP_RX_CTRL_UMAC_0_FRAME_COUNT), | |
| STAT_BCMASP_RX_CTRL_PER_INTF("Frames From Port", | |
| ASP_RX_CTRL_FB_0_FRAME_COUNT), | |
| STAT_BCMASP_RX_CTRL_PER_INTF("RX Buffer FIFO Depth", | |
| ASP_RX_CTRL_FB_RX_FIFO_DEPTH), | |
| STAT_BCMASP_RX_CTRL("Frames Out(Buffer)", | |
| ASP_RX_CTRL_FB_OUT_FRAME_COUNT), | |
| STAT_BCMASP_RX_CTRL("Frames Out(Filters)", | |
| ASP_RX_CTRL_FB_FILT_OUT_FRAME_COUNT), | |
| /* Software maintained statistics */ | |
| STAT_BCMASP_SOFT_MIB("RX SKB Alloc Failed"), | |
| STAT_BCMASP_SOFT_MIB("TX DMA Failed"), | |
| STAT_BCMASP_SOFT_MIB("Multicast Filters Full"), | |
| STAT_BCMASP_SOFT_MIB("Unicast Filters Full"), | |
| STAT_BCMASP_SOFT_MIB("MDA Filters Combined"), | |
| STAT_BCMASP_SOFT_MIB("Promisc Filter Set"), | |
| STAT_BCMASP_SOFT_MIB("TX Realloc For Offload Failed"), | |
| STAT_BCMASP_SOFT_MIB("Tx Timeout Count"), | |
| }; | |
| #define BCMASP_STATS_LEN ARRAY_SIZE(bcmasp_gstrings_stats) | |
| static int bcmasp_get_sset_count(struct net_device *dev, int string_set) | |
| { | |
| switch (string_set) { | |
| case ETH_SS_STATS: | |
| return BCMASP_STATS_LEN; | |
| default: | |
| return -EOPNOTSUPP; | |
| } | |
| } | |
| static void bcmasp_get_strings(struct net_device *dev, u32 stringset, | |
| u8 *data) | |
| { | |
| const char *str; | |
| unsigned int i; | |
| switch (stringset) { | |
| case ETH_SS_STATS: | |
| for (i = 0; i < BCMASP_STATS_LEN; i++) { | |
| str = bcmasp_gstrings_stats[i].stat_string; | |
| ethtool_puts(&data, str); | |
| } | |
| break; | |
| default: | |
| return; | |
| } | |
| } | |
| static void bcmasp_update_mib_counters(struct bcmasp_intf *intf) | |
| { | |
| unsigned int i; | |
| for (i = 0; i < BCMASP_STATS_LEN; i++) { | |
| const struct bcmasp_stats *s; | |
| u32 offset, val; | |
| char *p; | |
| s = &bcmasp_gstrings_stats[i]; | |
| offset = s->reg_offset; | |
| switch (s->type) { | |
| case BCMASP_STAT_SOFT: | |
| continue; | |
| case BCMASP_STAT_RX_CTRL: | |
| val = rx_ctrl_core_rl(intf->parent, offset); | |
| break; | |
| case BCMASP_STAT_RX_CTRL_PER_INTF: | |
| offset += sizeof(u32) * intf->port; | |
| val = rx_ctrl_core_rl(intf->parent, offset); | |
| break; | |
| default: | |
| continue; | |
| } | |
| p = (char *)(&intf->mib) + (i * sizeof(u32)); | |
| put_unaligned(val, (u32 *)p); | |
| } | |
| } | |
| static void bcmasp_get_ethtool_stats(struct net_device *dev, | |
| struct ethtool_stats *stats, | |
| u64 *data) | |
| { | |
| struct bcmasp_intf *intf = netdev_priv(dev); | |
| unsigned int i; | |
| char *p; | |
| if (netif_running(dev)) | |
| bcmasp_update_mib_counters(intf); | |
| for (i = 0; i < BCMASP_STATS_LEN; i++) { | |
| p = (char *)(&intf->mib) + (i * sizeof(u32)); | |
| data[i] = *(u32 *)p; | |
| } | |
| } | |
| static void bcmasp_get_drvinfo(struct net_device *dev, | |
| struct ethtool_drvinfo *info) | |
| { | |
| strscpy(info->driver, "bcmasp", sizeof(info->driver)); | |
| strscpy(info->bus_info, dev_name(dev->dev.parent), | |
| sizeof(info->bus_info)); | |
| } | |
| static u32 bcmasp_get_msglevel(struct net_device *dev) | |
| { | |
| struct bcmasp_intf *intf = netdev_priv(dev); | |
| return intf->msg_enable; | |
| } | |
| static void bcmasp_set_msglevel(struct net_device *dev, u32 level) | |
| { | |
| struct bcmasp_intf *intf = netdev_priv(dev); | |
| intf->msg_enable = level; | |
| } | |
| #define BCMASP_SUPPORTED_WAKE (WAKE_MAGIC | WAKE_MAGICSECURE | WAKE_FILTER) | |
| static void bcmasp_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) | |
| { | |
| struct bcmasp_intf *intf = netdev_priv(dev); | |
| struct bcmasp_priv *priv = intf->parent; | |
| struct device *kdev = &priv->pdev->dev; | |
| u32 phy_wolopts = 0; | |
| if (dev->phydev) { | |
| phy_ethtool_get_wol(dev->phydev, wol); | |
| phy_wolopts = wol->wolopts; | |
| } | |
| /* MAC is not wake-up capable, return what the PHY does */ | |
| if (!device_can_wakeup(kdev)) | |
| return; | |
| /* Overlay MAC capabilities with that of the PHY queried before */ | |
| wol->supported |= BCMASP_SUPPORTED_WAKE; | |
| wol->wolopts |= intf->wolopts; | |
| /* Return the PHY configured magic password */ | |
| if (phy_wolopts & WAKE_MAGICSECURE) | |
| return; | |
| memset(wol->sopass, 0, sizeof(wol->sopass)); | |
| /* Otherwise the MAC one */ | |
| if (wol->wolopts & WAKE_MAGICSECURE) | |
| memcpy(wol->sopass, intf->sopass, sizeof(intf->sopass)); | |
| } | |
| static int bcmasp_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol) | |
| { | |
| struct bcmasp_intf *intf = netdev_priv(dev); | |
| struct bcmasp_priv *priv = intf->parent; | |
| struct device *kdev = &priv->pdev->dev; | |
| int ret = 0; | |
| /* Try Wake-on-LAN from the PHY first */ | |
| if (dev->phydev) { | |
| ret = phy_ethtool_set_wol(dev->phydev, wol); | |
| if (ret != -EOPNOTSUPP && wol->wolopts) | |
| return ret; | |
| } | |
| if (!device_can_wakeup(kdev)) | |
| return -EOPNOTSUPP; | |
| if (wol->wolopts & ~BCMASP_SUPPORTED_WAKE) | |
| return -EINVAL; | |
| /* Interface Specific */ | |
| intf->wolopts = wol->wolopts; | |
| if (intf->wolopts & WAKE_MAGICSECURE) | |
| memcpy(intf->sopass, wol->sopass, sizeof(wol->sopass)); | |
| mutex_lock(&priv->wol_lock); | |
| bcmasp_enable_wol(intf, !!intf->wolopts); | |
| mutex_unlock(&priv->wol_lock); | |
| return 0; | |
| } | |
| static int bcmasp_flow_insert(struct net_device *dev, struct ethtool_rxnfc *cmd) | |
| { | |
| struct bcmasp_intf *intf = netdev_priv(dev); | |
| struct bcmasp_net_filter *nfilter; | |
| u32 loc = cmd->fs.location; | |
| bool wake = false; | |
| if (cmd->fs.ring_cookie == RX_CLS_FLOW_WAKE) | |
| wake = true; | |
| /* Currently only supports WAKE filters */ | |
| if (!wake) | |
| return -EOPNOTSUPP; | |
| switch (cmd->fs.flow_type & ~(FLOW_EXT | FLOW_MAC_EXT)) { | |
| case ETHER_FLOW: | |
| case IP_USER_FLOW: | |
| case TCP_V4_FLOW: | |
| case UDP_V4_FLOW: | |
| case TCP_V6_FLOW: | |
| case UDP_V6_FLOW: | |
| break; | |
| default: | |
| return -EOPNOTSUPP; | |
| } | |
| /* Check if filter already exists */ | |
| if (bcmasp_netfilt_check_dup(intf, &cmd->fs)) | |
| return -EINVAL; | |
| nfilter = bcmasp_netfilt_get_init(intf, loc, wake, true); | |
| if (IS_ERR(nfilter)) | |
| return PTR_ERR(nfilter); | |
| /* Return the location where we did insert the filter */ | |
| cmd->fs.location = nfilter->hw_index; | |
| memcpy(&nfilter->fs, &cmd->fs, sizeof(struct ethtool_rx_flow_spec)); | |
| /* Since we only support wake filters, defer register programming till | |
| * suspend time. | |
| */ | |
| return 0; | |
| } | |
| static int bcmasp_flow_delete(struct net_device *dev, struct ethtool_rxnfc *cmd) | |
| { | |
| struct bcmasp_intf *intf = netdev_priv(dev); | |
| struct bcmasp_net_filter *nfilter; | |
| nfilter = bcmasp_netfilt_get_init(intf, cmd->fs.location, false, false); | |
| if (IS_ERR(nfilter)) | |
| return PTR_ERR(nfilter); | |
| bcmasp_netfilt_release(intf, nfilter); | |
| return 0; | |
| } | |
| static int bcmasp_flow_get(struct bcmasp_intf *intf, struct ethtool_rxnfc *cmd) | |
| { | |
| struct bcmasp_net_filter *nfilter; | |
| nfilter = bcmasp_netfilt_get_init(intf, cmd->fs.location, false, false); | |
| if (IS_ERR(nfilter)) | |
| return PTR_ERR(nfilter); | |
| memcpy(&cmd->fs, &nfilter->fs, sizeof(nfilter->fs)); | |
| cmd->data = intf->parent->num_net_filters; | |
| return 0; | |
| } | |
| static int bcmasp_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd) | |
| { | |
| struct bcmasp_intf *intf = netdev_priv(dev); | |
| int ret = -EOPNOTSUPP; | |
| mutex_lock(&intf->parent->net_lock); | |
| switch (cmd->cmd) { | |
| case ETHTOOL_SRXCLSRLINS: | |
| ret = bcmasp_flow_insert(dev, cmd); | |
| break; | |
| case ETHTOOL_SRXCLSRLDEL: | |
| ret = bcmasp_flow_delete(dev, cmd); | |
| break; | |
| default: | |
| break; | |
| } | |
| mutex_unlock(&intf->parent->net_lock); | |
| return ret; | |
| } | |
| static int bcmasp_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd, | |
| u32 *rule_locs) | |
| { | |
| struct bcmasp_intf *intf = netdev_priv(dev); | |
| int err = 0; | |
| mutex_lock(&intf->parent->net_lock); | |
| switch (cmd->cmd) { | |
| case ETHTOOL_GRXCLSRLCNT: | |
| cmd->rule_cnt = bcmasp_netfilt_get_active(intf); | |
| /* We support specifying rule locations */ | |
| cmd->data |= RX_CLS_LOC_SPECIAL; | |
| break; | |
| case ETHTOOL_GRXCLSRULE: | |
| err = bcmasp_flow_get(intf, cmd); | |
| break; | |
| case ETHTOOL_GRXCLSRLALL: | |
| err = bcmasp_netfilt_get_all_active(intf, rule_locs, &cmd->rule_cnt); | |
| cmd->data = intf->parent->num_net_filters; | |
| break; | |
| default: | |
| err = -EOPNOTSUPP; | |
| break; | |
| } | |
| mutex_unlock(&intf->parent->net_lock); | |
| return err; | |
| } | |
| static int bcmasp_get_eee(struct net_device *dev, struct ethtool_keee *e) | |
| { | |
| if (!dev->phydev) | |
| return -ENODEV; | |
| return phy_ethtool_get_eee(dev->phydev, e); | |
| } | |
| static int bcmasp_set_eee(struct net_device *dev, struct ethtool_keee *e) | |
| { | |
| if (!dev->phydev) | |
| return -ENODEV; | |
| return phy_ethtool_set_eee(dev->phydev, e); | |
| } | |
| static void bcmasp_get_eth_mac_stats(struct net_device *dev, | |
| struct ethtool_eth_mac_stats *mac_stats) | |
| { | |
| struct bcmasp_intf *intf = netdev_priv(dev); | |
| mac_stats->FramesTransmittedOK = umac_rl(intf, UMC_GTPOK); | |
| mac_stats->SingleCollisionFrames = umac_rl(intf, UMC_GTSCL); | |
| mac_stats->MultipleCollisionFrames = umac_rl(intf, UMC_GTMCL); | |
| mac_stats->FramesReceivedOK = umac_rl(intf, UMC_GRPOK); | |
| mac_stats->FrameCheckSequenceErrors = umac_rl(intf, UMC_GRFCS); | |
| mac_stats->AlignmentErrors = umac_rl(intf, UMC_GRALN); | |
| mac_stats->OctetsTransmittedOK = umac_rl(intf, UMC_GTBYT); | |
| mac_stats->FramesWithDeferredXmissions = umac_rl(intf, UMC_GTDRF); | |
| mac_stats->LateCollisions = umac_rl(intf, UMC_GTLCL); | |
| mac_stats->FramesAbortedDueToXSColls = umac_rl(intf, UMC_GTXCL); | |
| mac_stats->OctetsReceivedOK = umac_rl(intf, UMC_GRBYT); | |
| mac_stats->MulticastFramesXmittedOK = umac_rl(intf, UMC_GTMCA); | |
| mac_stats->BroadcastFramesXmittedOK = umac_rl(intf, UMC_GTBCA); | |
| mac_stats->FramesWithExcessiveDeferral = umac_rl(intf, UMC_GTEDF); | |
| mac_stats->MulticastFramesReceivedOK = umac_rl(intf, UMC_GRMCA); | |
| mac_stats->BroadcastFramesReceivedOK = umac_rl(intf, UMC_GRBCA); | |
| } | |
| static const struct ethtool_rmon_hist_range bcmasp_rmon_ranges[] = { | |
| { 0, 64}, | |
| { 65, 127}, | |
| { 128, 255}, | |
| { 256, 511}, | |
| { 512, 1023}, | |
| { 1024, 1518}, | |
| { 1519, 1522}, | |
| {} | |
| }; | |
| static void bcmasp_get_rmon_stats(struct net_device *dev, | |
| struct ethtool_rmon_stats *rmon_stats, | |
| const struct ethtool_rmon_hist_range **ranges) | |
| { | |
| struct bcmasp_intf *intf = netdev_priv(dev); | |
| *ranges = bcmasp_rmon_ranges; | |
| rmon_stats->undersize_pkts = umac_rl(intf, UMC_RRUND); | |
| rmon_stats->oversize_pkts = umac_rl(intf, UMC_GROVR); | |
| rmon_stats->fragments = umac_rl(intf, UMC_RRFRG); | |
| rmon_stats->jabbers = umac_rl(intf, UMC_GRJBR); | |
| rmon_stats->hist[0] = umac_rl(intf, UMC_GR64); | |
| rmon_stats->hist[1] = umac_rl(intf, UMC_GR127); | |
| rmon_stats->hist[2] = umac_rl(intf, UMC_GR255); | |
| rmon_stats->hist[3] = umac_rl(intf, UMC_GR511); | |
| rmon_stats->hist[4] = umac_rl(intf, UMC_GR1023); | |
| rmon_stats->hist[5] = umac_rl(intf, UMC_GR1518); | |
| rmon_stats->hist[6] = umac_rl(intf, UMC_GRMGV); | |
| rmon_stats->hist_tx[0] = umac_rl(intf, UMC_TR64); | |
| rmon_stats->hist_tx[1] = umac_rl(intf, UMC_TR127); | |
| rmon_stats->hist_tx[2] = umac_rl(intf, UMC_TR255); | |
| rmon_stats->hist_tx[3] = umac_rl(intf, UMC_TR511); | |
| rmon_stats->hist_tx[4] = umac_rl(intf, UMC_TR1023); | |
| rmon_stats->hist_tx[5] = umac_rl(intf, UMC_TR1518); | |
| rmon_stats->hist_tx[6] = umac_rl(intf, UMC_TRMGV); | |
| } | |
| static void bcmasp_get_eth_ctrl_stats(struct net_device *dev, | |
| struct ethtool_eth_ctrl_stats *ctrl_stats) | |
| { | |
| struct bcmasp_intf *intf = netdev_priv(dev); | |
| ctrl_stats->MACControlFramesTransmitted = umac_rl(intf, UMC_GTXCF); | |
| ctrl_stats->MACControlFramesReceived = umac_rl(intf, UMC_GRXCF); | |
| ctrl_stats->UnsupportedOpcodesReceived = umac_rl(intf, UMC_GRXUO); | |
| } | |
| const struct ethtool_ops bcmasp_ethtool_ops = { | |
| .get_drvinfo = bcmasp_get_drvinfo, | |
| .get_link = ethtool_op_get_link, | |
| .get_link_ksettings = phy_ethtool_get_link_ksettings, | |
| .set_link_ksettings = phy_ethtool_set_link_ksettings, | |
| .get_msglevel = bcmasp_get_msglevel, | |
| .set_msglevel = bcmasp_set_msglevel, | |
| .get_wol = bcmasp_get_wol, | |
| .set_wol = bcmasp_set_wol, | |
| .get_rxnfc = bcmasp_get_rxnfc, | |
| .set_rxnfc = bcmasp_set_rxnfc, | |
| .set_eee = bcmasp_set_eee, | |
| .get_eee = bcmasp_get_eee, | |
| .get_eth_mac_stats = bcmasp_get_eth_mac_stats, | |
| .get_rmon_stats = bcmasp_get_rmon_stats, | |
| .get_eth_ctrl_stats = bcmasp_get_eth_ctrl_stats, | |
| .get_strings = bcmasp_get_strings, | |
| .get_ethtool_stats = bcmasp_get_ethtool_stats, | |
| .get_sset_count = bcmasp_get_sset_count, | |
| .get_ts_info = ethtool_op_get_ts_info, | |
| .nway_reset = phy_ethtool_nway_reset, | |
| }; |