| blob | 5ff6caa83948c2c14a6b85070ddaba54e0c50c3a |
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2013 - 2018 Intel Corporation. */
4 /* ethtool support for i40e */
10 /* The stat_string is expected to be a format string formatted using
11 * vsnprintf by i40e_add_stat_strings. Every member of a stats array
12 * should use the same format specifiers as they will be formatted
13 * using the same variadic arguments.
14 */
18 };
20 #define I40E_STAT(_type, _name, _stat) { \
21 .stat_string = _name, \
22 .sizeof_stat = FIELD_SIZEOF(_type, _stat), \
23 .stat_offset = offsetof(_type, _stat) \
24 }
26 #define I40E_NETDEV_STAT(_net_stat) \
27 I40E_STAT(struct rtnl_link_stats64, #_net_stat, _net_stat)
28 #define I40E_PF_STAT(_name, _stat) \
29 I40E_STAT(struct i40e_pf, _name, _stat)
30 #define I40E_VSI_STAT(_name, _stat) \
31 I40E_STAT(struct i40e_vsi, _name, _stat)
32 #define I40E_VEB_STAT(_name, _stat) \
33 I40E_STAT(struct i40e_veb, _name, _stat)
34 #define I40E_PFC_STAT(_name, _stat) \
35 I40E_STAT(struct i40e_pfc_stats, _name, _stat)
49 };
64 };
71 };
86 };
88 /* These PF_STATs might look like duplicates of some NETDEV_STATs,
89 * but they are separate. This device supports Virtualization, and
90 * as such might have several netdevs supporting VMDq and FCoE going
91 * through a single port. The NETDEV_STATs are for individual netdevs
92 * seen at the top of the stack, and the PF_STATs are for the physical
93 * function at the bottom of the stack hosting those netdevs.
94 *
95 * The PF_STATs are appended to the netdev stats only when ethtool -S
96 * is queried on the base PF netdev, not on the VMDq or FCoE netdev.
97 */
151 /* LPI stats */
156 };
159 u64 priority_xon_rx;
160 u64 priority_xoff_rx;
161 u64 priority_xon_tx;
162 u64 priority_xoff_tx;
163 u64 priority_xon_2_xoff;
164 };
172 };
174 /* We use num_tx_queues here as a proxy for the maximum number of queues
175 * available because we always allocate queues symmetrically.
176 */
177 #define I40E_MAX_NUM_QUEUES(n) ((n)->num_tx_queues)
178 #define I40E_QUEUE_STATS_LEN(n) \
179 (I40E_MAX_NUM_QUEUES(n) \
181 * (sizeof(struct i40e_queue_stats) / sizeof(u64)))
182 #define I40E_GLOBAL_STATS_LEN ARRAY_SIZE(i40e_gstrings_stats)
183 #define I40E_NETDEV_STATS_LEN ARRAY_SIZE(i40e_gstrings_net_stats)
184 #define I40E_MISC_STATS_LEN ARRAY_SIZE(i40e_gstrings_misc_stats)
185 #define I40E_VSI_STATS_LEN(n) (I40E_NETDEV_STATS_LEN + \
186 I40E_MISC_STATS_LEN + \
187 I40E_QUEUE_STATS_LEN((n)))
189 #define I40E_PFC_STATS_LEN (ARRAY_SIZE(i40e_gstrings_pfc_stats) * \
190 I40E_MAX_USER_PRIORITY)
192 #define I40E_VEB_STATS_LEN (ARRAY_SIZE(i40e_gstrings_veb_stats) + \
193 (ARRAY_SIZE(i40e_gstrings_veb_tc_stats) * \
194 I40E_MAX_TRAFFIC_CLASS))
196 #define I40E_PF_STATS_LEN(n) (I40E_GLOBAL_STATS_LEN + \
197 I40E_PFC_STATS_LEN + \
198 I40E_VEB_STATS_LEN + \
199 I40E_VSI_STATS_LEN((n)))
203 I40E_ETH_TEST_EEPROM,
204 I40E_ETH_TEST_INTR,
205 I40E_ETH_TEST_LINK,
206 };
212 "Link test (on/offline)"
213 };
215 #define I40E_TEST_LEN (sizeof(i40e_gstrings_test) / ETH_GSTRING_LEN)
219 u64 flag;
221 };
223 #define I40E_PRIV_FLAG(_name, _flag, _read_only) { \
224 .flag_string = _name, \
225 .flag = _flag, \
226 .read_only = _read_only, \
227 }
230 /* NOTE: MFP setting cannot be changed */
242 };
244 #define I40E_PRIV_FLAGS_STR_LEN ARRAY_SIZE(i40e_gstrings_priv_flags)
246 /* Private flags with a global effect, restricted to PF 0 */
250 };
252 #define I40E_GL_PRIV_FLAGS_STR_LEN ARRAY_SIZE(i40e_gl_gstrings_priv_flags)
254 /**
255 * i40e_partition_setting_complaint - generic complaint for MFP restriction
256 * @pf: the PF struct
257 **/
259 {
261 "The link settings are allowed to be changed only from the first partition of a given port. Please switch to the first partition in order to change the setting.\n");
262 }
264 /**
265 * i40e_phy_type_to_ethtool - convert the phy_types to ethtool link modes
266 * @pf: PF struct with phy_types
267 * @ks: ethtool link ksettings struct to fill out
268 *
269 **/
272 {
290 }
291 }
302 }
309 }
322 }
329 }
336 }
348 }
355 }
362 }
370 }
378 }
379 /* need to add 25G PHY types */
386 }
393 }
401 }
409 }
410 /* need to add new 10G PHY types */
418 }
425 }
432 }
441 }
442 /* Autoneg PHY types */
466 Autoneg);
468 Autoneg);
469 }
470 }
472 /**
473 * i40e_get_settings_link_up - Get the Link settings for when link is up
474 * @hw: hw structure
475 * @ks: ethtool ksettings to fill in
476 * @netdev: network interface device structure
477 * @pf: pointer to physical function struct
478 **/
483 {
488 /* Initialize supported and advertised settings based on phy settings */
540 I40E_MODULE_TYPE_1000BASE_SX ||
542 I40E_MODULE_TYPE_1000BASE_LX) {
546 I40E_LINK_SPEED_1GB)
549 }
614 I40E_LINK_SPEED_100MB)
617 }
675 /* if we got here and link is up something bad is afoot */
679 }
681 /* Now that we've worked out everything that could be supported by the
682 * current PHY type, get what is supported by the NVM and intersect
683 * them to get what is truly supported
684 */
689 /* Set speed and duplex */
711 }
713 }
715 /**
716 * i40e_get_settings_link_down - Get the Link settings for when link is down
717 * @hw: hw structure
718 * @ks: ethtool ksettings to fill in
719 * @pf: pointer to physical function struct
720 *
721 * Reports link settings that can be determined when link is down
722 **/
726 {
727 /* link is down and the driver needs to fall back on
728 * supported phy types to figure out what info to display
729 */
732 /* With no link speed and duplex are unknown */
735 }
737 /**
738 * i40e_get_link_ksettings - Get Link Speed and Duplex settings
739 * @netdev: network interface device structure
740 * @ks: ethtool ksettings
741 *
742 * Reports speed/duplex settings based on media_type
743 **/
746 {
758 else
761 /* Now set the settings that don't rely on link being up/down */
762 /* Set autoneg settings */
766 /* Set media type settings */
773 Backplane);
795 }
797 /* Set flow control settings */
806 Asym_Pause);
811 Asym_Pause);
816 Asym_Pause);
818 }
821 }
823 /**
824 * i40e_set_link_ksettings - Set Speed and Duplex
825 * @netdev: network interface device structure
826 * @ks: ethtool ksettings
827 *
828 * Set speed/duplex per media_types advertised/forced
829 **/
832 {
845 u8 autoneg;
847 /* Changing port settings is not supported if this isn't the
848 * port's controlling PF
849 */
853 }
870 }
872 /* copy the ksettings to copy_ks to avoid modifying the origin */
875 /* save autoneg out of ksettings */
878 /* get our own copy of the bits to check against */
885 /* Get link modes supported by hardware and check against modes
886 * requested by the user. Return an error if unsupported mode was set.
887 */
890 __ETHTOOL_LINK_MODE_MASK_NBITS))
893 /* set autoneg back to what it currently is */
896 /* If copy_ks.base and safe_ks.base are not the same now, then they are
897 * trying to set something that we do not support.
898 */
904 timeout--;
908 }
910 /* Get the current phy config */
912 NULL);
916 }
918 /* Copy abilities to config in case autoneg is not
919 * set below
920 */
924 /* Check autoneg */
926 /* If autoneg was not already enabled */
928 /* If autoneg is not supported, return error */
930 supported,
931 Autoneg)) {
935 }
936 /* Autoneg is allowed to change */
938 I40E_AQ_PHY_ENABLE_AN;
940 }
942 /* If autoneg is currently enabled */
944 /* If autoneg is supported 10GBASE_T is the only PHY
945 * that can disable it, so otherwise return error
946 */
948 supported,
949 Autoneg) &&
951 I40E_PHY_TYPE_10GBASE_T) {
955 }
956 /* Autoneg is allowed to change */
960 }
961 }
1006 /* If speed didn't get set, set it to what it currently is.
1007 * This is needed because if advertise is 0 (as it is when autoneg
1008 * is disabled) then speed won't get set.
1009 */
1013 /* copy over the rest of the abilities */
1020 I40E_AQ_PHY_FEC_CONFIG_MASK;
1022 /* save the requested speeds */
1024 /* set link and auto negotiation so changes take effect */
1026 /* If link is up put link down */
1028 /* Tell the OS link is going down, the link will go
1029 * back up when fw says it is ready asynchronously
1030 */
1034 }
1036 /* make the aq call */
1045 }
1056 }
1058 done:
1062 }
1065 {
1066 /* restart autonegotiation */
1079 }
1082 }
1084 /**
1085 * i40e_get_pauseparam - Get Flow Control status
1086 * @netdev: netdevice structure
1087 * @pause: buffer to return pause parameters
1088 *
1089 * Return tx/rx-pause status
1090 **/
1093 {
1104 /* PFC enabled so report LFC as off */
1109 }
1118 }
1119 }
1121 /**
1122 * i40e_set_pauseparam - Set Flow Control parameter
1123 * @netdev: network interface device structure
1124 * @pause: return tx/rx flow control status
1125 **/
1128 {
1136 i40e_status status;
1137 u8 aq_failures;
1140 /* Changing the port's flow control is not supported if this isn't the
1141 * port's controlling PF
1142 */
1146 }
1155 }
1157 /* If we have link and don't have autoneg */
1160 /* Send message that it might not necessarily work*/
1161 netdev_info(netdev, "Autoneg did not complete so changing settings may not result in an actual change.\n");
1162 }
1168 }
1178 else
1181 /* Tell the OS link is going down, the link will go back up when fw
1182 * says it is ready asynchronously
1183 */
1188 /* Set the fc mode and only restart an if link is up*/
1196 }
1202 }
1208 }
1211 /* Give it a little more time to try to come back */
1215 }
1218 }
1221 {
1230 }
1233 {
1239 else
1241 }
1244 {
1252 }
1256 {
1262 u32 reg;
1264 /* Tell ethtool which driver-version-specific regs output we have.
1265 *
1266 * At some point, if we have ethtool doing special formatting of
1267 * this data, it will rely on this version number to know how to
1268 * interpret things. Hence, this needs to be updated if/when the
1269 * diags register table is changed.
1270 */
1273 /* loop through the diags reg table for what to print */
1280 }
1281 }
1283 }
1287 {
1295 u32 magic;
1297 #define I40E_NVM_SECTOR_SIZE 4096
1301 /* check for NVMUpdate access method */
1307 /* make sure it is the right magic for NVMUpdate */
1313 else
1324 }
1326 /* normal ethtool get_eeprom support */
1339 }
1349 }
1357 offset);
1363 offset);
1370 }
1371 }
1375 free_buff:
1378 }
1381 {
1384 u32 val;
1386 #define X722_EEPROM_SCOPE_LIMIT 0x5B9FFF
1390 }
1394 /* register returns value in power of 2, 64Kbyte chunks. */
1397 }
1401 {
1408 u32 magic;
1410 /* normal ethtool set_eeprom is not supported */
1414 /* check for NVMUpdate access method */
1420 else
1431 }
1435 {
1450 }
1454 {
1467 }
1470 {
1475 }
1478 }
1482 {
1489 u16 tx_alloc_queue_pairs;
1505 }
1510 /* if nothing to do return success */
1516 timeout--;
1520 }
1523 /* simple case - set for the next time the netdev is started */
1529 }
1531 }
1533 /* We can't just free everything and then setup again,
1534 * because the ISRs in MSI-X mode get passed pointers
1535 * to the Tx and Rx ring structs.
1536 */
1538 /* alloc updated Tx and XDP Tx resources */
1550 }
1558 /* the desc and bi pointers will be reallocated in the
1559 * setup call
1560 */
1566 i--;
1570 }
1575 }
1576 }
1577 }
1579 /* alloc updated Rx resources */
1589 }
1592 u16 unused;
1594 /* clone ring and setup updated count */
1597 /* the desc and bi pointers will be reallocated in the
1598 * setup call
1599 */
1602 /* Clear cloned XDP RX-queue info before setup call */
1604 /* this is to allow wr32 to have something to write to
1605 * during early allocation of Rx buffers
1606 */
1612 /* now allocate the Rx buffers to make sure the OS
1613 * has enough memory, any failure here means abort
1614 */
1617 rx_unwind:
1626 }
1627 }
1628 }
1630 /* Bring interface down, copy in the new ring info,
1631 * then restore the interface
1632 */
1640 }
1641 }
1644 }
1649 /* get the real tail offset */
1651 /* this is to fake out the allocation routine
1652 * into thinking it has to realloc everything
1653 * but the recycling logic will let us re-use
1654 * the buffers allocated above
1655 */
1659 /* do a struct copy */
1661 }
1664 }
1668 free_tx:
1669 /* error cleanup if the Rx allocations failed after getting Tx */
1674 }
1677 }
1679 done:
1683 }
1685 /**
1686 * i40e_get_stats_count - return the stats count for a device
1687 * @netdev: the netdev to return the count for
1688 *
1689 * Returns the total number of statistics for this netdev. Note that even
1690 * though this is a function, it is required that the count for a specific
1691 * netdev must never change. Basing the count on static values such as the
1692 * maximum number of queues or the device type is ok. However, the API for
1693 * obtaining stats is *not* safe against changes based on non-static
1694 * values such as the *current* number of queues, or runtime flags.
1695 *
1696 * If a statistic is not always enabled, return it as part of the count
1697 * anyways, always return its string, and report its value as zero.
1698 **/
1700 {
1707 else
1709 }
1712 {
1727 }
1728 }
1730 /**
1731 * i40e_add_one_ethtool_stat - copy the stat into the supplied buffer
1732 * @data: location to store the stat value
1733 * @pointer: basis for where to copy from
1734 * @stat: the stat definition
1735 *
1736 * Copies the stat data defined by the pointer and stat structure pair into
1737 * the memory supplied as data. Used to implement i40e_add_ethtool_stats.
1738 * If the pointer is null, data will be zero'd.
1739 */
1743 {
1747 /* ensure that the ethtool data buffer is zero'd for any stats
1748 * which don't have a valid pointer.
1749 */
1752 }
1772 }
1773 }
1775 /**
1776 * __i40e_add_ethtool_stats - copy stats into the ethtool supplied buffer
1777 * @data: ethtool stats buffer
1778 * @pointer: location to copy stats from
1779 * @stats: array of stats to copy
1780 * @size: the size of the stats definition
1781 *
1782 * Copy the stats defined by the stats array using the pointer as a base into
1783 * the data buffer supplied by ethtool. Updates the data pointer to point to
1784 * the next empty location for successive calls to __i40e_add_ethtool_stats.
1785 * If pointer is null, set the data values to zero and update the pointer to
1786 * skip these stats.
1787 **/
1792 {
1797 }
1799 /**
1800 * i40e_add_ethtool_stats - copy stats into ethtool supplied buffer
1801 * @data: ethtool stats buffer
1802 * @pointer: location where stats are stored
1803 * @stats: static const array of stat definitions
1804 *
1805 * Macro to ease the use of __i40e_add_ethtool_stats by taking a static
1806 * constant stats array and passing the ARRAY_SIZE(). This avoids typos by
1807 * ensuring that we pass the size associated with the given stats array.
1808 * Assumes that stats is an array.
1809 **/
1810 #define i40e_add_ethtool_stats(data, pointer, stats) \
1811 __i40e_add_ethtool_stats(data, pointer, stats, ARRAY_SIZE(stats))
1813 /**
1814 * i40e_get_pfc_stats - copy HW PFC statistics to formatted structure
1815 * @pf: the PF device structure
1816 * @i: the priority value to copy
1817 *
1818 * The PFC stats are found as arrays in pf->stats, which is not easy to pass
1819 * into i40e_add_ethtool_stats. Produce a formatted i40e_pfc_stats structure
1820 * of the PFC stats for the given priority.
1821 **/
1824 {
1825 #define I40E_GET_PFC_STAT(stat, priority) \
1826 .stat = pf->stats.stat[priority]
1834 };
1836 }
1838 /**
1839 * i40e_get_ethtool_stats - copy stat values into supplied buffer
1840 * @netdev: the netdev to collect stats for
1841 * @stats: ethtool stats command structure
1842 * @data: ethtool supplied buffer
1843 *
1844 * Copy the stats values for this netdev into the buffer. Expects data to be
1845 * pre-allocated to the size returned by i40e_get_stats_count.. Note that all
1846 * statistics must be copied in a static order, and the count must not change
1847 * for a given netdev. See i40e_get_stats_count for more details.
1848 *
1849 * If a statistic is not currently valid (such as a disabled queue), this
1850 * function reports its value as zero.
1851 **/
1854 {
1868 i40e_gstrings_net_stats);
1877 /* Bump the stat counter to skip these stats, and make
1878 * sure the memory is zero'd
1879 */
1885 }
1887 /* process Tx ring statistics */
1895 /* Rx ring is the 2nd half of the queue pair */
1903 }
1911 /* If veb stats aren't enabled, pass NULL instead of the veb so that
1912 * we initialize stats to zero and update the data pointer
1913 * intelligently
1914 */
1916 i40e_gstrings_veb_stats);
1920 i40e_gstrings_veb_tc_stats);
1928 }
1930 check_data_pointer:
1933 }
1935 /**
1936 * __i40e_add_stat_strings - copy stat strings into ethtool buffer
1937 * @p: ethtool supplied buffer
1938 * @stats: stat definitions array
1939 * @size: size of the stats array
1940 *
1941 * Format and copy the strings described by stats into the buffer pointed at
1942 * by p.
1943 **/
1946 {
1956 }
1957 }
1959 /**
1960 * 40e_add_stat_strings - copy stat strings into ethtool buffer
1961 * @p: ethtool supplied buffer
1962 * @stats: stat definitions array
1963 *
1964 * Format and copy the strings described by the const static stats value into
1965 * the buffer pointed at by p. Assumes that stats can have ARRAY_SIZE called
1966 * for it.
1967 **/
1968 #define i40e_add_stat_strings(p, stats, ...) \
1969 __i40e_add_stat_strings(p, stats, ARRAY_SIZE(stats), ## __VA_ARGS__)
1971 /**
1972 * i40e_get_stat_strings - copy stat strings into supplied buffer
1973 * @netdev: the netdev to collect strings for
1974 * @data: supplied buffer to copy strings into
1975 *
1976 * Copy the strings related to stats for this netdev. Expects data to be
1977 * pre-allocated with the size reported by i40e_get_stats_count. Note that the
1978 * strings must be copied in a static order and the total count must not
1979 * change for a given netdev. See i40e_get_stats_count for more details.
1980 **/
1982 {
2002 }
2018 }
2021 {
2032 }
2039 }
2040 }
2044 {
2058 }
2059 }
2063 {
2066 /* only report HW timestamping if PTP is enabled */
2071 SOF_TIMESTAMPING_RX_SOFTWARE |
2072 SOF_TIMESTAMPING_SOFTWARE |
2073 SOF_TIMESTAMPING_TX_HARDWARE |
2074 SOF_TIMESTAMPING_RX_HARDWARE |
2075 SOF_TIMESTAMPING_RAW_HARDWARE;
2079 else
2100 }
2103 {
2106 i40e_status status;
2115 }
2119 else
2123 }
2126 {
2134 }
2137 {
2144 /* forcebly clear the NVM Update state machine */
2148 }
2151 {
2159 I40E_PFINT_DYN_CTL0_SWINT_TRIG_MASK |
2160 I40E_PFINT_DYN_CTL0_ITR_INDX_MASK |
2161 I40E_PFINT_DYN_CTL0_SW_ITR_INDX_ENA_MASK |
2162 I40E_PFINT_DYN_CTL0_SW_ITR_INDX_MASK));
2167 }
2170 {
2178 }
2181 {
2183 }
2187 {
2193 /* Offline tests */
2200 "Please take active VFs and Netqueues offline and restart the adapter before running NIC diagnostics\n");
2208 }
2210 /* If the device is online then take it offline */
2212 /* indicate we're in test mode */
2214 else
2215 /* This reset does not affect link - if it is
2216 * changed to a type of reset that does affect
2217 * link then the following link test would have
2218 * to be moved to before the reset
2219 */
2231 /* run reg test last, a reset is required after it */
2241 /* Online tests */
2247 /* Offline only tests, not run in online; pass by default */
2251 }
2253 skip_ol_tests:
2256 }
2260 {
2264 u16 wol_nvm_bits;
2266 /* NVM bit on means WoL disabled for the port */
2274 }
2275 }
2277 /**
2278 * i40e_set_wol - set the WakeOnLAN configuration
2279 * @netdev: the netdev in question
2280 * @wol: the ethtool WoL setting data
2281 **/
2283 {
2288 u16 wol_nvm_bits;
2290 /* WoL not supported if this isn't the controlling PF on the port */
2294 }
2299 /* NVM bit on means WoL disabled for the port */
2304 /* only magic packet is supported */
2308 /* is this a new value? */
2312 }
2315 }
2319 {
2325 u16 temp_status;
2334 NULL);
2338 }
2343 else
2349 else
2358 I40E_PHY_LED_MODE_ORIG));
2361 }
2365 }
2368 else
2370 }
2372 /* NOTE: i40e hardware uses a conversion factor of 2 for Interrupt
2373 * Throttle Rate (ITR) ie. ITR(1) = 2us ITR(10) = 20 us, and also
2374 * 125us (8000 interrupts per second) == ITR(62)
2375 */
2377 /**
2378 * __i40e_get_coalesce - get per-queue coalesce settings
2379 * @netdev: the netdev to check
2380 * @ec: ethtool coalesce data structure
2381 * @queue: which queue to pick
2382 *
2383 * Gets the per-queue settings for coalescence. Specifically Rx and Tx usecs
2384 * are per queue. If queue is <0 then we default to queue 0 as the
2385 * representative value.
2386 **/
2390 {
2398 /* rx and tx usecs has per queue value. If user doesn't specify the
2399 * queue, return queue 0's value to represent.
2400 */
2418 /* we use the _usecs_high to store/set the interrupt rate limit
2419 * that the hardware supports, that almost but not quite
2420 * fits the original intent of the ethtool variable,
2421 * the rx_coalesce_usecs_high limits total interrupts
2422 * per second from both tx/rx sources.
2423 */
2428 }
2430 /**
2431 * i40e_get_coalesce - get a netdev's coalesce settings
2432 * @netdev: the netdev to check
2433 * @ec: ethtool coalesce data structure
2434 *
2435 * Gets the coalesce settings for a particular netdev. Note that if user has
2436 * modified per-queue settings, this only guarantees to represent queue 0. See
2437 * __i40e_get_coalesce for more details.
2438 **/
2441 {
2443 }
2445 /**
2446 * i40e_get_per_queue_coalesce - gets coalesce settings for particular queue
2447 * @netdev: netdev structure
2448 * @ec: ethtool's coalesce settings
2449 * @queue: the particular queue to read
2450 *
2451 * Will read a specific queue's coalesce settings
2452 **/
2455 {
2457 }
2459 /**
2460 * i40e_set_itr_per_queue - set ITR values for specific queue
2461 * @vsi: the VSI to set values for
2462 * @ec: coalesce settings from ethtool
2463 * @queue: the queue to modify
2464 *
2465 * Change the ITR settings for a specific queue.
2466 **/
2470 {
2476 u16 intrl;
2485 else
2490 else
2499 /* The interrupt handler itself will take care of programming
2500 * the Tx and Rx ITR values based on the values we have entered
2501 * into the q_vector, no need to write the values now.
2502 */
2506 }
2508 /**
2509 * __i40e_set_coalesce - set coalesce settings for particular queue
2510 * @netdev: the netdev to change
2511 * @ec: ethtool coalesce settings
2512 * @queue: the queue to change
2513 *
2514 * Sets the coalesce settings for a particular queue.
2515 **/
2519 {
2539 }
2544 /* tx_coalesce_usecs_high is ignored, use rx-usecs-high instead */
2548 }
2554 }
2558 netif_info(pf, drv, netdev, "RX interrupt moderation cannot be changed if adaptive-rx is enabled.\n");
2560 }
2565 }
2569 netif_info(pf, drv, netdev, "TX interrupt moderation cannot be changed if adaptive-tx is enabled.\n");
2571 }
2576 }
2589 }
2591 /* rx and tx usecs has per queue value. If user doesn't specify the
2592 * queue, apply to all queues.
2593 */
2599 }
2602 }
2604 /**
2605 * i40e_set_coalesce - set coalesce settings for every queue on the netdev
2606 * @netdev: the netdev to change
2607 * @ec: ethtool coalesce settings
2608 *
2609 * This will set each queue to the same coalesce settings.
2610 **/
2613 {
2615 }
2617 /**
2618 * i40e_set_per_queue_coalesce - set specific queue's coalesce settings
2619 * @netdev: the netdev to change
2620 * @ec: ethtool's coalesce settings
2621 * @queue: the queue to change
2622 *
2623 * Sets the specified queue's coalesce settings.
2624 **/
2627 {
2629 }
2631 /**
2632 * i40e_get_rss_hash_opts - Get RSS hash Input Set for each flow type
2633 * @pf: pointer to the physical function struct
2634 * @cmd: ethtool rxnfc command
2635 *
2636 * Returns Success if the flow is supported, else Invalid Input.
2637 **/
2639 {
2669 /* Default is src/dest for IP, no matter the L4 hashing */
2674 }
2676 /* Read flow based hash input set register */
2679 flow_pctype)) |
2682 }
2684 /* Process bits of hash input set */
2703 }
2704 }
2707 }
2709 /**
2710 * i40e_check_mask - Check whether a mask field is set
2711 * @mask: the full mask value
2712 * @field: mask of the field to check
2713 *
2714 * If the given mask is fully set, return positive value. If the mask for the
2715 * field is fully unset, return zero. Otherwise return a negative error code.
2716 **/
2718 {
2725 else
2727 }
2729 /**
2730 * i40e_parse_rx_flow_user_data - Deconstruct user-defined data
2731 * @fsp: pointer to rx flow specification
2732 * @data: pointer to userdef data structure for storage
2733 *
2734 * Read the user-defined data and deconstruct the value into a structure. No
2735 * other code should read the user-defined data, so as to ensure that every
2736 * place consistently reads the value correctly.
2737 *
2738 * The user-defined field is a 64bit Big Endian format value, which we
2739 * deconstruct by reading bits or bit fields from it. Single bit flags shall
2740 * be defined starting from the highest bits, while small bit field values
2741 * shall be defined starting from the lowest bits.
2742 *
2743 * Returns 0 if the data is valid, and non-zero if the userdef data is invalid
2744 * and the filter should be rejected. The data structure will always be
2745 * modified even if FLOW_EXT is not set.
2746 *
2747 **/
2750 {
2754 /* Zero memory first so it's always consistent. */
2763 #define I40E_USERDEF_FLEX_WORD GENMASK_ULL(15, 0)
2764 #define I40E_USERDEF_FLEX_OFFSET GENMASK_ULL(31, 16)
2765 #define I40E_USERDEF_FLEX_FILTER GENMASK_ULL(31, 0)
2775 }
2778 }
2780 /**
2781 * i40e_fill_rx_flow_user_data - Fill in user-defined data field
2782 * @fsp: pointer to rx_flow specification
2783 * @data: pointer to return userdef data
2784 *
2785 * Reads the userdef data structure and properly fills in the user defined
2786 * fields of the rx_flow_spec.
2787 **/
2790 {
2797 }
2804 }
2806 /**
2807 * i40e_get_ethtool_fdir_all - Populates the rule count of a command
2808 * @pf: Pointer to the physical function struct
2809 * @cmd: The command to get or set Rx flow classification rules
2810 * @rule_locs: Array of used rule locations
2811 *
2812 * This function populates both the total and actual rule count of
2813 * the ethtool flow classification command
2814 *
2815 * Returns 0 on success or -EMSGSIZE if entry not found
2816 **/
2820 {
2825 /* report total rule count */
2834 cnt++;
2835 }
2840 }
2842 /**
2843 * i40e_get_ethtool_fdir_entry - Look up a filter based on Rx flow
2844 * @pf: Pointer to the physical function struct
2845 * @cmd: The command to get or set Rx flow classification rules
2846 *
2847 * This function looks up a filter based on the Rx flow classification
2848 * command and fills the flow spec info for it if found
2849 *
2850 * Returns 0 on success or -EINVAL if filter not found
2851 **/
2854 {
2860 u64 input_set;
2861 u16 index;
2867 }
2877 }
2879 /* Reverse the src and dest notion, since the HW views them from
2880 * Tx perspective where as the user expects it from Rx filter view.
2881 */
2901 /* If we have stored a filter with a flow type not listed here
2902 * it is almost certainly a driver bug. WARN(), and then
2903 * assign the input_set as if all fields are enabled to avoid
2904 * reading unassigned memory.
2905 */
2910 }
2914 no_input_set:
2929 else
2937 /* VFs are zero-indexed by the driver, but ethtool
2938 * expects them to be one-indexed, so add one here
2939 */
2944 }
2945 }
2951 }
2956 }
2958 /**
2959 * i40e_get_rxnfc - command to get RX flow classification rules
2960 * @netdev: network interface device structure
2961 * @cmd: ethtool rxnfc command
2962 * @rule_locs: pointer to store rule data
2963 *
2964 * Returns Success if the command is supported.
2965 **/
2968 {
2984 /* report total rule count */
2996 }
2999 }
3001 /**
3002 * i40e_get_rss_hash_bits - Read RSS Hash bits from register
3003 * @nfc: pointer to user request
3004 * @i_setc: bits currently set
3005 *
3006 * Returns value of bits to be set per user request
3007 **/
3009 {
3015 else
3019 else
3030 /* Any other flow type are not supported here */
3032 }
3036 else
3040 else
3044 }
3046 /**
3047 * i40e_set_rss_hash_opt - Enable/Disable flow types for RSS hash
3048 * @pf: pointer to the physical function struct
3049 * @nfc: ethtool rxnfc command
3050 *
3051 * Returns Success if the flow input set is supported.
3052 **/
3054 {
3065 }
3067 /* RSS does not support anything other than hashing
3068 * to queues on src and dst IPs and ports
3069 */
3078 hena |=
3084 hena |=
3087 hena |=
3093 hena |=
3102 hena |=
3136 }
3140 flow_pctype)) |
3149 }
3156 }
3158 /**
3159 * i40e_update_ethtool_fdir_entry - Updates the fdir filter entry
3160 * @vsi: Pointer to the targeted VSI
3161 * @input: The filter to update or NULL to indicate deletion
3162 * @sw_idx: Software index to the filter
3163 * @cmd: The command to get or set Rx flow classification rules
3164 *
3165 * This function updates (or deletes) a Flow Director entry from
3166 * the hlist of the corresponding PF
3167 *
3168 * Returns 0 on success
3169 **/
3172 u16 sw_idx,
3174 {
3185 /* hash found, or no matching entry */
3189 }
3191 /* if there is an old rule occupying our place remove it */
3193 /* Remove this rule, since we're either deleting it, or
3194 * replacing it.
3195 */
3200 }
3202 /* If we weren't given an input, this is a delete, so just return the
3203 * error code indicating if there was an entry at the requested slot
3204 */
3208 /* Otherwise, install the new rule as requested */
3211 /* add filter to the list */
3214 else
3218 /* update counts */
3222 }
3224 /**
3225 * i40e_prune_flex_pit_list - Cleanup unused entries in FLX_PIT table
3226 * @pf: pointer to PF structure
3227 *
3228 * This function searches the list of filters and determines which FLX_PIT
3229 * entries are still required. It will prune any entries which are no longer
3230 * in use after the deletion.
3231 **/
3233 {
3237 /* First, we'll check the l3 table */
3248 }
3249 }
3251 /* If we didn't find the filter, then we can prune this entry
3252 * from the list.
3253 */
3257 }
3258 }
3260 /* Followed by the L4 table */
3265 /* Skip this filter if it's L3, since we already
3266 * checked those in the above loop
3267 */
3274 }
3275 }
3277 /* If we didn't find the filter, then we can prune this entry
3278 * from the list.
3279 */
3283 }
3284 }
3285 }
3287 /**
3288 * i40e_del_fdir_entry - Deletes a Flow Director filter entry
3289 * @vsi: Pointer to the targeted VSI
3290 * @cmd: The command to get or set Rx flow classification rules
3291 *
3292 * The function removes a Flow Director filter entry from the
3293 * hlist of the corresponding PF
3294 *
3295 * Returns 0 on success
3296 */
3299 {
3318 }
3320 /**
3321 * i40e_unused_pit_index - Find an unused PIT index for given list
3322 * @pf: the PF data structure
3323 *
3324 * Find the first unused flexible PIT index entry. We search both the L3 and
3325 * L4 flexible PIT lists so that the returned index is unique and unused by
3326 * either currently programmed L3 or L4 filters. We use a bit field as storage
3327 * to track which indexes are already used.
3328 **/
3330 {
3334 /* We need to make sure that the new index isn't in use by either L3
3335 * or L4 filters so that IP_USER_FLOW filters can program both L3 and
3336 * L4 to use the same index.
3337 */
3346 }
3348 /**
3349 * i40e_find_flex_offset - Find an existing flex src_offset
3350 * @flex_pit_list: L3 or L4 flex PIT list
3351 * @src_offset: new src_offset to find
3352 *
3353 * Searches the flex_pit_list for an existing offset. If no offset is
3354 * currently programmed, then this will return an ERR_PTR if there is no space
3355 * to add a new offset, otherwise it returns NULL.
3356 **/
3357 static
3359 u16 src_offset)
3360 {
3364 /* Search for the src_offset first. If we find a matching entry
3365 * already programmed, we can simply re-use it.
3366 */
3368 size++;
3371 }
3373 /* If we haven't found an entry yet, then the provided src offset has
3374 * not yet been programmed. We will program the src offset later on,
3375 * but we need to indicate whether there is enough space to do so
3376 * here. We'll make use of ERR_PTR for this purpose.
3377 */
3382 }
3384 /**
3385 * i40e_add_flex_offset - Add src_offset to flex PIT table list
3386 * @flex_pit_list: L3 or L4 flex PIT list
3387 * @src_offset: new src_offset to add
3388 * @pit_index: the PIT index to program
3389 *
3390 * This function programs the new src_offset to the list. It is expected that
3391 * i40e_find_flex_offset has already been tried and returned NULL, indicating
3392 * that this offset is not programmed, and that the list has enough space to
3393 * store another offset.
3394 *
3395 * Returns 0 on success, and negative value on error.
3396 **/
3398 u16 src_offset,
3399 u8 pit_index)
3400 {
3410 /* We need to insert this item such that the list is sorted by
3411 * src_offset in ascending order.
3412 */
3417 }
3419 /* If we found an entry with our offset already programmed we
3420 * can simply return here, after freeing the memory. However,
3421 * if the pit_index does not match we need to report an error.
3422 */
3426 /* If the PIT index is not the same we can't re-use
3427 * the entry, so we must report an error.
3428 */
3434 }
3435 }
3437 /* If we reached here, then we haven't yet added the item. This means
3438 * that we should add the item at the end of the list.
3439 */
3442 }
3444 /**
3445 * __i40e_reprogram_flex_pit - Re-program specific FLX_PIT table
3446 * @pf: Pointer to the PF structure
3447 * @flex_pit_list: list of flexible src offsets in use
3448 * @flex_pit_start: index to first entry for this section of the table
3449 *
3450 * In order to handle flexible data, the hardware uses a table of values
3451 * called the FLX_PIT table. This table is used to indicate which sections of
3452 * the input correspond to what PIT index values. Unfortunately, hardware is
3453 * very restrictive about programming this table. Entries must be ordered by
3454 * src_offset in ascending order, without duplicates. Additionally, unused
3455 * entries must be set to the unused index value, and must have valid size and
3456 * length according to the src_offset ordering.
3457 *
3458 * This function will reprogram the FLX_PIT register from a book-keeping
3459 * structure that we guarantee is already ordered correctly, and has no more
3460 * than 3 entries.
3461 *
3462 * To make things easier, we only support flexible values of one word length,
3463 * rather than allowing variable length flexible values.
3464 **/
3468 {
3473 /* First, loop over the list of flex PIT entries, and reprogram the
3474 * registers.
3475 */
3477 /* We have to be careful when programming values for the
3478 * largest SRC_OFFSET value. It is possible that adding
3479 * additional empty values at the end would overflow the space
3480 * for the SRC_OFFSET in the FLX_PIT register. To avoid this,
3481 * we check here and add the empty values prior to adding the
3482 * largest value.
3483 *
3484 * To determine this, we will use a loop from i+1 to 3, which
3485 * will determine whether the unused entries would have valid
3486 * SRC_OFFSET. Note that there cannot be extra entries past
3487 * this value, because the only valid values would have been
3488 * larger than I40E_MAX_FLEX_SRC_OFFSET, and thus would not
3489 * have been added to the list in the first place.
3490 */
3501 value);
3502 i++;
3503 }
3504 }
3506 /* Now, we can program the actual value into the table */
3512 i++;
3513 }
3515 /* In order to program the last entries in the table, we need to
3516 * determine the valid offset. If the list is empty, we'll just start
3517 * with 0. Otherwise, we'll start with the last item offset and add 1.
3518 * This ensures that all entries have valid sizes. If we don't do this
3519 * correctly, the hardware will disable flexible field parsing.
3520 */
3529 last_offset));
3530 }
3531 }
3533 /**
3534 * i40e_reprogram_flex_pit - Reprogram all FLX_PIT tables after input set change
3535 * @pf: pointer to the PF structure
3536 *
3537 * This function reprograms both the L3 and L4 FLX_PIT tables. See the
3538 * internal helper function for implementation details.
3539 **/
3541 {
3543 I40E_FLEX_PIT_IDX_START_L3);
3546 I40E_FLEX_PIT_IDX_START_L4);
3548 /* We also need to program the L3 and L4 GLQF ORT register */
3558 }
3560 /**
3561 * i40e_flow_str - Converts a flow_type into a human readable string
3562 * @fsp: the flow specification
3563 *
3564 * Currently only flow types we support are included here, and the string
3565 * value attempts to match what ethtool would use to configure this flow type.
3566 **/
3568 {
3580 }
3581 }
3583 /**
3584 * i40e_pit_index_to_mask - Return the FLEX mask for a given PIT index
3585 * @pit_index: PIT index to convert
3586 *
3587 * Returns the mask for a given PIT index. Will return 0 if the pit_index is
3588 * of range.
3589 **/
3591 {
3611 }
3612 }
3614 /**
3615 * i40e_print_input_set - Show changes between two input sets
3616 * @vsi: the vsi being configured
3617 * @old: the old input set
3618 * @new: the new input set
3619 *
3620 * Print the difference between old and new input sets by showing which series
3621 * of words are toggled on or off. Only displays the bits we actually support
3622 * changing.
3623 **/
3625 {
3665 /* Show change of flexible filter entries */
3673 i,
3676 }
3679 old);
3682 }
3684 /**
3685 * i40e_check_fdir_input_set - Check that a given rx_flow_spec mask is valid
3686 * @vsi: pointer to the targeted VSI
3687 * @fsp: pointer to Rx flow specification
3688 * @userdef: userdefined data from flow specification
3689 *
3690 * Ensures that a given ethtool_rx_flow_spec has a valid mask. Some support
3691 * for partial matches exists with a few limitations. First, hardware only
3692 * supports masking by word boundary (2 bytes) and not per individual bit.
3693 * Second, hardware is limited to using one mask for a flow type and cannot
3694 * use a separate mask for each filter.
3695 *
3696 * To support these limitations, if we already have a configured filter for
3697 * the specified type, this function enforces that new filters of the type
3698 * match the configured input set. Otherwise, if we do not have a filter of
3699 * the specified type, we allow the input set to be updated to match the
3700 * desired filter.
3701 *
3702 * To help ensure that administrators understand why filters weren't displayed
3703 * as supported, we print a diagnostic message displaying how the input set
3704 * would change and warning to delete the preexisting filters if required.
3705 *
3706 * Returns 0 on successful input set match, and a negative return code on
3707 * failure.
3708 **/
3712 {
3744 }
3746 /* Read the current input set from register memory. */
3750 /* Determine, if any, the required changes to the input set in order
3751 * to support the provided mask.
3752 *
3753 * Hardware only supports masking at word (2 byte) granularity and does
3754 * not support full bitwise masking. This implementation simplifies
3755 * even further and only supports fully enabled or fully disabled
3756 * masks for each field, even though we could split the ip4src and
3757 * ip4dst fields.
3758 */
3762 /* Fall through */
3767 /* IPv4 source address */
3772 else
3775 /* IPv4 destination address */
3780 else
3783 /* L4 source port */
3788 else
3791 /* L4 destination port */
3796 else
3799 /* Filtering on Type of Service is not supported. */
3807 /* IPv4 source address */
3812 else
3815 /* IPv4 destination address */
3820 else
3823 /* First 4 bytes of L4 header */
3828 else
3831 /* Filtering on Type of Service is not supported. */
3835 /* Filtering on IP version is not supported */
3839 /* Filtering on L4 protocol is not supported */
3846 }
3848 /* First, clear all flexible filter entries */
3851 /* If we have a flexible filter, try to add this offset to the correct
3852 * flexible filter PIT list. Once finished, we can update the mask.
3853 * If the src_offset changed, we will get a new mask value which will
3854 * trigger an input set change.
3855 */
3859 /* Flexible offset must be even, since the flexible payload
3860 * must be aligned on 2-byte boundary.
3861 */
3866 }
3870 /* FLX_PIT source offset value is only so large */
3875 }
3877 /* See if this offset has already been programmed. If we get
3878 * an ERR_PTR, then the filter is not safe to add. Otherwise,
3879 * if we get a NULL pointer, this means we will need to add
3880 * the offset.
3881 */
3883 src_offset);
3887 /* IP_USER_FLOW filters match both L4 (ICMP) and L3 (unknown)
3888 * packet types, and thus we need to program both L3 and L4
3889 * flexible values. These must have identical flexible index,
3890 * as otherwise we can't correctly program the input set. So
3891 * we'll find both an L3 and L4 index and make sure they are
3892 * the same.
3893 */
3895 l3_flex_pit =
3897 src_offset);
3902 /* If we already had a matching L4 entry, we
3903 * need to make sure that the L3 entry we
3904 * obtained uses the same index.
3905 */
3910 }
3913 }
3916 }
3917 }
3919 /* If we didn't find an existing flex offset, we need to
3920 * program a new one. However, we don't immediately program it
3921 * here because we will wait to program until after we check
3922 * that it is safe to change the input set.
3923 */
3929 }
3931 /* Update the mask with the new offset */
3933 }
3935 /* If the mask and flexible filter offsets for this filter match the
3936 * currently programmed values we don't need any input set change, so
3937 * this filter is safe to install.
3938 */
3948 }
3950 /* Hardware input sets are global across multiple ports, so even the
3951 * main port cannot change them when in MFP mode as this would impact
3952 * any filters on the other ports.
3953 */
3955 netif_err(pf, drv, vsi->netdev, "Cannot change Flow Director input sets while MFP is enabled\n");
3957 }
3959 /* This filter requires us to update the input set. However, hardware
3960 * only supports one input set per flow type, and does not support
3961 * separate masks for each filter. This means that we can only support
3962 * a single mask for all filters of a specific type.
3963 *
3964 * If we have preexisting filters, they obviously depend on the
3965 * current programmed input set. Display a diagnostic message in this
3966 * case explaining why the filter could not be accepted.
3967 */
3969 netif_err(pf, drv, vsi->netdev, "Cannot change input set for %s flows until %d preexisting filters are removed\n",
3973 }
3977 /* IP_USER_FLOW filters match both IPv4/Other and IPv4/Fragmented
3978 * frames. If we're programming the input set for IPv4/Other, we also
3979 * need to program the IPv4/Fragmented input set. Since we don't have
3980 * separate support, we'll always assume and enforce that the two flow
3981 * types must have matching input sets.
3982 */
3985 new_mask);
3987 /* Add the new offset and update table, if necessary */
3990 pit_index);
3996 src_offset,
3997 pit_index);
4000 }
4003 }
4006 }
4008 /**
4009 * i40e_match_fdir_filter - Return true of two filters match
4010 * @a: pointer to filter struct
4011 * @b: pointer to filter struct
4012 *
4013 * Returns true if the two filters match exactly the same criteria. I.e. they
4014 * match the same flow type and have the same parameters. We don't need to
4015 * check any input-set since all filters of the same flow type must use the
4016 * same input set.
4017 **/
4020 {
4021 /* The filters do not much if any of these criteria differ. */
4031 }
4033 /**
4034 * i40e_disallow_matching_filters - Check that new filters differ
4035 * @vsi: pointer to the targeted VSI
4036 * @input: new filter to check
4037 *
4038 * Due to hardware limitations, it is not possible for two filters that match
4039 * similar criteria to be programmed at the same time. This is true for a few
4040 * reasons:
4041 *
4042 * (a) all filters matching a particular flow type must use the same input
4043 * set, that is they must match the same criteria.
4044 * (b) different flow types will never match the same packet, as the flow type
4045 * is decided by hardware before checking which rules apply.
4046 * (c) hardware has no way to distinguish which order filters apply in.
4047 *
4048 * Due to this, we can't really support using the location data to order
4049 * filters in the hardware parsing. It is technically possible for the user to
4050 * request two filters matching the same criteria but which select different
4051 * queues. In this case, rather than keep both filters in the list, we reject
4052 * the 2nd filter when the user requests adding it.
4053 *
4054 * This avoids needing to track location for programming the filter to
4055 * hardware, and ensures that we avoid some strange scenarios involving
4056 * deleting filters which match the same criteria.
4057 **/
4060 {
4065 /* Loop through every filter, and check that it doesn't match */
4068 /* Don't check the filters match if they share the same fd_id,
4069 * since the new filter is actually just updating the target
4070 * of the old filter.
4071 */
4075 /* If any filters match, then print a warning message to the
4076 * kernel message buffer and bail out.
4077 */
4083 }
4084 }
4087 }
4089 /**
4090 * i40e_add_fdir_ethtool - Add/Remove Flow Director filters
4091 * @vsi: pointer to the targeted VSI
4092 * @cmd: command to get or set RX flow classification rules
4093 *
4094 * Add Flow Director filters for a specific flow spec based on their
4095 * protocol. Returns 0 if the filters were successfully added.
4096 **/
4099 {
4106 u8 dest_ctl;
4127 /* Parse the user-defined field */
4131 /* Extended MAC field is not supported */
4142 }
4144 /* ring_cookie is either the drop index, or is a mask of the queue
4145 * index and VF id we wish to target.
4146 */
4158 /* VFs are zero-indexed, so we subtract one here */
4159 vf--;
4166 }
4169 }
4187 /* Reverse the src and dest notion, since the HW expects them to be from
4188 * Tx perspective where as the input from user is from Rx filter view.
4189 */
4199 }
4201 /* Avoid programming two filters with identical match criteria. */
4206 /* Add the input filter to the fdir_input_list, possibly replacing
4207 * a previous filter. Do not free the input structure after adding it
4208 * to the list as this would cause a use-after-free bug.
4209 */
4216 remove_sw_rule:
4219 free_filter_memory:
4222 }
4224 /**
4225 * i40e_set_rxnfc - command to set RX flow classification rules
4226 * @netdev: network interface device structure
4227 * @cmd: ethtool rxnfc command
4228 *
4229 * Returns Success if the command is supported.
4230 **/
4232 {
4250 }
4253 }
4255 /**
4256 * i40e_max_channels - get Max number of combined channels supported
4257 * @vsi: vsi pointer
4258 **/
4260 {
4261 /* TODO: This code assumes DCB and FD is disabled for now. */
4263 }
4265 /**
4266 * i40e_get_channels - Get the current channels enabled and max supported etc.
4267 * @dev: network interface device structure
4268 * @ch: ethtool channels structure
4269 *
4270 * We don't support separate tx and rx queues as channels. The other count
4271 * represents how many queues are being used for control. max_combined counts
4272 * how many queue pairs we can support. They may not be mapped 1 to 1 with
4273 * q_vectors since we support a lot more queue pairs than q_vectors.
4274 **/
4277 {
4282 /* report maximum channels */
4285 /* report info for other vector */
4289 /* Note: This code assumes DCB is disabled for now. */
4291 }
4293 /**
4294 * i40e_set_channels - Set the new channels count.
4295 * @dev: network interface device structure
4296 * @ch: ethtool channels structure
4297 *
4298 * The new channels count may not be the same as requested by the user
4299 * since it gets rounded down to a power of 2 value.
4300 **/
4303 {
4314 /* We do not support setting channels for any other VSI at present */
4318 /* We do not support setting channels via ethtool when TCs are
4319 * configured through mqprio
4320 */
4324 /* verify they are not requesting separate vectors */
4328 /* verify other_count has not changed */
4332 /* verify the number of channels does not exceed hardware limits */
4336 /* verify that the number of channels does not invalidate any current
4337 * flow director rules
4338 */
4346 }
4347 }
4352 count);
4354 }
4356 /* update feature limits from largest to smallest supported values */
4357 /* TODO: Flow director limit, DCB etc */
4359 /* use rss_reconfig to rebuild with new queue count and update traffic
4360 * class queue mapping
4361 */
4365 else
4367 }
4369 /**
4370 * i40e_get_rxfh_key_size - get the RSS hash key size
4371 * @netdev: network interface device structure
4372 *
4373 * Returns the table size.
4374 **/
4376 {
4378 }
4380 /**
4381 * i40e_get_rxfh_indir_size - get the rx flow hash indirection table size
4382 * @netdev: network interface device structure
4383 *
4384 * Returns the table size.
4385 **/
4387 {
4389 }
4391 /**
4392 * i40e_get_rxfh - get the rx flow hash indirection table
4393 * @netdev: network interface device structure
4394 * @indir: indirection table
4395 * @key: hash key
4396 * @hfunc: hash function
4397 *
4398 * Reads the indirection table directly from the hardware. Returns 0 on
4399 * success.
4400 **/
4403 {
4408 u16 i;
4426 out:
4430 }
4432 /**
4433 * i40e_set_rxfh - set the rx flow hash indirection table
4434 * @netdev: network interface device structure
4435 * @indir: indirection table
4436 * @key: hash key
4437 * @hfunc: hash function to use
4438 *
4439 * Returns -EINVAL if the table specifies an invalid queue id, otherwise
4440 * returns 0 after programming the table.
4441 **/
4444 {
4449 u16 i;
4457 GFP_KERNEL);
4460 }
4463 }
4468 }
4470 /* Each 32 bits pointed by 'indir' is stored with a lut entry */
4474 else
4479 I40E_HLUT_ARRAY_SIZE);
4480 }
4482 /**
4483 * i40e_get_priv_flags - report device private flags
4484 * @dev: network interface device structure
4485 *
4486 * The get string set count and the string set should be matched for each
4487 * flag returned. Add new strings for each flag to the i40e_gstrings_priv_flags
4488 * array.
4489 *
4490 * Returns a u32 bitmap of flags.
4491 **/
4493 {
4506 }
4518 }
4521 }
4523 /**
4524 * i40e_set_priv_flags - set private flags
4525 * @dev: network interface device structure
4526 * @flags: bit flags to be set
4527 **/
4529 {
4546 else
4549 /* If this is a read-only flag, it can't be changed */
4553 }
4565 else
4568 /* If this is a read-only flag, it can't be changed */
4572 }
4574 flags_complete:
4577 /* Before we finalize any flag changes, we need to perform some
4578 * checks to ensure that the changes are supported and safe.
4579 */
4581 /* ATR eviction is not supported on all devices */
4586 /* If the driver detected FW LLDP was disabled on init, this flag could
4587 * be set, however we do not support _changing_ the flag if NPAR is
4588 * enabled or FW API version < 1.7. There are situations where older
4589 * FW versions/NPAR enabled PFs could disable LLDP, however we _must_
4590 * not allow the user to enable/disable LLDP with this flag on
4591 * unsupported FW versions.
4592 */
4598 }
4599 }
4601 /* Now that we've checked to ensure that the new flags are valid, load
4602 * them into place. Since we only modify flags either (a) during
4603 * initialization or (b) while holding the RTNL lock, we don't need
4604 * anything fancy here.
4605 */
4608 /* Process any additional changes needed as a result of flag changes.
4609 * The changed_flags value reflects the list of bits that were
4610 * changed in the code above.
4611 */
4613 /* Flush current ATR settings if ATR was disabled */
4618 }
4635 /* not a fatal problem, just keep going */
4636 }
4637 }
4640 I40E_FLAG_LINK_DOWN_ON_CLOSE_ENABLED) &&
4651 /* reset local_dcbx_config to default */
4665 }
4666 }
4668 /* Issue reset to cause things to take effect, as additional bits
4669 * are added we will need to create a mask of bits requiring reset
4670 */
4672 I40E_FLAG_LEGACY_RX |
4673 I40E_FLAG_SOURCE_PRUNING_DISABLED |
4674 I40E_FLAG_DISABLE_FW_LLDP))
4678 }
4680 /**
4681 * i40e_get_module_info - get (Q)SFP+ module type info
4682 * @netdev: network interface device structure
4683 * @modinfo: module EEPROM size and layout information structure
4684 **/
4687 {
4695 i40e_status status;
4698 /* Check if firmware supports reading module EEPROM. */
4700 netdev_err(vsi->netdev, "Module EEPROM memory read not supported. Please update the NVM image.\n");
4702 }
4711 }
4718 I40E_AQ_PHY_REG_ACCESS_EXTERNAL_MODULE,
4719 I40E_I2C_EEPROM_DEV_ADDR,
4720 I40E_MODULE_SFF_8472_COMP,
4726 I40E_AQ_PHY_REG_ACCESS_EXTERNAL_MODULE,
4727 I40E_I2C_EEPROM_DEV_ADDR,
4728 I40E_MODULE_SFF_8472_SWAP,
4733 /* Check if the module requires address swap to access
4734 * the other EEPROM memory page.
4735 */
4741 /* Module is not SFF-8472 compliant */
4747 }
4750 /* Read from memory page 0. */
4752 I40E_AQ_PHY_REG_ACCESS_EXTERNAL_MODULE,
4754 I40E_MODULE_REVISION_ADDR,
4758 /* Determine revision compliance byte */
4760 /* Module is SFF-8636 compliant */
4766 }
4775 }
4777 }
4779 /**
4780 * i40e_get_module_eeprom - fills buffer with (Q)SFP+ module memory contents
4781 * @netdev: network interface device structure
4782 * @ee: EEPROM dump request structure
4783 * @data: buffer to be filled with EEPROM contents
4784 **/
4788 {
4794 i40e_status status;
4808 /* Check if we need to access the other memory page */
4813 }
4816 /* Compute memory page number and offset. */
4818 addr++;
4819 }
4820 }
4823 I40E_AQ_PHY_REG_ACCESS_EXTERNAL_MODULE,
4828 }
4830 }
4873 };
4876 {
4878 }