1 /* 2 * Copyright (C) 2015 Cavium, Inc. 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms of version 2 of the GNU General Public License 6 * as published by the Free Software Foundation. 7 */ 8 9 /* ETHTOOL Support for VNIC_VF Device*/ 10 11 #include <linux/pci.h> 12 13 #include "nic_reg.h" 14 #include "nic.h" 15 #include "nicvf_queues.h" 16 #include "q_struct.h" 17 #include "thunder_bgx.h" 18 19 #define DRV_NAME "thunder-nicvf" 20 #define DRV_VERSION "1.0" 21 22 struct nicvf_stat { 23 char name[ETH_GSTRING_LEN]; 24 unsigned int index; 25 }; 26 27 #define NICVF_HW_STAT(stat) { \ 28 .name = #stat, \ 29 .index = offsetof(struct nicvf_hw_stats, stat) / sizeof(u64), \ 30 } 31 32 #define NICVF_DRV_STAT(stat) { \ 33 .name = #stat, \ 34 .index = offsetof(struct nicvf_drv_stats, stat) / sizeof(u64), \ 35 } 36 37 static const struct nicvf_stat nicvf_hw_stats[] = { 38 NICVF_HW_STAT(rx_bytes_ok), 39 NICVF_HW_STAT(rx_ucast_frames_ok), 40 NICVF_HW_STAT(rx_bcast_frames_ok), 41 NICVF_HW_STAT(rx_mcast_frames_ok), 42 NICVF_HW_STAT(rx_fcs_errors), 43 NICVF_HW_STAT(rx_l2_errors), 44 NICVF_HW_STAT(rx_drop_red), 45 NICVF_HW_STAT(rx_drop_red_bytes), 46 NICVF_HW_STAT(rx_drop_overrun), 47 NICVF_HW_STAT(rx_drop_overrun_bytes), 48 NICVF_HW_STAT(rx_drop_bcast), 49 NICVF_HW_STAT(rx_drop_mcast), 50 NICVF_HW_STAT(rx_drop_l3_bcast), 51 NICVF_HW_STAT(rx_drop_l3_mcast), 52 NICVF_HW_STAT(tx_bytes_ok), 53 NICVF_HW_STAT(tx_ucast_frames_ok), 54 NICVF_HW_STAT(tx_bcast_frames_ok), 55 NICVF_HW_STAT(tx_mcast_frames_ok), 56 }; 57 58 static const struct nicvf_stat nicvf_drv_stats[] = { 59 NICVF_DRV_STAT(rx_frames_ok), 60 NICVF_DRV_STAT(rx_frames_64), 61 NICVF_DRV_STAT(rx_frames_127), 62 NICVF_DRV_STAT(rx_frames_255), 63 NICVF_DRV_STAT(rx_frames_511), 64 NICVF_DRV_STAT(rx_frames_1023), 65 NICVF_DRV_STAT(rx_frames_1518), 66 NICVF_DRV_STAT(rx_frames_jumbo), 67 NICVF_DRV_STAT(rx_drops), 68 NICVF_DRV_STAT(tx_frames_ok), 69 NICVF_DRV_STAT(tx_tso), 70 NICVF_DRV_STAT(tx_drops), 71 NICVF_DRV_STAT(txq_stop), 72 NICVF_DRV_STAT(txq_wake), 73 }; 74 75 static const struct nicvf_stat nicvf_queue_stats[] = { 76 { "bytes", 0 }, 77 { "frames", 1 }, 78 }; 79 80 static const unsigned int nicvf_n_hw_stats = ARRAY_SIZE(nicvf_hw_stats); 81 static const unsigned int nicvf_n_drv_stats = ARRAY_SIZE(nicvf_drv_stats); 82 static const unsigned int nicvf_n_queue_stats = ARRAY_SIZE(nicvf_queue_stats); 83 84 static int nicvf_get_settings(struct net_device *netdev, 85 struct ethtool_cmd *cmd) 86 { 87 struct nicvf *nic = netdev_priv(netdev); 88 89 cmd->supported = 0; 90 cmd->transceiver = XCVR_EXTERNAL; 91 if (nic->speed <= 1000) { 92 cmd->port = PORT_MII; 93 cmd->autoneg = AUTONEG_ENABLE; 94 } else { 95 cmd->port = PORT_FIBRE; 96 cmd->autoneg = AUTONEG_DISABLE; 97 } 98 cmd->duplex = nic->duplex; 99 ethtool_cmd_speed_set(cmd, nic->speed); 100 101 return 0; 102 } 103 104 static void nicvf_get_drvinfo(struct net_device *netdev, 105 struct ethtool_drvinfo *info) 106 { 107 struct nicvf *nic = netdev_priv(netdev); 108 109 strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 110 strlcpy(info->version, DRV_VERSION, sizeof(info->version)); 111 strlcpy(info->bus_info, pci_name(nic->pdev), sizeof(info->bus_info)); 112 } 113 114 static u32 nicvf_get_msglevel(struct net_device *netdev) 115 { 116 struct nicvf *nic = netdev_priv(netdev); 117 118 return nic->msg_enable; 119 } 120 121 static void nicvf_set_msglevel(struct net_device *netdev, u32 lvl) 122 { 123 struct nicvf *nic = netdev_priv(netdev); 124 125 nic->msg_enable = lvl; 126 } 127 128 static void nicvf_get_strings(struct net_device *netdev, u32 sset, u8 *data) 129 { 130 struct nicvf *nic = netdev_priv(netdev); 131 int stats, qidx; 132 133 if (sset != ETH_SS_STATS) 134 return; 135 136 for (stats = 0; stats < nicvf_n_hw_stats; stats++) { 137 memcpy(data, nicvf_hw_stats[stats].name, ETH_GSTRING_LEN); 138 data += ETH_GSTRING_LEN; 139 } 140 141 for (stats = 0; stats < nicvf_n_drv_stats; stats++) { 142 memcpy(data, nicvf_drv_stats[stats].name, ETH_GSTRING_LEN); 143 data += ETH_GSTRING_LEN; 144 } 145 146 for (qidx = 0; qidx < nic->qs->rq_cnt; qidx++) { 147 for (stats = 0; stats < nicvf_n_queue_stats; stats++) { 148 sprintf(data, "rxq%d: %s", qidx, 149 nicvf_queue_stats[stats].name); 150 data += ETH_GSTRING_LEN; 151 } 152 } 153 154 for (qidx = 0; qidx < nic->qs->sq_cnt; qidx++) { 155 for (stats = 0; stats < nicvf_n_queue_stats; stats++) { 156 sprintf(data, "txq%d: %s", qidx, 157 nicvf_queue_stats[stats].name); 158 data += ETH_GSTRING_LEN; 159 } 160 } 161 162 for (stats = 0; stats < BGX_RX_STATS_COUNT; stats++) { 163 sprintf(data, "bgx_rxstat%d: ", stats); 164 data += ETH_GSTRING_LEN; 165 } 166 167 for (stats = 0; stats < BGX_TX_STATS_COUNT; stats++) { 168 sprintf(data, "bgx_txstat%d: ", stats); 169 data += ETH_GSTRING_LEN; 170 } 171 } 172 173 static int nicvf_get_sset_count(struct net_device *netdev, int sset) 174 { 175 struct nicvf *nic = netdev_priv(netdev); 176 177 if (sset != ETH_SS_STATS) 178 return -EINVAL; 179 180 return nicvf_n_hw_stats + nicvf_n_drv_stats + 181 (nicvf_n_queue_stats * 182 (nic->qs->rq_cnt + nic->qs->sq_cnt)) + 183 BGX_RX_STATS_COUNT + BGX_TX_STATS_COUNT; 184 } 185 186 static void nicvf_get_ethtool_stats(struct net_device *netdev, 187 struct ethtool_stats *stats, u64 *data) 188 { 189 struct nicvf *nic = netdev_priv(netdev); 190 int stat, qidx; 191 192 nicvf_update_stats(nic); 193 194 /* Update LMAC stats */ 195 nicvf_update_lmac_stats(nic); 196 197 for (stat = 0; stat < nicvf_n_hw_stats; stat++) 198 *(data++) = ((u64 *)&nic->stats) 199 [nicvf_hw_stats[stat].index]; 200 for (stat = 0; stat < nicvf_n_drv_stats; stat++) 201 *(data++) = ((u64 *)&nic->drv_stats) 202 [nicvf_drv_stats[stat].index]; 203 204 for (qidx = 0; qidx < nic->qs->rq_cnt; qidx++) { 205 for (stat = 0; stat < nicvf_n_queue_stats; stat++) 206 *(data++) = ((u64 *)&nic->qs->rq[qidx].stats) 207 [nicvf_queue_stats[stat].index]; 208 } 209 210 for (qidx = 0; qidx < nic->qs->sq_cnt; qidx++) { 211 for (stat = 0; stat < nicvf_n_queue_stats; stat++) 212 *(data++) = ((u64 *)&nic->qs->sq[qidx].stats) 213 [nicvf_queue_stats[stat].index]; 214 } 215 216 for (stat = 0; stat < BGX_RX_STATS_COUNT; stat++) 217 *(data++) = nic->bgx_stats.rx_stats[stat]; 218 for (stat = 0; stat < BGX_TX_STATS_COUNT; stat++) 219 *(data++) = nic->bgx_stats.tx_stats[stat]; 220 } 221 222 static int nicvf_get_regs_len(struct net_device *dev) 223 { 224 return sizeof(u64) * NIC_VF_REG_COUNT; 225 } 226 227 static void nicvf_get_regs(struct net_device *dev, 228 struct ethtool_regs *regs, void *reg) 229 { 230 struct nicvf *nic = netdev_priv(dev); 231 u64 *p = (u64 *)reg; 232 u64 reg_offset; 233 int mbox, key, stat, q; 234 int i = 0; 235 236 regs->version = 0; 237 memset(p, 0, NIC_VF_REG_COUNT); 238 239 p[i++] = nicvf_reg_read(nic, NIC_VNIC_CFG); 240 /* Mailbox registers */ 241 for (mbox = 0; mbox < NIC_PF_VF_MAILBOX_SIZE; mbox++) 242 p[i++] = nicvf_reg_read(nic, 243 NIC_VF_PF_MAILBOX_0_1 | (mbox << 3)); 244 245 p[i++] = nicvf_reg_read(nic, NIC_VF_INT); 246 p[i++] = nicvf_reg_read(nic, NIC_VF_INT_W1S); 247 p[i++] = nicvf_reg_read(nic, NIC_VF_ENA_W1C); 248 p[i++] = nicvf_reg_read(nic, NIC_VF_ENA_W1S); 249 p[i++] = nicvf_reg_read(nic, NIC_VNIC_RSS_CFG); 250 251 for (key = 0; key < RSS_HASH_KEY_SIZE; key++) 252 p[i++] = nicvf_reg_read(nic, NIC_VNIC_RSS_KEY_0_4 | (key << 3)); 253 254 /* Tx/Rx statistics */ 255 for (stat = 0; stat < TX_STATS_ENUM_LAST; stat++) 256 p[i++] = nicvf_reg_read(nic, 257 NIC_VNIC_TX_STAT_0_4 | (stat << 3)); 258 259 for (i = 0; i < RX_STATS_ENUM_LAST; i++) 260 p[i++] = nicvf_reg_read(nic, 261 NIC_VNIC_RX_STAT_0_13 | (stat << 3)); 262 263 p[i++] = nicvf_reg_read(nic, NIC_QSET_RQ_GEN_CFG); 264 265 /* All completion queue's registers */ 266 for (q = 0; q < MAX_CMP_QUEUES_PER_QS; q++) { 267 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_CFG, q); 268 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_CFG2, q); 269 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_THRESH, q); 270 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_BASE, q); 271 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_HEAD, q); 272 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_TAIL, q); 273 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_DOOR, q); 274 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_STATUS, q); 275 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_STATUS2, q); 276 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_DEBUG, q); 277 } 278 279 /* All receive queue's registers */ 280 for (q = 0; q < MAX_RCV_QUEUES_PER_QS; q++) { 281 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RQ_0_7_CFG, q); 282 p[i++] = nicvf_queue_reg_read(nic, 283 NIC_QSET_RQ_0_7_STAT_0_1, q); 284 reg_offset = NIC_QSET_RQ_0_7_STAT_0_1 | (1 << 3); 285 p[i++] = nicvf_queue_reg_read(nic, reg_offset, q); 286 } 287 288 for (q = 0; q < MAX_SND_QUEUES_PER_QS; q++) { 289 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_CFG, q); 290 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_THRESH, q); 291 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_BASE, q); 292 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_HEAD, q); 293 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_TAIL, q); 294 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_DOOR, q); 295 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_STATUS, q); 296 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_DEBUG, q); 297 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_CNM_CHG, q); 298 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_STAT_0_1, q); 299 reg_offset = NIC_QSET_SQ_0_7_STAT_0_1 | (1 << 3); 300 p[i++] = nicvf_queue_reg_read(nic, reg_offset, q); 301 } 302 303 for (q = 0; q < MAX_RCV_BUF_DESC_RINGS_PER_QS; q++) { 304 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_CFG, q); 305 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_THRESH, q); 306 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_BASE, q); 307 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_HEAD, q); 308 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_TAIL, q); 309 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_DOOR, q); 310 p[i++] = nicvf_queue_reg_read(nic, 311 NIC_QSET_RBDR_0_1_STATUS0, q); 312 p[i++] = nicvf_queue_reg_read(nic, 313 NIC_QSET_RBDR_0_1_STATUS1, q); 314 reg_offset = NIC_QSET_RBDR_0_1_PREFETCH_STATUS; 315 p[i++] = nicvf_queue_reg_read(nic, reg_offset, q); 316 } 317 } 318 319 static int nicvf_get_coalesce(struct net_device *netdev, 320 struct ethtool_coalesce *cmd) 321 { 322 struct nicvf *nic = netdev_priv(netdev); 323 324 cmd->rx_coalesce_usecs = nic->cq_coalesce_usecs; 325 return 0; 326 } 327 328 static void nicvf_get_ringparam(struct net_device *netdev, 329 struct ethtool_ringparam *ring) 330 { 331 struct nicvf *nic = netdev_priv(netdev); 332 struct queue_set *qs = nic->qs; 333 334 ring->rx_max_pending = MAX_RCV_BUF_COUNT; 335 ring->rx_pending = qs->rbdr_len; 336 ring->tx_max_pending = MAX_SND_QUEUE_LEN; 337 ring->tx_pending = qs->sq_len; 338 } 339 340 static int nicvf_get_rss_hash_opts(struct nicvf *nic, 341 struct ethtool_rxnfc *info) 342 { 343 info->data = 0; 344 345 switch (info->flow_type) { 346 case TCP_V4_FLOW: 347 case TCP_V6_FLOW: 348 case UDP_V4_FLOW: 349 case UDP_V6_FLOW: 350 case SCTP_V4_FLOW: 351 case SCTP_V6_FLOW: 352 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 353 case IPV4_FLOW: 354 case IPV6_FLOW: 355 info->data |= RXH_IP_SRC | RXH_IP_DST; 356 break; 357 default: 358 return -EINVAL; 359 } 360 361 return 0; 362 } 363 364 static int nicvf_get_rxnfc(struct net_device *dev, 365 struct ethtool_rxnfc *info, u32 *rules) 366 { 367 struct nicvf *nic = netdev_priv(dev); 368 int ret = -EOPNOTSUPP; 369 370 switch (info->cmd) { 371 case ETHTOOL_GRXRINGS: 372 info->data = nic->qs->rq_cnt; 373 ret = 0; 374 break; 375 case ETHTOOL_GRXFH: 376 return nicvf_get_rss_hash_opts(nic, info); 377 default: 378 break; 379 } 380 return ret; 381 } 382 383 static int nicvf_set_rss_hash_opts(struct nicvf *nic, 384 struct ethtool_rxnfc *info) 385 { 386 struct nicvf_rss_info *rss = &nic->rss_info; 387 u64 rss_cfg = nicvf_reg_read(nic, NIC_VNIC_RSS_CFG); 388 389 if (!rss->enable) 390 netdev_err(nic->netdev, 391 "RSS is disabled, hash cannot be set\n"); 392 393 netdev_info(nic->netdev, "Set RSS flow type = %d, data = %lld\n", 394 info->flow_type, info->data); 395 396 if (!(info->data & RXH_IP_SRC) || !(info->data & RXH_IP_DST)) 397 return -EINVAL; 398 399 switch (info->flow_type) { 400 case TCP_V4_FLOW: 401 case TCP_V6_FLOW: 402 switch (info->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 403 case 0: 404 rss_cfg &= ~(1ULL << RSS_HASH_TCP); 405 break; 406 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 407 rss_cfg |= (1ULL << RSS_HASH_TCP); 408 break; 409 default: 410 return -EINVAL; 411 } 412 break; 413 case UDP_V4_FLOW: 414 case UDP_V6_FLOW: 415 switch (info->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 416 case 0: 417 rss_cfg &= ~(1ULL << RSS_HASH_UDP); 418 break; 419 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 420 rss_cfg |= (1ULL << RSS_HASH_UDP); 421 break; 422 default: 423 return -EINVAL; 424 } 425 break; 426 case SCTP_V4_FLOW: 427 case SCTP_V6_FLOW: 428 switch (info->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 429 case 0: 430 rss_cfg &= ~(1ULL << RSS_HASH_L4ETC); 431 break; 432 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 433 rss_cfg |= (1ULL << RSS_HASH_L4ETC); 434 break; 435 default: 436 return -EINVAL; 437 } 438 break; 439 case IPV4_FLOW: 440 case IPV6_FLOW: 441 rss_cfg = RSS_HASH_IP; 442 break; 443 default: 444 return -EINVAL; 445 } 446 447 nicvf_reg_write(nic, NIC_VNIC_RSS_CFG, rss_cfg); 448 return 0; 449 } 450 451 static int nicvf_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info) 452 { 453 struct nicvf *nic = netdev_priv(dev); 454 455 switch (info->cmd) { 456 case ETHTOOL_SRXFH: 457 return nicvf_set_rss_hash_opts(nic, info); 458 default: 459 break; 460 } 461 return -EOPNOTSUPP; 462 } 463 464 static u32 nicvf_get_rxfh_key_size(struct net_device *netdev) 465 { 466 return RSS_HASH_KEY_SIZE * sizeof(u64); 467 } 468 469 static u32 nicvf_get_rxfh_indir_size(struct net_device *dev) 470 { 471 struct nicvf *nic = netdev_priv(dev); 472 473 return nic->rss_info.rss_size; 474 } 475 476 static int nicvf_get_rxfh(struct net_device *dev, u32 *indir, u8 *hkey, 477 u8 *hfunc) 478 { 479 struct nicvf *nic = netdev_priv(dev); 480 struct nicvf_rss_info *rss = &nic->rss_info; 481 int idx; 482 483 if (indir) { 484 for (idx = 0; idx < rss->rss_size; idx++) 485 indir[idx] = rss->ind_tbl[idx]; 486 } 487 488 if (hkey) 489 memcpy(hkey, rss->key, RSS_HASH_KEY_SIZE * sizeof(u64)); 490 491 if (hfunc) 492 *hfunc = ETH_RSS_HASH_TOP; 493 494 return 0; 495 } 496 497 static int nicvf_set_rxfh(struct net_device *dev, const u32 *indir, 498 const u8 *hkey, u8 hfunc) 499 { 500 struct nicvf *nic = netdev_priv(dev); 501 struct nicvf_rss_info *rss = &nic->rss_info; 502 int idx; 503 504 if ((nic->qs->rq_cnt <= 1) || (nic->cpi_alg != CPI_ALG_NONE)) { 505 rss->enable = false; 506 rss->hash_bits = 0; 507 return -EIO; 508 } 509 510 /* We do not allow change in unsupported parameters */ 511 if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP) 512 return -EOPNOTSUPP; 513 514 rss->enable = true; 515 if (indir) { 516 for (idx = 0; idx < rss->rss_size; idx++) 517 rss->ind_tbl[idx] = indir[idx]; 518 } 519 520 if (hkey) { 521 memcpy(rss->key, hkey, RSS_HASH_KEY_SIZE * sizeof(u64)); 522 nicvf_set_rss_key(nic); 523 } 524 525 nicvf_config_rss(nic); 526 return 0; 527 } 528 529 /* Get no of queues device supports and current queue count */ 530 static void nicvf_get_channels(struct net_device *dev, 531 struct ethtool_channels *channel) 532 { 533 struct nicvf *nic = netdev_priv(dev); 534 535 memset(channel, 0, sizeof(*channel)); 536 537 channel->max_rx = MAX_RCV_QUEUES_PER_QS; 538 channel->max_tx = MAX_SND_QUEUES_PER_QS; 539 540 channel->rx_count = nic->qs->rq_cnt; 541 channel->tx_count = nic->qs->sq_cnt; 542 } 543 544 /* Set no of Tx, Rx queues to be used */ 545 static int nicvf_set_channels(struct net_device *dev, 546 struct ethtool_channels *channel) 547 { 548 struct nicvf *nic = netdev_priv(dev); 549 int err = 0; 550 bool if_up = netif_running(dev); 551 552 if (!channel->rx_count || !channel->tx_count) 553 return -EINVAL; 554 if (channel->rx_count > MAX_RCV_QUEUES_PER_QS) 555 return -EINVAL; 556 if (channel->tx_count > MAX_SND_QUEUES_PER_QS) 557 return -EINVAL; 558 559 if (if_up) 560 nicvf_stop(dev); 561 562 nic->qs->rq_cnt = channel->rx_count; 563 nic->qs->sq_cnt = channel->tx_count; 564 nic->qs->cq_cnt = max(nic->qs->rq_cnt, nic->qs->sq_cnt); 565 566 err = nicvf_set_real_num_queues(dev, nic->qs->sq_cnt, nic->qs->rq_cnt); 567 if (err) 568 return err; 569 570 if (if_up) 571 nicvf_open(dev); 572 573 netdev_info(dev, "Setting num Tx rings to %d, Rx rings to %d success\n", 574 nic->qs->sq_cnt, nic->qs->rq_cnt); 575 576 return err; 577 } 578 579 static const struct ethtool_ops nicvf_ethtool_ops = { 580 .get_settings = nicvf_get_settings, 581 .get_link = ethtool_op_get_link, 582 .get_drvinfo = nicvf_get_drvinfo, 583 .get_msglevel = nicvf_get_msglevel, 584 .set_msglevel = nicvf_set_msglevel, 585 .get_strings = nicvf_get_strings, 586 .get_sset_count = nicvf_get_sset_count, 587 .get_ethtool_stats = nicvf_get_ethtool_stats, 588 .get_regs_len = nicvf_get_regs_len, 589 .get_regs = nicvf_get_regs, 590 .get_coalesce = nicvf_get_coalesce, 591 .get_ringparam = nicvf_get_ringparam, 592 .get_rxnfc = nicvf_get_rxnfc, 593 .set_rxnfc = nicvf_set_rxnfc, 594 .get_rxfh_key_size = nicvf_get_rxfh_key_size, 595 .get_rxfh_indir_size = nicvf_get_rxfh_indir_size, 596 .get_rxfh = nicvf_get_rxfh, 597 .set_rxfh = nicvf_set_rxfh, 598 .get_channels = nicvf_get_channels, 599 .set_channels = nicvf_set_channels, 600 .get_ts_info = ethtool_op_get_ts_info, 601 }; 602 603 void nicvf_set_ethtool_ops(struct net_device *netdev) 604 { 605 netdev->ethtool_ops = &nicvf_ethtool_ops; 606 } 607