1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2015 Cavium, Inc. 4 */ 5 6 /* ETHTOOL Support for VNIC_VF Device*/ 7 8 #include <linux/pci.h> 9 #include <linux/net_tstamp.h> 10 11 #include "nic_reg.h" 12 #include "nic.h" 13 #include "nicvf_queues.h" 14 #include "q_struct.h" 15 #include "thunder_bgx.h" 16 #include "../common/cavium_ptp.h" 17 18 #define DRV_NAME "nicvf" 19 20 struct nicvf_stat { 21 char name[ETH_GSTRING_LEN]; 22 unsigned int index; 23 }; 24 25 #define NICVF_HW_STAT(stat) { \ 26 .name = #stat, \ 27 .index = offsetof(struct nicvf_hw_stats, stat) / sizeof(u64), \ 28 } 29 30 #define NICVF_DRV_STAT(stat) { \ 31 .name = #stat, \ 32 .index = offsetof(struct nicvf_drv_stats, stat) / sizeof(u64), \ 33 } 34 35 static const struct nicvf_stat nicvf_hw_stats[] = { 36 NICVF_HW_STAT(rx_bytes), 37 NICVF_HW_STAT(rx_frames), 38 NICVF_HW_STAT(rx_ucast_frames), 39 NICVF_HW_STAT(rx_bcast_frames), 40 NICVF_HW_STAT(rx_mcast_frames), 41 NICVF_HW_STAT(rx_drops), 42 NICVF_HW_STAT(rx_drop_red), 43 NICVF_HW_STAT(rx_drop_red_bytes), 44 NICVF_HW_STAT(rx_drop_overrun), 45 NICVF_HW_STAT(rx_drop_overrun_bytes), 46 NICVF_HW_STAT(rx_drop_bcast), 47 NICVF_HW_STAT(rx_drop_mcast), 48 NICVF_HW_STAT(rx_drop_l3_bcast), 49 NICVF_HW_STAT(rx_drop_l3_mcast), 50 NICVF_HW_STAT(rx_fcs_errors), 51 NICVF_HW_STAT(rx_l2_errors), 52 NICVF_HW_STAT(tx_bytes), 53 NICVF_HW_STAT(tx_frames), 54 NICVF_HW_STAT(tx_ucast_frames), 55 NICVF_HW_STAT(tx_bcast_frames), 56 NICVF_HW_STAT(tx_mcast_frames), 57 NICVF_HW_STAT(tx_drops), 58 }; 59 60 static const struct nicvf_stat nicvf_drv_stats[] = { 61 NICVF_DRV_STAT(rx_bgx_truncated_pkts), 62 NICVF_DRV_STAT(rx_jabber_errs), 63 NICVF_DRV_STAT(rx_fcs_errs), 64 NICVF_DRV_STAT(rx_bgx_errs), 65 NICVF_DRV_STAT(rx_prel2_errs), 66 NICVF_DRV_STAT(rx_l2_hdr_malformed), 67 NICVF_DRV_STAT(rx_oversize), 68 NICVF_DRV_STAT(rx_undersize), 69 NICVF_DRV_STAT(rx_l2_len_mismatch), 70 NICVF_DRV_STAT(rx_l2_pclp), 71 NICVF_DRV_STAT(rx_ip_ver_errs), 72 NICVF_DRV_STAT(rx_ip_csum_errs), 73 NICVF_DRV_STAT(rx_ip_hdr_malformed), 74 NICVF_DRV_STAT(rx_ip_payload_malformed), 75 NICVF_DRV_STAT(rx_ip_ttl_errs), 76 NICVF_DRV_STAT(rx_l3_pclp), 77 NICVF_DRV_STAT(rx_l4_malformed), 78 NICVF_DRV_STAT(rx_l4_csum_errs), 79 NICVF_DRV_STAT(rx_udp_len_errs), 80 NICVF_DRV_STAT(rx_l4_port_errs), 81 NICVF_DRV_STAT(rx_tcp_flag_errs), 82 NICVF_DRV_STAT(rx_tcp_offset_errs), 83 NICVF_DRV_STAT(rx_l4_pclp), 84 NICVF_DRV_STAT(rx_truncated_pkts), 85 86 NICVF_DRV_STAT(tx_desc_fault), 87 NICVF_DRV_STAT(tx_hdr_cons_err), 88 NICVF_DRV_STAT(tx_subdesc_err), 89 NICVF_DRV_STAT(tx_max_size_exceeded), 90 NICVF_DRV_STAT(tx_imm_size_oflow), 91 NICVF_DRV_STAT(tx_data_seq_err), 92 NICVF_DRV_STAT(tx_mem_seq_err), 93 NICVF_DRV_STAT(tx_lock_viol), 94 NICVF_DRV_STAT(tx_data_fault), 95 NICVF_DRV_STAT(tx_tstmp_conflict), 96 NICVF_DRV_STAT(tx_tstmp_timeout), 97 NICVF_DRV_STAT(tx_mem_fault), 98 NICVF_DRV_STAT(tx_csum_overlap), 99 NICVF_DRV_STAT(tx_csum_overflow), 100 101 NICVF_DRV_STAT(tx_tso), 102 NICVF_DRV_STAT(tx_timeout), 103 NICVF_DRV_STAT(txq_stop), 104 NICVF_DRV_STAT(txq_wake), 105 NICVF_DRV_STAT(rcv_buffer_alloc_failures), 106 NICVF_DRV_STAT(page_alloc), 107 }; 108 109 static const struct nicvf_stat nicvf_queue_stats[] = { 110 { "bytes", 0 }, 111 { "frames", 1 }, 112 }; 113 114 static const unsigned int nicvf_n_hw_stats = ARRAY_SIZE(nicvf_hw_stats); 115 static const unsigned int nicvf_n_drv_stats = ARRAY_SIZE(nicvf_drv_stats); 116 static const unsigned int nicvf_n_queue_stats = ARRAY_SIZE(nicvf_queue_stats); 117 118 static int nicvf_get_link_ksettings(struct net_device *netdev, 119 struct ethtool_link_ksettings *cmd) 120 { 121 struct nicvf *nic = netdev_priv(netdev); 122 u32 supported, advertising; 123 124 supported = 0; 125 advertising = 0; 126 127 if (!nic->link_up) { 128 cmd->base.duplex = DUPLEX_UNKNOWN; 129 cmd->base.speed = SPEED_UNKNOWN; 130 return 0; 131 } 132 133 switch (nic->speed) { 134 case SPEED_1000: 135 cmd->base.port = PORT_MII | PORT_TP; 136 cmd->base.autoneg = AUTONEG_ENABLE; 137 supported |= SUPPORTED_MII | SUPPORTED_TP; 138 supported |= SUPPORTED_1000baseT_Full | 139 SUPPORTED_1000baseT_Half | 140 SUPPORTED_100baseT_Full | 141 SUPPORTED_100baseT_Half | 142 SUPPORTED_10baseT_Full | 143 SUPPORTED_10baseT_Half; 144 supported |= SUPPORTED_Autoneg; 145 advertising |= ADVERTISED_1000baseT_Full | 146 ADVERTISED_1000baseT_Half | 147 ADVERTISED_100baseT_Full | 148 ADVERTISED_100baseT_Half | 149 ADVERTISED_10baseT_Full | 150 ADVERTISED_10baseT_Half; 151 break; 152 case SPEED_10000: 153 if (nic->mac_type == BGX_MODE_RXAUI) { 154 cmd->base.port = PORT_TP; 155 supported |= SUPPORTED_TP; 156 } else { 157 cmd->base.port = PORT_FIBRE; 158 supported |= SUPPORTED_FIBRE; 159 } 160 cmd->base.autoneg = AUTONEG_DISABLE; 161 supported |= SUPPORTED_10000baseT_Full; 162 break; 163 case SPEED_40000: 164 cmd->base.port = PORT_FIBRE; 165 cmd->base.autoneg = AUTONEG_DISABLE; 166 supported |= SUPPORTED_FIBRE; 167 supported |= SUPPORTED_40000baseCR4_Full; 168 break; 169 } 170 cmd->base.duplex = nic->duplex; 171 cmd->base.speed = nic->speed; 172 173 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported, 174 supported); 175 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising, 176 advertising); 177 178 return 0; 179 } 180 181 static u32 nicvf_get_link(struct net_device *netdev) 182 { 183 struct nicvf *nic = netdev_priv(netdev); 184 185 return nic->link_up; 186 } 187 188 static void nicvf_get_drvinfo(struct net_device *netdev, 189 struct ethtool_drvinfo *info) 190 { 191 struct nicvf *nic = netdev_priv(netdev); 192 193 strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 194 strlcpy(info->bus_info, pci_name(nic->pdev), sizeof(info->bus_info)); 195 } 196 197 static u32 nicvf_get_msglevel(struct net_device *netdev) 198 { 199 struct nicvf *nic = netdev_priv(netdev); 200 201 return nic->msg_enable; 202 } 203 204 static void nicvf_set_msglevel(struct net_device *netdev, u32 lvl) 205 { 206 struct nicvf *nic = netdev_priv(netdev); 207 208 nic->msg_enable = lvl; 209 } 210 211 static void nicvf_get_qset_strings(struct nicvf *nic, u8 **data, int qset) 212 { 213 int stats, qidx; 214 int start_qidx = qset * MAX_RCV_QUEUES_PER_QS; 215 216 for (qidx = 0; qidx < nic->qs->rq_cnt; qidx++) { 217 for (stats = 0; stats < nicvf_n_queue_stats; stats++) { 218 sprintf(*data, "rxq%d: %s", qidx + start_qidx, 219 nicvf_queue_stats[stats].name); 220 *data += ETH_GSTRING_LEN; 221 } 222 } 223 224 for (qidx = 0; qidx < nic->qs->sq_cnt; qidx++) { 225 for (stats = 0; stats < nicvf_n_queue_stats; stats++) { 226 sprintf(*data, "txq%d: %s", qidx + start_qidx, 227 nicvf_queue_stats[stats].name); 228 *data += ETH_GSTRING_LEN; 229 } 230 } 231 } 232 233 static void nicvf_get_strings(struct net_device *netdev, u32 sset, u8 *data) 234 { 235 struct nicvf *nic = netdev_priv(netdev); 236 int stats; 237 int sqs; 238 239 if (sset != ETH_SS_STATS) 240 return; 241 242 for (stats = 0; stats < nicvf_n_hw_stats; stats++) { 243 memcpy(data, nicvf_hw_stats[stats].name, ETH_GSTRING_LEN); 244 data += ETH_GSTRING_LEN; 245 } 246 247 for (stats = 0; stats < nicvf_n_drv_stats; stats++) { 248 memcpy(data, nicvf_drv_stats[stats].name, ETH_GSTRING_LEN); 249 data += ETH_GSTRING_LEN; 250 } 251 252 nicvf_get_qset_strings(nic, &data, 0); 253 254 for (sqs = 0; sqs < nic->sqs_count; sqs++) { 255 if (!nic->snicvf[sqs]) 256 continue; 257 nicvf_get_qset_strings(nic->snicvf[sqs], &data, sqs + 1); 258 } 259 260 for (stats = 0; stats < BGX_RX_STATS_COUNT; stats++) { 261 sprintf(data, "bgx_rxstat%d: ", stats); 262 data += ETH_GSTRING_LEN; 263 } 264 265 for (stats = 0; stats < BGX_TX_STATS_COUNT; stats++) { 266 sprintf(data, "bgx_txstat%d: ", stats); 267 data += ETH_GSTRING_LEN; 268 } 269 } 270 271 static int nicvf_get_sset_count(struct net_device *netdev, int sset) 272 { 273 struct nicvf *nic = netdev_priv(netdev); 274 int qstats_count; 275 int sqs; 276 277 if (sset != ETH_SS_STATS) 278 return -EINVAL; 279 280 qstats_count = nicvf_n_queue_stats * 281 (nic->qs->rq_cnt + nic->qs->sq_cnt); 282 for (sqs = 0; sqs < nic->sqs_count; sqs++) { 283 struct nicvf *snic; 284 285 snic = nic->snicvf[sqs]; 286 if (!snic) 287 continue; 288 qstats_count += nicvf_n_queue_stats * 289 (snic->qs->rq_cnt + snic->qs->sq_cnt); 290 } 291 292 return nicvf_n_hw_stats + nicvf_n_drv_stats + 293 qstats_count + 294 BGX_RX_STATS_COUNT + BGX_TX_STATS_COUNT; 295 } 296 297 static void nicvf_get_qset_stats(struct nicvf *nic, 298 struct ethtool_stats *stats, u64 **data) 299 { 300 int stat, qidx; 301 302 if (!nic) 303 return; 304 305 for (qidx = 0; qidx < nic->qs->rq_cnt; qidx++) { 306 nicvf_update_rq_stats(nic, qidx); 307 for (stat = 0; stat < nicvf_n_queue_stats; stat++) 308 *((*data)++) = ((u64 *)&nic->qs->rq[qidx].stats) 309 [nicvf_queue_stats[stat].index]; 310 } 311 312 for (qidx = 0; qidx < nic->qs->sq_cnt; qidx++) { 313 nicvf_update_sq_stats(nic, qidx); 314 for (stat = 0; stat < nicvf_n_queue_stats; stat++) 315 *((*data)++) = ((u64 *)&nic->qs->sq[qidx].stats) 316 [nicvf_queue_stats[stat].index]; 317 } 318 } 319 320 static void nicvf_get_ethtool_stats(struct net_device *netdev, 321 struct ethtool_stats *stats, u64 *data) 322 { 323 struct nicvf *nic = netdev_priv(netdev); 324 int stat, tmp_stats; 325 int sqs, cpu; 326 327 nicvf_update_stats(nic); 328 329 /* Update LMAC stats */ 330 nicvf_update_lmac_stats(nic); 331 332 for (stat = 0; stat < nicvf_n_hw_stats; stat++) 333 *(data++) = ((u64 *)&nic->hw_stats) 334 [nicvf_hw_stats[stat].index]; 335 for (stat = 0; stat < nicvf_n_drv_stats; stat++) { 336 tmp_stats = 0; 337 for_each_possible_cpu(cpu) 338 tmp_stats += ((u64 *)per_cpu_ptr(nic->drv_stats, cpu)) 339 [nicvf_drv_stats[stat].index]; 340 *(data++) = tmp_stats; 341 } 342 343 nicvf_get_qset_stats(nic, stats, &data); 344 345 for (sqs = 0; sqs < nic->sqs_count; sqs++) { 346 if (!nic->snicvf[sqs]) 347 continue; 348 nicvf_get_qset_stats(nic->snicvf[sqs], stats, &data); 349 } 350 351 for (stat = 0; stat < BGX_RX_STATS_COUNT; stat++) 352 *(data++) = nic->bgx_stats.rx_stats[stat]; 353 for (stat = 0; stat < BGX_TX_STATS_COUNT; stat++) 354 *(data++) = nic->bgx_stats.tx_stats[stat]; 355 } 356 357 static int nicvf_get_regs_len(struct net_device *dev) 358 { 359 return sizeof(u64) * NIC_VF_REG_COUNT; 360 } 361 362 static void nicvf_get_regs(struct net_device *dev, 363 struct ethtool_regs *regs, void *reg) 364 { 365 struct nicvf *nic = netdev_priv(dev); 366 u64 *p = (u64 *)reg; 367 u64 reg_offset; 368 int mbox, key, stat, q; 369 int i = 0; 370 371 regs->version = 0; 372 memset(p, 0, NIC_VF_REG_COUNT); 373 374 p[i++] = nicvf_reg_read(nic, NIC_VNIC_CFG); 375 /* Mailbox registers */ 376 for (mbox = 0; mbox < NIC_PF_VF_MAILBOX_SIZE; mbox++) 377 p[i++] = nicvf_reg_read(nic, 378 NIC_VF_PF_MAILBOX_0_1 | (mbox << 3)); 379 380 p[i++] = nicvf_reg_read(nic, NIC_VF_INT); 381 p[i++] = nicvf_reg_read(nic, NIC_VF_INT_W1S); 382 p[i++] = nicvf_reg_read(nic, NIC_VF_ENA_W1C); 383 p[i++] = nicvf_reg_read(nic, NIC_VF_ENA_W1S); 384 p[i++] = nicvf_reg_read(nic, NIC_VNIC_RSS_CFG); 385 386 for (key = 0; key < RSS_HASH_KEY_SIZE; key++) 387 p[i++] = nicvf_reg_read(nic, NIC_VNIC_RSS_KEY_0_4 | (key << 3)); 388 389 /* Tx/Rx statistics */ 390 for (stat = 0; stat < TX_STATS_ENUM_LAST; stat++) 391 p[i++] = nicvf_reg_read(nic, 392 NIC_VNIC_TX_STAT_0_4 | (stat << 3)); 393 394 for (i = 0; i < RX_STATS_ENUM_LAST; i++) 395 p[i++] = nicvf_reg_read(nic, 396 NIC_VNIC_RX_STAT_0_13 | (stat << 3)); 397 398 p[i++] = nicvf_reg_read(nic, NIC_QSET_RQ_GEN_CFG); 399 400 /* All completion queue's registers */ 401 for (q = 0; q < MAX_CMP_QUEUES_PER_QS; q++) { 402 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_CFG, q); 403 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_CFG2, q); 404 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_THRESH, q); 405 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_BASE, q); 406 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_HEAD, q); 407 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_TAIL, q); 408 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_DOOR, q); 409 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_STATUS, q); 410 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_STATUS2, q); 411 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_DEBUG, q); 412 } 413 414 /* All receive queue's registers */ 415 for (q = 0; q < MAX_RCV_QUEUES_PER_QS; q++) { 416 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RQ_0_7_CFG, q); 417 p[i++] = nicvf_queue_reg_read(nic, 418 NIC_QSET_RQ_0_7_STAT_0_1, q); 419 reg_offset = NIC_QSET_RQ_0_7_STAT_0_1 | (1 << 3); 420 p[i++] = nicvf_queue_reg_read(nic, reg_offset, q); 421 } 422 423 for (q = 0; q < MAX_SND_QUEUES_PER_QS; q++) { 424 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_CFG, q); 425 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_THRESH, q); 426 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_BASE, q); 427 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_HEAD, q); 428 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_TAIL, q); 429 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_DOOR, q); 430 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_STATUS, q); 431 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_DEBUG, q); 432 /* Padding, was NIC_QSET_SQ_0_7_CNM_CHG, which 433 * produces bus errors when read 434 */ 435 p[i++] = 0; 436 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_STAT_0_1, q); 437 reg_offset = NIC_QSET_SQ_0_7_STAT_0_1 | (1 << 3); 438 p[i++] = nicvf_queue_reg_read(nic, reg_offset, q); 439 } 440 441 for (q = 0; q < MAX_RCV_BUF_DESC_RINGS_PER_QS; q++) { 442 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_CFG, q); 443 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_THRESH, q); 444 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_BASE, q); 445 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_HEAD, q); 446 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_TAIL, q); 447 p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_DOOR, q); 448 p[i++] = nicvf_queue_reg_read(nic, 449 NIC_QSET_RBDR_0_1_STATUS0, q); 450 p[i++] = nicvf_queue_reg_read(nic, 451 NIC_QSET_RBDR_0_1_STATUS1, q); 452 reg_offset = NIC_QSET_RBDR_0_1_PREFETCH_STATUS; 453 p[i++] = nicvf_queue_reg_read(nic, reg_offset, q); 454 } 455 } 456 457 static int nicvf_get_coalesce(struct net_device *netdev, 458 struct ethtool_coalesce *cmd) 459 { 460 struct nicvf *nic = netdev_priv(netdev); 461 462 cmd->rx_coalesce_usecs = nic->cq_coalesce_usecs; 463 return 0; 464 } 465 466 static void nicvf_get_ringparam(struct net_device *netdev, 467 struct ethtool_ringparam *ring) 468 { 469 struct nicvf *nic = netdev_priv(netdev); 470 struct queue_set *qs = nic->qs; 471 472 ring->rx_max_pending = MAX_CMP_QUEUE_LEN; 473 ring->rx_pending = qs->cq_len; 474 ring->tx_max_pending = MAX_SND_QUEUE_LEN; 475 ring->tx_pending = qs->sq_len; 476 } 477 478 static int nicvf_set_ringparam(struct net_device *netdev, 479 struct ethtool_ringparam *ring) 480 { 481 struct nicvf *nic = netdev_priv(netdev); 482 struct queue_set *qs = nic->qs; 483 u32 rx_count, tx_count; 484 485 /* Due to HW errata this is not supported on T88 pass 1.x silicon */ 486 if (pass1_silicon(nic->pdev)) 487 return -EINVAL; 488 489 if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending)) 490 return -EINVAL; 491 492 tx_count = clamp_t(u32, ring->tx_pending, 493 MIN_SND_QUEUE_LEN, MAX_SND_QUEUE_LEN); 494 rx_count = clamp_t(u32, ring->rx_pending, 495 MIN_CMP_QUEUE_LEN, MAX_CMP_QUEUE_LEN); 496 497 if ((tx_count == qs->sq_len) && (rx_count == qs->cq_len)) 498 return 0; 499 500 /* Permitted lengths are 1K, 2K, 4K, 8K, 16K, 32K, 64K */ 501 qs->sq_len = rounddown_pow_of_two(tx_count); 502 qs->cq_len = rounddown_pow_of_two(rx_count); 503 504 if (netif_running(netdev)) { 505 nicvf_stop(netdev); 506 nicvf_open(netdev); 507 } 508 509 return 0; 510 } 511 512 static int nicvf_get_rss_hash_opts(struct nicvf *nic, 513 struct ethtool_rxnfc *info) 514 { 515 info->data = 0; 516 517 switch (info->flow_type) { 518 case TCP_V4_FLOW: 519 case TCP_V6_FLOW: 520 case UDP_V4_FLOW: 521 case UDP_V6_FLOW: 522 case SCTP_V4_FLOW: 523 case SCTP_V6_FLOW: 524 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 525 /* Fall through */ 526 case IPV4_FLOW: 527 case IPV6_FLOW: 528 info->data |= RXH_IP_SRC | RXH_IP_DST; 529 break; 530 default: 531 return -EINVAL; 532 } 533 534 return 0; 535 } 536 537 static int nicvf_get_rxnfc(struct net_device *dev, 538 struct ethtool_rxnfc *info, u32 *rules) 539 { 540 struct nicvf *nic = netdev_priv(dev); 541 int ret = -EOPNOTSUPP; 542 543 switch (info->cmd) { 544 case ETHTOOL_GRXRINGS: 545 info->data = nic->rx_queues; 546 ret = 0; 547 break; 548 case ETHTOOL_GRXFH: 549 return nicvf_get_rss_hash_opts(nic, info); 550 default: 551 break; 552 } 553 return ret; 554 } 555 556 static int nicvf_set_rss_hash_opts(struct nicvf *nic, 557 struct ethtool_rxnfc *info) 558 { 559 struct nicvf_rss_info *rss = &nic->rss_info; 560 u64 rss_cfg = nicvf_reg_read(nic, NIC_VNIC_RSS_CFG); 561 562 if (!rss->enable) 563 netdev_err(nic->netdev, 564 "RSS is disabled, hash cannot be set\n"); 565 566 netdev_info(nic->netdev, "Set RSS flow type = %d, data = %lld\n", 567 info->flow_type, info->data); 568 569 if (!(info->data & RXH_IP_SRC) || !(info->data & RXH_IP_DST)) 570 return -EINVAL; 571 572 switch (info->flow_type) { 573 case TCP_V4_FLOW: 574 case TCP_V6_FLOW: 575 switch (info->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 576 case 0: 577 rss_cfg &= ~(1ULL << RSS_HASH_TCP); 578 break; 579 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 580 rss_cfg |= (1ULL << RSS_HASH_TCP); 581 break; 582 default: 583 return -EINVAL; 584 } 585 break; 586 case UDP_V4_FLOW: 587 case UDP_V6_FLOW: 588 switch (info->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 589 case 0: 590 rss_cfg &= ~(1ULL << RSS_HASH_UDP); 591 break; 592 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 593 rss_cfg |= (1ULL << RSS_HASH_UDP); 594 break; 595 default: 596 return -EINVAL; 597 } 598 break; 599 case SCTP_V4_FLOW: 600 case SCTP_V6_FLOW: 601 switch (info->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 602 case 0: 603 rss_cfg &= ~(1ULL << RSS_HASH_L4ETC); 604 break; 605 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 606 rss_cfg |= (1ULL << RSS_HASH_L4ETC); 607 break; 608 default: 609 return -EINVAL; 610 } 611 break; 612 case IPV4_FLOW: 613 case IPV6_FLOW: 614 rss_cfg = RSS_HASH_IP; 615 break; 616 default: 617 return -EINVAL; 618 } 619 620 nicvf_reg_write(nic, NIC_VNIC_RSS_CFG, rss_cfg); 621 return 0; 622 } 623 624 static int nicvf_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info) 625 { 626 struct nicvf *nic = netdev_priv(dev); 627 628 switch (info->cmd) { 629 case ETHTOOL_SRXFH: 630 return nicvf_set_rss_hash_opts(nic, info); 631 default: 632 break; 633 } 634 return -EOPNOTSUPP; 635 } 636 637 static u32 nicvf_get_rxfh_key_size(struct net_device *netdev) 638 { 639 return RSS_HASH_KEY_SIZE * sizeof(u64); 640 } 641 642 static u32 nicvf_get_rxfh_indir_size(struct net_device *dev) 643 { 644 struct nicvf *nic = netdev_priv(dev); 645 646 return nic->rss_info.rss_size; 647 } 648 649 static int nicvf_get_rxfh(struct net_device *dev, u32 *indir, u8 *hkey, 650 u8 *hfunc) 651 { 652 struct nicvf *nic = netdev_priv(dev); 653 struct nicvf_rss_info *rss = &nic->rss_info; 654 int idx; 655 656 if (indir) { 657 for (idx = 0; idx < rss->rss_size; idx++) 658 indir[idx] = rss->ind_tbl[idx]; 659 } 660 661 if (hkey) 662 memcpy(hkey, rss->key, RSS_HASH_KEY_SIZE * sizeof(u64)); 663 664 if (hfunc) 665 *hfunc = ETH_RSS_HASH_TOP; 666 667 return 0; 668 } 669 670 static int nicvf_set_rxfh(struct net_device *dev, const u32 *indir, 671 const u8 *hkey, const u8 hfunc) 672 { 673 struct nicvf *nic = netdev_priv(dev); 674 struct nicvf_rss_info *rss = &nic->rss_info; 675 int idx; 676 677 if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP) 678 return -EOPNOTSUPP; 679 680 if (!rss->enable) { 681 netdev_err(nic->netdev, 682 "RSS is disabled, cannot change settings\n"); 683 return -EIO; 684 } 685 686 if (indir) { 687 for (idx = 0; idx < rss->rss_size; idx++) 688 rss->ind_tbl[idx] = indir[idx]; 689 } 690 691 if (hkey) { 692 memcpy(rss->key, hkey, RSS_HASH_KEY_SIZE * sizeof(u64)); 693 nicvf_set_rss_key(nic); 694 } 695 696 nicvf_config_rss(nic); 697 return 0; 698 } 699 700 /* Get no of queues device supports and current queue count */ 701 static void nicvf_get_channels(struct net_device *dev, 702 struct ethtool_channels *channel) 703 { 704 struct nicvf *nic = netdev_priv(dev); 705 706 memset(channel, 0, sizeof(*channel)); 707 708 channel->max_rx = nic->max_queues; 709 channel->max_tx = nic->max_queues; 710 711 channel->rx_count = nic->rx_queues; 712 channel->tx_count = nic->tx_queues; 713 } 714 715 /* Set no of Tx, Rx queues to be used */ 716 static int nicvf_set_channels(struct net_device *dev, 717 struct ethtool_channels *channel) 718 { 719 struct nicvf *nic = netdev_priv(dev); 720 int err = 0; 721 bool if_up = netif_running(dev); 722 u8 cqcount, txq_count; 723 724 if (!channel->rx_count || !channel->tx_count) 725 return -EINVAL; 726 if (channel->rx_count > nic->max_queues) 727 return -EINVAL; 728 if (channel->tx_count > nic->max_queues) 729 return -EINVAL; 730 731 if (nic->xdp_prog && 732 ((channel->tx_count + channel->rx_count) > nic->max_queues)) { 733 netdev_err(nic->netdev, 734 "XDP mode, RXQs + TXQs > Max %d\n", 735 nic->max_queues); 736 return -EINVAL; 737 } 738 739 if (if_up) 740 nicvf_stop(dev); 741 742 nic->rx_queues = channel->rx_count; 743 nic->tx_queues = channel->tx_count; 744 if (!nic->xdp_prog) 745 nic->xdp_tx_queues = 0; 746 else 747 nic->xdp_tx_queues = channel->rx_count; 748 749 txq_count = nic->xdp_tx_queues + nic->tx_queues; 750 cqcount = max(nic->rx_queues, txq_count); 751 752 if (cqcount > MAX_CMP_QUEUES_PER_QS) { 753 nic->sqs_count = roundup(cqcount, MAX_CMP_QUEUES_PER_QS); 754 nic->sqs_count = (nic->sqs_count / MAX_CMP_QUEUES_PER_QS) - 1; 755 } else { 756 nic->sqs_count = 0; 757 } 758 759 nic->qs->rq_cnt = min_t(u8, nic->rx_queues, MAX_RCV_QUEUES_PER_QS); 760 nic->qs->sq_cnt = min_t(u8, txq_count, MAX_SND_QUEUES_PER_QS); 761 nic->qs->cq_cnt = max(nic->qs->rq_cnt, nic->qs->sq_cnt); 762 763 err = nicvf_set_real_num_queues(dev, nic->tx_queues, nic->rx_queues); 764 if (err) 765 return err; 766 767 if (if_up) 768 nicvf_open(dev); 769 770 netdev_info(dev, "Setting num Tx rings to %d, Rx rings to %d success\n", 771 nic->tx_queues, nic->rx_queues); 772 773 return err; 774 } 775 776 static void nicvf_get_pauseparam(struct net_device *dev, 777 struct ethtool_pauseparam *pause) 778 { 779 struct nicvf *nic = netdev_priv(dev); 780 union nic_mbx mbx = {}; 781 782 /* Supported only for 10G/40G interfaces */ 783 if ((nic->mac_type == BGX_MODE_SGMII) || 784 (nic->mac_type == BGX_MODE_QSGMII) || 785 (nic->mac_type == BGX_MODE_RGMII)) 786 return; 787 788 mbx.pfc.msg = NIC_MBOX_MSG_PFC; 789 mbx.pfc.get = 1; 790 if (!nicvf_send_msg_to_pf(nic, &mbx)) { 791 pause->autoneg = nic->pfc.autoneg; 792 pause->rx_pause = nic->pfc.fc_rx; 793 pause->tx_pause = nic->pfc.fc_tx; 794 } 795 } 796 797 static int nicvf_set_pauseparam(struct net_device *dev, 798 struct ethtool_pauseparam *pause) 799 { 800 struct nicvf *nic = netdev_priv(dev); 801 union nic_mbx mbx = {}; 802 803 /* Supported only for 10G/40G interfaces */ 804 if ((nic->mac_type == BGX_MODE_SGMII) || 805 (nic->mac_type == BGX_MODE_QSGMII) || 806 (nic->mac_type == BGX_MODE_RGMII)) 807 return -EOPNOTSUPP; 808 809 if (pause->autoneg) 810 return -EOPNOTSUPP; 811 812 mbx.pfc.msg = NIC_MBOX_MSG_PFC; 813 mbx.pfc.get = 0; 814 mbx.pfc.fc_rx = pause->rx_pause; 815 mbx.pfc.fc_tx = pause->tx_pause; 816 if (nicvf_send_msg_to_pf(nic, &mbx)) 817 return -EAGAIN; 818 819 nic->pfc.fc_rx = pause->rx_pause; 820 nic->pfc.fc_tx = pause->tx_pause; 821 822 return 0; 823 } 824 825 static int nicvf_get_ts_info(struct net_device *netdev, 826 struct ethtool_ts_info *info) 827 { 828 struct nicvf *nic = netdev_priv(netdev); 829 830 if (!nic->ptp_clock) 831 return ethtool_op_get_ts_info(netdev, info); 832 833 info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE | 834 SOF_TIMESTAMPING_RX_SOFTWARE | 835 SOF_TIMESTAMPING_SOFTWARE | 836 SOF_TIMESTAMPING_TX_HARDWARE | 837 SOF_TIMESTAMPING_RX_HARDWARE | 838 SOF_TIMESTAMPING_RAW_HARDWARE; 839 840 info->phc_index = cavium_ptp_clock_index(nic->ptp_clock); 841 842 info->tx_types = (1 << HWTSTAMP_TX_OFF) | (1 << HWTSTAMP_TX_ON); 843 844 info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) | 845 (1 << HWTSTAMP_FILTER_ALL); 846 847 return 0; 848 } 849 850 static const struct ethtool_ops nicvf_ethtool_ops = { 851 .get_link = nicvf_get_link, 852 .get_drvinfo = nicvf_get_drvinfo, 853 .get_msglevel = nicvf_get_msglevel, 854 .set_msglevel = nicvf_set_msglevel, 855 .get_strings = nicvf_get_strings, 856 .get_sset_count = nicvf_get_sset_count, 857 .get_ethtool_stats = nicvf_get_ethtool_stats, 858 .get_regs_len = nicvf_get_regs_len, 859 .get_regs = nicvf_get_regs, 860 .get_coalesce = nicvf_get_coalesce, 861 .get_ringparam = nicvf_get_ringparam, 862 .set_ringparam = nicvf_set_ringparam, 863 .get_rxnfc = nicvf_get_rxnfc, 864 .set_rxnfc = nicvf_set_rxnfc, 865 .get_rxfh_key_size = nicvf_get_rxfh_key_size, 866 .get_rxfh_indir_size = nicvf_get_rxfh_indir_size, 867 .get_rxfh = nicvf_get_rxfh, 868 .set_rxfh = nicvf_set_rxfh, 869 .get_channels = nicvf_get_channels, 870 .set_channels = nicvf_set_channels, 871 .get_pauseparam = nicvf_get_pauseparam, 872 .set_pauseparam = nicvf_set_pauseparam, 873 .get_ts_info = nicvf_get_ts_info, 874 .get_link_ksettings = nicvf_get_link_ksettings, 875 }; 876 877 void nicvf_set_ethtool_ops(struct net_device *netdev) 878 { 879 netdev->ethtool_ops = &nicvf_ethtool_ops; 880 } 881