1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) 2 /* QLogic qede NIC Driver 3 * Copyright (c) 2015-2017 QLogic Corporation 4 * Copyright (c) 2019-2020 Marvell International Ltd. 5 */ 6 7 #include <linux/types.h> 8 #include <linux/netdevice.h> 9 #include <linux/etherdevice.h> 10 #include <linux/ethtool.h> 11 #include <linux/string.h> 12 #include <linux/pci.h> 13 #include <linux/capability.h> 14 #include <linux/vmalloc.h> 15 #include <linux/phylink.h> 16 17 #include "qede.h" 18 #include "qede_ptp.h" 19 20 #define QEDE_RQSTAT_OFFSET(stat_name) \ 21 (offsetof(struct qede_rx_queue, stat_name)) 22 #define QEDE_RQSTAT_STRING(stat_name) (#stat_name) 23 #define QEDE_RQSTAT(stat_name) \ 24 {QEDE_RQSTAT_OFFSET(stat_name), QEDE_RQSTAT_STRING(stat_name)} 25 26 #define QEDE_SELFTEST_POLL_COUNT 100 27 #define QEDE_DUMP_VERSION 0x1 28 #define QEDE_DUMP_NVM_ARG_COUNT 2 29 30 static const struct { 31 u64 offset; 32 char string[ETH_GSTRING_LEN]; 33 } qede_rqstats_arr[] = { 34 QEDE_RQSTAT(rcv_pkts), 35 QEDE_RQSTAT(rx_hw_errors), 36 QEDE_RQSTAT(rx_alloc_errors), 37 QEDE_RQSTAT(rx_ip_frags), 38 QEDE_RQSTAT(xdp_no_pass), 39 }; 40 41 #define QEDE_NUM_RQSTATS ARRAY_SIZE(qede_rqstats_arr) 42 #define QEDE_TQSTAT_OFFSET(stat_name) \ 43 (offsetof(struct qede_tx_queue, stat_name)) 44 #define QEDE_TQSTAT_STRING(stat_name) (#stat_name) 45 #define QEDE_TQSTAT(stat_name) \ 46 {QEDE_TQSTAT_OFFSET(stat_name), QEDE_TQSTAT_STRING(stat_name)} 47 #define QEDE_NUM_TQSTATS ARRAY_SIZE(qede_tqstats_arr) 48 static const struct { 49 u64 offset; 50 char string[ETH_GSTRING_LEN]; 51 } qede_tqstats_arr[] = { 52 QEDE_TQSTAT(xmit_pkts), 53 QEDE_TQSTAT(stopped_cnt), 54 QEDE_TQSTAT(tx_mem_alloc_err), 55 }; 56 57 #define QEDE_STAT_OFFSET(stat_name, type, base) \ 58 (offsetof(type, stat_name) + (base)) 59 #define QEDE_STAT_STRING(stat_name) (#stat_name) 60 #define _QEDE_STAT(stat_name, type, base, attr) \ 61 {QEDE_STAT_OFFSET(stat_name, type, base), \ 62 QEDE_STAT_STRING(stat_name), \ 63 attr} 64 #define QEDE_STAT(stat_name) \ 65 _QEDE_STAT(stat_name, struct qede_stats_common, 0, 0x0) 66 #define QEDE_PF_STAT(stat_name) \ 67 _QEDE_STAT(stat_name, struct qede_stats_common, 0, \ 68 BIT(QEDE_STAT_PF_ONLY)) 69 #define QEDE_PF_BB_STAT(stat_name) \ 70 _QEDE_STAT(stat_name, struct qede_stats_bb, \ 71 offsetof(struct qede_stats, bb), \ 72 BIT(QEDE_STAT_PF_ONLY) | BIT(QEDE_STAT_BB_ONLY)) 73 #define QEDE_PF_AH_STAT(stat_name) \ 74 _QEDE_STAT(stat_name, struct qede_stats_ah, \ 75 offsetof(struct qede_stats, ah), \ 76 BIT(QEDE_STAT_PF_ONLY) | BIT(QEDE_STAT_AH_ONLY)) 77 static const struct { 78 u64 offset; 79 char string[ETH_GSTRING_LEN]; 80 unsigned long attr; 81 #define QEDE_STAT_PF_ONLY 0 82 #define QEDE_STAT_BB_ONLY 1 83 #define QEDE_STAT_AH_ONLY 2 84 } qede_stats_arr[] = { 85 QEDE_STAT(rx_ucast_bytes), 86 QEDE_STAT(rx_mcast_bytes), 87 QEDE_STAT(rx_bcast_bytes), 88 QEDE_STAT(rx_ucast_pkts), 89 QEDE_STAT(rx_mcast_pkts), 90 QEDE_STAT(rx_bcast_pkts), 91 92 QEDE_STAT(tx_ucast_bytes), 93 QEDE_STAT(tx_mcast_bytes), 94 QEDE_STAT(tx_bcast_bytes), 95 QEDE_STAT(tx_ucast_pkts), 96 QEDE_STAT(tx_mcast_pkts), 97 QEDE_STAT(tx_bcast_pkts), 98 99 QEDE_PF_STAT(rx_64_byte_packets), 100 QEDE_PF_STAT(rx_65_to_127_byte_packets), 101 QEDE_PF_STAT(rx_128_to_255_byte_packets), 102 QEDE_PF_STAT(rx_256_to_511_byte_packets), 103 QEDE_PF_STAT(rx_512_to_1023_byte_packets), 104 QEDE_PF_STAT(rx_1024_to_1518_byte_packets), 105 QEDE_PF_BB_STAT(rx_1519_to_1522_byte_packets), 106 QEDE_PF_BB_STAT(rx_1519_to_2047_byte_packets), 107 QEDE_PF_BB_STAT(rx_2048_to_4095_byte_packets), 108 QEDE_PF_BB_STAT(rx_4096_to_9216_byte_packets), 109 QEDE_PF_BB_STAT(rx_9217_to_16383_byte_packets), 110 QEDE_PF_AH_STAT(rx_1519_to_max_byte_packets), 111 QEDE_PF_STAT(tx_64_byte_packets), 112 QEDE_PF_STAT(tx_65_to_127_byte_packets), 113 QEDE_PF_STAT(tx_128_to_255_byte_packets), 114 QEDE_PF_STAT(tx_256_to_511_byte_packets), 115 QEDE_PF_STAT(tx_512_to_1023_byte_packets), 116 QEDE_PF_STAT(tx_1024_to_1518_byte_packets), 117 QEDE_PF_BB_STAT(tx_1519_to_2047_byte_packets), 118 QEDE_PF_BB_STAT(tx_2048_to_4095_byte_packets), 119 QEDE_PF_BB_STAT(tx_4096_to_9216_byte_packets), 120 QEDE_PF_BB_STAT(tx_9217_to_16383_byte_packets), 121 QEDE_PF_AH_STAT(tx_1519_to_max_byte_packets), 122 QEDE_PF_STAT(rx_mac_crtl_frames), 123 QEDE_PF_STAT(tx_mac_ctrl_frames), 124 QEDE_PF_STAT(rx_pause_frames), 125 QEDE_PF_STAT(tx_pause_frames), 126 QEDE_PF_STAT(rx_pfc_frames), 127 QEDE_PF_STAT(tx_pfc_frames), 128 129 QEDE_PF_STAT(rx_crc_errors), 130 QEDE_PF_STAT(rx_align_errors), 131 QEDE_PF_STAT(rx_carrier_errors), 132 QEDE_PF_STAT(rx_oversize_packets), 133 QEDE_PF_STAT(rx_jabbers), 134 QEDE_PF_STAT(rx_undersize_packets), 135 QEDE_PF_STAT(rx_fragments), 136 QEDE_PF_BB_STAT(tx_lpi_entry_count), 137 QEDE_PF_BB_STAT(tx_total_collisions), 138 QEDE_PF_STAT(brb_truncates), 139 QEDE_PF_STAT(brb_discards), 140 QEDE_STAT(no_buff_discards), 141 QEDE_PF_STAT(mftag_filter_discards), 142 QEDE_PF_STAT(mac_filter_discards), 143 QEDE_PF_STAT(gft_filter_drop), 144 QEDE_STAT(tx_err_drop_pkts), 145 QEDE_STAT(ttl0_discard), 146 QEDE_STAT(packet_too_big_discard), 147 148 QEDE_STAT(coalesced_pkts), 149 QEDE_STAT(coalesced_events), 150 QEDE_STAT(coalesced_aborts_num), 151 QEDE_STAT(non_coalesced_pkts), 152 QEDE_STAT(coalesced_bytes), 153 154 QEDE_STAT(link_change_count), 155 QEDE_STAT(ptp_skip_txts), 156 }; 157 158 #define QEDE_NUM_STATS ARRAY_SIZE(qede_stats_arr) 159 #define QEDE_STAT_IS_PF_ONLY(i) \ 160 test_bit(QEDE_STAT_PF_ONLY, &qede_stats_arr[i].attr) 161 #define QEDE_STAT_IS_BB_ONLY(i) \ 162 test_bit(QEDE_STAT_BB_ONLY, &qede_stats_arr[i].attr) 163 #define QEDE_STAT_IS_AH_ONLY(i) \ 164 test_bit(QEDE_STAT_AH_ONLY, &qede_stats_arr[i].attr) 165 166 enum { 167 QEDE_PRI_FLAG_CMT, 168 QEDE_PRI_FLAG_SMART_AN_SUPPORT, /* MFW supports SmartAN */ 169 QEDE_PRI_FLAG_RECOVER_ON_ERROR, 170 QEDE_PRI_FLAG_ESL_SUPPORT, /* MFW supports Enhanced System Lockdown */ 171 QEDE_PRI_FLAG_ESL_ACTIVE, /* Enhanced System Lockdown Active status */ 172 QEDE_PRI_FLAG_LEN, 173 }; 174 175 static const char qede_private_arr[QEDE_PRI_FLAG_LEN][ETH_GSTRING_LEN] = { 176 "Coupled-Function", 177 "SmartAN capable", 178 "Recover on error", 179 "ESL capable", 180 "ESL active", 181 }; 182 183 enum qede_ethtool_tests { 184 QEDE_ETHTOOL_INT_LOOPBACK, 185 QEDE_ETHTOOL_INTERRUPT_TEST, 186 QEDE_ETHTOOL_MEMORY_TEST, 187 QEDE_ETHTOOL_REGISTER_TEST, 188 QEDE_ETHTOOL_CLOCK_TEST, 189 QEDE_ETHTOOL_NVRAM_TEST, 190 QEDE_ETHTOOL_TEST_MAX 191 }; 192 193 static const char qede_tests_str_arr[QEDE_ETHTOOL_TEST_MAX][ETH_GSTRING_LEN] = { 194 "Internal loopback (offline)", 195 "Interrupt (online)\t", 196 "Memory (online)\t\t", 197 "Register (online)\t", 198 "Clock (online)\t\t", 199 "Nvram (online)\t\t", 200 }; 201 202 /* Forced speed capabilities maps */ 203 204 static const u32 qede_forced_speed_1000[] __initconst = { 205 ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 206 ETHTOOL_LINK_MODE_1000baseKX_Full_BIT, 207 ETHTOOL_LINK_MODE_1000baseX_Full_BIT, 208 }; 209 210 static const u32 qede_forced_speed_10000[] __initconst = { 211 ETHTOOL_LINK_MODE_10000baseT_Full_BIT, 212 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT, 213 ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT, 214 ETHTOOL_LINK_MODE_10000baseR_FEC_BIT, 215 ETHTOOL_LINK_MODE_10000baseCR_Full_BIT, 216 ETHTOOL_LINK_MODE_10000baseSR_Full_BIT, 217 ETHTOOL_LINK_MODE_10000baseLR_Full_BIT, 218 ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT, 219 }; 220 221 static const u32 qede_forced_speed_20000[] __initconst = { 222 ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT, 223 }; 224 225 static const u32 qede_forced_speed_25000[] __initconst = { 226 ETHTOOL_LINK_MODE_25000baseKR_Full_BIT, 227 ETHTOOL_LINK_MODE_25000baseCR_Full_BIT, 228 ETHTOOL_LINK_MODE_25000baseSR_Full_BIT, 229 }; 230 231 static const u32 qede_forced_speed_40000[] __initconst = { 232 ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT, 233 ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT, 234 ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT, 235 ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT, 236 }; 237 238 static const u32 qede_forced_speed_50000[] __initconst = { 239 ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT, 240 ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT, 241 ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT, 242 }; 243 244 static const u32 qede_forced_speed_100000[] __initconst = { 245 ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT, 246 ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT, 247 ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT, 248 ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT, 249 }; 250 251 static struct ethtool_forced_speed_map 252 qede_forced_speed_maps[] __ro_after_init = { 253 ETHTOOL_FORCED_SPEED_MAP(qede_forced_speed, 1000), 254 ETHTOOL_FORCED_SPEED_MAP(qede_forced_speed, 10000), 255 ETHTOOL_FORCED_SPEED_MAP(qede_forced_speed, 20000), 256 ETHTOOL_FORCED_SPEED_MAP(qede_forced_speed, 25000), 257 ETHTOOL_FORCED_SPEED_MAP(qede_forced_speed, 40000), 258 ETHTOOL_FORCED_SPEED_MAP(qede_forced_speed, 50000), 259 ETHTOOL_FORCED_SPEED_MAP(qede_forced_speed, 100000), 260 }; 261 262 void __init qede_forced_speed_maps_init(void) 263 { 264 ethtool_forced_speed_maps_init(qede_forced_speed_maps, 265 ARRAY_SIZE(qede_forced_speed_maps)); 266 } 267 268 /* Ethtool callbacks */ 269 270 static void qede_get_strings_stats_txq(struct qede_dev *edev, 271 struct qede_tx_queue *txq, u8 **buf) 272 { 273 int i; 274 275 for (i = 0; i < QEDE_NUM_TQSTATS; i++) 276 if (txq->is_xdp) 277 ethtool_sprintf(buf, "%d [XDP]: %s", 278 QEDE_TXQ_XDP_TO_IDX(edev, txq), 279 qede_tqstats_arr[i].string); 280 else 281 ethtool_sprintf(buf, "%d_%d: %s", txq->index, txq->cos, 282 qede_tqstats_arr[i].string); 283 } 284 285 static void qede_get_strings_stats_rxq(struct qede_dev *edev, 286 struct qede_rx_queue *rxq, u8 **buf) 287 { 288 int i; 289 290 for (i = 0; i < QEDE_NUM_RQSTATS; i++) 291 ethtool_sprintf(buf, "%d: %s", rxq->rxq_id, 292 qede_rqstats_arr[i].string); 293 } 294 295 static bool qede_is_irrelevant_stat(struct qede_dev *edev, int stat_index) 296 { 297 return (IS_VF(edev) && QEDE_STAT_IS_PF_ONLY(stat_index)) || 298 (QEDE_IS_BB(edev) && QEDE_STAT_IS_AH_ONLY(stat_index)) || 299 (QEDE_IS_AH(edev) && QEDE_STAT_IS_BB_ONLY(stat_index)); 300 } 301 302 static void qede_get_strings_stats(struct qede_dev *edev, u8 *buf) 303 { 304 struct qede_fastpath *fp; 305 int i; 306 307 /* Account for queue statistics */ 308 for (i = 0; i < QEDE_QUEUE_CNT(edev); i++) { 309 fp = &edev->fp_array[i]; 310 311 if (fp->type & QEDE_FASTPATH_RX) 312 qede_get_strings_stats_rxq(edev, fp->rxq, &buf); 313 314 if (fp->type & QEDE_FASTPATH_XDP) 315 qede_get_strings_stats_txq(edev, fp->xdp_tx, &buf); 316 317 if (fp->type & QEDE_FASTPATH_TX) { 318 int cos; 319 320 for_each_cos_in_txq(edev, cos) 321 qede_get_strings_stats_txq(edev, 322 &fp->txq[cos], &buf); 323 } 324 } 325 326 /* Account for non-queue statistics */ 327 for (i = 0; i < QEDE_NUM_STATS; i++) { 328 if (qede_is_irrelevant_stat(edev, i)) 329 continue; 330 ethtool_puts(&buf, qede_stats_arr[i].string); 331 } 332 } 333 334 static void qede_get_strings(struct net_device *dev, u32 stringset, u8 *buf) 335 { 336 struct qede_dev *edev = netdev_priv(dev); 337 int i; 338 339 switch (stringset) { 340 case ETH_SS_STATS: 341 qede_get_strings_stats(edev, buf); 342 break; 343 case ETH_SS_PRIV_FLAGS: 344 for (i = 0; i < QEDE_PRI_FLAG_LEN; i++) 345 ethtool_puts(&buf, qede_private_arr[i]); 346 break; 347 case ETH_SS_TEST: 348 for (i = 0; i < QEDE_ETHTOOL_TEST_MAX; i++) 349 ethtool_puts(&buf, qede_tests_str_arr[i]); 350 break; 351 default: 352 DP_VERBOSE(edev, QED_MSG_DEBUG, 353 "Unsupported stringset 0x%08x\n", stringset); 354 } 355 } 356 357 static void qede_get_ethtool_stats_txq(struct qede_tx_queue *txq, u64 **buf) 358 { 359 int i; 360 361 for (i = 0; i < QEDE_NUM_TQSTATS; i++) { 362 **buf = *((u64 *)(((void *)txq) + qede_tqstats_arr[i].offset)); 363 (*buf)++; 364 } 365 } 366 367 static void qede_get_ethtool_stats_rxq(struct qede_rx_queue *rxq, u64 **buf) 368 { 369 int i; 370 371 for (i = 0; i < QEDE_NUM_RQSTATS; i++) { 372 **buf = *((u64 *)(((void *)rxq) + qede_rqstats_arr[i].offset)); 373 (*buf)++; 374 } 375 } 376 377 static void qede_get_ethtool_stats(struct net_device *dev, 378 struct ethtool_stats *stats, u64 *buf) 379 { 380 struct qede_dev *edev = netdev_priv(dev); 381 struct qede_fastpath *fp; 382 int i; 383 384 qede_fill_by_demand_stats(edev); 385 386 /* Need to protect the access to the fastpath array */ 387 __qede_lock(edev); 388 389 for (i = 0; i < QEDE_QUEUE_CNT(edev); i++) { 390 fp = &edev->fp_array[i]; 391 392 if (fp->type & QEDE_FASTPATH_RX) 393 qede_get_ethtool_stats_rxq(fp->rxq, &buf); 394 395 if (fp->type & QEDE_FASTPATH_XDP) 396 qede_get_ethtool_stats_txq(fp->xdp_tx, &buf); 397 398 if (fp->type & QEDE_FASTPATH_TX) { 399 int cos; 400 401 for_each_cos_in_txq(edev, cos) 402 qede_get_ethtool_stats_txq(&fp->txq[cos], &buf); 403 } 404 } 405 406 spin_lock(&edev->stats_lock); 407 408 for (i = 0; i < QEDE_NUM_STATS; i++) { 409 if (qede_is_irrelevant_stat(edev, i)) 410 continue; 411 *buf = *((u64 *)(((void *)&edev->stats) + 412 qede_stats_arr[i].offset)); 413 414 buf++; 415 } 416 417 spin_unlock(&edev->stats_lock); 418 419 __qede_unlock(edev); 420 } 421 422 static int qede_get_sset_count(struct net_device *dev, int stringset) 423 { 424 struct qede_dev *edev = netdev_priv(dev); 425 int num_stats = QEDE_NUM_STATS, i; 426 427 switch (stringset) { 428 case ETH_SS_STATS: 429 for (i = 0; i < QEDE_NUM_STATS; i++) 430 if (qede_is_irrelevant_stat(edev, i)) 431 num_stats--; 432 433 /* Account for the Regular Tx statistics */ 434 num_stats += QEDE_TSS_COUNT(edev) * QEDE_NUM_TQSTATS * 435 edev->dev_info.num_tc; 436 437 /* Account for the Regular Rx statistics */ 438 num_stats += QEDE_RSS_COUNT(edev) * QEDE_NUM_RQSTATS; 439 440 /* Account for XDP statistics [if needed] */ 441 if (edev->xdp_prog) 442 num_stats += QEDE_RSS_COUNT(edev) * QEDE_NUM_TQSTATS; 443 return num_stats; 444 445 case ETH_SS_PRIV_FLAGS: 446 return QEDE_PRI_FLAG_LEN; 447 case ETH_SS_TEST: 448 if (!IS_VF(edev)) 449 return QEDE_ETHTOOL_TEST_MAX; 450 else 451 return 0; 452 default: 453 DP_VERBOSE(edev, QED_MSG_DEBUG, 454 "Unsupported stringset 0x%08x\n", stringset); 455 return -EINVAL; 456 } 457 } 458 459 static u32 qede_get_priv_flags(struct net_device *dev) 460 { 461 struct qede_dev *edev = netdev_priv(dev); 462 bool esl_active; 463 u32 flags = 0; 464 465 if (edev->dev_info.common.num_hwfns > 1) 466 flags |= BIT(QEDE_PRI_FLAG_CMT); 467 468 if (edev->dev_info.common.smart_an) 469 flags |= BIT(QEDE_PRI_FLAG_SMART_AN_SUPPORT); 470 471 if (edev->err_flags & BIT(QEDE_ERR_IS_RECOVERABLE)) 472 flags |= BIT(QEDE_PRI_FLAG_RECOVER_ON_ERROR); 473 474 if (edev->dev_info.common.esl) 475 flags |= BIT(QEDE_PRI_FLAG_ESL_SUPPORT); 476 477 edev->ops->common->get_esl_status(edev->cdev, &esl_active); 478 479 if (esl_active) 480 flags |= BIT(QEDE_PRI_FLAG_ESL_ACTIVE); 481 482 return flags; 483 } 484 485 static int qede_set_priv_flags(struct net_device *dev, u32 flags) 486 { 487 struct qede_dev *edev = netdev_priv(dev); 488 u32 cflags = qede_get_priv_flags(dev); 489 u32 dflags = flags ^ cflags; 490 491 /* can only change RECOVER_ON_ERROR flag */ 492 if (dflags & ~BIT(QEDE_PRI_FLAG_RECOVER_ON_ERROR)) 493 return -EINVAL; 494 495 if (flags & BIT(QEDE_PRI_FLAG_RECOVER_ON_ERROR)) 496 set_bit(QEDE_ERR_IS_RECOVERABLE, &edev->err_flags); 497 else 498 clear_bit(QEDE_ERR_IS_RECOVERABLE, &edev->err_flags); 499 500 return 0; 501 } 502 503 static int qede_get_link_ksettings(struct net_device *dev, 504 struct ethtool_link_ksettings *cmd) 505 { 506 typeof(cmd->link_modes) *link_modes = &cmd->link_modes; 507 struct ethtool_link_settings *base = &cmd->base; 508 struct qede_dev *edev = netdev_priv(dev); 509 struct qed_link_output current_link; 510 511 __qede_lock(edev); 512 513 memset(¤t_link, 0, sizeof(current_link)); 514 edev->ops->common->get_link(edev->cdev, ¤t_link); 515 516 linkmode_copy(link_modes->supported, current_link.supported_caps); 517 linkmode_copy(link_modes->advertising, current_link.advertised_caps); 518 linkmode_copy(link_modes->lp_advertising, current_link.lp_caps); 519 520 if ((edev->state == QEDE_STATE_OPEN) && (current_link.link_up)) { 521 base->speed = current_link.speed; 522 base->duplex = current_link.duplex; 523 } else { 524 base->speed = SPEED_UNKNOWN; 525 base->duplex = DUPLEX_UNKNOWN; 526 } 527 528 __qede_unlock(edev); 529 530 base->port = current_link.port; 531 base->autoneg = (current_link.autoneg) ? AUTONEG_ENABLE : 532 AUTONEG_DISABLE; 533 534 return 0; 535 } 536 537 static int qede_set_link_ksettings(struct net_device *dev, 538 const struct ethtool_link_ksettings *cmd) 539 { 540 const struct ethtool_link_settings *base = &cmd->base; 541 const struct ethtool_forced_speed_map *map; 542 struct qede_dev *edev = netdev_priv(dev); 543 struct qed_link_output current_link; 544 struct qed_link_params params; 545 u32 i; 546 547 if (!edev->ops || !edev->ops->common->can_link_change(edev->cdev)) { 548 DP_INFO(edev, "Link settings are not allowed to be changed\n"); 549 return -EOPNOTSUPP; 550 } 551 memset(¤t_link, 0, sizeof(current_link)); 552 memset(¶ms, 0, sizeof(params)); 553 edev->ops->common->get_link(edev->cdev, ¤t_link); 554 555 params.override_flags |= QED_LINK_OVERRIDE_SPEED_ADV_SPEEDS; 556 params.override_flags |= QED_LINK_OVERRIDE_SPEED_AUTONEG; 557 558 if (base->autoneg == AUTONEG_ENABLE) { 559 if (!phylink_test(current_link.supported_caps, Autoneg)) { 560 DP_INFO(edev, "Auto negotiation is not supported\n"); 561 return -EOPNOTSUPP; 562 } 563 564 params.autoneg = true; 565 params.forced_speed = 0; 566 567 linkmode_copy(params.adv_speeds, cmd->link_modes.advertising); 568 } else { /* forced speed */ 569 params.override_flags |= QED_LINK_OVERRIDE_SPEED_FORCED_SPEED; 570 params.autoneg = false; 571 params.forced_speed = base->speed; 572 573 for (i = 0; i < ARRAY_SIZE(qede_forced_speed_maps); i++) { 574 map = qede_forced_speed_maps + i; 575 576 if (base->speed != map->speed || 577 !linkmode_intersects(current_link.supported_caps, 578 map->caps)) 579 continue; 580 581 linkmode_and(params.adv_speeds, 582 current_link.supported_caps, map->caps); 583 goto set_link; 584 } 585 586 DP_INFO(edev, "Unsupported speed %u\n", base->speed); 587 return -EINVAL; 588 } 589 590 set_link: 591 params.link_up = true; 592 edev->ops->common->set_link(edev->cdev, ¶ms); 593 594 return 0; 595 } 596 597 static void qede_get_drvinfo(struct net_device *ndev, 598 struct ethtool_drvinfo *info) 599 { 600 char mfw[ETHTOOL_FWVERS_LEN], storm[ETHTOOL_FWVERS_LEN]; 601 struct qede_dev *edev = netdev_priv(ndev); 602 char mbi[ETHTOOL_FWVERS_LEN]; 603 604 strscpy(info->driver, "qede", sizeof(info->driver)); 605 606 snprintf(storm, ETHTOOL_FWVERS_LEN, "%d.%d.%d.%d", 607 edev->dev_info.common.fw_major, 608 edev->dev_info.common.fw_minor, 609 edev->dev_info.common.fw_rev, 610 edev->dev_info.common.fw_eng); 611 612 snprintf(mfw, ETHTOOL_FWVERS_LEN, "%d.%d.%d.%d", 613 (edev->dev_info.common.mfw_rev >> 24) & 0xFF, 614 (edev->dev_info.common.mfw_rev >> 16) & 0xFF, 615 (edev->dev_info.common.mfw_rev >> 8) & 0xFF, 616 edev->dev_info.common.mfw_rev & 0xFF); 617 618 if ((strlen(storm) + strlen("[storm]")) < 619 sizeof(info->version)) 620 snprintf(info->version, sizeof(info->version), 621 "[storm %s]", storm); 622 else 623 snprintf(info->version, sizeof(info->version), 624 "%s", storm); 625 626 if (edev->dev_info.common.mbi_version) { 627 snprintf(mbi, ETHTOOL_FWVERS_LEN, "%d.%d.%d", 628 (edev->dev_info.common.mbi_version & 629 QED_MBI_VERSION_2_MASK) >> QED_MBI_VERSION_2_OFFSET, 630 (edev->dev_info.common.mbi_version & 631 QED_MBI_VERSION_1_MASK) >> QED_MBI_VERSION_1_OFFSET, 632 (edev->dev_info.common.mbi_version & 633 QED_MBI_VERSION_0_MASK) >> QED_MBI_VERSION_0_OFFSET); 634 snprintf(info->fw_version, sizeof(info->fw_version), 635 "mbi %s [mfw %s]", mbi, mfw); 636 } else { 637 snprintf(info->fw_version, sizeof(info->fw_version), 638 "mfw %s", mfw); 639 } 640 641 strscpy(info->bus_info, pci_name(edev->pdev), sizeof(info->bus_info)); 642 } 643 644 static void qede_get_wol(struct net_device *ndev, struct ethtool_wolinfo *wol) 645 { 646 struct qede_dev *edev = netdev_priv(ndev); 647 648 if (edev->dev_info.common.wol_support) { 649 wol->supported = WAKE_MAGIC; 650 wol->wolopts = edev->wol_enabled ? WAKE_MAGIC : 0; 651 } 652 } 653 654 static int qede_set_wol(struct net_device *ndev, struct ethtool_wolinfo *wol) 655 { 656 struct qede_dev *edev = netdev_priv(ndev); 657 bool wol_requested; 658 int rc; 659 660 if (wol->wolopts & ~WAKE_MAGIC) { 661 DP_INFO(edev, 662 "Can't support WoL options other than magic-packet\n"); 663 return -EINVAL; 664 } 665 666 wol_requested = !!(wol->wolopts & WAKE_MAGIC); 667 if (wol_requested == edev->wol_enabled) 668 return 0; 669 670 /* Need to actually change configuration */ 671 if (!edev->dev_info.common.wol_support) { 672 DP_INFO(edev, "Device doesn't support WoL\n"); 673 return -EINVAL; 674 } 675 676 rc = edev->ops->common->update_wol(edev->cdev, wol_requested); 677 if (!rc) 678 edev->wol_enabled = wol_requested; 679 680 return rc; 681 } 682 683 static u32 qede_get_msglevel(struct net_device *ndev) 684 { 685 struct qede_dev *edev = netdev_priv(ndev); 686 687 return ((u32)edev->dp_level << QED_LOG_LEVEL_SHIFT) | edev->dp_module; 688 } 689 690 static void qede_set_msglevel(struct net_device *ndev, u32 level) 691 { 692 struct qede_dev *edev = netdev_priv(ndev); 693 u32 dp_module = 0; 694 u8 dp_level = 0; 695 696 qede_config_debug(level, &dp_module, &dp_level); 697 698 edev->dp_level = dp_level; 699 edev->dp_module = dp_module; 700 edev->ops->common->update_msglvl(edev->cdev, 701 dp_module, dp_level); 702 } 703 704 static int qede_nway_reset(struct net_device *dev) 705 { 706 struct qede_dev *edev = netdev_priv(dev); 707 struct qed_link_output current_link; 708 struct qed_link_params link_params; 709 710 if (!edev->ops || !edev->ops->common->can_link_change(edev->cdev)) { 711 DP_INFO(edev, "Link settings are not allowed to be changed\n"); 712 return -EOPNOTSUPP; 713 } 714 715 if (!netif_running(dev)) 716 return 0; 717 718 memset(¤t_link, 0, sizeof(current_link)); 719 edev->ops->common->get_link(edev->cdev, ¤t_link); 720 if (!current_link.link_up) 721 return 0; 722 723 /* Toggle the link */ 724 memset(&link_params, 0, sizeof(link_params)); 725 link_params.link_up = false; 726 edev->ops->common->set_link(edev->cdev, &link_params); 727 link_params.link_up = true; 728 edev->ops->common->set_link(edev->cdev, &link_params); 729 730 return 0; 731 } 732 733 static u32 qede_get_link(struct net_device *dev) 734 { 735 struct qede_dev *edev = netdev_priv(dev); 736 struct qed_link_output current_link; 737 738 memset(¤t_link, 0, sizeof(current_link)); 739 edev->ops->common->get_link(edev->cdev, ¤t_link); 740 741 return current_link.link_up; 742 } 743 744 static int qede_flash_device(struct net_device *dev, 745 struct ethtool_flash *flash) 746 { 747 struct qede_dev *edev = netdev_priv(dev); 748 749 return edev->ops->common->nvm_flash(edev->cdev, flash->data); 750 } 751 752 static int qede_get_coalesce(struct net_device *dev, 753 struct ethtool_coalesce *coal, 754 struct kernel_ethtool_coalesce *kernel_coal, 755 struct netlink_ext_ack *extack) 756 { 757 void *rx_handle = NULL, *tx_handle = NULL; 758 struct qede_dev *edev = netdev_priv(dev); 759 u16 rx_coal, tx_coal, i, rc = 0; 760 struct qede_fastpath *fp; 761 762 rx_coal = QED_DEFAULT_RX_USECS; 763 tx_coal = QED_DEFAULT_TX_USECS; 764 765 memset(coal, 0, sizeof(struct ethtool_coalesce)); 766 767 __qede_lock(edev); 768 if (edev->state == QEDE_STATE_OPEN) { 769 for_each_queue(i) { 770 fp = &edev->fp_array[i]; 771 772 if (fp->type & QEDE_FASTPATH_RX) { 773 rx_handle = fp->rxq->handle; 774 break; 775 } 776 } 777 778 rc = edev->ops->get_coalesce(edev->cdev, &rx_coal, rx_handle); 779 if (rc) { 780 DP_INFO(edev, "Read Rx coalesce error\n"); 781 goto out; 782 } 783 784 for_each_queue(i) { 785 struct qede_tx_queue *txq; 786 787 fp = &edev->fp_array[i]; 788 789 /* All TX queues of given fastpath uses same 790 * coalescing value, so no need to iterate over 791 * all TCs, TC0 txq should suffice. 792 */ 793 if (fp->type & QEDE_FASTPATH_TX) { 794 txq = QEDE_FP_TC0_TXQ(fp); 795 tx_handle = txq->handle; 796 break; 797 } 798 } 799 800 rc = edev->ops->get_coalesce(edev->cdev, &tx_coal, tx_handle); 801 if (rc) 802 DP_INFO(edev, "Read Tx coalesce error\n"); 803 } 804 805 out: 806 __qede_unlock(edev); 807 808 coal->rx_coalesce_usecs = rx_coal; 809 coal->tx_coalesce_usecs = tx_coal; 810 coal->stats_block_coalesce_usecs = edev->stats_coal_usecs; 811 812 return rc; 813 } 814 815 int qede_set_coalesce(struct net_device *dev, struct ethtool_coalesce *coal, 816 struct kernel_ethtool_coalesce *kernel_coal, 817 struct netlink_ext_ack *extack) 818 { 819 struct qede_dev *edev = netdev_priv(dev); 820 struct qede_fastpath *fp; 821 int i, rc = 0; 822 u16 rxc, txc; 823 824 if (edev->stats_coal_usecs != coal->stats_block_coalesce_usecs) { 825 edev->stats_coal_usecs = coal->stats_block_coalesce_usecs; 826 if (edev->stats_coal_usecs) { 827 edev->stats_coal_ticks = usecs_to_jiffies(edev->stats_coal_usecs); 828 schedule_delayed_work(&edev->periodic_task, 0); 829 830 DP_INFO(edev, "Configured stats coal ticks=%lu jiffies\n", 831 edev->stats_coal_ticks); 832 } else { 833 cancel_delayed_work_sync(&edev->periodic_task); 834 } 835 } 836 837 if (!netif_running(dev)) { 838 DP_INFO(edev, "Interface is down\n"); 839 return -EINVAL; 840 } 841 842 if (coal->rx_coalesce_usecs > QED_COALESCE_MAX || 843 coal->tx_coalesce_usecs > QED_COALESCE_MAX) { 844 DP_INFO(edev, 845 "Can't support requested %s coalesce value [max supported value %d]\n", 846 coal->rx_coalesce_usecs > QED_COALESCE_MAX ? "rx" : 847 "tx", QED_COALESCE_MAX); 848 return -EINVAL; 849 } 850 851 rxc = (u16)coal->rx_coalesce_usecs; 852 txc = (u16)coal->tx_coalesce_usecs; 853 for_each_queue(i) { 854 fp = &edev->fp_array[i]; 855 856 if (edev->fp_array[i].type & QEDE_FASTPATH_RX) { 857 rc = edev->ops->common->set_coalesce(edev->cdev, 858 rxc, 0, 859 fp->rxq->handle); 860 if (rc) { 861 DP_INFO(edev, 862 "Set RX coalesce error, rc = %d\n", rc); 863 return rc; 864 } 865 edev->coal_entry[i].rxc = rxc; 866 edev->coal_entry[i].isvalid = true; 867 } 868 869 if (edev->fp_array[i].type & QEDE_FASTPATH_TX) { 870 struct qede_tx_queue *txq; 871 872 /* All TX queues of given fastpath uses same 873 * coalescing value, so no need to iterate over 874 * all TCs, TC0 txq should suffice. 875 */ 876 txq = QEDE_FP_TC0_TXQ(fp); 877 878 rc = edev->ops->common->set_coalesce(edev->cdev, 879 0, txc, 880 txq->handle); 881 if (rc) { 882 DP_INFO(edev, 883 "Set TX coalesce error, rc = %d\n", rc); 884 return rc; 885 } 886 edev->coal_entry[i].txc = txc; 887 edev->coal_entry[i].isvalid = true; 888 } 889 } 890 891 return rc; 892 } 893 894 static void qede_get_ringparam(struct net_device *dev, 895 struct ethtool_ringparam *ering, 896 struct kernel_ethtool_ringparam *kernel_ering, 897 struct netlink_ext_ack *extack) 898 { 899 struct qede_dev *edev = netdev_priv(dev); 900 901 ering->rx_max_pending = NUM_RX_BDS_MAX; 902 ering->rx_pending = edev->q_num_rx_buffers; 903 ering->tx_max_pending = NUM_TX_BDS_MAX; 904 ering->tx_pending = edev->q_num_tx_buffers; 905 } 906 907 static int qede_set_ringparam(struct net_device *dev, 908 struct ethtool_ringparam *ering, 909 struct kernel_ethtool_ringparam *kernel_ering, 910 struct netlink_ext_ack *extack) 911 { 912 struct qede_dev *edev = netdev_priv(dev); 913 914 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN), 915 "Set ring params command parameters: rx_pending = %d, tx_pending = %d\n", 916 ering->rx_pending, ering->tx_pending); 917 918 /* Validate legality of configuration */ 919 if (ering->rx_pending > NUM_RX_BDS_MAX || 920 ering->rx_pending < NUM_RX_BDS_MIN || 921 ering->tx_pending > NUM_TX_BDS_MAX || 922 ering->tx_pending < NUM_TX_BDS_MIN) { 923 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN), 924 "Can only support Rx Buffer size [0%08x,...,0x%08x] and Tx Buffer size [0x%08x,...,0x%08x]\n", 925 NUM_RX_BDS_MIN, NUM_RX_BDS_MAX, 926 NUM_TX_BDS_MIN, NUM_TX_BDS_MAX); 927 return -EINVAL; 928 } 929 930 /* Change ring size and re-load */ 931 edev->q_num_rx_buffers = ering->rx_pending; 932 edev->q_num_tx_buffers = ering->tx_pending; 933 934 qede_reload(edev, NULL, false); 935 936 return 0; 937 } 938 939 static void qede_get_pauseparam(struct net_device *dev, 940 struct ethtool_pauseparam *epause) 941 { 942 struct qede_dev *edev = netdev_priv(dev); 943 struct qed_link_output current_link; 944 945 memset(¤t_link, 0, sizeof(current_link)); 946 edev->ops->common->get_link(edev->cdev, ¤t_link); 947 948 if (current_link.pause_config & QED_LINK_PAUSE_AUTONEG_ENABLE) 949 epause->autoneg = true; 950 if (current_link.pause_config & QED_LINK_PAUSE_RX_ENABLE) 951 epause->rx_pause = true; 952 if (current_link.pause_config & QED_LINK_PAUSE_TX_ENABLE) 953 epause->tx_pause = true; 954 955 DP_VERBOSE(edev, QED_MSG_DEBUG, 956 "ethtool_pauseparam: cmd %d autoneg %d rx_pause %d tx_pause %d\n", 957 epause->cmd, epause->autoneg, epause->rx_pause, 958 epause->tx_pause); 959 } 960 961 static int qede_set_pauseparam(struct net_device *dev, 962 struct ethtool_pauseparam *epause) 963 { 964 struct qede_dev *edev = netdev_priv(dev); 965 struct qed_link_params params; 966 struct qed_link_output current_link; 967 968 if (!edev->ops || !edev->ops->common->can_link_change(edev->cdev)) { 969 DP_INFO(edev, 970 "Pause settings are not allowed to be changed\n"); 971 return -EOPNOTSUPP; 972 } 973 974 memset(¤t_link, 0, sizeof(current_link)); 975 edev->ops->common->get_link(edev->cdev, ¤t_link); 976 977 memset(¶ms, 0, sizeof(params)); 978 params.override_flags |= QED_LINK_OVERRIDE_PAUSE_CONFIG; 979 980 if (epause->autoneg) { 981 if (!phylink_test(current_link.supported_caps, Autoneg)) { 982 DP_INFO(edev, "autoneg not supported\n"); 983 return -EINVAL; 984 } 985 986 params.pause_config |= QED_LINK_PAUSE_AUTONEG_ENABLE; 987 } 988 989 if (epause->rx_pause) 990 params.pause_config |= QED_LINK_PAUSE_RX_ENABLE; 991 if (epause->tx_pause) 992 params.pause_config |= QED_LINK_PAUSE_TX_ENABLE; 993 994 params.link_up = true; 995 edev->ops->common->set_link(edev->cdev, ¶ms); 996 997 return 0; 998 } 999 1000 static void qede_get_regs(struct net_device *ndev, 1001 struct ethtool_regs *regs, void *buffer) 1002 { 1003 struct qede_dev *edev = netdev_priv(ndev); 1004 1005 regs->version = 0; 1006 memset(buffer, 0, regs->len); 1007 1008 if (edev->ops && edev->ops->common) 1009 edev->ops->common->dbg_all_data(edev->cdev, buffer); 1010 } 1011 1012 static int qede_get_regs_len(struct net_device *ndev) 1013 { 1014 struct qede_dev *edev = netdev_priv(ndev); 1015 1016 if (edev->ops && edev->ops->common) 1017 return edev->ops->common->dbg_all_data_size(edev->cdev); 1018 else 1019 return -EINVAL; 1020 } 1021 1022 static void qede_update_mtu(struct qede_dev *edev, 1023 struct qede_reload_args *args) 1024 { 1025 WRITE_ONCE(edev->ndev->mtu, args->u.mtu); 1026 } 1027 1028 /* Netdevice NDOs */ 1029 int qede_change_mtu(struct net_device *ndev, int new_mtu) 1030 { 1031 struct qede_dev *edev = netdev_priv(ndev); 1032 struct qede_reload_args args; 1033 1034 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN), 1035 "Configuring MTU size of %d\n", new_mtu); 1036 1037 if (new_mtu > PAGE_SIZE) 1038 ndev->features &= ~NETIF_F_GRO_HW; 1039 1040 /* Set the mtu field and re-start the interface if needed */ 1041 args.u.mtu = new_mtu; 1042 args.func = &qede_update_mtu; 1043 qede_reload(edev, &args, false); 1044 #if IS_ENABLED(CONFIG_QED_RDMA) 1045 qede_rdma_event_change_mtu(edev); 1046 #endif 1047 edev->ops->common->update_mtu(edev->cdev, new_mtu); 1048 1049 return 0; 1050 } 1051 1052 static void qede_get_channels(struct net_device *dev, 1053 struct ethtool_channels *channels) 1054 { 1055 struct qede_dev *edev = netdev_priv(dev); 1056 1057 channels->max_combined = QEDE_MAX_RSS_CNT(edev); 1058 channels->max_rx = QEDE_MAX_RSS_CNT(edev); 1059 channels->max_tx = QEDE_MAX_RSS_CNT(edev); 1060 channels->combined_count = QEDE_QUEUE_CNT(edev) - edev->fp_num_tx - 1061 edev->fp_num_rx; 1062 channels->tx_count = edev->fp_num_tx; 1063 channels->rx_count = edev->fp_num_rx; 1064 } 1065 1066 static int qede_set_channels(struct net_device *dev, 1067 struct ethtool_channels *channels) 1068 { 1069 struct qede_dev *edev = netdev_priv(dev); 1070 u32 count; 1071 1072 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN), 1073 "set-channels command parameters: rx = %d, tx = %d, other = %d, combined = %d\n", 1074 channels->rx_count, channels->tx_count, 1075 channels->other_count, channels->combined_count); 1076 1077 count = channels->rx_count + channels->tx_count + 1078 channels->combined_count; 1079 1080 /* We don't support `other' channels */ 1081 if (channels->other_count) { 1082 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN), 1083 "command parameters not supported\n"); 1084 return -EINVAL; 1085 } 1086 1087 if (!(channels->combined_count || (channels->rx_count && 1088 channels->tx_count))) { 1089 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN), 1090 "need to request at least one transmit and one receive channel\n"); 1091 return -EINVAL; 1092 } 1093 1094 if (count > QEDE_MAX_RSS_CNT(edev)) { 1095 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN), 1096 "requested channels = %d max supported channels = %d\n", 1097 count, QEDE_MAX_RSS_CNT(edev)); 1098 return -EINVAL; 1099 } 1100 1101 /* Check if there was a change in the active parameters */ 1102 if ((count == QEDE_QUEUE_CNT(edev)) && 1103 (channels->tx_count == edev->fp_num_tx) && 1104 (channels->rx_count == edev->fp_num_rx)) { 1105 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN), 1106 "No change in active parameters\n"); 1107 return 0; 1108 } 1109 1110 /* We need the number of queues to be divisible between the hwfns */ 1111 if ((count % edev->dev_info.common.num_hwfns) || 1112 (channels->tx_count % edev->dev_info.common.num_hwfns) || 1113 (channels->rx_count % edev->dev_info.common.num_hwfns)) { 1114 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN), 1115 "Number of channels must be divisible by %04x\n", 1116 edev->dev_info.common.num_hwfns); 1117 return -EINVAL; 1118 } 1119 1120 /* Set number of queues and reload if necessary */ 1121 edev->req_queues = count; 1122 edev->req_num_tx = channels->tx_count; 1123 edev->req_num_rx = channels->rx_count; 1124 /* Reset the indirection table if rx queue count is updated */ 1125 if ((edev->req_queues - edev->req_num_tx) != QEDE_RSS_COUNT(edev)) { 1126 edev->rss_params_inited &= ~QEDE_RSS_INDIR_INITED; 1127 memset(edev->rss_ind_table, 0, sizeof(edev->rss_ind_table)); 1128 } 1129 1130 qede_reload(edev, NULL, false); 1131 1132 return 0; 1133 } 1134 1135 static int qede_get_ts_info(struct net_device *dev, 1136 struct kernel_ethtool_ts_info *info) 1137 { 1138 struct qede_dev *edev = netdev_priv(dev); 1139 1140 return qede_ptp_get_ts_info(edev, info); 1141 } 1142 1143 static int qede_set_phys_id(struct net_device *dev, 1144 enum ethtool_phys_id_state state) 1145 { 1146 struct qede_dev *edev = netdev_priv(dev); 1147 u8 led_state = 0; 1148 1149 switch (state) { 1150 case ETHTOOL_ID_ACTIVE: 1151 return 1; /* cycle on/off once per second */ 1152 1153 case ETHTOOL_ID_ON: 1154 led_state = QED_LED_MODE_ON; 1155 break; 1156 1157 case ETHTOOL_ID_OFF: 1158 led_state = QED_LED_MODE_OFF; 1159 break; 1160 1161 case ETHTOOL_ID_INACTIVE: 1162 led_state = QED_LED_MODE_RESTORE; 1163 break; 1164 } 1165 1166 edev->ops->common->set_led(edev->cdev, led_state); 1167 1168 return 0; 1169 } 1170 1171 static int qede_get_rss_flags(struct qede_dev *edev, struct ethtool_rxnfc *info) 1172 { 1173 info->data = RXH_IP_SRC | RXH_IP_DST; 1174 1175 switch (info->flow_type) { 1176 case TCP_V4_FLOW: 1177 case TCP_V6_FLOW: 1178 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 1179 break; 1180 case UDP_V4_FLOW: 1181 if (edev->rss_caps & QED_RSS_IPV4_UDP) 1182 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 1183 break; 1184 case UDP_V6_FLOW: 1185 if (edev->rss_caps & QED_RSS_IPV6_UDP) 1186 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 1187 break; 1188 case IPV4_FLOW: 1189 case IPV6_FLOW: 1190 break; 1191 default: 1192 info->data = 0; 1193 break; 1194 } 1195 1196 return 0; 1197 } 1198 1199 static int qede_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info, 1200 u32 *rule_locs) 1201 { 1202 struct qede_dev *edev = netdev_priv(dev); 1203 int rc = 0; 1204 1205 switch (info->cmd) { 1206 case ETHTOOL_GRXRINGS: 1207 info->data = QEDE_RSS_COUNT(edev); 1208 break; 1209 case ETHTOOL_GRXFH: 1210 rc = qede_get_rss_flags(edev, info); 1211 break; 1212 case ETHTOOL_GRXCLSRLCNT: 1213 info->rule_cnt = qede_get_arfs_filter_count(edev); 1214 info->data = QEDE_RFS_MAX_FLTR; 1215 break; 1216 case ETHTOOL_GRXCLSRULE: 1217 rc = qede_get_cls_rule_entry(edev, info); 1218 break; 1219 case ETHTOOL_GRXCLSRLALL: 1220 rc = qede_get_cls_rule_all(edev, info, rule_locs); 1221 break; 1222 default: 1223 DP_ERR(edev, "Command parameters not supported\n"); 1224 rc = -EOPNOTSUPP; 1225 } 1226 1227 return rc; 1228 } 1229 1230 static int qede_set_rss_flags(struct qede_dev *edev, struct ethtool_rxnfc *info) 1231 { 1232 struct qed_update_vport_params *vport_update_params; 1233 u8 set_caps = 0, clr_caps = 0; 1234 int rc = 0; 1235 1236 DP_VERBOSE(edev, QED_MSG_DEBUG, 1237 "Set rss flags command parameters: flow type = %d, data = %llu\n", 1238 info->flow_type, info->data); 1239 1240 switch (info->flow_type) { 1241 case TCP_V4_FLOW: 1242 case TCP_V6_FLOW: 1243 /* For TCP only 4-tuple hash is supported */ 1244 if (info->data ^ (RXH_IP_SRC | RXH_IP_DST | 1245 RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 1246 DP_INFO(edev, "Command parameters not supported\n"); 1247 return -EINVAL; 1248 } 1249 return 0; 1250 case UDP_V4_FLOW: 1251 /* For UDP either 2-tuple hash or 4-tuple hash is supported */ 1252 if (info->data == (RXH_IP_SRC | RXH_IP_DST | 1253 RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 1254 set_caps = QED_RSS_IPV4_UDP; 1255 DP_VERBOSE(edev, QED_MSG_DEBUG, 1256 "UDP 4-tuple enabled\n"); 1257 } else if (info->data == (RXH_IP_SRC | RXH_IP_DST)) { 1258 clr_caps = QED_RSS_IPV4_UDP; 1259 DP_VERBOSE(edev, QED_MSG_DEBUG, 1260 "UDP 4-tuple disabled\n"); 1261 } else { 1262 return -EINVAL; 1263 } 1264 break; 1265 case UDP_V6_FLOW: 1266 /* For UDP either 2-tuple hash or 4-tuple hash is supported */ 1267 if (info->data == (RXH_IP_SRC | RXH_IP_DST | 1268 RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 1269 set_caps = QED_RSS_IPV6_UDP; 1270 DP_VERBOSE(edev, QED_MSG_DEBUG, 1271 "UDP 4-tuple enabled\n"); 1272 } else if (info->data == (RXH_IP_SRC | RXH_IP_DST)) { 1273 clr_caps = QED_RSS_IPV6_UDP; 1274 DP_VERBOSE(edev, QED_MSG_DEBUG, 1275 "UDP 4-tuple disabled\n"); 1276 } else { 1277 return -EINVAL; 1278 } 1279 break; 1280 case IPV4_FLOW: 1281 case IPV6_FLOW: 1282 /* For IP only 2-tuple hash is supported */ 1283 if (info->data ^ (RXH_IP_SRC | RXH_IP_DST)) { 1284 DP_INFO(edev, "Command parameters not supported\n"); 1285 return -EINVAL; 1286 } 1287 return 0; 1288 case SCTP_V4_FLOW: 1289 case AH_ESP_V4_FLOW: 1290 case AH_V4_FLOW: 1291 case ESP_V4_FLOW: 1292 case SCTP_V6_FLOW: 1293 case AH_ESP_V6_FLOW: 1294 case AH_V6_FLOW: 1295 case ESP_V6_FLOW: 1296 case IP_USER_FLOW: 1297 case ETHER_FLOW: 1298 /* RSS is not supported for these protocols */ 1299 if (info->data) { 1300 DP_INFO(edev, "Command parameters not supported\n"); 1301 return -EINVAL; 1302 } 1303 return 0; 1304 default: 1305 return -EINVAL; 1306 } 1307 1308 /* No action is needed if there is no change in the rss capability */ 1309 if (edev->rss_caps == ((edev->rss_caps & ~clr_caps) | set_caps)) 1310 return 0; 1311 1312 /* Update internal configuration */ 1313 edev->rss_caps = ((edev->rss_caps & ~clr_caps) | set_caps); 1314 edev->rss_params_inited |= QEDE_RSS_CAPS_INITED; 1315 1316 /* Re-configure if possible */ 1317 __qede_lock(edev); 1318 if (edev->state == QEDE_STATE_OPEN) { 1319 vport_update_params = vzalloc(sizeof(*vport_update_params)); 1320 if (!vport_update_params) { 1321 __qede_unlock(edev); 1322 return -ENOMEM; 1323 } 1324 qede_fill_rss_params(edev, &vport_update_params->rss_params, 1325 &vport_update_params->update_rss_flg); 1326 rc = edev->ops->vport_update(edev->cdev, vport_update_params); 1327 vfree(vport_update_params); 1328 } 1329 __qede_unlock(edev); 1330 1331 return rc; 1332 } 1333 1334 static int qede_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info) 1335 { 1336 struct qede_dev *edev = netdev_priv(dev); 1337 int rc; 1338 1339 switch (info->cmd) { 1340 case ETHTOOL_SRXFH: 1341 rc = qede_set_rss_flags(edev, info); 1342 break; 1343 case ETHTOOL_SRXCLSRLINS: 1344 rc = qede_add_cls_rule(edev, info); 1345 break; 1346 case ETHTOOL_SRXCLSRLDEL: 1347 rc = qede_delete_flow_filter(edev, info->fs.location); 1348 break; 1349 default: 1350 DP_INFO(edev, "Command parameters not supported\n"); 1351 rc = -EOPNOTSUPP; 1352 } 1353 1354 return rc; 1355 } 1356 1357 static u32 qede_get_rxfh_indir_size(struct net_device *dev) 1358 { 1359 return QED_RSS_IND_TABLE_SIZE; 1360 } 1361 1362 static u32 qede_get_rxfh_key_size(struct net_device *dev) 1363 { 1364 struct qede_dev *edev = netdev_priv(dev); 1365 1366 return sizeof(edev->rss_key); 1367 } 1368 1369 static int qede_get_rxfh(struct net_device *dev, 1370 struct ethtool_rxfh_param *rxfh) 1371 { 1372 struct qede_dev *edev = netdev_priv(dev); 1373 int i; 1374 1375 rxfh->hfunc = ETH_RSS_HASH_TOP; 1376 1377 if (!rxfh->indir) 1378 return 0; 1379 1380 for (i = 0; i < QED_RSS_IND_TABLE_SIZE; i++) 1381 rxfh->indir[i] = edev->rss_ind_table[i]; 1382 1383 if (rxfh->key) 1384 memcpy(rxfh->key, edev->rss_key, qede_get_rxfh_key_size(dev)); 1385 1386 return 0; 1387 } 1388 1389 static int qede_set_rxfh(struct net_device *dev, 1390 struct ethtool_rxfh_param *rxfh, 1391 struct netlink_ext_ack *extack) 1392 { 1393 struct qed_update_vport_params *vport_update_params; 1394 struct qede_dev *edev = netdev_priv(dev); 1395 int i, rc = 0; 1396 1397 if (edev->dev_info.common.num_hwfns > 1) { 1398 DP_INFO(edev, 1399 "RSS configuration is not supported for 100G devices\n"); 1400 return -EOPNOTSUPP; 1401 } 1402 1403 if (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE && 1404 rxfh->hfunc != ETH_RSS_HASH_TOP) 1405 return -EOPNOTSUPP; 1406 1407 if (!rxfh->indir && !rxfh->key) 1408 return 0; 1409 1410 if (rxfh->indir) { 1411 for (i = 0; i < QED_RSS_IND_TABLE_SIZE; i++) 1412 edev->rss_ind_table[i] = rxfh->indir[i]; 1413 edev->rss_params_inited |= QEDE_RSS_INDIR_INITED; 1414 } 1415 1416 if (rxfh->key) { 1417 memcpy(&edev->rss_key, rxfh->key, qede_get_rxfh_key_size(dev)); 1418 edev->rss_params_inited |= QEDE_RSS_KEY_INITED; 1419 } 1420 1421 __qede_lock(edev); 1422 if (edev->state == QEDE_STATE_OPEN) { 1423 vport_update_params = vzalloc(sizeof(*vport_update_params)); 1424 if (!vport_update_params) { 1425 __qede_unlock(edev); 1426 return -ENOMEM; 1427 } 1428 qede_fill_rss_params(edev, &vport_update_params->rss_params, 1429 &vport_update_params->update_rss_flg); 1430 rc = edev->ops->vport_update(edev->cdev, vport_update_params); 1431 vfree(vport_update_params); 1432 } 1433 __qede_unlock(edev); 1434 1435 return rc; 1436 } 1437 1438 /* This function enables the interrupt generation and the NAPI on the device */ 1439 static void qede_netif_start(struct qede_dev *edev) 1440 { 1441 int i; 1442 1443 if (!netif_running(edev->ndev)) 1444 return; 1445 1446 for_each_queue(i) { 1447 /* Update and reenable interrupts */ 1448 qed_sb_ack(edev->fp_array[i].sb_info, IGU_INT_ENABLE, 1); 1449 napi_enable(&edev->fp_array[i].napi); 1450 } 1451 } 1452 1453 /* This function disables the NAPI and the interrupt generation on the device */ 1454 static void qede_netif_stop(struct qede_dev *edev) 1455 { 1456 int i; 1457 1458 for_each_queue(i) { 1459 napi_disable(&edev->fp_array[i].napi); 1460 /* Disable interrupts */ 1461 qed_sb_ack(edev->fp_array[i].sb_info, IGU_INT_DISABLE, 0); 1462 } 1463 } 1464 1465 static int qede_selftest_transmit_traffic(struct qede_dev *edev, 1466 struct sk_buff *skb) 1467 { 1468 struct qede_tx_queue *txq = NULL; 1469 struct eth_tx_1st_bd *first_bd; 1470 dma_addr_t mapping; 1471 int i, idx; 1472 u16 val; 1473 1474 for_each_queue(i) { 1475 struct qede_fastpath *fp = &edev->fp_array[i]; 1476 1477 if (fp->type & QEDE_FASTPATH_TX) { 1478 txq = QEDE_FP_TC0_TXQ(fp); 1479 break; 1480 } 1481 } 1482 1483 if (!txq) { 1484 DP_NOTICE(edev, "Tx path is not available\n"); 1485 return -1; 1486 } 1487 1488 /* Fill the entry in the SW ring and the BDs in the FW ring */ 1489 idx = txq->sw_tx_prod; 1490 txq->sw_tx_ring.skbs[idx].skb = skb; 1491 first_bd = qed_chain_produce(&txq->tx_pbl); 1492 memset(first_bd, 0, sizeof(*first_bd)); 1493 val = 1 << ETH_TX_1ST_BD_FLAGS_START_BD_SHIFT; 1494 first_bd->data.bd_flags.bitfields = val; 1495 val = skb->len & ETH_TX_DATA_1ST_BD_PKT_LEN_MASK; 1496 val = val << ETH_TX_DATA_1ST_BD_PKT_LEN_SHIFT; 1497 first_bd->data.bitfields |= cpu_to_le16(val); 1498 1499 /* Map skb linear data for DMA and set in the first BD */ 1500 mapping = dma_map_single(&edev->pdev->dev, skb->data, 1501 skb_headlen(skb), DMA_TO_DEVICE); 1502 if (unlikely(dma_mapping_error(&edev->pdev->dev, mapping))) { 1503 DP_NOTICE(edev, "SKB mapping failed\n"); 1504 return -ENOMEM; 1505 } 1506 BD_SET_UNMAP_ADDR_LEN(first_bd, mapping, skb_headlen(skb)); 1507 1508 /* update the first BD with the actual num BDs */ 1509 first_bd->data.nbds = 1; 1510 txq->sw_tx_prod = (txq->sw_tx_prod + 1) % txq->num_tx_buffers; 1511 /* 'next page' entries are counted in the producer value */ 1512 val = qed_chain_get_prod_idx(&txq->tx_pbl); 1513 txq->tx_db.data.bd_prod = cpu_to_le16(val); 1514 1515 /* wmb makes sure that the BDs data is updated before updating the 1516 * producer, otherwise FW may read old data from the BDs. 1517 */ 1518 wmb(); 1519 barrier(); 1520 writel(txq->tx_db.raw, txq->doorbell_addr); 1521 1522 for (i = 0; i < QEDE_SELFTEST_POLL_COUNT; i++) { 1523 if (qede_txq_has_work(txq)) 1524 break; 1525 usleep_range(100, 200); 1526 } 1527 1528 if (!qede_txq_has_work(txq)) { 1529 DP_NOTICE(edev, "Tx completion didn't happen\n"); 1530 return -1; 1531 } 1532 1533 first_bd = (struct eth_tx_1st_bd *)qed_chain_consume(&txq->tx_pbl); 1534 dma_unmap_single(&edev->pdev->dev, BD_UNMAP_ADDR(first_bd), 1535 BD_UNMAP_LEN(first_bd), DMA_TO_DEVICE); 1536 txq->sw_tx_cons = (txq->sw_tx_cons + 1) % txq->num_tx_buffers; 1537 txq->sw_tx_ring.skbs[idx].skb = NULL; 1538 1539 return 0; 1540 } 1541 1542 static int qede_selftest_receive_traffic(struct qede_dev *edev) 1543 { 1544 u16 sw_rx_index, len; 1545 struct eth_fast_path_rx_reg_cqe *fp_cqe; 1546 struct qede_rx_queue *rxq = NULL; 1547 struct sw_rx_data *sw_rx_data; 1548 union eth_rx_cqe *cqe; 1549 int i, iter, rc = 0; 1550 u8 *data_ptr; 1551 1552 for_each_queue(i) { 1553 if (edev->fp_array[i].type & QEDE_FASTPATH_RX) { 1554 rxq = edev->fp_array[i].rxq; 1555 break; 1556 } 1557 } 1558 1559 if (!rxq) { 1560 DP_NOTICE(edev, "Rx path is not available\n"); 1561 return -1; 1562 } 1563 1564 /* The packet is expected to receive on rx-queue 0 even though RSS is 1565 * enabled. This is because the queue 0 is configured as the default 1566 * queue and that the loopback traffic is not IP. 1567 */ 1568 for (iter = 0; iter < QEDE_SELFTEST_POLL_COUNT; iter++) { 1569 if (!qede_has_rx_work(rxq)) { 1570 usleep_range(100, 200); 1571 continue; 1572 } 1573 1574 /* Get the CQE from the completion ring */ 1575 cqe = (union eth_rx_cqe *)qed_chain_consume(&rxq->rx_comp_ring); 1576 1577 /* Get the data from the SW ring */ 1578 sw_rx_index = rxq->sw_rx_cons & NUM_RX_BDS_MAX; 1579 sw_rx_data = &rxq->sw_rx_ring[sw_rx_index]; 1580 fp_cqe = &cqe->fast_path_regular; 1581 len = le16_to_cpu(fp_cqe->len_on_first_bd); 1582 data_ptr = (u8 *)(page_address(sw_rx_data->data) + 1583 fp_cqe->placement_offset + 1584 sw_rx_data->page_offset + 1585 rxq->rx_headroom); 1586 if (ether_addr_equal(data_ptr, edev->ndev->dev_addr) && 1587 ether_addr_equal(data_ptr + ETH_ALEN, 1588 edev->ndev->dev_addr)) { 1589 for (i = ETH_HLEN; i < len; i++) 1590 if (data_ptr[i] != (unsigned char)(i & 0xff)) { 1591 rc = -1; 1592 break; 1593 } 1594 1595 qede_recycle_rx_bd_ring(rxq, 1); 1596 qed_chain_recycle_consumed(&rxq->rx_comp_ring); 1597 break; 1598 } 1599 1600 DP_INFO(edev, "Not the transmitted packet\n"); 1601 qede_recycle_rx_bd_ring(rxq, 1); 1602 qed_chain_recycle_consumed(&rxq->rx_comp_ring); 1603 } 1604 1605 if (iter == QEDE_SELFTEST_POLL_COUNT) { 1606 DP_NOTICE(edev, "Failed to receive the traffic\n"); 1607 return -1; 1608 } 1609 1610 qede_update_rx_prod(edev, rxq); 1611 1612 return rc; 1613 } 1614 1615 static int qede_selftest_run_loopback(struct qede_dev *edev, u32 loopback_mode) 1616 { 1617 struct qed_link_params link_params; 1618 struct sk_buff *skb = NULL; 1619 int rc = 0, i; 1620 u32 pkt_size; 1621 u8 *packet; 1622 1623 if (!netif_running(edev->ndev)) { 1624 DP_NOTICE(edev, "Interface is down\n"); 1625 return -EINVAL; 1626 } 1627 1628 qede_netif_stop(edev); 1629 1630 /* Bring up the link in Loopback mode */ 1631 memset(&link_params, 0, sizeof(link_params)); 1632 link_params.link_up = true; 1633 link_params.override_flags = QED_LINK_OVERRIDE_LOOPBACK_MODE; 1634 link_params.loopback_mode = loopback_mode; 1635 edev->ops->common->set_link(edev->cdev, &link_params); 1636 1637 /* Wait for loopback configuration to apply */ 1638 msleep_interruptible(500); 1639 1640 /* Setting max packet size to 1.5K to avoid data being split over 1641 * multiple BDs in cases where MTU > PAGE_SIZE. 1642 */ 1643 pkt_size = (((edev->ndev->mtu < ETH_DATA_LEN) ? 1644 edev->ndev->mtu : ETH_DATA_LEN) + ETH_HLEN); 1645 1646 skb = netdev_alloc_skb(edev->ndev, pkt_size); 1647 if (!skb) { 1648 DP_INFO(edev, "Can't allocate skb\n"); 1649 rc = -ENOMEM; 1650 goto test_loopback_exit; 1651 } 1652 packet = skb_put(skb, pkt_size); 1653 ether_addr_copy(packet, edev->ndev->dev_addr); 1654 ether_addr_copy(packet + ETH_ALEN, edev->ndev->dev_addr); 1655 memset(packet + (2 * ETH_ALEN), 0x77, (ETH_HLEN - (2 * ETH_ALEN))); 1656 for (i = ETH_HLEN; i < pkt_size; i++) 1657 packet[i] = (unsigned char)(i & 0xff); 1658 1659 rc = qede_selftest_transmit_traffic(edev, skb); 1660 if (rc) 1661 goto test_loopback_exit; 1662 1663 rc = qede_selftest_receive_traffic(edev); 1664 if (rc) 1665 goto test_loopback_exit; 1666 1667 DP_VERBOSE(edev, NETIF_MSG_RX_STATUS, "Loopback test successful\n"); 1668 1669 test_loopback_exit: 1670 dev_kfree_skb(skb); 1671 1672 /* Bring up the link in Normal mode */ 1673 memset(&link_params, 0, sizeof(link_params)); 1674 link_params.link_up = true; 1675 link_params.override_flags = QED_LINK_OVERRIDE_LOOPBACK_MODE; 1676 link_params.loopback_mode = QED_LINK_LOOPBACK_NONE; 1677 edev->ops->common->set_link(edev->cdev, &link_params); 1678 1679 /* Wait for loopback configuration to apply */ 1680 msleep_interruptible(500); 1681 1682 qede_netif_start(edev); 1683 1684 return rc; 1685 } 1686 1687 static void qede_self_test(struct net_device *dev, 1688 struct ethtool_test *etest, u64 *buf) 1689 { 1690 struct qede_dev *edev = netdev_priv(dev); 1691 1692 DP_VERBOSE(edev, QED_MSG_DEBUG, 1693 "Self-test command parameters: offline = %d, external_lb = %d\n", 1694 (etest->flags & ETH_TEST_FL_OFFLINE), 1695 (etest->flags & ETH_TEST_FL_EXTERNAL_LB) >> 2); 1696 1697 memset(buf, 0, sizeof(u64) * QEDE_ETHTOOL_TEST_MAX); 1698 1699 if (etest->flags & ETH_TEST_FL_OFFLINE) { 1700 if (qede_selftest_run_loopback(edev, 1701 QED_LINK_LOOPBACK_INT_PHY)) { 1702 buf[QEDE_ETHTOOL_INT_LOOPBACK] = 1; 1703 etest->flags |= ETH_TEST_FL_FAILED; 1704 } 1705 } 1706 1707 if (edev->ops->common->selftest->selftest_interrupt(edev->cdev)) { 1708 buf[QEDE_ETHTOOL_INTERRUPT_TEST] = 1; 1709 etest->flags |= ETH_TEST_FL_FAILED; 1710 } 1711 1712 if (edev->ops->common->selftest->selftest_memory(edev->cdev)) { 1713 buf[QEDE_ETHTOOL_MEMORY_TEST] = 1; 1714 etest->flags |= ETH_TEST_FL_FAILED; 1715 } 1716 1717 if (edev->ops->common->selftest->selftest_register(edev->cdev)) { 1718 buf[QEDE_ETHTOOL_REGISTER_TEST] = 1; 1719 etest->flags |= ETH_TEST_FL_FAILED; 1720 } 1721 1722 if (edev->ops->common->selftest->selftest_clock(edev->cdev)) { 1723 buf[QEDE_ETHTOOL_CLOCK_TEST] = 1; 1724 etest->flags |= ETH_TEST_FL_FAILED; 1725 } 1726 1727 if (edev->ops->common->selftest->selftest_nvram(edev->cdev)) { 1728 buf[QEDE_ETHTOOL_NVRAM_TEST] = 1; 1729 etest->flags |= ETH_TEST_FL_FAILED; 1730 } 1731 } 1732 1733 static int qede_set_tunable(struct net_device *dev, 1734 const struct ethtool_tunable *tuna, 1735 const void *data) 1736 { 1737 struct qede_dev *edev = netdev_priv(dev); 1738 u32 val; 1739 1740 switch (tuna->id) { 1741 case ETHTOOL_RX_COPYBREAK: 1742 val = *(u32 *)data; 1743 if (val < QEDE_MIN_PKT_LEN || val > QEDE_RX_HDR_SIZE) { 1744 DP_VERBOSE(edev, QED_MSG_DEBUG, 1745 "Invalid rx copy break value, range is [%u, %u]", 1746 QEDE_MIN_PKT_LEN, QEDE_RX_HDR_SIZE); 1747 return -EINVAL; 1748 } 1749 1750 edev->rx_copybreak = *(u32 *)data; 1751 break; 1752 default: 1753 return -EOPNOTSUPP; 1754 } 1755 1756 return 0; 1757 } 1758 1759 static int qede_get_tunable(struct net_device *dev, 1760 const struct ethtool_tunable *tuna, void *data) 1761 { 1762 struct qede_dev *edev = netdev_priv(dev); 1763 1764 switch (tuna->id) { 1765 case ETHTOOL_RX_COPYBREAK: 1766 *(u32 *)data = edev->rx_copybreak; 1767 break; 1768 default: 1769 return -EOPNOTSUPP; 1770 } 1771 1772 return 0; 1773 } 1774 1775 static int qede_get_eee(struct net_device *dev, struct ethtool_keee *edata) 1776 { 1777 struct qede_dev *edev = netdev_priv(dev); 1778 struct qed_link_output current_link; 1779 1780 memset(¤t_link, 0, sizeof(current_link)); 1781 edev->ops->common->get_link(edev->cdev, ¤t_link); 1782 1783 if (!current_link.eee_supported) { 1784 DP_INFO(edev, "EEE is not supported\n"); 1785 return -EOPNOTSUPP; 1786 } 1787 1788 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1789 edata->advertised, 1790 current_link.eee.adv_caps & QED_EEE_1G_ADV); 1791 linkmode_mod_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT, 1792 edata->advertised, 1793 current_link.eee.adv_caps & QED_EEE_10G_ADV); 1794 1795 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1796 edata->supported, 1797 current_link.sup_caps & QED_EEE_1G_ADV); 1798 linkmode_mod_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT, 1799 edata->supported, 1800 current_link.sup_caps & QED_EEE_10G_ADV); 1801 1802 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1803 edata->lp_advertised, 1804 current_link.eee.lp_adv_caps & QED_EEE_1G_ADV); 1805 linkmode_mod_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT, 1806 edata->lp_advertised, 1807 current_link.eee.lp_adv_caps & QED_EEE_10G_ADV); 1808 1809 edata->tx_lpi_timer = current_link.eee.tx_lpi_timer; 1810 edata->eee_enabled = current_link.eee.enable; 1811 edata->tx_lpi_enabled = current_link.eee.tx_lpi_enable; 1812 edata->eee_active = current_link.eee_active; 1813 1814 return 0; 1815 } 1816 1817 static int qede_set_eee(struct net_device *dev, struct ethtool_keee *edata) 1818 { 1819 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported) = {}; 1820 __ETHTOOL_DECLARE_LINK_MODE_MASK(tmp) = {}; 1821 struct qede_dev *edev = netdev_priv(dev); 1822 struct qed_link_output current_link; 1823 struct qed_link_params params; 1824 bool unsupp; 1825 1826 if (!edev->ops->common->can_link_change(edev->cdev)) { 1827 DP_INFO(edev, "Link settings are not allowed to be changed\n"); 1828 return -EOPNOTSUPP; 1829 } 1830 1831 memset(¤t_link, 0, sizeof(current_link)); 1832 edev->ops->common->get_link(edev->cdev, ¤t_link); 1833 1834 if (!current_link.eee_supported) { 1835 DP_INFO(edev, "EEE is not supported\n"); 1836 return -EOPNOTSUPP; 1837 } 1838 1839 memset(¶ms, 0, sizeof(params)); 1840 params.override_flags |= QED_LINK_OVERRIDE_EEE_CONFIG; 1841 1842 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT, 1843 supported); 1844 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1845 supported); 1846 1847 unsupp = linkmode_andnot(tmp, edata->advertised, supported); 1848 if (unsupp) { 1849 DP_VERBOSE(edev, QED_MSG_DEBUG, 1850 "Invalid advertised capabilities %*pb\n", 1851 __ETHTOOL_LINK_MODE_MASK_NBITS, edata->advertised); 1852 return -EINVAL; 1853 } 1854 1855 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1856 edata->advertised)) 1857 params.eee.adv_caps = QED_EEE_1G_ADV; 1858 if (linkmode_test_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT, 1859 edata->advertised)) 1860 params.eee.adv_caps = QED_EEE_10G_ADV; 1861 1862 params.eee.enable = edata->eee_enabled; 1863 params.eee.tx_lpi_enable = edata->tx_lpi_enabled; 1864 params.eee.tx_lpi_timer = edata->tx_lpi_timer; 1865 1866 params.link_up = true; 1867 edev->ops->common->set_link(edev->cdev, ¶ms); 1868 1869 return 0; 1870 } 1871 1872 static u32 qede_link_to_ethtool_fec(u32 link_fec) 1873 { 1874 u32 eth_fec = 0; 1875 1876 if (link_fec & QED_FEC_MODE_NONE) 1877 eth_fec |= ETHTOOL_FEC_OFF; 1878 if (link_fec & QED_FEC_MODE_FIRECODE) 1879 eth_fec |= ETHTOOL_FEC_BASER; 1880 if (link_fec & QED_FEC_MODE_RS) 1881 eth_fec |= ETHTOOL_FEC_RS; 1882 if (link_fec & QED_FEC_MODE_AUTO) 1883 eth_fec |= ETHTOOL_FEC_AUTO; 1884 if (link_fec & QED_FEC_MODE_UNSUPPORTED) 1885 eth_fec |= ETHTOOL_FEC_NONE; 1886 1887 return eth_fec; 1888 } 1889 1890 static u32 qede_ethtool_to_link_fec(u32 eth_fec) 1891 { 1892 u32 link_fec = 0; 1893 1894 if (eth_fec & ETHTOOL_FEC_OFF) 1895 link_fec |= QED_FEC_MODE_NONE; 1896 if (eth_fec & ETHTOOL_FEC_BASER) 1897 link_fec |= QED_FEC_MODE_FIRECODE; 1898 if (eth_fec & ETHTOOL_FEC_RS) 1899 link_fec |= QED_FEC_MODE_RS; 1900 if (eth_fec & ETHTOOL_FEC_AUTO) 1901 link_fec |= QED_FEC_MODE_AUTO; 1902 if (eth_fec & ETHTOOL_FEC_NONE) 1903 link_fec |= QED_FEC_MODE_UNSUPPORTED; 1904 1905 return link_fec; 1906 } 1907 1908 static int qede_get_fecparam(struct net_device *dev, 1909 struct ethtool_fecparam *fecparam) 1910 { 1911 struct qede_dev *edev = netdev_priv(dev); 1912 struct qed_link_output curr_link; 1913 1914 memset(&curr_link, 0, sizeof(curr_link)); 1915 edev->ops->common->get_link(edev->cdev, &curr_link); 1916 1917 fecparam->active_fec = qede_link_to_ethtool_fec(curr_link.active_fec); 1918 fecparam->fec = qede_link_to_ethtool_fec(curr_link.sup_fec); 1919 1920 return 0; 1921 } 1922 1923 static int qede_set_fecparam(struct net_device *dev, 1924 struct ethtool_fecparam *fecparam) 1925 { 1926 struct qede_dev *edev = netdev_priv(dev); 1927 struct qed_link_params params; 1928 1929 if (!edev->ops || !edev->ops->common->can_link_change(edev->cdev)) { 1930 DP_INFO(edev, "Link settings are not allowed to be changed\n"); 1931 return -EOPNOTSUPP; 1932 } 1933 1934 memset(¶ms, 0, sizeof(params)); 1935 params.override_flags |= QED_LINK_OVERRIDE_FEC_CONFIG; 1936 params.fec = qede_ethtool_to_link_fec(fecparam->fec); 1937 params.link_up = true; 1938 1939 edev->ops->common->set_link(edev->cdev, ¶ms); 1940 1941 return 0; 1942 } 1943 1944 static int qede_get_module_info(struct net_device *dev, 1945 struct ethtool_modinfo *modinfo) 1946 { 1947 struct qede_dev *edev = netdev_priv(dev); 1948 u8 buf[4]; 1949 int rc; 1950 1951 /* Read first 4 bytes to find the sfp type */ 1952 rc = edev->ops->common->read_module_eeprom(edev->cdev, buf, 1953 QED_I2C_DEV_ADDR_A0, 0, 4); 1954 if (rc) { 1955 DP_ERR(edev, "Failed reading EEPROM data %d\n", rc); 1956 return rc; 1957 } 1958 1959 switch (buf[0]) { 1960 case 0x3: /* SFP, SFP+, SFP-28 */ 1961 modinfo->type = ETH_MODULE_SFF_8472; 1962 modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN; 1963 break; 1964 case 0xc: /* QSFP */ 1965 case 0xd: /* QSFP+ */ 1966 modinfo->type = ETH_MODULE_SFF_8436; 1967 modinfo->eeprom_len = ETH_MODULE_SFF_8436_LEN; 1968 break; 1969 case 0x11: /* QSFP-28 */ 1970 modinfo->type = ETH_MODULE_SFF_8636; 1971 modinfo->eeprom_len = ETH_MODULE_SFF_8636_LEN; 1972 break; 1973 default: 1974 DP_ERR(edev, "Unknown transceiver type 0x%x\n", buf[0]); 1975 return -EINVAL; 1976 } 1977 1978 return 0; 1979 } 1980 1981 static int qede_get_module_eeprom(struct net_device *dev, 1982 struct ethtool_eeprom *ee, u8 *data) 1983 { 1984 struct qede_dev *edev = netdev_priv(dev); 1985 u32 start_addr = ee->offset, size = 0; 1986 u8 *buf = data; 1987 int rc = 0; 1988 1989 /* Read A0 section */ 1990 if (ee->offset < ETH_MODULE_SFF_8079_LEN) { 1991 /* Limit transfer size to the A0 section boundary */ 1992 if (ee->offset + ee->len > ETH_MODULE_SFF_8079_LEN) 1993 size = ETH_MODULE_SFF_8079_LEN - ee->offset; 1994 else 1995 size = ee->len; 1996 1997 rc = edev->ops->common->read_module_eeprom(edev->cdev, buf, 1998 QED_I2C_DEV_ADDR_A0, 1999 start_addr, size); 2000 if (rc) { 2001 DP_ERR(edev, "Failed reading A0 section %d\n", rc); 2002 return rc; 2003 } 2004 2005 buf += size; 2006 start_addr += size; 2007 } 2008 2009 /* Read A2 section */ 2010 if (start_addr >= ETH_MODULE_SFF_8079_LEN && 2011 start_addr < ETH_MODULE_SFF_8472_LEN) { 2012 size = ee->len - size; 2013 /* Limit transfer size to the A2 section boundary */ 2014 if (start_addr + size > ETH_MODULE_SFF_8472_LEN) 2015 size = ETH_MODULE_SFF_8472_LEN - start_addr; 2016 start_addr -= ETH_MODULE_SFF_8079_LEN; 2017 rc = edev->ops->common->read_module_eeprom(edev->cdev, buf, 2018 QED_I2C_DEV_ADDR_A2, 2019 start_addr, size); 2020 if (rc) { 2021 DP_VERBOSE(edev, QED_MSG_DEBUG, 2022 "Failed reading A2 section %d\n", rc); 2023 return 0; 2024 } 2025 } 2026 2027 return rc; 2028 } 2029 2030 static int qede_set_dump(struct net_device *dev, struct ethtool_dump *val) 2031 { 2032 struct qede_dev *edev = netdev_priv(dev); 2033 int rc = 0; 2034 2035 if (edev->dump_info.cmd == QEDE_DUMP_CMD_NONE) { 2036 if (val->flag > QEDE_DUMP_CMD_MAX) { 2037 DP_ERR(edev, "Invalid command %d\n", val->flag); 2038 return -EINVAL; 2039 } 2040 edev->dump_info.cmd = val->flag; 2041 edev->dump_info.num_args = 0; 2042 return 0; 2043 } 2044 2045 if (edev->dump_info.num_args == QEDE_DUMP_MAX_ARGS) { 2046 DP_ERR(edev, "Arg count = %d\n", edev->dump_info.num_args); 2047 return -EINVAL; 2048 } 2049 2050 switch (edev->dump_info.cmd) { 2051 case QEDE_DUMP_CMD_NVM_CFG: 2052 edev->dump_info.args[edev->dump_info.num_args] = val->flag; 2053 edev->dump_info.num_args++; 2054 break; 2055 case QEDE_DUMP_CMD_GRCDUMP: 2056 rc = edev->ops->common->set_grc_config(edev->cdev, 2057 val->flag, 1); 2058 break; 2059 default: 2060 break; 2061 } 2062 2063 return rc; 2064 } 2065 2066 static int qede_get_dump_flag(struct net_device *dev, 2067 struct ethtool_dump *dump) 2068 { 2069 struct qede_dev *edev = netdev_priv(dev); 2070 2071 if (!edev->ops || !edev->ops->common) { 2072 DP_ERR(edev, "Edev ops not populated\n"); 2073 return -EINVAL; 2074 } 2075 2076 dump->version = QEDE_DUMP_VERSION; 2077 switch (edev->dump_info.cmd) { 2078 case QEDE_DUMP_CMD_NVM_CFG: 2079 dump->flag = QEDE_DUMP_CMD_NVM_CFG; 2080 dump->len = edev->ops->common->read_nvm_cfg_len(edev->cdev, 2081 edev->dump_info.args[0]); 2082 break; 2083 case QEDE_DUMP_CMD_GRCDUMP: 2084 dump->flag = QEDE_DUMP_CMD_GRCDUMP; 2085 dump->len = edev->ops->common->dbg_all_data_size(edev->cdev); 2086 break; 2087 default: 2088 DP_ERR(edev, "Invalid cmd = %d\n", edev->dump_info.cmd); 2089 return -EINVAL; 2090 } 2091 2092 DP_VERBOSE(edev, QED_MSG_DEBUG, 2093 "dump->version = 0x%x dump->flag = %d dump->len = %d\n", 2094 dump->version, dump->flag, dump->len); 2095 return 0; 2096 } 2097 2098 static int qede_get_dump_data(struct net_device *dev, 2099 struct ethtool_dump *dump, void *buf) 2100 { 2101 struct qede_dev *edev = netdev_priv(dev); 2102 int rc = 0; 2103 2104 if (!edev->ops || !edev->ops->common) { 2105 DP_ERR(edev, "Edev ops not populated\n"); 2106 rc = -EINVAL; 2107 goto err; 2108 } 2109 2110 switch (edev->dump_info.cmd) { 2111 case QEDE_DUMP_CMD_NVM_CFG: 2112 if (edev->dump_info.num_args != QEDE_DUMP_NVM_ARG_COUNT) { 2113 DP_ERR(edev, "Arg count = %d required = %d\n", 2114 edev->dump_info.num_args, 2115 QEDE_DUMP_NVM_ARG_COUNT); 2116 rc = -EINVAL; 2117 goto err; 2118 } 2119 rc = edev->ops->common->read_nvm_cfg(edev->cdev, (u8 **)&buf, 2120 edev->dump_info.args[0], 2121 edev->dump_info.args[1]); 2122 break; 2123 case QEDE_DUMP_CMD_GRCDUMP: 2124 memset(buf, 0, dump->len); 2125 rc = edev->ops->common->dbg_all_data(edev->cdev, buf); 2126 break; 2127 default: 2128 DP_ERR(edev, "Invalid cmd = %d\n", edev->dump_info.cmd); 2129 rc = -EINVAL; 2130 break; 2131 } 2132 2133 err: 2134 edev->dump_info.cmd = QEDE_DUMP_CMD_NONE; 2135 edev->dump_info.num_args = 0; 2136 memset(edev->dump_info.args, 0, sizeof(edev->dump_info.args)); 2137 2138 return rc; 2139 } 2140 2141 int qede_set_per_coalesce(struct net_device *dev, u32 queue, 2142 struct ethtool_coalesce *coal) 2143 { 2144 struct qede_dev *edev = netdev_priv(dev); 2145 struct qede_fastpath *fp; 2146 u16 rxc, txc; 2147 int rc = 0; 2148 2149 if (coal->rx_coalesce_usecs > QED_COALESCE_MAX || 2150 coal->tx_coalesce_usecs > QED_COALESCE_MAX) { 2151 DP_INFO(edev, 2152 "Can't support requested %s coalesce value [max supported value %d]\n", 2153 coal->rx_coalesce_usecs > QED_COALESCE_MAX ? "rx" 2154 : "tx", 2155 QED_COALESCE_MAX); 2156 return -EINVAL; 2157 } 2158 2159 rxc = (u16)coal->rx_coalesce_usecs; 2160 txc = (u16)coal->tx_coalesce_usecs; 2161 2162 __qede_lock(edev); 2163 if (queue >= edev->num_queues) { 2164 DP_INFO(edev, "Invalid queue\n"); 2165 rc = -EINVAL; 2166 goto out; 2167 } 2168 2169 if (edev->state != QEDE_STATE_OPEN) { 2170 rc = -EINVAL; 2171 goto out; 2172 } 2173 2174 fp = &edev->fp_array[queue]; 2175 2176 if (edev->fp_array[queue].type & QEDE_FASTPATH_RX) { 2177 rc = edev->ops->common->set_coalesce(edev->cdev, 2178 rxc, 0, 2179 fp->rxq->handle); 2180 if (rc) { 2181 DP_INFO(edev, 2182 "Set RX coalesce error, rc = %d\n", rc); 2183 goto out; 2184 } 2185 edev->coal_entry[queue].rxc = rxc; 2186 edev->coal_entry[queue].isvalid = true; 2187 } 2188 2189 if (edev->fp_array[queue].type & QEDE_FASTPATH_TX) { 2190 rc = edev->ops->common->set_coalesce(edev->cdev, 2191 0, txc, 2192 fp->txq->handle); 2193 if (rc) { 2194 DP_INFO(edev, 2195 "Set TX coalesce error, rc = %d\n", rc); 2196 goto out; 2197 } 2198 edev->coal_entry[queue].txc = txc; 2199 edev->coal_entry[queue].isvalid = true; 2200 } 2201 out: 2202 __qede_unlock(edev); 2203 2204 return rc; 2205 } 2206 2207 static int qede_get_per_coalesce(struct net_device *dev, 2208 u32 queue, 2209 struct ethtool_coalesce *coal) 2210 { 2211 void *rx_handle = NULL, *tx_handle = NULL; 2212 struct qede_dev *edev = netdev_priv(dev); 2213 struct qede_fastpath *fp; 2214 u16 rx_coal, tx_coal; 2215 int rc = 0; 2216 2217 rx_coal = QED_DEFAULT_RX_USECS; 2218 tx_coal = QED_DEFAULT_TX_USECS; 2219 2220 memset(coal, 0, sizeof(struct ethtool_coalesce)); 2221 2222 __qede_lock(edev); 2223 if (queue >= edev->num_queues) { 2224 DP_INFO(edev, "Invalid queue\n"); 2225 rc = -EINVAL; 2226 goto out; 2227 } 2228 2229 if (edev->state != QEDE_STATE_OPEN) { 2230 rc = -EINVAL; 2231 goto out; 2232 } 2233 2234 fp = &edev->fp_array[queue]; 2235 2236 if (fp->type & QEDE_FASTPATH_RX) 2237 rx_handle = fp->rxq->handle; 2238 2239 rc = edev->ops->get_coalesce(edev->cdev, &rx_coal, 2240 rx_handle); 2241 if (rc) { 2242 DP_INFO(edev, "Read Rx coalesce error\n"); 2243 goto out; 2244 } 2245 2246 fp = &edev->fp_array[queue]; 2247 if (fp->type & QEDE_FASTPATH_TX) 2248 tx_handle = fp->txq->handle; 2249 2250 rc = edev->ops->get_coalesce(edev->cdev, &tx_coal, 2251 tx_handle); 2252 if (rc) 2253 DP_INFO(edev, "Read Tx coalesce error\n"); 2254 2255 out: 2256 __qede_unlock(edev); 2257 2258 coal->rx_coalesce_usecs = rx_coal; 2259 coal->tx_coalesce_usecs = tx_coal; 2260 2261 return rc; 2262 } 2263 2264 static const struct ethtool_ops qede_ethtool_ops = { 2265 .supported_coalesce_params = ETHTOOL_COALESCE_USECS | 2266 ETHTOOL_COALESCE_STATS_BLOCK_USECS, 2267 .get_link_ksettings = qede_get_link_ksettings, 2268 .set_link_ksettings = qede_set_link_ksettings, 2269 .get_drvinfo = qede_get_drvinfo, 2270 .get_regs_len = qede_get_regs_len, 2271 .get_regs = qede_get_regs, 2272 .get_wol = qede_get_wol, 2273 .set_wol = qede_set_wol, 2274 .get_msglevel = qede_get_msglevel, 2275 .set_msglevel = qede_set_msglevel, 2276 .nway_reset = qede_nway_reset, 2277 .get_link = qede_get_link, 2278 .get_coalesce = qede_get_coalesce, 2279 .set_coalesce = qede_set_coalesce, 2280 .get_ringparam = qede_get_ringparam, 2281 .set_ringparam = qede_set_ringparam, 2282 .get_pauseparam = qede_get_pauseparam, 2283 .set_pauseparam = qede_set_pauseparam, 2284 .get_strings = qede_get_strings, 2285 .set_phys_id = qede_set_phys_id, 2286 .get_ethtool_stats = qede_get_ethtool_stats, 2287 .get_priv_flags = qede_get_priv_flags, 2288 .set_priv_flags = qede_set_priv_flags, 2289 .get_sset_count = qede_get_sset_count, 2290 .get_rxnfc = qede_get_rxnfc, 2291 .set_rxnfc = qede_set_rxnfc, 2292 .get_rxfh_indir_size = qede_get_rxfh_indir_size, 2293 .get_rxfh_key_size = qede_get_rxfh_key_size, 2294 .get_rxfh = qede_get_rxfh, 2295 .set_rxfh = qede_set_rxfh, 2296 .get_ts_info = qede_get_ts_info, 2297 .get_channels = qede_get_channels, 2298 .set_channels = qede_set_channels, 2299 .self_test = qede_self_test, 2300 .get_module_info = qede_get_module_info, 2301 .get_module_eeprom = qede_get_module_eeprom, 2302 .get_eee = qede_get_eee, 2303 .set_eee = qede_set_eee, 2304 .get_fecparam = qede_get_fecparam, 2305 .set_fecparam = qede_set_fecparam, 2306 .get_tunable = qede_get_tunable, 2307 .set_tunable = qede_set_tunable, 2308 .get_per_queue_coalesce = qede_get_per_coalesce, 2309 .set_per_queue_coalesce = qede_set_per_coalesce, 2310 .flash_device = qede_flash_device, 2311 .get_dump_flag = qede_get_dump_flag, 2312 .get_dump_data = qede_get_dump_data, 2313 .set_dump = qede_set_dump, 2314 }; 2315 2316 static const struct ethtool_ops qede_vf_ethtool_ops = { 2317 .supported_coalesce_params = ETHTOOL_COALESCE_USECS | 2318 ETHTOOL_COALESCE_STATS_BLOCK_USECS, 2319 .get_link_ksettings = qede_get_link_ksettings, 2320 .get_drvinfo = qede_get_drvinfo, 2321 .get_msglevel = qede_get_msglevel, 2322 .set_msglevel = qede_set_msglevel, 2323 .get_link = qede_get_link, 2324 .get_coalesce = qede_get_coalesce, 2325 .set_coalesce = qede_set_coalesce, 2326 .get_ringparam = qede_get_ringparam, 2327 .set_ringparam = qede_set_ringparam, 2328 .get_strings = qede_get_strings, 2329 .get_ethtool_stats = qede_get_ethtool_stats, 2330 .get_priv_flags = qede_get_priv_flags, 2331 .get_sset_count = qede_get_sset_count, 2332 .get_rxnfc = qede_get_rxnfc, 2333 .set_rxnfc = qede_set_rxnfc, 2334 .get_rxfh_indir_size = qede_get_rxfh_indir_size, 2335 .get_rxfh_key_size = qede_get_rxfh_key_size, 2336 .get_rxfh = qede_get_rxfh, 2337 .set_rxfh = qede_set_rxfh, 2338 .get_channels = qede_get_channels, 2339 .set_channels = qede_set_channels, 2340 .get_per_queue_coalesce = qede_get_per_coalesce, 2341 .set_per_queue_coalesce = qede_set_per_coalesce, 2342 .get_tunable = qede_get_tunable, 2343 .set_tunable = qede_set_tunable, 2344 }; 2345 2346 void qede_set_ethtool_ops(struct net_device *dev) 2347 { 2348 struct qede_dev *edev = netdev_priv(dev); 2349 2350 if (IS_VF(edev)) 2351 dev->ethtool_ops = &qede_vf_ethtool_ops; 2352 else 2353 dev->ethtool_ops = &qede_ethtool_ops; 2354 } 2355