drivers/net/ethernet/samsung/sxgbe/sxgbe_ethtool.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* 10G controller driver for Samsung SoCs
   3  *
   4  * Copyright (C) 2013 Samsung Electronics Co., Ltd.
   5  *              http://www.samsung.com
   6  *
   7  * Author: Siva Reddy Kallam <siva.kallam@samsung.com>
   8  */
   9
  10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11
  12 #include <linux/clk.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/kernel.h>
  15 #include <linux/netdevice.h>
  16 #include <linux/net_tstamp.h>
  17 #include <linux/phy.h>
  18 #include <linux/ptp_clock_kernel.h>
  19
  20 #include "sxgbe_common.h"
  21 #include "sxgbe_reg.h"
  22 #include "sxgbe_dma.h"
  23
  24 struct sxgbe_stats {
  25         char stat_string[ETH_GSTRING_LEN];
  26         int sizeof_stat;
  27         int stat_offset;
  28 };
  29
  30 #define SXGBE_STAT(m)                                           \
  31 {                                                               \
  32         #m,                                                     \
  33         sizeof_field(struct sxgbe_extra_stats, m),              \
  34         offsetof(struct sxgbe_priv_data, xstats.m)              \
  35 }
  36
  37 static const struct sxgbe_stats sxgbe_gstrings_stats[] = {
  38         /* TX/RX IRQ events */
  39         SXGBE_STAT(tx_process_stopped_irq),
  40         SXGBE_STAT(tx_ctxt_desc_err),
  41         SXGBE_STAT(tx_threshold),
  42         SXGBE_STAT(rx_threshold),
  43         SXGBE_STAT(tx_pkt_n),
  44         SXGBE_STAT(rx_pkt_n),
  45         SXGBE_STAT(normal_irq_n),
  46         SXGBE_STAT(tx_normal_irq_n),
  47         SXGBE_STAT(rx_normal_irq_n),
  48         SXGBE_STAT(napi_poll),
  49         SXGBE_STAT(tx_clean),
  50         SXGBE_STAT(tx_reset_ic_bit),
  51         SXGBE_STAT(rx_process_stopped_irq),
  52         SXGBE_STAT(rx_underflow_irq),
  53
  54         /* Bus access errors */
  55         SXGBE_STAT(fatal_bus_error_irq),
  56         SXGBE_STAT(tx_read_transfer_err),
  57         SXGBE_STAT(tx_write_transfer_err),
  58         SXGBE_STAT(tx_desc_access_err),
  59         SXGBE_STAT(tx_buffer_access_err),
  60         SXGBE_STAT(tx_data_transfer_err),
  61         SXGBE_STAT(rx_read_transfer_err),
  62         SXGBE_STAT(rx_write_transfer_err),
  63         SXGBE_STAT(rx_desc_access_err),
  64         SXGBE_STAT(rx_buffer_access_err),
  65         SXGBE_STAT(rx_data_transfer_err),
  66
  67         /* EEE-LPI stats */
  68         SXGBE_STAT(tx_lpi_entry_n),
  69         SXGBE_STAT(tx_lpi_exit_n),
  70         SXGBE_STAT(rx_lpi_entry_n),
  71         SXGBE_STAT(rx_lpi_exit_n),
  72         SXGBE_STAT(eee_wakeup_error_n),
  73
  74         /* RX specific */
  75         /* L2 error */
  76         SXGBE_STAT(rx_code_gmii_err),
  77         SXGBE_STAT(rx_watchdog_err),
  78         SXGBE_STAT(rx_crc_err),
  79         SXGBE_STAT(rx_gaint_pkt_err),
  80         SXGBE_STAT(ip_hdr_err),
  81         SXGBE_STAT(ip_payload_err),
  82         SXGBE_STAT(overflow_error),
  83
  84         /* L2 Pkt type */
  85         SXGBE_STAT(len_pkt),
  86         SXGBE_STAT(mac_ctl_pkt),
  87         SXGBE_STAT(dcb_ctl_pkt),
  88         SXGBE_STAT(arp_pkt),
  89         SXGBE_STAT(oam_pkt),
  90         SXGBE_STAT(untag_okt),
  91         SXGBE_STAT(other_pkt),
  92         SXGBE_STAT(svlan_tag_pkt),
  93         SXGBE_STAT(cvlan_tag_pkt),
  94         SXGBE_STAT(dvlan_ocvlan_icvlan_pkt),
  95         SXGBE_STAT(dvlan_osvlan_isvlan_pkt),
  96         SXGBE_STAT(dvlan_osvlan_icvlan_pkt),
  97         SXGBE_STAT(dvan_ocvlan_icvlan_pkt),
  98
  99         /* L3/L4 Pkt type */
 100         SXGBE_STAT(not_ip_pkt),
 101         SXGBE_STAT(ip4_tcp_pkt),
 102         SXGBE_STAT(ip4_udp_pkt),
 103         SXGBE_STAT(ip4_icmp_pkt),
 104         SXGBE_STAT(ip4_unknown_pkt),
 105         SXGBE_STAT(ip6_tcp_pkt),
 106         SXGBE_STAT(ip6_udp_pkt),
 107         SXGBE_STAT(ip6_icmp_pkt),
 108         SXGBE_STAT(ip6_unknown_pkt),
 109
 110         /* Filter specific */
 111         SXGBE_STAT(vlan_filter_match),
 112         SXGBE_STAT(sa_filter_fail),
 113         SXGBE_STAT(da_filter_fail),
 114         SXGBE_STAT(hash_filter_pass),
 115         SXGBE_STAT(l3_filter_match),
 116         SXGBE_STAT(l4_filter_match),
 117
 118         /* RX context specific */
 119         SXGBE_STAT(timestamp_dropped),
 120         SXGBE_STAT(rx_msg_type_no_ptp),
 121         SXGBE_STAT(rx_ptp_type_sync),
 122         SXGBE_STAT(rx_ptp_type_follow_up),
 123         SXGBE_STAT(rx_ptp_type_delay_req),
 124         SXGBE_STAT(rx_ptp_type_delay_resp),
 125         SXGBE_STAT(rx_ptp_type_pdelay_req),
 126         SXGBE_STAT(rx_ptp_type_pdelay_resp),
 127         SXGBE_STAT(rx_ptp_type_pdelay_follow_up),
 128         SXGBE_STAT(rx_ptp_announce),
 129         SXGBE_STAT(rx_ptp_mgmt),
 130         SXGBE_STAT(rx_ptp_signal),
 131         SXGBE_STAT(rx_ptp_resv_msg_type),
 132 };
 133 #define SXGBE_STATS_LEN ARRAY_SIZE(sxgbe_gstrings_stats)
 134
 135 static int sxgbe_get_eee(struct net_device *dev,
 136                          struct ethtool_eee *edata)
 137 {
 138         struct sxgbe_priv_data *priv = netdev_priv(dev);
 139
 140         if (!priv->hw_cap.eee)
 141                 return -EOPNOTSUPP;
 142
 143         edata->eee_enabled = priv->eee_enabled;
 144         edata->eee_active = priv->eee_active;
 145         edata->tx_lpi_timer = priv->tx_lpi_timer;
 146
 147         return phy_ethtool_get_eee(dev->phydev, edata);
 148 }
 149
 150 static int sxgbe_set_eee(struct net_device *dev,
 151                          struct ethtool_eee *edata)
 152 {
 153         struct sxgbe_priv_data *priv = netdev_priv(dev);
 154
 155         priv->eee_enabled = edata->eee_enabled;
 156
 157         if (!priv->eee_enabled) {
 158                 sxgbe_disable_eee_mode(priv);
 159         } else {
 160                 /* We are asking for enabling the EEE but it is safe
 161                  * to verify all by invoking the eee_init function.
 162                  * In case of failure it will return an error.
 163                  */
 164                 priv->eee_enabled = sxgbe_eee_init(priv);
 165                 if (!priv->eee_enabled)
 166                         return -EOPNOTSUPP;
 167
 168                 /* Do not change tx_lpi_timer in case of failure */
 169                 priv->tx_lpi_timer = edata->tx_lpi_timer;
 170         }
 171
 172         return phy_ethtool_set_eee(dev->phydev, edata);
 173 }
 174
 175 static void sxgbe_getdrvinfo(struct net_device *dev,
 176                              struct ethtool_drvinfo *info)
 177 {
 178         strscpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
 179         strscpy(info->version, DRV_VERSION, sizeof(info->version));
 180 }
 181
 182 static u32 sxgbe_getmsglevel(struct net_device *dev)
 183 {
 184         struct sxgbe_priv_data *priv = netdev_priv(dev);
 185         return priv->msg_enable;
 186 }
 187
 188 static void sxgbe_setmsglevel(struct net_device *dev, u32 level)
 189 {
 190         struct sxgbe_priv_data *priv = netdev_priv(dev);
 191         priv->msg_enable = level;
 192 }
 193
 194 static void sxgbe_get_strings(struct net_device *dev, u32 stringset, u8 *data)
 195 {
 196         int i;
 197         u8 *p = data;
 198
 199         switch (stringset) {
 200         case ETH_SS_STATS:
 201                 for (i = 0; i < SXGBE_STATS_LEN; i++) {
 202                         memcpy(p, sxgbe_gstrings_stats[i].stat_string,
 203                                ETH_GSTRING_LEN);
 204                         p += ETH_GSTRING_LEN;
 205                 }
 206                 break;
 207         default:
 208                 WARN_ON(1);
 209                 break;
 210         }
 211 }
 212
 213 static int sxgbe_get_sset_count(struct net_device *netdev, int sset)
 214 {
 215         int len;
 216
 217         switch (sset) {
 218         case ETH_SS_STATS:
 219                 len = SXGBE_STATS_LEN;
 220                 return len;
 221         default:
 222                 return -EINVAL;
 223         }
 224 }
 225
 226 static void sxgbe_get_ethtool_stats(struct net_device *dev,
 227                                     struct ethtool_stats *dummy, u64 *data)
 228 {
 229         struct sxgbe_priv_data *priv = netdev_priv(dev);
 230         int i;
 231         char *p;
 232
 233         if (priv->eee_enabled) {
 234                 int val = phy_get_eee_err(dev->phydev);
 235
 236                 if (val)
 237                         priv->xstats.eee_wakeup_error_n = val;
 238         }
 239
 240         for (i = 0; i < SXGBE_STATS_LEN; i++) {
 241                 p = (char *)priv + sxgbe_gstrings_stats[i].stat_offset;
 242                 data[i] = (sxgbe_gstrings_stats[i].sizeof_stat == sizeof(u64))
 243                         ? (*(u64 *)p) : (*(u32 *)p);
 244         }
 245 }
 246
 247 static void sxgbe_get_channels(struct net_device *dev,
 248                                struct ethtool_channels *channel)
 249 {
 250         channel->max_rx = SXGBE_MAX_RX_CHANNELS;
 251         channel->max_tx = SXGBE_MAX_TX_CHANNELS;
 252         channel->rx_count = SXGBE_RX_QUEUES;
 253         channel->tx_count = SXGBE_TX_QUEUES;
 254 }
 255
 256 static u32 sxgbe_riwt2usec(u32 riwt, struct sxgbe_priv_data *priv)
 257 {
 258         unsigned long clk = clk_get_rate(priv->sxgbe_clk);
 259
 260         if (!clk)
 261                 return 0;
 262
 263         return (riwt * 256) / (clk / 1000000);
 264 }
 265
 266 static u32 sxgbe_usec2riwt(u32 usec, struct sxgbe_priv_data *priv)
 267 {
 268         unsigned long clk = clk_get_rate(priv->sxgbe_clk);
 269
 270         if (!clk)
 271                 return 0;
 272
 273         return (usec * (clk / 1000000)) / 256;
 274 }
 275
 276 static int sxgbe_get_coalesce(struct net_device *dev,
 277                               struct ethtool_coalesce *ec,
 278                               struct kernel_ethtool_coalesce *kernel_coal,
 279                               struct netlink_ext_ack *extack)
 280 {
 281         struct sxgbe_priv_data *priv = netdev_priv(dev);
 282
 283         if (priv->use_riwt)
 284                 ec->rx_coalesce_usecs = sxgbe_riwt2usec(priv->rx_riwt, priv);
 285
 286         return 0;
 287 }
 288
 289 static int sxgbe_set_coalesce(struct net_device *dev,
 290                               struct ethtool_coalesce *ec,
 291                               struct kernel_ethtool_coalesce *kernel_coal,
 292                               struct netlink_ext_ack *extack)
 293 {
 294         struct sxgbe_priv_data *priv = netdev_priv(dev);
 295         unsigned int rx_riwt;
 296
 297         if (!ec->rx_coalesce_usecs)
 298                 return -EINVAL;
 299
 300         rx_riwt = sxgbe_usec2riwt(ec->rx_coalesce_usecs, priv);
 301
 302         if ((rx_riwt > SXGBE_MAX_DMA_RIWT) || (rx_riwt < SXGBE_MIN_DMA_RIWT))
 303                 return -EINVAL;
 304         else if (!priv->use_riwt)
 305                 return -EOPNOTSUPP;
 306
 307         priv->rx_riwt = rx_riwt;
 308         priv->hw->dma->rx_watchdog(priv->ioaddr, priv->rx_riwt);
 309
 310         return 0;
 311 }
 312
 313 static int sxgbe_get_rss_hash_opts(struct sxgbe_priv_data *priv,
 314                                    struct ethtool_rxnfc *cmd)
 315 {
 316         cmd->data = 0;
 317
 318         /* Report default options for RSS on sxgbe */
 319         switch (cmd->flow_type) {
 320         case TCP_V4_FLOW:
 321         case UDP_V4_FLOW:
 322                 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
 323                 fallthrough;
 324         case SCTP_V4_FLOW:
 325         case AH_ESP_V4_FLOW:
 326         case AH_V4_FLOW:
 327         case ESP_V4_FLOW:
 328         case IPV4_FLOW:
 329                 cmd->data |= RXH_IP_SRC | RXH_IP_DST;
 330                 break;
 331         case TCP_V6_FLOW:
 332         case UDP_V6_FLOW:
 333                 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
 334                 fallthrough;
 335         case SCTP_V6_FLOW:
 336         case AH_ESP_V6_FLOW:
 337         case AH_V6_FLOW:
 338         case ESP_V6_FLOW:
 339         case IPV6_FLOW:
 340                 cmd->data |= RXH_IP_SRC | RXH_IP_DST;
 341                 break;
 342         default:
 343                 return -EINVAL;
 344         }
 345
 346         return 0;
 347 }
 348
 349 static int sxgbe_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
 350                            u32 *rule_locs)
 351 {
 352         struct sxgbe_priv_data *priv = netdev_priv(dev);
 353         int ret = -EOPNOTSUPP;
 354
 355         switch (cmd->cmd) {
 356         case ETHTOOL_GRXFH:
 357                 ret = sxgbe_get_rss_hash_opts(priv, cmd);
 358                 break;
 359         default:
 360                 break;
 361         }
 362
 363         return ret;
 364 }
 365
 366 static int sxgbe_set_rss_hash_opt(struct sxgbe_priv_data *priv,
 367                                   struct ethtool_rxnfc *cmd)
 368 {
 369         u32 reg_val = 0;
 370
 371         /* RSS does not support anything other than hashing
 372          * to queues on src and dst IPs and ports
 373          */
 374         if (cmd->data & ~(RXH_IP_SRC | RXH_IP_DST |
 375                           RXH_L4_B_0_1 | RXH_L4_B_2_3))
 376                 return -EINVAL;
 377
 378         switch (cmd->flow_type) {
 379         case TCP_V4_FLOW:
 380         case TCP_V6_FLOW:
 381                 if (!(cmd->data & RXH_IP_SRC) ||
 382                     !(cmd->data & RXH_IP_DST) ||
 383                     !(cmd->data & RXH_L4_B_0_1) ||
 384                     !(cmd->data & RXH_L4_B_2_3))
 385                         return -EINVAL;
 386                 reg_val = SXGBE_CORE_RSS_CTL_TCP4TE;
 387                 break;
 388         case UDP_V4_FLOW:
 389         case UDP_V6_FLOW:
 390                 if (!(cmd->data & RXH_IP_SRC) ||
 391                     !(cmd->data & RXH_IP_DST) ||
 392                     !(cmd->data & RXH_L4_B_0_1) ||
 393                     !(cmd->data & RXH_L4_B_2_3))
 394                         return -EINVAL;
 395                 reg_val = SXGBE_CORE_RSS_CTL_UDP4TE;
 396                 break;
 397         case SCTP_V4_FLOW:
 398         case AH_ESP_V4_FLOW:
 399         case AH_V4_FLOW:
 400         case ESP_V4_FLOW:
 401         case AH_ESP_V6_FLOW:
 402         case AH_V6_FLOW:
 403         case ESP_V6_FLOW:
 404         case SCTP_V6_FLOW:
 405         case IPV4_FLOW:
 406         case IPV6_FLOW:
 407                 if (!(cmd->data & RXH_IP_SRC) ||
 408                     !(cmd->data & RXH_IP_DST) ||
 409                     (cmd->data & RXH_L4_B_0_1) ||
 410                     (cmd->data & RXH_L4_B_2_3))
 411                         return -EINVAL;
 412                 reg_val = SXGBE_CORE_RSS_CTL_IP2TE;
 413                 break;
 414         default:
 415                 return -EINVAL;
 416         }
 417
 418         /* Read SXGBE RSS control register and update */
 419         reg_val |= readl(priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
 420         writel(reg_val, priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
 421         readl(priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
 422
 423         return 0;
 424 }
 425
 426 static int sxgbe_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
 427 {
 428         struct sxgbe_priv_data *priv = netdev_priv(dev);
 429         int ret = -EOPNOTSUPP;
 430
 431         switch (cmd->cmd) {
 432         case ETHTOOL_SRXFH:
 433                 ret = sxgbe_set_rss_hash_opt(priv, cmd);
 434                 break;
 435         default:
 436                 break;
 437         }
 438
 439         return ret;
 440 }
 441
 442 static void sxgbe_get_regs(struct net_device *dev,
 443                            struct ethtool_regs *regs, void *space)
 444 {
 445         struct sxgbe_priv_data *priv = netdev_priv(dev);
 446         u32 *reg_space = (u32 *)space;
 447         int reg_offset;
 448         int reg_ix = 0;
 449         void __iomem *ioaddr = priv->ioaddr;
 450
 451         memset(reg_space, 0x0, REG_SPACE_SIZE);
 452
 453         /* MAC registers */
 454         for (reg_offset = START_MAC_REG_OFFSET;
 455              reg_offset <= MAX_MAC_REG_OFFSET; reg_offset += 4) {
 456                 reg_space[reg_ix] = readl(ioaddr + reg_offset);
 457                 reg_ix++;
 458         }
 459
 460         /* MTL registers */
 461         for (reg_offset = START_MTL_REG_OFFSET;
 462              reg_offset <= MAX_MTL_REG_OFFSET; reg_offset += 4) {
 463                 reg_space[reg_ix] = readl(ioaddr + reg_offset);
 464                 reg_ix++;
 465         }
 466
 467         /* DMA registers */
 468         for (reg_offset = START_DMA_REG_OFFSET;
 469              reg_offset <= MAX_DMA_REG_OFFSET; reg_offset += 4) {
 470                 reg_space[reg_ix] = readl(ioaddr + reg_offset);
 471                 reg_ix++;
 472         }
 473
 474         BUG_ON(reg_ix * 4 > REG_SPACE_SIZE);
 475 }
 476
 477 static int sxgbe_get_regs_len(struct net_device *dev)
 478 {
 479         return REG_SPACE_SIZE;
 480 }
 481
 482 static const struct ethtool_ops sxgbe_ethtool_ops = {
 483         .supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,
 484         .get_drvinfo = sxgbe_getdrvinfo,
 485         .get_msglevel = sxgbe_getmsglevel,
 486         .set_msglevel = sxgbe_setmsglevel,
 487         .get_link = ethtool_op_get_link,
 488         .get_strings = sxgbe_get_strings,
 489         .get_ethtool_stats = sxgbe_get_ethtool_stats,
 490         .get_sset_count = sxgbe_get_sset_count,
 491         .get_channels = sxgbe_get_channels,
 492         .get_coalesce = sxgbe_get_coalesce,
 493         .set_coalesce = sxgbe_set_coalesce,
 494         .get_rxnfc = sxgbe_get_rxnfc,
 495         .set_rxnfc = sxgbe_set_rxnfc,
 496         .get_regs = sxgbe_get_regs,
 497         .get_regs_len = sxgbe_get_regs_len,
 498         .get_eee = sxgbe_get_eee,
 499         .set_eee = sxgbe_set_eee,
 500         .get_link_ksettings = phy_ethtool_get_link_ksettings,
 501         .set_link_ksettings = phy_ethtool_set_link_ksettings,
 502 };
 503
 504 void sxgbe_set_ethtool_ops(struct net_device *netdev)
 505 {
 506         netdev->ethtool_ops = &sxgbe_ethtool_ops;
 507 }