Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright(c) 2013 - 2019 Intel Corporation. */
0003 
0004 #include <linux/ethtool.h>
0005 #include <linux/vmalloc.h>
0006 
0007 #include "fm10k.h"
0008 
0009 struct fm10k_stats {
0010     /* The stat_string is expected to be a format string formatted using
0011      * vsnprintf by fm10k_add_stat_strings. Every member of a stats array
0012      * should use the same format specifiers as they will be formatted
0013      * using the same variadic arguments.
0014      */
0015     char stat_string[ETH_GSTRING_LEN];
0016     int sizeof_stat;
0017     int stat_offset;
0018 };
0019 
0020 #define FM10K_STAT_FIELDS(_type, _name, _stat) { \
0021     .stat_string = _name, \
0022     .sizeof_stat = sizeof_field(_type, _stat), \
0023     .stat_offset = offsetof(_type, _stat) \
0024 }
0025 
0026 /* netdevice statistics */
0027 #define FM10K_NETDEV_STAT(_net_stat) \
0028     FM10K_STAT_FIELDS(struct net_device_stats, __stringify(_net_stat), \
0029               _net_stat)
0030 
0031 static const struct fm10k_stats fm10k_gstrings_net_stats[] = {
0032     FM10K_NETDEV_STAT(tx_packets),
0033     FM10K_NETDEV_STAT(tx_bytes),
0034     FM10K_NETDEV_STAT(tx_errors),
0035     FM10K_NETDEV_STAT(rx_packets),
0036     FM10K_NETDEV_STAT(rx_bytes),
0037     FM10K_NETDEV_STAT(rx_errors),
0038     FM10K_NETDEV_STAT(rx_dropped),
0039 
0040     /* detailed Rx errors */
0041     FM10K_NETDEV_STAT(rx_length_errors),
0042     FM10K_NETDEV_STAT(rx_crc_errors),
0043     FM10K_NETDEV_STAT(rx_fifo_errors),
0044 };
0045 
0046 #define FM10K_NETDEV_STATS_LEN  ARRAY_SIZE(fm10k_gstrings_net_stats)
0047 
0048 /* General interface statistics */
0049 #define FM10K_STAT(_name, _stat) \
0050     FM10K_STAT_FIELDS(struct fm10k_intfc, _name, _stat)
0051 
0052 static const struct fm10k_stats fm10k_gstrings_global_stats[] = {
0053     FM10K_STAT("tx_restart_queue", restart_queue),
0054     FM10K_STAT("tx_busy", tx_busy),
0055     FM10K_STAT("tx_csum_errors", tx_csum_errors),
0056     FM10K_STAT("rx_alloc_failed", alloc_failed),
0057     FM10K_STAT("rx_csum_errors", rx_csum_errors),
0058 
0059     FM10K_STAT("tx_packets_nic", tx_packets_nic),
0060     FM10K_STAT("tx_bytes_nic", tx_bytes_nic),
0061     FM10K_STAT("rx_packets_nic", rx_packets_nic),
0062     FM10K_STAT("rx_bytes_nic", rx_bytes_nic),
0063     FM10K_STAT("rx_drops_nic", rx_drops_nic),
0064     FM10K_STAT("rx_overrun_pf", rx_overrun_pf),
0065     FM10K_STAT("rx_overrun_vf", rx_overrun_vf),
0066 
0067     FM10K_STAT("swapi_status", hw.swapi.status),
0068     FM10K_STAT("mac_rules_used", hw.swapi.mac.used),
0069     FM10K_STAT("mac_rules_avail", hw.swapi.mac.avail),
0070 
0071     FM10K_STAT("reset_while_pending", hw.mac.reset_while_pending),
0072 
0073     FM10K_STAT("tx_hang_count", tx_timeout_count),
0074 };
0075 
0076 static const struct fm10k_stats fm10k_gstrings_pf_stats[] = {
0077     FM10K_STAT("timeout", stats.timeout.count),
0078     FM10K_STAT("ur", stats.ur.count),
0079     FM10K_STAT("ca", stats.ca.count),
0080     FM10K_STAT("um", stats.um.count),
0081     FM10K_STAT("xec", stats.xec.count),
0082     FM10K_STAT("vlan_drop", stats.vlan_drop.count),
0083     FM10K_STAT("loopback_drop", stats.loopback_drop.count),
0084     FM10K_STAT("nodesc_drop", stats.nodesc_drop.count),
0085 };
0086 
0087 /* mailbox statistics */
0088 #define FM10K_MBX_STAT(_name, _stat) \
0089     FM10K_STAT_FIELDS(struct fm10k_mbx_info, _name, _stat)
0090 
0091 static const struct fm10k_stats fm10k_gstrings_mbx_stats[] = {
0092     FM10K_MBX_STAT("mbx_tx_busy", tx_busy),
0093     FM10K_MBX_STAT("mbx_tx_dropped", tx_dropped),
0094     FM10K_MBX_STAT("mbx_tx_messages", tx_messages),
0095     FM10K_MBX_STAT("mbx_tx_dwords", tx_dwords),
0096     FM10K_MBX_STAT("mbx_tx_mbmem_pulled", tx_mbmem_pulled),
0097     FM10K_MBX_STAT("mbx_rx_messages", rx_messages),
0098     FM10K_MBX_STAT("mbx_rx_dwords", rx_dwords),
0099     FM10K_MBX_STAT("mbx_rx_parse_err", rx_parse_err),
0100     FM10K_MBX_STAT("mbx_rx_mbmem_pushed", rx_mbmem_pushed),
0101 };
0102 
0103 /* per-queue ring statistics */
0104 #define FM10K_QUEUE_STAT(_name, _stat) \
0105     FM10K_STAT_FIELDS(struct fm10k_ring, _name, _stat)
0106 
0107 static const struct fm10k_stats fm10k_gstrings_queue_stats[] = {
0108     FM10K_QUEUE_STAT("%s_queue_%u_packets", stats.packets),
0109     FM10K_QUEUE_STAT("%s_queue_%u_bytes", stats.bytes),
0110 };
0111 
0112 #define FM10K_GLOBAL_STATS_LEN ARRAY_SIZE(fm10k_gstrings_global_stats)
0113 #define FM10K_PF_STATS_LEN ARRAY_SIZE(fm10k_gstrings_pf_stats)
0114 #define FM10K_MBX_STATS_LEN ARRAY_SIZE(fm10k_gstrings_mbx_stats)
0115 #define FM10K_QUEUE_STATS_LEN ARRAY_SIZE(fm10k_gstrings_queue_stats)
0116 
0117 #define FM10K_STATIC_STATS_LEN (FM10K_GLOBAL_STATS_LEN + \
0118                 FM10K_NETDEV_STATS_LEN + \
0119                 FM10K_MBX_STATS_LEN)
0120 
0121 static const char fm10k_gstrings_test[][ETH_GSTRING_LEN] = {
0122     "Mailbox test (on/offline)"
0123 };
0124 
0125 #define FM10K_TEST_LEN (sizeof(fm10k_gstrings_test) / ETH_GSTRING_LEN)
0126 
0127 enum fm10k_self_test_types {
0128     FM10K_TEST_MBX,
0129     FM10K_TEST_MAX = FM10K_TEST_LEN
0130 };
0131 
0132 enum {
0133     FM10K_PRV_FLAG_LEN,
0134 };
0135 
0136 static const char fm10k_prv_flags[FM10K_PRV_FLAG_LEN][ETH_GSTRING_LEN] = {
0137 };
0138 
0139 static void __fm10k_add_stat_strings(u8 **p, const struct fm10k_stats stats[],
0140                      const unsigned int size, ...)
0141 {
0142     unsigned int i;
0143 
0144     for (i = 0; i < size; i++) {
0145         va_list args;
0146 
0147         va_start(args, size);
0148         vsnprintf(*p, ETH_GSTRING_LEN, stats[i].stat_string, args);
0149         *p += ETH_GSTRING_LEN;
0150         va_end(args);
0151     }
0152 }
0153 
0154 #define fm10k_add_stat_strings(p, stats, ...) \
0155     __fm10k_add_stat_strings(p, stats, ARRAY_SIZE(stats), ## __VA_ARGS__)
0156 
0157 static void fm10k_get_stat_strings(struct net_device *dev, u8 *data)
0158 {
0159     struct fm10k_intfc *interface = netdev_priv(dev);
0160     unsigned int i;
0161 
0162     fm10k_add_stat_strings(&data, fm10k_gstrings_net_stats);
0163 
0164     fm10k_add_stat_strings(&data, fm10k_gstrings_global_stats);
0165 
0166     fm10k_add_stat_strings(&data, fm10k_gstrings_mbx_stats);
0167 
0168     if (interface->hw.mac.type != fm10k_mac_vf)
0169         fm10k_add_stat_strings(&data, fm10k_gstrings_pf_stats);
0170 
0171     for (i = 0; i < interface->hw.mac.max_queues; i++) {
0172         fm10k_add_stat_strings(&data, fm10k_gstrings_queue_stats,
0173                        "tx", i);
0174 
0175         fm10k_add_stat_strings(&data, fm10k_gstrings_queue_stats,
0176                        "rx", i);
0177     }
0178 }
0179 
0180 static void fm10k_get_strings(struct net_device *dev,
0181                   u32 stringset, u8 *data)
0182 {
0183     switch (stringset) {
0184     case ETH_SS_TEST:
0185         memcpy(data, fm10k_gstrings_test,
0186                FM10K_TEST_LEN * ETH_GSTRING_LEN);
0187         break;
0188     case ETH_SS_STATS:
0189         fm10k_get_stat_strings(dev, data);
0190         break;
0191     case ETH_SS_PRIV_FLAGS:
0192         memcpy(data, fm10k_prv_flags,
0193                FM10K_PRV_FLAG_LEN * ETH_GSTRING_LEN);
0194         break;
0195     }
0196 }
0197 
0198 static int fm10k_get_sset_count(struct net_device *dev, int sset)
0199 {
0200     struct fm10k_intfc *interface = netdev_priv(dev);
0201     struct fm10k_hw *hw = &interface->hw;
0202     int stats_len = FM10K_STATIC_STATS_LEN;
0203 
0204     switch (sset) {
0205     case ETH_SS_TEST:
0206         return FM10K_TEST_LEN;
0207     case ETH_SS_STATS:
0208         stats_len += hw->mac.max_queues * 2 * FM10K_QUEUE_STATS_LEN;
0209 
0210         if (hw->mac.type != fm10k_mac_vf)
0211             stats_len += FM10K_PF_STATS_LEN;
0212 
0213         return stats_len;
0214     case ETH_SS_PRIV_FLAGS:
0215         return FM10K_PRV_FLAG_LEN;
0216     default:
0217         return -EOPNOTSUPP;
0218     }
0219 }
0220 
0221 static void __fm10k_add_ethtool_stats(u64 **data, void *pointer,
0222                       const struct fm10k_stats stats[],
0223                       const unsigned int size)
0224 {
0225     unsigned int i;
0226 
0227     if (!pointer) {
0228         /* memory is not zero allocated so we have to clear it */
0229         for (i = 0; i < size; i++)
0230             *((*data)++) = 0;
0231         return;
0232     }
0233 
0234     for (i = 0; i < size; i++) {
0235         char *p = (char *)pointer + stats[i].stat_offset;
0236 
0237         switch (stats[i].sizeof_stat) {
0238         case sizeof(u64):
0239             *((*data)++) = *(u64 *)p;
0240             break;
0241         case sizeof(u32):
0242             *((*data)++) = *(u32 *)p;
0243             break;
0244         case sizeof(u16):
0245             *((*data)++) = *(u16 *)p;
0246             break;
0247         case sizeof(u8):
0248             *((*data)++) = *(u8 *)p;
0249             break;
0250         default:
0251             WARN_ONCE(1, "unexpected stat size for %s",
0252                   stats[i].stat_string);
0253             *((*data)++) = 0;
0254         }
0255     }
0256 }
0257 
0258 #define fm10k_add_ethtool_stats(data, pointer, stats) \
0259     __fm10k_add_ethtool_stats(data, pointer, stats, ARRAY_SIZE(stats))
0260 
0261 static void fm10k_get_ethtool_stats(struct net_device *netdev,
0262                     struct ethtool_stats __always_unused *stats,
0263                     u64 *data)
0264 {
0265     struct fm10k_intfc *interface = netdev_priv(netdev);
0266     struct net_device_stats *net_stats = &netdev->stats;
0267     int i;
0268 
0269     fm10k_update_stats(interface);
0270 
0271     fm10k_add_ethtool_stats(&data, net_stats, fm10k_gstrings_net_stats);
0272 
0273     fm10k_add_ethtool_stats(&data, interface, fm10k_gstrings_global_stats);
0274 
0275     fm10k_add_ethtool_stats(&data, &interface->hw.mbx,
0276                 fm10k_gstrings_mbx_stats);
0277 
0278     if (interface->hw.mac.type != fm10k_mac_vf) {
0279         fm10k_add_ethtool_stats(&data, interface,
0280                     fm10k_gstrings_pf_stats);
0281     }
0282 
0283     for (i = 0; i < interface->hw.mac.max_queues; i++) {
0284         struct fm10k_ring *ring;
0285 
0286         ring = interface->tx_ring[i];
0287         fm10k_add_ethtool_stats(&data, ring,
0288                     fm10k_gstrings_queue_stats);
0289 
0290         ring = interface->rx_ring[i];
0291         fm10k_add_ethtool_stats(&data, ring,
0292                     fm10k_gstrings_queue_stats);
0293     }
0294 }
0295 
0296 /* If function below adds more registers this define needs to be updated */
0297 #define FM10K_REGS_LEN_Q 29
0298 
0299 static void fm10k_get_reg_q(struct fm10k_hw *hw, u32 *buff, int i)
0300 {
0301     int idx = 0;
0302 
0303     buff[idx++] = fm10k_read_reg(hw, FM10K_RDBAL(i));
0304     buff[idx++] = fm10k_read_reg(hw, FM10K_RDBAH(i));
0305     buff[idx++] = fm10k_read_reg(hw, FM10K_RDLEN(i));
0306     buff[idx++] = fm10k_read_reg(hw, FM10K_TPH_RXCTRL(i));
0307     buff[idx++] = fm10k_read_reg(hw, FM10K_RDH(i));
0308     buff[idx++] = fm10k_read_reg(hw, FM10K_RDT(i));
0309     buff[idx++] = fm10k_read_reg(hw, FM10K_RXQCTL(i));
0310     buff[idx++] = fm10k_read_reg(hw, FM10K_RXDCTL(i));
0311     buff[idx++] = fm10k_read_reg(hw, FM10K_RXINT(i));
0312     buff[idx++] = fm10k_read_reg(hw, FM10K_SRRCTL(i));
0313     buff[idx++] = fm10k_read_reg(hw, FM10K_QPRC(i));
0314     buff[idx++] = fm10k_read_reg(hw, FM10K_QPRDC(i));
0315     buff[idx++] = fm10k_read_reg(hw, FM10K_QBRC_L(i));
0316     buff[idx++] = fm10k_read_reg(hw, FM10K_QBRC_H(i));
0317     buff[idx++] = fm10k_read_reg(hw, FM10K_TDBAL(i));
0318     buff[idx++] = fm10k_read_reg(hw, FM10K_TDBAH(i));
0319     buff[idx++] = fm10k_read_reg(hw, FM10K_TDLEN(i));
0320     buff[idx++] = fm10k_read_reg(hw, FM10K_TPH_TXCTRL(i));
0321     buff[idx++] = fm10k_read_reg(hw, FM10K_TDH(i));
0322     buff[idx++] = fm10k_read_reg(hw, FM10K_TDT(i));
0323     buff[idx++] = fm10k_read_reg(hw, FM10K_TXDCTL(i));
0324     buff[idx++] = fm10k_read_reg(hw, FM10K_TXQCTL(i));
0325     buff[idx++] = fm10k_read_reg(hw, FM10K_TXINT(i));
0326     buff[idx++] = fm10k_read_reg(hw, FM10K_QPTC(i));
0327     buff[idx++] = fm10k_read_reg(hw, FM10K_QBTC_L(i));
0328     buff[idx++] = fm10k_read_reg(hw, FM10K_QBTC_H(i));
0329     buff[idx++] = fm10k_read_reg(hw, FM10K_TQDLOC(i));
0330     buff[idx++] = fm10k_read_reg(hw, FM10K_TX_SGLORT(i));
0331     buff[idx++] = fm10k_read_reg(hw, FM10K_PFVTCTL(i));
0332 
0333     BUG_ON(idx != FM10K_REGS_LEN_Q);
0334 }
0335 
0336 /* If function above adds more registers this define needs to be updated */
0337 #define FM10K_REGS_LEN_VSI 43
0338 
0339 static void fm10k_get_reg_vsi(struct fm10k_hw *hw, u32 *buff, int i)
0340 {
0341     int idx = 0, j;
0342 
0343     buff[idx++] = fm10k_read_reg(hw, FM10K_MRQC(i));
0344     for (j = 0; j < 10; j++)
0345         buff[idx++] = fm10k_read_reg(hw, FM10K_RSSRK(i, j));
0346     for (j = 0; j < 32; j++)
0347         buff[idx++] = fm10k_read_reg(hw, FM10K_RETA(i, j));
0348 
0349     BUG_ON(idx != FM10K_REGS_LEN_VSI);
0350 }
0351 
0352 static void fm10k_get_regs(struct net_device *netdev,
0353                struct ethtool_regs *regs, void *p)
0354 {
0355     struct fm10k_intfc *interface = netdev_priv(netdev);
0356     struct fm10k_hw *hw = &interface->hw;
0357     u32 *buff = p;
0358     u16 i;
0359 
0360     regs->version = BIT(24) | (hw->revision_id << 16) | hw->device_id;
0361 
0362     switch (hw->mac.type) {
0363     case fm10k_mac_pf:
0364         /* General PF Registers */
0365         *(buff++) = fm10k_read_reg(hw, FM10K_CTRL);
0366         *(buff++) = fm10k_read_reg(hw, FM10K_CTRL_EXT);
0367         *(buff++) = fm10k_read_reg(hw, FM10K_GCR);
0368         *(buff++) = fm10k_read_reg(hw, FM10K_GCR_EXT);
0369 
0370         for (i = 0; i < 8; i++) {
0371             *(buff++) = fm10k_read_reg(hw, FM10K_DGLORTMAP(i));
0372             *(buff++) = fm10k_read_reg(hw, FM10K_DGLORTDEC(i));
0373         }
0374 
0375         for (i = 0; i < 65; i++) {
0376             fm10k_get_reg_vsi(hw, buff, i);
0377             buff += FM10K_REGS_LEN_VSI;
0378         }
0379 
0380         *(buff++) = fm10k_read_reg(hw, FM10K_DMA_CTRL);
0381         *(buff++) = fm10k_read_reg(hw, FM10K_DMA_CTRL2);
0382 
0383         for (i = 0; i < FM10K_MAX_QUEUES_PF; i++) {
0384             fm10k_get_reg_q(hw, buff, i);
0385             buff += FM10K_REGS_LEN_Q;
0386         }
0387 
0388         *(buff++) = fm10k_read_reg(hw, FM10K_TPH_CTRL);
0389 
0390         for (i = 0; i < 8; i++)
0391             *(buff++) = fm10k_read_reg(hw, FM10K_INT_MAP(i));
0392 
0393         /* Interrupt Throttling Registers */
0394         for (i = 0; i < 130; i++)
0395             *(buff++) = fm10k_read_reg(hw, FM10K_ITR(i));
0396 
0397         break;
0398     case fm10k_mac_vf:
0399         /* General VF registers */
0400         *(buff++) = fm10k_read_reg(hw, FM10K_VFCTRL);
0401         *(buff++) = fm10k_read_reg(hw, FM10K_VFINT_MAP);
0402         *(buff++) = fm10k_read_reg(hw, FM10K_VFSYSTIME);
0403 
0404         /* Interrupt Throttling Registers */
0405         for (i = 0; i < 8; i++)
0406             *(buff++) = fm10k_read_reg(hw, FM10K_VFITR(i));
0407 
0408         fm10k_get_reg_vsi(hw, buff, 0);
0409         buff += FM10K_REGS_LEN_VSI;
0410 
0411         for (i = 0; i < FM10K_MAX_QUEUES_POOL; i++) {
0412             if (i < hw->mac.max_queues)
0413                 fm10k_get_reg_q(hw, buff, i);
0414             else
0415                 memset(buff, 0, sizeof(u32) * FM10K_REGS_LEN_Q);
0416             buff += FM10K_REGS_LEN_Q;
0417         }
0418 
0419         break;
0420     default:
0421         return;
0422     }
0423 }
0424 
0425 /* If function above adds more registers these define need to be updated */
0426 #define FM10K_REGS_LEN_PF \
0427 (162 + (65 * FM10K_REGS_LEN_VSI) + (FM10K_MAX_QUEUES_PF * FM10K_REGS_LEN_Q))
0428 #define FM10K_REGS_LEN_VF \
0429 (11 + FM10K_REGS_LEN_VSI + (FM10K_MAX_QUEUES_POOL * FM10K_REGS_LEN_Q))
0430 
0431 static int fm10k_get_regs_len(struct net_device *netdev)
0432 {
0433     struct fm10k_intfc *interface = netdev_priv(netdev);
0434     struct fm10k_hw *hw = &interface->hw;
0435 
0436     switch (hw->mac.type) {
0437     case fm10k_mac_pf:
0438         return FM10K_REGS_LEN_PF * sizeof(u32);
0439     case fm10k_mac_vf:
0440         return FM10K_REGS_LEN_VF * sizeof(u32);
0441     default:
0442         return 0;
0443     }
0444 }
0445 
0446 static void fm10k_get_drvinfo(struct net_device *dev,
0447                   struct ethtool_drvinfo *info)
0448 {
0449     struct fm10k_intfc *interface = netdev_priv(dev);
0450 
0451     strncpy(info->driver, fm10k_driver_name,
0452         sizeof(info->driver) - 1);
0453     strncpy(info->bus_info, pci_name(interface->pdev),
0454         sizeof(info->bus_info) - 1);
0455 }
0456 
0457 static void fm10k_get_pauseparam(struct net_device *dev,
0458                  struct ethtool_pauseparam *pause)
0459 {
0460     struct fm10k_intfc *interface = netdev_priv(dev);
0461 
0462     /* record fixed values for autoneg and tx pause */
0463     pause->autoneg = 0;
0464     pause->tx_pause = 1;
0465 
0466     pause->rx_pause = interface->rx_pause ? 1 : 0;
0467 }
0468 
0469 static int fm10k_set_pauseparam(struct net_device *dev,
0470                 struct ethtool_pauseparam *pause)
0471 {
0472     struct fm10k_intfc *interface = netdev_priv(dev);
0473     struct fm10k_hw *hw = &interface->hw;
0474 
0475     if (pause->autoneg || !pause->tx_pause)
0476         return -EINVAL;
0477 
0478     /* we can only support pause on the PF to avoid head-of-line blocking */
0479     if (hw->mac.type == fm10k_mac_pf)
0480         interface->rx_pause = pause->rx_pause ? ~0 : 0;
0481     else if (pause->rx_pause)
0482         return -EINVAL;
0483 
0484     if (netif_running(dev))
0485         fm10k_update_rx_drop_en(interface);
0486 
0487     return 0;
0488 }
0489 
0490 static u32 fm10k_get_msglevel(struct net_device *netdev)
0491 {
0492     struct fm10k_intfc *interface = netdev_priv(netdev);
0493 
0494     return interface->msg_enable;
0495 }
0496 
0497 static void fm10k_set_msglevel(struct net_device *netdev, u32 data)
0498 {
0499     struct fm10k_intfc *interface = netdev_priv(netdev);
0500 
0501     interface->msg_enable = data;
0502 }
0503 
0504 static void fm10k_get_ringparam(struct net_device *netdev,
0505                 struct ethtool_ringparam *ring,
0506                 struct kernel_ethtool_ringparam *kernel_ring,
0507                 struct netlink_ext_ack *extack)
0508 {
0509     struct fm10k_intfc *interface = netdev_priv(netdev);
0510 
0511     ring->rx_max_pending = FM10K_MAX_RXD;
0512     ring->tx_max_pending = FM10K_MAX_TXD;
0513     ring->rx_mini_max_pending = 0;
0514     ring->rx_jumbo_max_pending = 0;
0515     ring->rx_pending = interface->rx_ring_count;
0516     ring->tx_pending = interface->tx_ring_count;
0517     ring->rx_mini_pending = 0;
0518     ring->rx_jumbo_pending = 0;
0519 }
0520 
0521 static int fm10k_set_ringparam(struct net_device *netdev,
0522                    struct ethtool_ringparam *ring,
0523                    struct kernel_ethtool_ringparam *kernel_ring,
0524                    struct netlink_ext_ack *extack)
0525 {
0526     struct fm10k_intfc *interface = netdev_priv(netdev);
0527     struct fm10k_ring *temp_ring;
0528     int i, err = 0;
0529     u32 new_rx_count, new_tx_count;
0530 
0531     if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
0532         return -EINVAL;
0533 
0534     new_tx_count = clamp_t(u32, ring->tx_pending,
0535                    FM10K_MIN_TXD, FM10K_MAX_TXD);
0536     new_tx_count = ALIGN(new_tx_count, FM10K_REQ_TX_DESCRIPTOR_MULTIPLE);
0537 
0538     new_rx_count = clamp_t(u32, ring->rx_pending,
0539                    FM10K_MIN_RXD, FM10K_MAX_RXD);
0540     new_rx_count = ALIGN(new_rx_count, FM10K_REQ_RX_DESCRIPTOR_MULTIPLE);
0541 
0542     if ((new_tx_count == interface->tx_ring_count) &&
0543         (new_rx_count == interface->rx_ring_count)) {
0544         /* nothing to do */
0545         return 0;
0546     }
0547 
0548     while (test_and_set_bit(__FM10K_RESETTING, interface->state))
0549         usleep_range(1000, 2000);
0550 
0551     if (!netif_running(interface->netdev)) {
0552         for (i = 0; i < interface->num_tx_queues; i++)
0553             interface->tx_ring[i]->count = new_tx_count;
0554         for (i = 0; i < interface->num_rx_queues; i++)
0555             interface->rx_ring[i]->count = new_rx_count;
0556         interface->tx_ring_count = new_tx_count;
0557         interface->rx_ring_count = new_rx_count;
0558         goto clear_reset;
0559     }
0560 
0561     /* allocate temporary buffer to store rings in */
0562     i = max_t(int, interface->num_tx_queues, interface->num_rx_queues);
0563     temp_ring = vmalloc(array_size(i, sizeof(struct fm10k_ring)));
0564 
0565     if (!temp_ring) {
0566         err = -ENOMEM;
0567         goto clear_reset;
0568     }
0569 
0570     fm10k_down(interface);
0571 
0572     /* Setup new Tx resources and free the old Tx resources in that order.
0573      * We can then assign the new resources to the rings via a memcpy.
0574      * The advantage to this approach is that we are guaranteed to still
0575      * have resources even in the case of an allocation failure.
0576      */
0577     if (new_tx_count != interface->tx_ring_count) {
0578         for (i = 0; i < interface->num_tx_queues; i++) {
0579             memcpy(&temp_ring[i], interface->tx_ring[i],
0580                    sizeof(struct fm10k_ring));
0581 
0582             temp_ring[i].count = new_tx_count;
0583             err = fm10k_setup_tx_resources(&temp_ring[i]);
0584             if (err) {
0585                 while (i) {
0586                     i--;
0587                     fm10k_free_tx_resources(&temp_ring[i]);
0588                 }
0589                 goto err_setup;
0590             }
0591         }
0592 
0593         for (i = 0; i < interface->num_tx_queues; i++) {
0594             fm10k_free_tx_resources(interface->tx_ring[i]);
0595 
0596             memcpy(interface->tx_ring[i], &temp_ring[i],
0597                    sizeof(struct fm10k_ring));
0598         }
0599 
0600         interface->tx_ring_count = new_tx_count;
0601     }
0602 
0603     /* Repeat the process for the Rx rings if needed */
0604     if (new_rx_count != interface->rx_ring_count) {
0605         for (i = 0; i < interface->num_rx_queues; i++) {
0606             memcpy(&temp_ring[i], interface->rx_ring[i],
0607                    sizeof(struct fm10k_ring));
0608 
0609             temp_ring[i].count = new_rx_count;
0610             err = fm10k_setup_rx_resources(&temp_ring[i]);
0611             if (err) {
0612                 while (i) {
0613                     i--;
0614                     fm10k_free_rx_resources(&temp_ring[i]);
0615                 }
0616                 goto err_setup;
0617             }
0618         }
0619 
0620         for (i = 0; i < interface->num_rx_queues; i++) {
0621             fm10k_free_rx_resources(interface->rx_ring[i]);
0622 
0623             memcpy(interface->rx_ring[i], &temp_ring[i],
0624                    sizeof(struct fm10k_ring));
0625         }
0626 
0627         interface->rx_ring_count = new_rx_count;
0628     }
0629 
0630 err_setup:
0631     fm10k_up(interface);
0632     vfree(temp_ring);
0633 clear_reset:
0634     clear_bit(__FM10K_RESETTING, interface->state);
0635     return err;
0636 }
0637 
0638 static int fm10k_get_coalesce(struct net_device *dev,
0639                   struct ethtool_coalesce *ec,
0640                   struct kernel_ethtool_coalesce *kernel_coal,
0641                   struct netlink_ext_ack *extack)
0642 {
0643     struct fm10k_intfc *interface = netdev_priv(dev);
0644 
0645     ec->use_adaptive_tx_coalesce = ITR_IS_ADAPTIVE(interface->tx_itr);
0646     ec->tx_coalesce_usecs = interface->tx_itr & ~FM10K_ITR_ADAPTIVE;
0647 
0648     ec->use_adaptive_rx_coalesce = ITR_IS_ADAPTIVE(interface->rx_itr);
0649     ec->rx_coalesce_usecs = interface->rx_itr & ~FM10K_ITR_ADAPTIVE;
0650 
0651     return 0;
0652 }
0653 
0654 static int fm10k_set_coalesce(struct net_device *dev,
0655                   struct ethtool_coalesce *ec,
0656                   struct kernel_ethtool_coalesce *kernel_coal,
0657                   struct netlink_ext_ack *extack)
0658 {
0659     struct fm10k_intfc *interface = netdev_priv(dev);
0660     u16 tx_itr, rx_itr;
0661     int i;
0662 
0663     /* verify limits */
0664     if ((ec->rx_coalesce_usecs > FM10K_ITR_MAX) ||
0665         (ec->tx_coalesce_usecs > FM10K_ITR_MAX))
0666         return -EINVAL;
0667 
0668     /* record settings */
0669     tx_itr = ec->tx_coalesce_usecs;
0670     rx_itr = ec->rx_coalesce_usecs;
0671 
0672     /* set initial values for adaptive ITR */
0673     if (ec->use_adaptive_tx_coalesce)
0674         tx_itr = FM10K_ITR_ADAPTIVE | FM10K_TX_ITR_DEFAULT;
0675 
0676     if (ec->use_adaptive_rx_coalesce)
0677         rx_itr = FM10K_ITR_ADAPTIVE | FM10K_RX_ITR_DEFAULT;
0678 
0679     /* update interface */
0680     interface->tx_itr = tx_itr;
0681     interface->rx_itr = rx_itr;
0682 
0683     /* update q_vectors */
0684     for (i = 0; i < interface->num_q_vectors; i++) {
0685         struct fm10k_q_vector *qv = interface->q_vector[i];
0686 
0687         qv->tx.itr = tx_itr;
0688         qv->rx.itr = rx_itr;
0689     }
0690 
0691     return 0;
0692 }
0693 
0694 static int fm10k_get_rss_hash_opts(struct fm10k_intfc *interface,
0695                    struct ethtool_rxnfc *cmd)
0696 {
0697     cmd->data = 0;
0698 
0699     /* Report default options for RSS on fm10k */
0700     switch (cmd->flow_type) {
0701     case TCP_V4_FLOW:
0702     case TCP_V6_FLOW:
0703         cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
0704         fallthrough;
0705     case UDP_V4_FLOW:
0706         if (test_bit(FM10K_FLAG_RSS_FIELD_IPV4_UDP,
0707                  interface->flags))
0708             cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
0709         fallthrough;
0710     case SCTP_V4_FLOW:
0711     case SCTP_V6_FLOW:
0712     case AH_ESP_V4_FLOW:
0713     case AH_ESP_V6_FLOW:
0714     case AH_V4_FLOW:
0715     case AH_V6_FLOW:
0716     case ESP_V4_FLOW:
0717     case ESP_V6_FLOW:
0718     case IPV4_FLOW:
0719     case IPV6_FLOW:
0720         cmd->data |= RXH_IP_SRC | RXH_IP_DST;
0721         break;
0722     case UDP_V6_FLOW:
0723         if (test_bit(FM10K_FLAG_RSS_FIELD_IPV6_UDP,
0724                  interface->flags))
0725             cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
0726         cmd->data |= RXH_IP_SRC | RXH_IP_DST;
0727         break;
0728     default:
0729         return -EINVAL;
0730     }
0731 
0732     return 0;
0733 }
0734 
0735 static int fm10k_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
0736                u32 __always_unused *rule_locs)
0737 {
0738     struct fm10k_intfc *interface = netdev_priv(dev);
0739     int ret = -EOPNOTSUPP;
0740 
0741     switch (cmd->cmd) {
0742     case ETHTOOL_GRXRINGS:
0743         cmd->data = interface->num_rx_queues;
0744         ret = 0;
0745         break;
0746     case ETHTOOL_GRXFH:
0747         ret = fm10k_get_rss_hash_opts(interface, cmd);
0748         break;
0749     default:
0750         break;
0751     }
0752 
0753     return ret;
0754 }
0755 
0756 static int fm10k_set_rss_hash_opt(struct fm10k_intfc *interface,
0757                   struct ethtool_rxnfc *nfc)
0758 {
0759     int rss_ipv4_udp = test_bit(FM10K_FLAG_RSS_FIELD_IPV4_UDP,
0760                     interface->flags);
0761     int rss_ipv6_udp = test_bit(FM10K_FLAG_RSS_FIELD_IPV6_UDP,
0762                     interface->flags);
0763 
0764     /* RSS does not support anything other than hashing
0765      * to queues on src and dst IPs and ports
0766      */
0767     if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |
0768               RXH_L4_B_0_1 | RXH_L4_B_2_3))
0769         return -EINVAL;
0770 
0771     switch (nfc->flow_type) {
0772     case TCP_V4_FLOW:
0773     case TCP_V6_FLOW:
0774         if (!(nfc->data & RXH_IP_SRC) ||
0775             !(nfc->data & RXH_IP_DST) ||
0776             !(nfc->data & RXH_L4_B_0_1) ||
0777             !(nfc->data & RXH_L4_B_2_3))
0778             return -EINVAL;
0779         break;
0780     case UDP_V4_FLOW:
0781         if (!(nfc->data & RXH_IP_SRC) ||
0782             !(nfc->data & RXH_IP_DST))
0783             return -EINVAL;
0784         switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
0785         case 0:
0786             clear_bit(FM10K_FLAG_RSS_FIELD_IPV4_UDP,
0787                   interface->flags);
0788             break;
0789         case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
0790             set_bit(FM10K_FLAG_RSS_FIELD_IPV4_UDP,
0791                 interface->flags);
0792             break;
0793         default:
0794             return -EINVAL;
0795         }
0796         break;
0797     case UDP_V6_FLOW:
0798         if (!(nfc->data & RXH_IP_SRC) ||
0799             !(nfc->data & RXH_IP_DST))
0800             return -EINVAL;
0801         switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
0802         case 0:
0803             clear_bit(FM10K_FLAG_RSS_FIELD_IPV6_UDP,
0804                   interface->flags);
0805             break;
0806         case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
0807             set_bit(FM10K_FLAG_RSS_FIELD_IPV6_UDP,
0808                 interface->flags);
0809             break;
0810         default:
0811             return -EINVAL;
0812         }
0813         break;
0814     case AH_ESP_V4_FLOW:
0815     case AH_V4_FLOW:
0816     case ESP_V4_FLOW:
0817     case SCTP_V4_FLOW:
0818     case AH_ESP_V6_FLOW:
0819     case AH_V6_FLOW:
0820     case ESP_V6_FLOW:
0821     case SCTP_V6_FLOW:
0822         if (!(nfc->data & RXH_IP_SRC) ||
0823             !(nfc->data & RXH_IP_DST) ||
0824             (nfc->data & RXH_L4_B_0_1) ||
0825             (nfc->data & RXH_L4_B_2_3))
0826             return -EINVAL;
0827         break;
0828     default:
0829         return -EINVAL;
0830     }
0831 
0832     /* If something changed we need to update the MRQC register. Note that
0833      * test_bit() is guaranteed to return strictly 0 or 1, so testing for
0834      * equality is safe.
0835      */
0836     if ((rss_ipv4_udp != test_bit(FM10K_FLAG_RSS_FIELD_IPV4_UDP,
0837                       interface->flags)) ||
0838         (rss_ipv6_udp != test_bit(FM10K_FLAG_RSS_FIELD_IPV6_UDP,
0839                       interface->flags))) {
0840         struct fm10k_hw *hw = &interface->hw;
0841         bool warn = false;
0842         u32 mrqc;
0843 
0844         /* Perform hash on these packet types */
0845         mrqc = FM10K_MRQC_IPV4 |
0846                FM10K_MRQC_TCP_IPV4 |
0847                FM10K_MRQC_IPV6 |
0848                FM10K_MRQC_TCP_IPV6;
0849 
0850         if (test_bit(FM10K_FLAG_RSS_FIELD_IPV4_UDP,
0851                  interface->flags)) {
0852             mrqc |= FM10K_MRQC_UDP_IPV4;
0853             warn = true;
0854         }
0855         if (test_bit(FM10K_FLAG_RSS_FIELD_IPV6_UDP,
0856                  interface->flags)) {
0857             mrqc |= FM10K_MRQC_UDP_IPV6;
0858             warn = true;
0859         }
0860 
0861         /* If we enable UDP RSS display a warning that this may cause
0862          * fragmented UDP packets to arrive out of order.
0863          */
0864         if (warn)
0865             netif_warn(interface, drv, interface->netdev,
0866                    "enabling UDP RSS: fragmented packets may arrive out of order to the stack above\n");
0867 
0868         fm10k_write_reg(hw, FM10K_MRQC(0), mrqc);
0869     }
0870 
0871     return 0;
0872 }
0873 
0874 static int fm10k_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
0875 {
0876     struct fm10k_intfc *interface = netdev_priv(dev);
0877     int ret = -EOPNOTSUPP;
0878 
0879     switch (cmd->cmd) {
0880     case ETHTOOL_SRXFH:
0881         ret = fm10k_set_rss_hash_opt(interface, cmd);
0882         break;
0883     default:
0884         break;
0885     }
0886 
0887     return ret;
0888 }
0889 
0890 static int fm10k_mbx_test(struct fm10k_intfc *interface, u64 *data)
0891 {
0892     struct fm10k_hw *hw = &interface->hw;
0893     struct fm10k_mbx_info *mbx = &hw->mbx;
0894     u32 attr_flag, test_msg[6];
0895     unsigned long timeout;
0896     int err = -EINVAL;
0897 
0898     /* For now this is a VF only feature */
0899     if (hw->mac.type != fm10k_mac_vf)
0900         return 0;
0901 
0902     /* loop through both nested and unnested attribute types */
0903     for (attr_flag = BIT(FM10K_TEST_MSG_UNSET);
0904          attr_flag < BIT(2 * FM10K_TEST_MSG_NESTED);
0905          attr_flag += attr_flag) {
0906         /* generate message to be tested */
0907         fm10k_tlv_msg_test_create(test_msg, attr_flag);
0908 
0909         fm10k_mbx_lock(interface);
0910         mbx->test_result = FM10K_NOT_IMPLEMENTED;
0911         err = mbx->ops.enqueue_tx(hw, mbx, test_msg);
0912         fm10k_mbx_unlock(interface);
0913 
0914         /* wait up to 1 second for response */
0915         timeout = jiffies + HZ;
0916         do {
0917             if (err < 0)
0918                 goto err_out;
0919 
0920             usleep_range(500, 1000);
0921 
0922             fm10k_mbx_lock(interface);
0923             mbx->ops.process(hw, mbx);
0924             fm10k_mbx_unlock(interface);
0925 
0926             err = mbx->test_result;
0927             if (!err)
0928                 break;
0929         } while (time_is_after_jiffies(timeout));
0930 
0931         /* reporting errors */
0932         if (err)
0933             goto err_out;
0934     }
0935 
0936 err_out:
0937     *data = err < 0 ? (attr_flag) : (err > 0);
0938     return err;
0939 }
0940 
0941 static void fm10k_self_test(struct net_device *dev,
0942                 struct ethtool_test *eth_test, u64 *data)
0943 {
0944     struct fm10k_intfc *interface = netdev_priv(dev);
0945     struct fm10k_hw *hw = &interface->hw;
0946 
0947     memset(data, 0, sizeof(*data) * FM10K_TEST_LEN);
0948 
0949     if (FM10K_REMOVED(hw->hw_addr)) {
0950         netif_err(interface, drv, dev,
0951               "Interface removed - test blocked\n");
0952         eth_test->flags |= ETH_TEST_FL_FAILED;
0953         return;
0954     }
0955 
0956     if (fm10k_mbx_test(interface, &data[FM10K_TEST_MBX]))
0957         eth_test->flags |= ETH_TEST_FL_FAILED;
0958 }
0959 
0960 static u32 fm10k_get_priv_flags(struct net_device *netdev)
0961 {
0962     return 0;
0963 }
0964 
0965 static int fm10k_set_priv_flags(struct net_device *netdev, u32 priv_flags)
0966 {
0967     if (priv_flags >= BIT(FM10K_PRV_FLAG_LEN))
0968         return -EINVAL;
0969 
0970     return 0;
0971 }
0972 
0973 static u32 fm10k_get_reta_size(struct net_device __always_unused *netdev)
0974 {
0975     return FM10K_RETA_SIZE * FM10K_RETA_ENTRIES_PER_REG;
0976 }
0977 
0978 void fm10k_write_reta(struct fm10k_intfc *interface, const u32 *indir)
0979 {
0980     u16 rss_i = interface->ring_feature[RING_F_RSS].indices;
0981     struct fm10k_hw *hw = &interface->hw;
0982     u32 table[4];
0983     int i, j;
0984 
0985     /* record entries to reta table */
0986     for (i = 0; i < FM10K_RETA_SIZE; i++) {
0987         u32 reta, n;
0988 
0989         /* generate a new table if we weren't given one */
0990         for (j = 0; j < 4; j++) {
0991             if (indir)
0992                 n = indir[4 * i + j];
0993             else
0994                 n = ethtool_rxfh_indir_default(4 * i + j,
0995                                    rss_i);
0996 
0997             table[j] = n;
0998         }
0999 
1000         reta = table[0] |
1001             (table[1] << 8) |
1002             (table[2] << 16) |
1003             (table[3] << 24);
1004 
1005         if (interface->reta[i] == reta)
1006             continue;
1007 
1008         interface->reta[i] = reta;
1009         fm10k_write_reg(hw, FM10K_RETA(0, i), reta);
1010     }
1011 }
1012 
1013 static int fm10k_get_reta(struct net_device *netdev, u32 *indir)
1014 {
1015     struct fm10k_intfc *interface = netdev_priv(netdev);
1016     int i;
1017 
1018     if (!indir)
1019         return 0;
1020 
1021     for (i = 0; i < FM10K_RETA_SIZE; i++, indir += 4) {
1022         u32 reta = interface->reta[i];
1023 
1024         indir[0] = (reta << 24) >> 24;
1025         indir[1] = (reta << 16) >> 24;
1026         indir[2] = (reta <<  8) >> 24;
1027         indir[3] = (reta) >> 24;
1028     }
1029 
1030     return 0;
1031 }
1032 
1033 static int fm10k_set_reta(struct net_device *netdev, const u32 *indir)
1034 {
1035     struct fm10k_intfc *interface = netdev_priv(netdev);
1036     int i;
1037     u16 rss_i;
1038 
1039     if (!indir)
1040         return 0;
1041 
1042     /* Verify user input. */
1043     rss_i = interface->ring_feature[RING_F_RSS].indices;
1044     for (i = fm10k_get_reta_size(netdev); i--;) {
1045         if (indir[i] < rss_i)
1046             continue;
1047         return -EINVAL;
1048     }
1049 
1050     fm10k_write_reta(interface, indir);
1051 
1052     return 0;
1053 }
1054 
1055 static u32 fm10k_get_rssrk_size(struct net_device __always_unused *netdev)
1056 {
1057     return FM10K_RSSRK_SIZE * FM10K_RSSRK_ENTRIES_PER_REG;
1058 }
1059 
1060 static int fm10k_get_rssh(struct net_device *netdev, u32 *indir, u8 *key,
1061               u8 *hfunc)
1062 {
1063     struct fm10k_intfc *interface = netdev_priv(netdev);
1064     int i, err;
1065 
1066     if (hfunc)
1067         *hfunc = ETH_RSS_HASH_TOP;
1068 
1069     err = fm10k_get_reta(netdev, indir);
1070     if (err || !key)
1071         return err;
1072 
1073     for (i = 0; i < FM10K_RSSRK_SIZE; i++, key += 4)
1074         *(__le32 *)key = cpu_to_le32(interface->rssrk[i]);
1075 
1076     return 0;
1077 }
1078 
1079 static int fm10k_set_rssh(struct net_device *netdev, const u32 *indir,
1080               const u8 *key, const u8 hfunc)
1081 {
1082     struct fm10k_intfc *interface = netdev_priv(netdev);
1083     struct fm10k_hw *hw = &interface->hw;
1084     int i, err;
1085 
1086     /* We do not allow change in unsupported parameters */
1087     if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)
1088         return -EOPNOTSUPP;
1089 
1090     err = fm10k_set_reta(netdev, indir);
1091     if (err || !key)
1092         return err;
1093 
1094     for (i = 0; i < FM10K_RSSRK_SIZE; i++, key += 4) {
1095         u32 rssrk = le32_to_cpu(*(__le32 *)key);
1096 
1097         if (interface->rssrk[i] == rssrk)
1098             continue;
1099 
1100         interface->rssrk[i] = rssrk;
1101         fm10k_write_reg(hw, FM10K_RSSRK(0, i), rssrk);
1102     }
1103 
1104     return 0;
1105 }
1106 
1107 static unsigned int fm10k_max_channels(struct net_device *dev)
1108 {
1109     struct fm10k_intfc *interface = netdev_priv(dev);
1110     unsigned int max_combined = interface->hw.mac.max_queues;
1111     u8 tcs = netdev_get_num_tc(dev);
1112 
1113     /* For QoS report channels per traffic class */
1114     if (tcs > 1)
1115         max_combined = BIT((fls(max_combined / tcs) - 1));
1116 
1117     return max_combined;
1118 }
1119 
1120 static void fm10k_get_channels(struct net_device *dev,
1121                    struct ethtool_channels *ch)
1122 {
1123     struct fm10k_intfc *interface = netdev_priv(dev);
1124 
1125     /* report maximum channels */
1126     ch->max_combined = fm10k_max_channels(dev);
1127 
1128     /* report info for other vector */
1129     ch->max_other = NON_Q_VECTORS;
1130     ch->other_count = ch->max_other;
1131 
1132     /* record RSS queues */
1133     ch->combined_count = interface->ring_feature[RING_F_RSS].indices;
1134 }
1135 
1136 static int fm10k_set_channels(struct net_device *dev,
1137                   struct ethtool_channels *ch)
1138 {
1139     struct fm10k_intfc *interface = netdev_priv(dev);
1140     unsigned int count = ch->combined_count;
1141 
1142     /* verify they are not requesting separate vectors */
1143     if (!count || ch->rx_count || ch->tx_count)
1144         return -EINVAL;
1145 
1146     /* verify other_count has not changed */
1147     if (ch->other_count != NON_Q_VECTORS)
1148         return -EINVAL;
1149 
1150     /* verify the number of channels does not exceed hardware limits */
1151     if (count > fm10k_max_channels(dev))
1152         return -EINVAL;
1153 
1154     interface->ring_feature[RING_F_RSS].limit = count;
1155 
1156     /* use setup TC to update any traffic class queue mapping */
1157     return fm10k_setup_tc(dev, netdev_get_num_tc(dev));
1158 }
1159 
1160 static const struct ethtool_ops fm10k_ethtool_ops = {
1161     .supported_coalesce_params = ETHTOOL_COALESCE_USECS |
1162                      ETHTOOL_COALESCE_USE_ADAPTIVE,
1163     .get_strings        = fm10k_get_strings,
1164     .get_sset_count     = fm10k_get_sset_count,
1165     .get_ethtool_stats      = fm10k_get_ethtool_stats,
1166     .get_drvinfo        = fm10k_get_drvinfo,
1167     .get_link       = ethtool_op_get_link,
1168     .get_pauseparam     = fm10k_get_pauseparam,
1169     .set_pauseparam     = fm10k_set_pauseparam,
1170     .get_msglevel       = fm10k_get_msglevel,
1171     .set_msglevel       = fm10k_set_msglevel,
1172     .get_ringparam      = fm10k_get_ringparam,
1173     .set_ringparam      = fm10k_set_ringparam,
1174     .get_coalesce       = fm10k_get_coalesce,
1175     .set_coalesce       = fm10k_set_coalesce,
1176     .get_rxnfc      = fm10k_get_rxnfc,
1177     .set_rxnfc      = fm10k_set_rxnfc,
1178     .get_regs               = fm10k_get_regs,
1179     .get_regs_len           = fm10k_get_regs_len,
1180     .self_test      = fm10k_self_test,
1181     .get_priv_flags     = fm10k_get_priv_flags,
1182     .set_priv_flags     = fm10k_set_priv_flags,
1183     .get_rxfh_indir_size    = fm10k_get_reta_size,
1184     .get_rxfh_key_size  = fm10k_get_rssrk_size,
1185     .get_rxfh       = fm10k_get_rssh,
1186     .set_rxfh       = fm10k_set_rssh,
1187     .get_channels       = fm10k_get_channels,
1188     .set_channels       = fm10k_set_channels,
1189     .get_ts_info        = ethtool_op_get_ts_info,
1190 };
1191 
1192 void fm10k_set_ethtool_ops(struct net_device *dev)
1193 {
1194     dev->ethtool_ops = &fm10k_ethtool_ops;
1195 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!