1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright IBM Corp. 2018
6 #define KMSG_COMPONENT "qeth"
7 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
9 #include <linux/ethtool.h>
10 #include "qeth_core.h"
13 #define QETH_TXQ_STAT(_name, _stat) { \
15 .offset = offsetof(struct qeth_out_q_stats, _stat) \
18 #define QETH_CARD_STAT(_name, _stat) { \
20 .offset = offsetof(struct qeth_card_stats, _stat) \
24 char name[ETH_GSTRING_LEN];
28 static const struct qeth_stats txq_stats[] = {
29 QETH_TXQ_STAT("IO buffers", bufs),
30 QETH_TXQ_STAT("IO buffer elements", buf_elements),
31 QETH_TXQ_STAT("packed IO buffers", bufs_pack),
32 QETH_TXQ_STAT("skbs", tx_packets),
33 QETH_TXQ_STAT("packed skbs", skbs_pack),
34 QETH_TXQ_STAT("SG skbs", skbs_sg),
35 QETH_TXQ_STAT("HW csum skbs", skbs_csum),
36 QETH_TXQ_STAT("TSO skbs", skbs_tso),
37 QETH_TXQ_STAT("linearized skbs", skbs_linearized),
38 QETH_TXQ_STAT("linearized+error skbs", skbs_linearized_fail),
39 QETH_TXQ_STAT("TSO bytes", tso_bytes),
40 QETH_TXQ_STAT("Packing mode switches", packing_mode_switch),
43 static const struct qeth_stats card_stats[] = {
44 QETH_CARD_STAT("rx0 IO buffers", rx_bufs),
45 QETH_CARD_STAT("rx0 HW csum skbs", rx_skb_csum),
46 QETH_CARD_STAT("rx0 SG skbs", rx_sg_skbs),
47 QETH_CARD_STAT("rx0 SG page frags", rx_sg_frags),
48 QETH_CARD_STAT("rx0 SG page allocs", rx_sg_alloc_page),
51 #define TXQ_STATS_LEN ARRAY_SIZE(txq_stats)
52 #define CARD_STATS_LEN ARRAY_SIZE(card_stats)
54 static void qeth_add_stat_data(u64 **dst, void *src,
55 const struct qeth_stats stats[],
61 for (i = 0; i < size; i++) {
62 stat = (char *)src + stats[i].offset;
68 static void qeth_add_stat_strings(u8 **data, const char *prefix,
69 const struct qeth_stats stats[],
74 for (i = 0; i < size; i++) {
75 snprintf(*data, ETH_GSTRING_LEN, "%s%s", prefix, stats[i].name);
76 *data += ETH_GSTRING_LEN;
80 static int qeth_get_sset_count(struct net_device *dev, int stringset)
82 struct qeth_card *card = dev->ml_priv;
86 return CARD_STATS_LEN +
87 card->qdio.no_out_queues * TXQ_STATS_LEN;
93 static void qeth_get_ethtool_stats(struct net_device *dev,
94 struct ethtool_stats *stats, u64 *data)
96 struct qeth_card *card = dev->ml_priv;
99 qeth_add_stat_data(&data, &card->stats, card_stats, CARD_STATS_LEN);
100 for (i = 0; i < card->qdio.no_out_queues; i++)
101 qeth_add_stat_data(&data, &card->qdio.out_qs[i]->stats,
102 txq_stats, TXQ_STATS_LEN);
105 static void qeth_get_ringparam(struct net_device *dev,
106 struct ethtool_ringparam *param)
108 struct qeth_card *card = dev->ml_priv;
110 param->rx_max_pending = QDIO_MAX_BUFFERS_PER_Q;
111 param->rx_mini_max_pending = 0;
112 param->rx_jumbo_max_pending = 0;
113 param->tx_max_pending = QDIO_MAX_BUFFERS_PER_Q;
115 param->rx_pending = card->qdio.in_buf_pool.buf_count;
116 param->rx_mini_pending = 0;
117 param->rx_jumbo_pending = 0;
118 param->tx_pending = QDIO_MAX_BUFFERS_PER_Q;
121 static void qeth_get_strings(struct net_device *dev, u32 stringset, u8 *data)
123 struct qeth_card *card = dev->ml_priv;
124 char prefix[ETH_GSTRING_LEN] = "";
129 qeth_add_stat_strings(&data, prefix, card_stats,
131 for (i = 0; i < card->qdio.no_out_queues; i++) {
132 snprintf(prefix, ETH_GSTRING_LEN, "tx%u ", i);
133 qeth_add_stat_strings(&data, prefix, txq_stats,
143 static void qeth_get_drvinfo(struct net_device *dev,
144 struct ethtool_drvinfo *info)
146 struct qeth_card *card = dev->ml_priv;
148 strlcpy(info->driver, IS_LAYER2(card) ? "qeth_l2" : "qeth_l3",
149 sizeof(info->driver));
150 strlcpy(info->version, "1.0", sizeof(info->version));
151 strlcpy(info->fw_version, card->info.mcl_level,
152 sizeof(info->fw_version));
153 snprintf(info->bus_info, sizeof(info->bus_info), "%s/%s/%s",
154 CARD_RDEV_ID(card), CARD_WDEV_ID(card), CARD_DDEV_ID(card));
157 /* Helper function to fill 'advertising' and 'supported' which are the same. */
158 /* Autoneg and full-duplex are supported and advertised unconditionally. */
159 /* Always advertise and support all speeds up to specified, and only one */
160 /* specified port type. */
161 static void qeth_set_cmd_adv_sup(struct ethtool_link_ksettings *cmd,
162 int maxspeed, int porttype)
164 ethtool_link_ksettings_zero_link_mode(cmd, supported);
165 ethtool_link_ksettings_zero_link_mode(cmd, advertising);
166 ethtool_link_ksettings_zero_link_mode(cmd, lp_advertising);
168 ethtool_link_ksettings_add_link_mode(cmd, supported, Autoneg);
169 ethtool_link_ksettings_add_link_mode(cmd, advertising, Autoneg);
173 ethtool_link_ksettings_add_link_mode(cmd, supported, TP);
174 ethtool_link_ksettings_add_link_mode(cmd, advertising, TP);
177 ethtool_link_ksettings_add_link_mode(cmd, supported, FIBRE);
178 ethtool_link_ksettings_add_link_mode(cmd, advertising, FIBRE);
181 ethtool_link_ksettings_add_link_mode(cmd, supported, TP);
182 ethtool_link_ksettings_add_link_mode(cmd, advertising, TP);
186 /* partially does fall through, to also select lower speeds */
189 ethtool_link_ksettings_add_link_mode(cmd, supported,
191 ethtool_link_ksettings_add_link_mode(cmd, advertising,
195 ethtool_link_ksettings_add_link_mode(cmd, supported,
197 ethtool_link_ksettings_add_link_mode(cmd, advertising,
201 ethtool_link_ksettings_add_link_mode(cmd, supported,
203 ethtool_link_ksettings_add_link_mode(cmd, advertising,
205 ethtool_link_ksettings_add_link_mode(cmd, supported,
207 ethtool_link_ksettings_add_link_mode(cmd, advertising,
211 ethtool_link_ksettings_add_link_mode(cmd, supported,
213 ethtool_link_ksettings_add_link_mode(cmd, advertising,
215 ethtool_link_ksettings_add_link_mode(cmd, supported,
217 ethtool_link_ksettings_add_link_mode(cmd, advertising,
221 ethtool_link_ksettings_add_link_mode(cmd, supported,
223 ethtool_link_ksettings_add_link_mode(cmd, advertising,
225 ethtool_link_ksettings_add_link_mode(cmd, supported,
227 ethtool_link_ksettings_add_link_mode(cmd, advertising,
231 ethtool_link_ksettings_add_link_mode(cmd, supported,
233 ethtool_link_ksettings_add_link_mode(cmd, advertising,
235 ethtool_link_ksettings_add_link_mode(cmd, supported,
237 ethtool_link_ksettings_add_link_mode(cmd, advertising,
244 static int qeth_get_link_ksettings(struct net_device *netdev,
245 struct ethtool_link_ksettings *cmd)
247 struct qeth_card *card = netdev->ml_priv;
248 enum qeth_link_types link_type;
249 struct carrier_info carrier_info;
252 if (IS_IQD(card) || IS_VM_NIC(card))
253 link_type = QETH_LINK_TYPE_10GBIT_ETH;
255 link_type = card->info.link_type;
257 cmd->base.duplex = DUPLEX_FULL;
258 cmd->base.autoneg = AUTONEG_ENABLE;
259 cmd->base.phy_address = 0;
260 cmd->base.mdio_support = 0;
261 cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;
262 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_INVALID;
265 case QETH_LINK_TYPE_FAST_ETH:
266 case QETH_LINK_TYPE_LANE_ETH100:
267 cmd->base.speed = SPEED_100;
268 cmd->base.port = PORT_TP;
270 case QETH_LINK_TYPE_GBIT_ETH:
271 case QETH_LINK_TYPE_LANE_ETH1000:
272 cmd->base.speed = SPEED_1000;
273 cmd->base.port = PORT_FIBRE;
275 case QETH_LINK_TYPE_10GBIT_ETH:
276 cmd->base.speed = SPEED_10000;
277 cmd->base.port = PORT_FIBRE;
279 case QETH_LINK_TYPE_25GBIT_ETH:
280 cmd->base.speed = SPEED_25000;
281 cmd->base.port = PORT_FIBRE;
284 cmd->base.speed = SPEED_10;
285 cmd->base.port = PORT_TP;
287 qeth_set_cmd_adv_sup(cmd, cmd->base.speed, cmd->base.port);
289 /* Check if we can obtain more accurate information. */
290 /* If QUERY_CARD_INFO command is not supported or fails, */
291 /* just return the heuristics that was filled above. */
292 rc = qeth_query_card_info(card, &carrier_info);
293 if (rc == -EOPNOTSUPP) /* for old hardware, return heuristic */
295 if (rc) /* report error from the hardware operation */
297 /* on success, fill in the information got from the hardware */
300 "card info: card_type=0x%02x, port_mode=0x%04x, port_speed=0x%08x\n",
301 carrier_info.card_type,
302 carrier_info.port_mode,
303 carrier_info.port_speed);
305 /* Update attributes for which we've obtained more authoritative */
306 /* information, leave the rest the way they where filled above. */
307 switch (carrier_info.card_type) {
308 case CARD_INFO_TYPE_1G_COPPER_A:
309 case CARD_INFO_TYPE_1G_COPPER_B:
310 cmd->base.port = PORT_TP;
311 qeth_set_cmd_adv_sup(cmd, SPEED_1000, cmd->base.port);
313 case CARD_INFO_TYPE_1G_FIBRE_A:
314 case CARD_INFO_TYPE_1G_FIBRE_B:
315 cmd->base.port = PORT_FIBRE;
316 qeth_set_cmd_adv_sup(cmd, SPEED_1000, cmd->base.port);
318 case CARD_INFO_TYPE_10G_FIBRE_A:
319 case CARD_INFO_TYPE_10G_FIBRE_B:
320 cmd->base.port = PORT_FIBRE;
321 qeth_set_cmd_adv_sup(cmd, SPEED_10000, cmd->base.port);
325 switch (carrier_info.port_mode) {
326 case CARD_INFO_PORTM_FULLDUPLEX:
327 cmd->base.duplex = DUPLEX_FULL;
329 case CARD_INFO_PORTM_HALFDUPLEX:
330 cmd->base.duplex = DUPLEX_HALF;
334 switch (carrier_info.port_speed) {
335 case CARD_INFO_PORTS_10M:
336 cmd->base.speed = SPEED_10;
338 case CARD_INFO_PORTS_100M:
339 cmd->base.speed = SPEED_100;
341 case CARD_INFO_PORTS_1G:
342 cmd->base.speed = SPEED_1000;
344 case CARD_INFO_PORTS_10G:
345 cmd->base.speed = SPEED_10000;
347 case CARD_INFO_PORTS_25G:
348 cmd->base.speed = SPEED_25000;
355 const struct ethtool_ops qeth_ethtool_ops = {
356 .get_link = ethtool_op_get_link,
357 .get_ringparam = qeth_get_ringparam,
358 .get_strings = qeth_get_strings,
359 .get_ethtool_stats = qeth_get_ethtool_stats,
360 .get_sset_count = qeth_get_sset_count,
361 .get_drvinfo = qeth_get_drvinfo,
362 .get_link_ksettings = qeth_get_link_ksettings,
365 const struct ethtool_ops qeth_osn_ethtool_ops = {
366 .get_strings = qeth_get_strings,
367 .get_ethtool_stats = qeth_get_ethtool_stats,
368 .get_sset_count = qeth_get_sset_count,
369 .get_drvinfo = qeth_get_drvinfo,