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