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