1 // SPDX-License-Identifier: GPL-2.0 2 /* Marvell RVU Ethernet driver 3 * 4 * Copyright (C) 2020 Marvell. 5 * 6 */ 7 8 #include <linux/pci.h> 9 #include <linux/ethtool.h> 10 #include <linux/stddef.h> 11 #include <linux/etherdevice.h> 12 #include <linux/log2.h> 13 #include <linux/net_tstamp.h> 14 #include <linux/linkmode.h> 15 16 #include "otx2_common.h" 17 #include "otx2_ptp.h" 18 19 #define DRV_NAME "rvu-nicpf" 20 #define DRV_VF_NAME "rvu-nicvf" 21 22 struct otx2_stat { 23 char name[ETH_GSTRING_LEN]; 24 unsigned int index; 25 }; 26 27 /* HW device stats */ 28 #define OTX2_DEV_STAT(stat) { \ 29 .name = #stat, \ 30 .index = offsetof(struct otx2_dev_stats, stat) / sizeof(u64), \ 31 } 32 33 enum link_mode { 34 OTX2_MODE_SUPPORTED, 35 OTX2_MODE_ADVERTISED 36 }; 37 38 static const struct otx2_stat otx2_dev_stats[] = { 39 OTX2_DEV_STAT(rx_ucast_frames), 40 OTX2_DEV_STAT(rx_bcast_frames), 41 OTX2_DEV_STAT(rx_mcast_frames), 42 43 OTX2_DEV_STAT(tx_ucast_frames), 44 OTX2_DEV_STAT(tx_bcast_frames), 45 OTX2_DEV_STAT(tx_mcast_frames), 46 }; 47 48 /* Driver level stats */ 49 #define OTX2_DRV_STAT(stat) { \ 50 .name = #stat, \ 51 .index = offsetof(struct otx2_drv_stats, stat) / sizeof(atomic_t), \ 52 } 53 54 static const struct otx2_stat otx2_drv_stats[] = { 55 OTX2_DRV_STAT(rx_fcs_errs), 56 OTX2_DRV_STAT(rx_oversize_errs), 57 OTX2_DRV_STAT(rx_undersize_errs), 58 OTX2_DRV_STAT(rx_csum_errs), 59 OTX2_DRV_STAT(rx_len_errs), 60 OTX2_DRV_STAT(rx_other_errs), 61 }; 62 63 static const struct otx2_stat otx2_queue_stats[] = { 64 { "bytes", 0 }, 65 { "frames", 1 }, 66 }; 67 68 static const unsigned int otx2_n_dev_stats = ARRAY_SIZE(otx2_dev_stats); 69 static const unsigned int otx2_n_drv_stats = ARRAY_SIZE(otx2_drv_stats); 70 static const unsigned int otx2_n_queue_stats = ARRAY_SIZE(otx2_queue_stats); 71 72 static struct cgx_fw_data *otx2_get_fwdata(struct otx2_nic *pfvf); 73 74 static void otx2_get_drvinfo(struct net_device *netdev, 75 struct ethtool_drvinfo *info) 76 { 77 struct otx2_nic *pfvf = netdev_priv(netdev); 78 79 strscpy(info->driver, DRV_NAME, sizeof(info->driver)); 80 strscpy(info->bus_info, pci_name(pfvf->pdev), sizeof(info->bus_info)); 81 } 82 83 static void otx2_get_qset_strings(struct otx2_nic *pfvf, u8 **data, int qset) 84 { 85 int start_qidx = qset * pfvf->hw.rx_queues; 86 int qidx, stats; 87 88 for (qidx = 0; qidx < pfvf->hw.rx_queues; qidx++) 89 for (stats = 0; stats < otx2_n_queue_stats; stats++) 90 ethtool_sprintf(data, "rxq%d: %s", qidx + start_qidx, 91 otx2_queue_stats[stats].name); 92 93 for (qidx = 0; qidx < otx2_get_total_tx_queues(pfvf); qidx++) 94 for (stats = 0; stats < otx2_n_queue_stats; stats++) 95 if (qidx >= pfvf->hw.non_qos_queues) 96 ethtool_sprintf(data, "txq_qos%d: %s", 97 qidx + start_qidx - 98 pfvf->hw.non_qos_queues, 99 otx2_queue_stats[stats].name); 100 else 101 ethtool_sprintf(data, "txq%d: %s", 102 qidx + start_qidx, 103 otx2_queue_stats[stats].name); 104 } 105 106 static void otx2_get_strings(struct net_device *netdev, u32 sset, u8 *data) 107 { 108 struct otx2_nic *pfvf = netdev_priv(netdev); 109 int stats; 110 111 if (sset != ETH_SS_STATS) 112 return; 113 114 for (stats = 0; stats < otx2_n_dev_stats; stats++) 115 ethtool_puts(&data, otx2_dev_stats[stats].name); 116 117 for (stats = 0; stats < otx2_n_drv_stats; stats++) 118 ethtool_puts(&data, otx2_drv_stats[stats].name); 119 120 otx2_get_qset_strings(pfvf, &data, 0); 121 122 if (!test_bit(CN10K_RPM, &pfvf->hw.cap_flag)) { 123 for (stats = 0; stats < CGX_RX_STATS_COUNT; stats++) 124 ethtool_sprintf(&data, "cgx_rxstat%d: ", stats); 125 126 for (stats = 0; stats < CGX_TX_STATS_COUNT; stats++) 127 ethtool_sprintf(&data, "cgx_txstat%d: ", stats); 128 } 129 130 ethtool_puts(&data, "reset_count"); 131 ethtool_puts(&data, "Fec Corrected Errors: "); 132 ethtool_puts(&data, "Fec Uncorrected Errors: "); 133 } 134 135 static void otx2_get_qset_stats(struct otx2_nic *pfvf, 136 struct ethtool_stats *stats, u64 **data) 137 { 138 int stat, qidx; 139 140 if (!pfvf) 141 return; 142 for (qidx = 0; qidx < pfvf->hw.rx_queues; qidx++) { 143 if (!otx2_update_rq_stats(pfvf, qidx)) { 144 for (stat = 0; stat < otx2_n_queue_stats; stat++) 145 *((*data)++) = 0; 146 continue; 147 } 148 for (stat = 0; stat < otx2_n_queue_stats; stat++) 149 *((*data)++) = ((u64 *)&pfvf->qset.rq[qidx].stats) 150 [otx2_queue_stats[stat].index]; 151 } 152 153 for (qidx = 0; qidx < otx2_get_total_tx_queues(pfvf); qidx++) { 154 if (!otx2_update_sq_stats(pfvf, qidx)) { 155 for (stat = 0; stat < otx2_n_queue_stats; stat++) 156 *((*data)++) = 0; 157 continue; 158 } 159 for (stat = 0; stat < otx2_n_queue_stats; stat++) 160 *((*data)++) = ((u64 *)&pfvf->qset.sq[qidx].stats) 161 [otx2_queue_stats[stat].index]; 162 } 163 } 164 165 static int otx2_get_phy_fec_stats(struct otx2_nic *pfvf) 166 { 167 struct msg_req *req; 168 int rc = -ENOMEM; 169 170 mutex_lock(&pfvf->mbox.lock); 171 req = otx2_mbox_alloc_msg_cgx_get_phy_fec_stats(&pfvf->mbox); 172 if (!req) 173 goto end; 174 175 if (!otx2_sync_mbox_msg(&pfvf->mbox)) 176 rc = 0; 177 end: 178 mutex_unlock(&pfvf->mbox.lock); 179 return rc; 180 } 181 182 /* Get device and per queue statistics */ 183 static void otx2_get_ethtool_stats(struct net_device *netdev, 184 struct ethtool_stats *stats, u64 *data) 185 { 186 struct otx2_nic *pfvf = netdev_priv(netdev); 187 u64 fec_corr_blks, fec_uncorr_blks; 188 struct cgx_fw_data *rsp; 189 int stat; 190 191 otx2_get_dev_stats(pfvf); 192 for (stat = 0; stat < otx2_n_dev_stats; stat++) 193 *(data++) = ((u64 *)&pfvf->hw.dev_stats) 194 [otx2_dev_stats[stat].index]; 195 196 for (stat = 0; stat < otx2_n_drv_stats; stat++) 197 *(data++) = atomic_read(&((atomic_t *)&pfvf->hw.drv_stats) 198 [otx2_drv_stats[stat].index]); 199 200 otx2_get_qset_stats(pfvf, stats, &data); 201 202 if (!test_bit(CN10K_RPM, &pfvf->hw.cap_flag)) { 203 otx2_update_lmac_stats(pfvf); 204 for (stat = 0; stat < CGX_RX_STATS_COUNT; stat++) 205 *(data++) = pfvf->hw.cgx_rx_stats[stat]; 206 for (stat = 0; stat < CGX_TX_STATS_COUNT; stat++) 207 *(data++) = pfvf->hw.cgx_tx_stats[stat]; 208 } 209 210 *(data++) = pfvf->reset_count; 211 212 fec_corr_blks = pfvf->hw.cgx_fec_corr_blks; 213 fec_uncorr_blks = pfvf->hw.cgx_fec_uncorr_blks; 214 215 rsp = otx2_get_fwdata(pfvf); 216 if (!IS_ERR(rsp) && rsp->fwdata.phy.misc.has_fec_stats && 217 !otx2_get_phy_fec_stats(pfvf)) { 218 /* Fetch fwdata again because it's been recently populated with 219 * latest PHY FEC stats. 220 */ 221 rsp = otx2_get_fwdata(pfvf); 222 if (!IS_ERR(rsp)) { 223 struct fec_stats_s *p = &rsp->fwdata.phy.fec_stats; 224 225 if (pfvf->linfo.fec == OTX2_FEC_BASER) { 226 fec_corr_blks = p->brfec_corr_blks; 227 fec_uncorr_blks = p->brfec_uncorr_blks; 228 } else { 229 fec_corr_blks = p->rsfec_corr_cws; 230 fec_uncorr_blks = p->rsfec_uncorr_cws; 231 } 232 } 233 } 234 235 *(data++) = fec_corr_blks; 236 *(data++) = fec_uncorr_blks; 237 } 238 239 static int otx2_get_sset_count(struct net_device *netdev, int sset) 240 { 241 struct otx2_nic *pfvf = netdev_priv(netdev); 242 int qstats_count, mac_stats = 0; 243 244 if (sset != ETH_SS_STATS) 245 return -EINVAL; 246 247 qstats_count = otx2_n_queue_stats * 248 (pfvf->hw.rx_queues + otx2_get_total_tx_queues(pfvf)); 249 if (!test_bit(CN10K_RPM, &pfvf->hw.cap_flag)) 250 mac_stats = CGX_RX_STATS_COUNT + CGX_TX_STATS_COUNT; 251 otx2_update_lmac_fec_stats(pfvf); 252 253 return otx2_n_dev_stats + otx2_n_drv_stats + qstats_count + 254 mac_stats + OTX2_FEC_STATS_CNT + 1; 255 } 256 257 /* Get no of queues device supports and current queue count */ 258 static void otx2_get_channels(struct net_device *dev, 259 struct ethtool_channels *channel) 260 { 261 struct otx2_nic *pfvf = netdev_priv(dev); 262 263 channel->max_rx = pfvf->hw.max_queues; 264 channel->max_tx = pfvf->hw.max_queues; 265 266 channel->rx_count = pfvf->hw.rx_queues; 267 channel->tx_count = pfvf->hw.tx_queues; 268 } 269 270 /* Set no of Tx, Rx queues to be used */ 271 static int otx2_set_channels(struct net_device *dev, 272 struct ethtool_channels *channel) 273 { 274 struct otx2_nic *pfvf = netdev_priv(dev); 275 bool if_up = netif_running(dev); 276 int err, qos_txqs; 277 278 if (!channel->rx_count || !channel->tx_count) 279 return -EINVAL; 280 281 if (bitmap_weight(&pfvf->rq_bmap, pfvf->hw.rx_queues) > 1) { 282 netdev_err(dev, 283 "Receive queues are in use by TC police action\n"); 284 return -EINVAL; 285 } 286 287 if (if_up) 288 dev->netdev_ops->ndo_stop(dev); 289 290 qos_txqs = bitmap_weight(pfvf->qos.qos_sq_bmap, 291 OTX2_QOS_MAX_LEAF_NODES); 292 293 err = otx2_set_real_num_queues(dev, channel->tx_count + qos_txqs, 294 channel->rx_count); 295 if (err) 296 return err; 297 298 pfvf->hw.rx_queues = channel->rx_count; 299 pfvf->hw.tx_queues = channel->tx_count; 300 if (pfvf->xdp_prog) 301 pfvf->hw.xdp_queues = channel->rx_count; 302 303 if (if_up) 304 err = dev->netdev_ops->ndo_open(dev); 305 306 netdev_info(dev, "Setting num Tx rings to %d, Rx rings to %d success\n", 307 pfvf->hw.tx_queues, pfvf->hw.rx_queues); 308 309 return err; 310 } 311 312 static void otx2_get_pauseparam(struct net_device *netdev, 313 struct ethtool_pauseparam *pause) 314 { 315 struct otx2_nic *pfvf = netdev_priv(netdev); 316 struct cgx_pause_frm_cfg *req, *rsp; 317 318 if (is_otx2_lbkvf(pfvf->pdev) || is_otx2_sdp_rep(pfvf->pdev)) 319 return; 320 321 mutex_lock(&pfvf->mbox.lock); 322 req = otx2_mbox_alloc_msg_cgx_cfg_pause_frm(&pfvf->mbox); 323 if (!req) { 324 mutex_unlock(&pfvf->mbox.lock); 325 return; 326 } 327 328 if (!otx2_sync_mbox_msg(&pfvf->mbox)) { 329 rsp = (struct cgx_pause_frm_cfg *) 330 otx2_mbox_get_rsp(&pfvf->mbox.mbox, 0, &req->hdr); 331 if (IS_ERR(rsp)) { 332 mutex_unlock(&pfvf->mbox.lock); 333 return; 334 } 335 336 pause->rx_pause = rsp->rx_pause; 337 pause->tx_pause = rsp->tx_pause; 338 } 339 mutex_unlock(&pfvf->mbox.lock); 340 } 341 342 static int otx2_set_pauseparam(struct net_device *netdev, 343 struct ethtool_pauseparam *pause) 344 { 345 struct otx2_nic *pfvf = netdev_priv(netdev); 346 347 if (pause->autoneg) 348 return -EOPNOTSUPP; 349 350 if (is_otx2_lbkvf(pfvf->pdev) || is_otx2_sdp_rep(pfvf->pdev)) 351 return -EOPNOTSUPP; 352 353 if (pause->rx_pause) 354 pfvf->flags |= OTX2_FLAG_RX_PAUSE_ENABLED; 355 else 356 pfvf->flags &= ~OTX2_FLAG_RX_PAUSE_ENABLED; 357 358 if (pause->tx_pause) 359 pfvf->flags |= OTX2_FLAG_TX_PAUSE_ENABLED; 360 else 361 pfvf->flags &= ~OTX2_FLAG_TX_PAUSE_ENABLED; 362 363 return otx2_config_pause_frm(pfvf); 364 } 365 366 static void otx2_get_ringparam(struct net_device *netdev, 367 struct ethtool_ringparam *ring, 368 struct kernel_ethtool_ringparam *kernel_ring, 369 struct netlink_ext_ack *extack) 370 { 371 struct otx2_nic *pfvf = netdev_priv(netdev); 372 struct otx2_qset *qs = &pfvf->qset; 373 374 ring->rx_max_pending = Q_COUNT(Q_SIZE_MAX); 375 ring->rx_pending = qs->rqe_cnt ? qs->rqe_cnt : Q_COUNT(Q_SIZE_256); 376 ring->tx_max_pending = Q_COUNT(Q_SIZE_MAX); 377 ring->tx_pending = qs->sqe_cnt ? qs->sqe_cnt : Q_COUNT(Q_SIZE_4K); 378 kernel_ring->rx_buf_len = pfvf->hw.rbuf_len; 379 kernel_ring->cqe_size = pfvf->hw.xqe_size; 380 } 381 382 static int otx2_set_ringparam(struct net_device *netdev, 383 struct ethtool_ringparam *ring, 384 struct kernel_ethtool_ringparam *kernel_ring, 385 struct netlink_ext_ack *extack) 386 { 387 struct otx2_nic *pfvf = netdev_priv(netdev); 388 u32 rx_buf_len = kernel_ring->rx_buf_len; 389 u32 old_rx_buf_len = pfvf->hw.rbuf_len; 390 u32 xqe_size = kernel_ring->cqe_size; 391 bool if_up = netif_running(netdev); 392 struct otx2_qset *qs = &pfvf->qset; 393 u32 rx_count, tx_count; 394 395 if (ring->rx_mini_pending || ring->rx_jumbo_pending) 396 return -EINVAL; 397 398 /* Hardware supports max size of 32k for a receive buffer 399 * and 1536 is typical ethernet frame size. 400 */ 401 if (rx_buf_len && (rx_buf_len < 1536 || rx_buf_len > 32768)) { 402 netdev_err(netdev, 403 "Receive buffer range is 1536 - 32768"); 404 return -EINVAL; 405 } 406 407 if (xqe_size != 128 && xqe_size != 512) { 408 netdev_err(netdev, 409 "Completion event size must be 128 or 512"); 410 return -EINVAL; 411 } 412 413 /* Permitted lengths are 16 64 256 1K 4K 16K 64K 256K 1M */ 414 rx_count = ring->rx_pending; 415 /* On some silicon variants a skid or reserved CQEs are 416 * needed to avoid CQ overflow. 417 */ 418 if (rx_count < pfvf->hw.rq_skid) 419 rx_count = pfvf->hw.rq_skid; 420 rx_count = Q_COUNT(Q_SIZE(rx_count, 3)); 421 422 /* Due pipelining impact minimum 2000 unused SQ CQE's 423 * need to be maintained to avoid CQ overflow, hence the 424 * minimum 4K size. 425 */ 426 tx_count = clamp_t(u32, ring->tx_pending, 427 Q_COUNT(Q_SIZE_4K), Q_COUNT(Q_SIZE_MAX)); 428 tx_count = Q_COUNT(Q_SIZE(tx_count, 3)); 429 430 if (tx_count == qs->sqe_cnt && rx_count == qs->rqe_cnt && 431 rx_buf_len == old_rx_buf_len && xqe_size == pfvf->hw.xqe_size) 432 return 0; 433 434 if (if_up) 435 netdev->netdev_ops->ndo_stop(netdev); 436 437 /* Assigned to the nearest possible exponent. */ 438 qs->sqe_cnt = tx_count; 439 qs->rqe_cnt = rx_count; 440 441 pfvf->hw.rbuf_len = rx_buf_len; 442 pfvf->hw.xqe_size = xqe_size; 443 444 if (if_up) 445 return netdev->netdev_ops->ndo_open(netdev); 446 447 return 0; 448 } 449 450 static int otx2_get_coalesce(struct net_device *netdev, 451 struct ethtool_coalesce *cmd, 452 struct kernel_ethtool_coalesce *kernel_coal, 453 struct netlink_ext_ack *extack) 454 { 455 struct otx2_nic *pfvf = netdev_priv(netdev); 456 struct otx2_hw *hw = &pfvf->hw; 457 458 cmd->rx_coalesce_usecs = hw->cq_time_wait; 459 cmd->rx_max_coalesced_frames = hw->cq_ecount_wait; 460 cmd->tx_coalesce_usecs = hw->cq_time_wait; 461 cmd->tx_max_coalesced_frames = hw->cq_ecount_wait; 462 if ((pfvf->flags & OTX2_FLAG_ADPTV_INT_COAL_ENABLED) == 463 OTX2_FLAG_ADPTV_INT_COAL_ENABLED) { 464 cmd->use_adaptive_rx_coalesce = 1; 465 cmd->use_adaptive_tx_coalesce = 1; 466 } else { 467 cmd->use_adaptive_rx_coalesce = 0; 468 cmd->use_adaptive_tx_coalesce = 0; 469 } 470 471 return 0; 472 } 473 474 static int otx2_set_coalesce(struct net_device *netdev, 475 struct ethtool_coalesce *ec, 476 struct kernel_ethtool_coalesce *kernel_coal, 477 struct netlink_ext_ack *extack) 478 { 479 struct otx2_nic *pfvf = netdev_priv(netdev); 480 struct otx2_hw *hw = &pfvf->hw; 481 u8 priv_coalesce_status; 482 int qidx; 483 484 if (!ec->rx_max_coalesced_frames || !ec->tx_max_coalesced_frames) 485 return 0; 486 487 if (ec->use_adaptive_rx_coalesce != ec->use_adaptive_tx_coalesce) { 488 netdev_err(netdev, 489 "adaptive-rx should be same as adaptive-tx"); 490 return -EINVAL; 491 } 492 493 /* Check and update coalesce status */ 494 if ((pfvf->flags & OTX2_FLAG_ADPTV_INT_COAL_ENABLED) == 495 OTX2_FLAG_ADPTV_INT_COAL_ENABLED) { 496 priv_coalesce_status = 1; 497 if (!ec->use_adaptive_rx_coalesce) 498 pfvf->flags &= ~OTX2_FLAG_ADPTV_INT_COAL_ENABLED; 499 } else { 500 priv_coalesce_status = 0; 501 if (ec->use_adaptive_rx_coalesce) 502 pfvf->flags |= OTX2_FLAG_ADPTV_INT_COAL_ENABLED; 503 } 504 505 /* 'cq_time_wait' is 8bit and is in multiple of 100ns, 506 * so clamp the user given value to the range of 1 to 25usec. 507 */ 508 ec->rx_coalesce_usecs = clamp_t(u32, ec->rx_coalesce_usecs, 509 1, CQ_TIMER_THRESH_MAX); 510 ec->tx_coalesce_usecs = clamp_t(u32, ec->tx_coalesce_usecs, 511 1, CQ_TIMER_THRESH_MAX); 512 513 /* Rx and Tx are mapped to same CQ, check which one 514 * is changed, if both then choose the min. 515 */ 516 if (hw->cq_time_wait == ec->rx_coalesce_usecs) 517 hw->cq_time_wait = ec->tx_coalesce_usecs; 518 else if (hw->cq_time_wait == ec->tx_coalesce_usecs) 519 hw->cq_time_wait = ec->rx_coalesce_usecs; 520 else 521 hw->cq_time_wait = min_t(u8, ec->rx_coalesce_usecs, 522 ec->tx_coalesce_usecs); 523 524 /* Max ecount_wait supported is 16bit, 525 * so clamp the user given value to the range of 1 to 64k. 526 */ 527 ec->rx_max_coalesced_frames = clamp_t(u32, ec->rx_max_coalesced_frames, 528 1, NAPI_POLL_WEIGHT); 529 ec->tx_max_coalesced_frames = clamp_t(u32, ec->tx_max_coalesced_frames, 530 1, NAPI_POLL_WEIGHT); 531 532 /* Rx and Tx are mapped to same CQ, check which one 533 * is changed, if both then choose the min. 534 */ 535 if (hw->cq_ecount_wait == ec->rx_max_coalesced_frames) 536 hw->cq_ecount_wait = ec->tx_max_coalesced_frames; 537 else if (hw->cq_ecount_wait == ec->tx_max_coalesced_frames) 538 hw->cq_ecount_wait = ec->rx_max_coalesced_frames; 539 else 540 hw->cq_ecount_wait = min_t(u16, ec->rx_max_coalesced_frames, 541 ec->tx_max_coalesced_frames); 542 543 /* Reset 'cq_time_wait' and 'cq_ecount_wait' to 544 * default values if coalesce status changed from 545 * 'on' to 'off'. 546 */ 547 if (priv_coalesce_status && 548 ((pfvf->flags & OTX2_FLAG_ADPTV_INT_COAL_ENABLED) != 549 OTX2_FLAG_ADPTV_INT_COAL_ENABLED)) { 550 hw->cq_time_wait = CQ_TIMER_THRESH_DEFAULT; 551 hw->cq_ecount_wait = CQ_CQE_THRESH_DEFAULT; 552 } 553 554 if (netif_running(netdev)) { 555 for (qidx = 0; qidx < pfvf->hw.cint_cnt; qidx++) 556 otx2_config_irq_coalescing(pfvf, qidx); 557 } 558 559 return 0; 560 } 561 562 static int otx2_get_rss_hash_opts(struct net_device *dev, 563 struct ethtool_rxfh_fields *nfc) 564 { 565 struct otx2_nic *pfvf = netdev_priv(dev); 566 struct otx2_rss_info *rss; 567 568 rss = &pfvf->hw.rss_info; 569 570 if (!(rss->flowkey_cfg & 571 (NIX_FLOW_KEY_TYPE_IPV4 | NIX_FLOW_KEY_TYPE_IPV6))) 572 return 0; 573 574 /* Mimimum is IPv4 and IPv6, SIP/DIP */ 575 nfc->data = RXH_IP_SRC | RXH_IP_DST; 576 if (rss->flowkey_cfg & NIX_FLOW_KEY_TYPE_VLAN) 577 nfc->data |= RXH_VLAN; 578 579 switch (nfc->flow_type) { 580 case TCP_V4_FLOW: 581 case TCP_V6_FLOW: 582 if (rss->flowkey_cfg & NIX_FLOW_KEY_TYPE_TCP) 583 nfc->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 584 break; 585 case UDP_V4_FLOW: 586 case UDP_V6_FLOW: 587 if (rss->flowkey_cfg & NIX_FLOW_KEY_TYPE_UDP) 588 nfc->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 589 break; 590 case SCTP_V4_FLOW: 591 case SCTP_V6_FLOW: 592 if (rss->flowkey_cfg & NIX_FLOW_KEY_TYPE_SCTP) 593 nfc->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 594 break; 595 case AH_ESP_V4_FLOW: 596 case AH_ESP_V6_FLOW: 597 if (rss->flowkey_cfg & NIX_FLOW_KEY_TYPE_ESP) 598 nfc->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 599 break; 600 case AH_V4_FLOW: 601 case ESP_V4_FLOW: 602 case IPV4_FLOW: 603 break; 604 case AH_V6_FLOW: 605 case ESP_V6_FLOW: 606 case IPV6_FLOW: 607 break; 608 default: 609 return -EINVAL; 610 } 611 612 return 0; 613 } 614 615 static int otx2_set_rss_hash_opts(struct net_device *dev, 616 const struct ethtool_rxfh_fields *nfc, 617 struct netlink_ext_ack *extack) 618 { 619 struct otx2_nic *pfvf = netdev_priv(dev); 620 u32 rxh_l4 = RXH_L4_B_0_1 | RXH_L4_B_2_3; 621 struct otx2_rss_info *rss; 622 u32 rss_cfg; 623 624 rss = &pfvf->hw.rss_info; 625 rss_cfg = rss->flowkey_cfg; 626 627 if (!rss->enable) { 628 netdev_err(pfvf->netdev, 629 "RSS is disabled, cannot change settings\n"); 630 return -EIO; 631 } 632 633 /* Mimimum is IPv4 and IPv6, SIP/DIP */ 634 if (!(nfc->data & RXH_IP_SRC) || !(nfc->data & RXH_IP_DST)) 635 return -EINVAL; 636 637 if (nfc->data & RXH_VLAN) 638 rss_cfg |= NIX_FLOW_KEY_TYPE_VLAN; 639 else 640 rss_cfg &= ~NIX_FLOW_KEY_TYPE_VLAN; 641 642 switch (nfc->flow_type) { 643 case TCP_V4_FLOW: 644 case TCP_V6_FLOW: 645 /* Different config for v4 and v6 is not supported. 646 * Both of them have to be either 4-tuple or 2-tuple. 647 */ 648 switch (nfc->data & rxh_l4) { 649 case 0: 650 rss_cfg &= ~NIX_FLOW_KEY_TYPE_TCP; 651 break; 652 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 653 rss_cfg |= NIX_FLOW_KEY_TYPE_TCP; 654 break; 655 default: 656 return -EINVAL; 657 } 658 break; 659 case UDP_V4_FLOW: 660 case UDP_V6_FLOW: 661 switch (nfc->data & rxh_l4) { 662 case 0: 663 rss_cfg &= ~NIX_FLOW_KEY_TYPE_UDP; 664 break; 665 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 666 rss_cfg |= NIX_FLOW_KEY_TYPE_UDP; 667 break; 668 default: 669 return -EINVAL; 670 } 671 break; 672 case SCTP_V4_FLOW: 673 case SCTP_V6_FLOW: 674 switch (nfc->data & rxh_l4) { 675 case 0: 676 rss_cfg &= ~NIX_FLOW_KEY_TYPE_SCTP; 677 break; 678 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 679 rss_cfg |= NIX_FLOW_KEY_TYPE_SCTP; 680 break; 681 default: 682 return -EINVAL; 683 } 684 break; 685 case AH_ESP_V4_FLOW: 686 case AH_ESP_V6_FLOW: 687 switch (nfc->data & rxh_l4) { 688 case 0: 689 rss_cfg &= ~(NIX_FLOW_KEY_TYPE_ESP | 690 NIX_FLOW_KEY_TYPE_AH); 691 rss_cfg |= NIX_FLOW_KEY_TYPE_VLAN | 692 NIX_FLOW_KEY_TYPE_IPV4_PROTO; 693 break; 694 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 695 /* If VLAN hashing is also requested for ESP then do not 696 * allow because of hardware 40 bytes flow key limit. 697 */ 698 if (rss_cfg & NIX_FLOW_KEY_TYPE_VLAN) { 699 netdev_err(pfvf->netdev, 700 "RSS hash of ESP or AH with VLAN is not supported\n"); 701 return -EOPNOTSUPP; 702 } 703 704 rss_cfg |= NIX_FLOW_KEY_TYPE_ESP | NIX_FLOW_KEY_TYPE_AH; 705 /* Disable IPv4 proto hashing since IPv6 SA+DA(32 bytes) 706 * and ESP SPI+sequence(8 bytes) uses hardware maximum 707 * limit of 40 byte flow key. 708 */ 709 rss_cfg &= ~NIX_FLOW_KEY_TYPE_IPV4_PROTO; 710 break; 711 default: 712 return -EINVAL; 713 } 714 break; 715 case IPV4_FLOW: 716 case IPV6_FLOW: 717 rss_cfg = NIX_FLOW_KEY_TYPE_IPV4 | NIX_FLOW_KEY_TYPE_IPV6; 718 break; 719 default: 720 return -EINVAL; 721 } 722 723 rss->flowkey_cfg = rss_cfg; 724 otx2_set_flowkey_cfg(pfvf); 725 return 0; 726 } 727 728 static int otx2_get_rxnfc(struct net_device *dev, 729 struct ethtool_rxnfc *nfc, u32 *rules) 730 { 731 bool ntuple = !!(dev->features & NETIF_F_NTUPLE); 732 struct otx2_nic *pfvf = netdev_priv(dev); 733 int ret = -EOPNOTSUPP; 734 735 switch (nfc->cmd) { 736 case ETHTOOL_GRXRINGS: 737 nfc->data = pfvf->hw.rx_queues; 738 ret = 0; 739 break; 740 case ETHTOOL_GRXCLSRLCNT: 741 if (netif_running(dev) && ntuple) { 742 nfc->rule_cnt = pfvf->flow_cfg->nr_flows; 743 ret = 0; 744 } 745 break; 746 case ETHTOOL_GRXCLSRULE: 747 if (netif_running(dev) && ntuple) 748 ret = otx2_get_flow(pfvf, nfc, nfc->fs.location); 749 break; 750 case ETHTOOL_GRXCLSRLALL: 751 if (netif_running(dev) && ntuple) 752 ret = otx2_get_all_flows(pfvf, nfc, rules); 753 break; 754 default: 755 break; 756 } 757 return ret; 758 } 759 760 static int otx2_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *nfc) 761 { 762 bool ntuple = !!(dev->features & NETIF_F_NTUPLE); 763 struct otx2_nic *pfvf = netdev_priv(dev); 764 int ret = -EOPNOTSUPP; 765 766 pfvf->flow_cfg->ntuple = ntuple; 767 switch (nfc->cmd) { 768 case ETHTOOL_SRXCLSRLINS: 769 if (netif_running(dev) && ntuple) 770 ret = otx2_add_flow(pfvf, nfc); 771 break; 772 case ETHTOOL_SRXCLSRLDEL: 773 if (netif_running(dev) && ntuple) 774 ret = otx2_remove_flow(pfvf, nfc->fs.location); 775 break; 776 default: 777 break; 778 } 779 780 return ret; 781 } 782 783 static u32 otx2_get_rxfh_key_size(struct net_device *netdev) 784 { 785 struct otx2_nic *pfvf = netdev_priv(netdev); 786 struct otx2_rss_info *rss; 787 788 rss = &pfvf->hw.rss_info; 789 790 return sizeof(rss->key); 791 } 792 793 static u32 otx2_get_rxfh_indir_size(struct net_device *dev) 794 { 795 return MAX_RSS_INDIR_TBL_SIZE; 796 } 797 798 static int otx2_rss_ctx_delete(struct otx2_nic *pfvf, int ctx_id) 799 { 800 struct otx2_rss_info *rss = &pfvf->hw.rss_info; 801 802 otx2_rss_ctx_flow_del(pfvf, ctx_id); 803 kfree(rss->rss_ctx[ctx_id]); 804 rss->rss_ctx[ctx_id] = NULL; 805 806 return 0; 807 } 808 809 static int otx2_rss_ctx_create(struct otx2_nic *pfvf, 810 u32 *rss_context) 811 { 812 struct otx2_rss_info *rss = &pfvf->hw.rss_info; 813 u8 ctx; 814 815 for (ctx = 0; ctx < MAX_RSS_GROUPS; ctx++) { 816 if (!rss->rss_ctx[ctx]) 817 break; 818 } 819 if (ctx == MAX_RSS_GROUPS) 820 return -EINVAL; 821 822 rss->rss_ctx[ctx] = kzalloc(sizeof(*rss->rss_ctx[ctx]), GFP_KERNEL); 823 if (!rss->rss_ctx[ctx]) 824 return -ENOMEM; 825 *rss_context = ctx; 826 827 return 0; 828 } 829 830 /* Configure RSS table and hash key */ 831 static int otx2_set_rxfh(struct net_device *dev, 832 struct ethtool_rxfh_param *rxfh, 833 struct netlink_ext_ack *extack) 834 { 835 u32 rss_context = DEFAULT_RSS_CONTEXT_GROUP; 836 struct otx2_nic *pfvf = netdev_priv(dev); 837 struct otx2_rss_ctx *rss_ctx; 838 struct otx2_rss_info *rss; 839 int ret, idx; 840 841 if (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE && 842 rxfh->hfunc != ETH_RSS_HASH_TOP) 843 return -EOPNOTSUPP; 844 845 if (rxfh->rss_context) 846 rss_context = rxfh->rss_context; 847 848 if (rss_context != ETH_RXFH_CONTEXT_ALLOC && 849 rss_context >= MAX_RSS_GROUPS) 850 return -EINVAL; 851 852 rss = &pfvf->hw.rss_info; 853 854 if (!rss->enable) { 855 netdev_err(dev, "RSS is disabled, cannot change settings\n"); 856 return -EIO; 857 } 858 859 if (rxfh->key) { 860 memcpy(rss->key, rxfh->key, sizeof(rss->key)); 861 otx2_set_rss_key(pfvf); 862 } 863 if (rxfh->rss_delete) 864 return otx2_rss_ctx_delete(pfvf, rss_context); 865 866 if (rss_context == ETH_RXFH_CONTEXT_ALLOC) { 867 ret = otx2_rss_ctx_create(pfvf, &rss_context); 868 rxfh->rss_context = rss_context; 869 if (ret) 870 return ret; 871 } 872 if (rxfh->indir) { 873 rss_ctx = rss->rss_ctx[rss_context]; 874 for (idx = 0; idx < rss->rss_size; idx++) 875 rss_ctx->ind_tbl[idx] = rxfh->indir[idx]; 876 } 877 otx2_set_rss_table(pfvf, rss_context); 878 879 return 0; 880 } 881 882 /* Get RSS configuration */ 883 static int otx2_get_rxfh(struct net_device *dev, 884 struct ethtool_rxfh_param *rxfh) 885 { 886 u32 rss_context = DEFAULT_RSS_CONTEXT_GROUP; 887 struct otx2_nic *pfvf = netdev_priv(dev); 888 struct otx2_rss_ctx *rss_ctx; 889 struct otx2_rss_info *rss; 890 u32 *indir = rxfh->indir; 891 int idx, rx_queues; 892 893 rss = &pfvf->hw.rss_info; 894 895 rxfh->hfunc = ETH_RSS_HASH_TOP; 896 if (rxfh->rss_context) 897 rss_context = rxfh->rss_context; 898 899 if (!indir) 900 return 0; 901 902 if (!rss->enable && rss_context == DEFAULT_RSS_CONTEXT_GROUP) { 903 rx_queues = pfvf->hw.rx_queues; 904 for (idx = 0; idx < MAX_RSS_INDIR_TBL_SIZE; idx++) 905 indir[idx] = ethtool_rxfh_indir_default(idx, rx_queues); 906 return 0; 907 } 908 if (rss_context >= MAX_RSS_GROUPS) 909 return -ENOENT; 910 911 rss_ctx = rss->rss_ctx[rss_context]; 912 if (!rss_ctx) 913 return -ENOENT; 914 915 if (indir) { 916 for (idx = 0; idx < rss->rss_size; idx++) { 917 /* Ignore if the rx queue is AF_XDP zero copy enabled */ 918 if (test_bit(rss_ctx->ind_tbl[idx], pfvf->af_xdp_zc_qidx)) 919 continue; 920 indir[idx] = rss_ctx->ind_tbl[idx]; 921 } 922 } 923 if (rxfh->key) 924 memcpy(rxfh->key, rss->key, sizeof(rss->key)); 925 926 return 0; 927 } 928 929 static u32 otx2_get_msglevel(struct net_device *netdev) 930 { 931 struct otx2_nic *pfvf = netdev_priv(netdev); 932 933 return pfvf->msg_enable; 934 } 935 936 static void otx2_set_msglevel(struct net_device *netdev, u32 val) 937 { 938 struct otx2_nic *pfvf = netdev_priv(netdev); 939 940 pfvf->msg_enable = val; 941 } 942 943 static u32 otx2_get_link(struct net_device *netdev) 944 { 945 struct otx2_nic *pfvf = netdev_priv(netdev); 946 947 /* LBK and SDP links are internal and always UP */ 948 if (is_otx2_lbkvf(pfvf->pdev) || is_otx2_sdp_rep(pfvf->pdev)) 949 return 1; 950 return pfvf->linfo.link_up; 951 } 952 953 static int otx2_get_ts_info(struct net_device *netdev, 954 struct kernel_ethtool_ts_info *info) 955 { 956 struct otx2_nic *pfvf = netdev_priv(netdev); 957 958 if (!pfvf->ptp) 959 return ethtool_op_get_ts_info(netdev, info); 960 961 info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE | 962 SOF_TIMESTAMPING_TX_HARDWARE | 963 SOF_TIMESTAMPING_RX_HARDWARE | 964 SOF_TIMESTAMPING_RAW_HARDWARE; 965 966 info->phc_index = otx2_ptp_clock_index(pfvf); 967 968 info->tx_types = BIT(HWTSTAMP_TX_OFF) | BIT(HWTSTAMP_TX_ON); 969 if (test_bit(CN10K_PTP_ONESTEP, &pfvf->hw.cap_flag)) 970 info->tx_types |= BIT(HWTSTAMP_TX_ONESTEP_SYNC); 971 972 info->rx_filters = BIT(HWTSTAMP_FILTER_NONE) | 973 BIT(HWTSTAMP_FILTER_ALL); 974 975 return 0; 976 } 977 978 static struct cgx_fw_data *otx2_get_fwdata(struct otx2_nic *pfvf) 979 { 980 struct cgx_fw_data *rsp = NULL; 981 struct msg_req *req; 982 int err = 0; 983 984 mutex_lock(&pfvf->mbox.lock); 985 req = otx2_mbox_alloc_msg_cgx_get_aux_link_info(&pfvf->mbox); 986 if (!req) { 987 mutex_unlock(&pfvf->mbox.lock); 988 return ERR_PTR(-ENOMEM); 989 } 990 991 err = otx2_sync_mbox_msg(&pfvf->mbox); 992 if (!err) { 993 rsp = (struct cgx_fw_data *) 994 otx2_mbox_get_rsp(&pfvf->mbox.mbox, 0, &req->hdr); 995 } else { 996 rsp = ERR_PTR(err); 997 } 998 999 mutex_unlock(&pfvf->mbox.lock); 1000 return rsp; 1001 } 1002 1003 static int otx2_get_fecparam(struct net_device *netdev, 1004 struct ethtool_fecparam *fecparam) 1005 { 1006 struct otx2_nic *pfvf = netdev_priv(netdev); 1007 struct cgx_fw_data *rsp; 1008 const int fec[] = { 1009 ETHTOOL_FEC_OFF, 1010 ETHTOOL_FEC_BASER, 1011 ETHTOOL_FEC_RS, 1012 ETHTOOL_FEC_BASER | ETHTOOL_FEC_RS}; 1013 #define FEC_MAX_INDEX 4 1014 if (pfvf->linfo.fec < FEC_MAX_INDEX) 1015 fecparam->active_fec = fec[pfvf->linfo.fec]; 1016 1017 rsp = otx2_get_fwdata(pfvf); 1018 if (IS_ERR(rsp)) 1019 return PTR_ERR(rsp); 1020 1021 if (rsp->fwdata.supported_fec < FEC_MAX_INDEX) { 1022 if (!rsp->fwdata.supported_fec) 1023 fecparam->fec = ETHTOOL_FEC_NONE; 1024 else 1025 fecparam->fec = fec[rsp->fwdata.supported_fec]; 1026 } 1027 return 0; 1028 } 1029 1030 static int otx2_set_fecparam(struct net_device *netdev, 1031 struct ethtool_fecparam *fecparam) 1032 { 1033 struct otx2_nic *pfvf = netdev_priv(netdev); 1034 struct mbox *mbox = &pfvf->mbox; 1035 struct fec_mode *req, *rsp; 1036 int err = 0, fec = 0; 1037 1038 switch (fecparam->fec) { 1039 /* Firmware does not support AUTO mode consider it as FEC_OFF */ 1040 case ETHTOOL_FEC_OFF: 1041 case ETHTOOL_FEC_AUTO: 1042 fec = OTX2_FEC_OFF; 1043 break; 1044 case ETHTOOL_FEC_RS: 1045 fec = OTX2_FEC_RS; 1046 break; 1047 case ETHTOOL_FEC_BASER: 1048 fec = OTX2_FEC_BASER; 1049 break; 1050 default: 1051 netdev_warn(pfvf->netdev, "Unsupported FEC mode: %d", 1052 fecparam->fec); 1053 return -EINVAL; 1054 } 1055 1056 if (fec == pfvf->linfo.fec) 1057 return 0; 1058 1059 mutex_lock(&mbox->lock); 1060 req = otx2_mbox_alloc_msg_cgx_set_fec_param(&pfvf->mbox); 1061 if (!req) { 1062 err = -ENOMEM; 1063 goto end; 1064 } 1065 req->fec = fec; 1066 err = otx2_sync_mbox_msg(&pfvf->mbox); 1067 if (err) 1068 goto end; 1069 1070 rsp = (struct fec_mode *)otx2_mbox_get_rsp(&pfvf->mbox.mbox, 1071 0, &req->hdr); 1072 if (IS_ERR(rsp)) { 1073 err = PTR_ERR(rsp); 1074 goto end; 1075 } 1076 1077 if (rsp->fec >= 0) 1078 pfvf->linfo.fec = rsp->fec; 1079 else 1080 err = rsp->fec; 1081 end: 1082 mutex_unlock(&mbox->lock); 1083 return err; 1084 } 1085 1086 static void otx2_get_fec_info(u64 index, int req_mode, 1087 struct ethtool_link_ksettings *link_ksettings) 1088 { 1089 __ETHTOOL_DECLARE_LINK_MODE_MASK(otx2_fec_modes) = { 0, }; 1090 1091 switch (index) { 1092 case OTX2_FEC_NONE: 1093 linkmode_set_bit(ETHTOOL_LINK_MODE_FEC_NONE_BIT, 1094 otx2_fec_modes); 1095 break; 1096 case OTX2_FEC_BASER: 1097 linkmode_set_bit(ETHTOOL_LINK_MODE_FEC_BASER_BIT, 1098 otx2_fec_modes); 1099 break; 1100 case OTX2_FEC_RS: 1101 linkmode_set_bit(ETHTOOL_LINK_MODE_FEC_RS_BIT, 1102 otx2_fec_modes); 1103 break; 1104 case OTX2_FEC_BASER | OTX2_FEC_RS: 1105 linkmode_set_bit(ETHTOOL_LINK_MODE_FEC_BASER_BIT, 1106 otx2_fec_modes); 1107 linkmode_set_bit(ETHTOOL_LINK_MODE_FEC_RS_BIT, 1108 otx2_fec_modes); 1109 break; 1110 } 1111 1112 /* Add fec modes to existing modes */ 1113 if (req_mode == OTX2_MODE_ADVERTISED) 1114 linkmode_or(link_ksettings->link_modes.advertising, 1115 link_ksettings->link_modes.advertising, 1116 otx2_fec_modes); 1117 else 1118 linkmode_or(link_ksettings->link_modes.supported, 1119 link_ksettings->link_modes.supported, 1120 otx2_fec_modes); 1121 } 1122 1123 static void otx2_get_link_mode_info(u64 link_mode_bmap, 1124 bool req_mode, 1125 struct ethtool_link_ksettings 1126 *link_ksettings) 1127 { 1128 __ETHTOOL_DECLARE_LINK_MODE_MASK(otx2_link_modes) = { 0, }; 1129 const int otx2_sgmii_features[6] = { 1130 ETHTOOL_LINK_MODE_10baseT_Half_BIT, 1131 ETHTOOL_LINK_MODE_10baseT_Full_BIT, 1132 ETHTOOL_LINK_MODE_100baseT_Half_BIT, 1133 ETHTOOL_LINK_MODE_100baseT_Full_BIT, 1134 ETHTOOL_LINK_MODE_1000baseT_Half_BIT, 1135 ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1136 }; 1137 /* CGX link modes to Ethtool link mode mapping */ 1138 const int cgx_link_mode[27] = { 1139 0, /* SGMII Mode */ 1140 ETHTOOL_LINK_MODE_1000baseX_Full_BIT, 1141 ETHTOOL_LINK_MODE_10000baseT_Full_BIT, 1142 ETHTOOL_LINK_MODE_10000baseSR_Full_BIT, 1143 ETHTOOL_LINK_MODE_10000baseLR_Full_BIT, 1144 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT, 1145 0, 1146 ETHTOOL_LINK_MODE_25000baseSR_Full_BIT, 1147 0, 1148 0, 1149 ETHTOOL_LINK_MODE_25000baseCR_Full_BIT, 1150 ETHTOOL_LINK_MODE_25000baseKR_Full_BIT, 1151 ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT, 1152 ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT, 1153 ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT, 1154 ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT, 1155 0, 1156 ETHTOOL_LINK_MODE_50000baseSR_Full_BIT, 1157 0, 1158 ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT, 1159 ETHTOOL_LINK_MODE_50000baseCR_Full_BIT, 1160 ETHTOOL_LINK_MODE_50000baseKR_Full_BIT, 1161 0, 1162 ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT, 1163 ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT, 1164 ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT, 1165 ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT 1166 }; 1167 u8 bit; 1168 1169 for_each_set_bit(bit, (unsigned long *)&link_mode_bmap, 27) { 1170 /* SGMII mode is set */ 1171 if (bit == 0) 1172 linkmode_set_bit_array(otx2_sgmii_features, 1173 ARRAY_SIZE(otx2_sgmii_features), 1174 otx2_link_modes); 1175 else 1176 linkmode_set_bit(cgx_link_mode[bit], otx2_link_modes); 1177 } 1178 1179 if (req_mode == OTX2_MODE_ADVERTISED) 1180 linkmode_copy(link_ksettings->link_modes.advertising, 1181 otx2_link_modes); 1182 else 1183 linkmode_copy(link_ksettings->link_modes.supported, 1184 otx2_link_modes); 1185 } 1186 1187 static int otx2_get_link_ksettings(struct net_device *netdev, 1188 struct ethtool_link_ksettings *cmd) 1189 { 1190 struct otx2_nic *pfvf = netdev_priv(netdev); 1191 struct cgx_fw_data *rsp = NULL; 1192 1193 cmd->base.duplex = pfvf->linfo.full_duplex; 1194 cmd->base.speed = pfvf->linfo.speed; 1195 cmd->base.autoneg = pfvf->linfo.an; 1196 1197 rsp = otx2_get_fwdata(pfvf); 1198 if (IS_ERR(rsp)) 1199 return PTR_ERR(rsp); 1200 1201 if (rsp->fwdata.supported_an) 1202 ethtool_link_ksettings_add_link_mode(cmd, 1203 supported, 1204 Autoneg); 1205 1206 otx2_get_link_mode_info(rsp->fwdata.advertised_link_modes, 1207 OTX2_MODE_ADVERTISED, cmd); 1208 otx2_get_fec_info(rsp->fwdata.advertised_fec, 1209 OTX2_MODE_ADVERTISED, cmd); 1210 otx2_get_link_mode_info(rsp->fwdata.supported_link_modes, 1211 OTX2_MODE_SUPPORTED, cmd); 1212 otx2_get_fec_info(rsp->fwdata.supported_fec, 1213 OTX2_MODE_SUPPORTED, cmd); 1214 return 0; 1215 } 1216 1217 static void otx2_get_advertised_mode(const struct ethtool_link_ksettings *cmd, 1218 u64 *mode) 1219 { 1220 u32 bit_pos; 1221 1222 /* Firmware does not support requesting multiple advertised modes 1223 * return first set bit 1224 */ 1225 bit_pos = find_first_bit(cmd->link_modes.advertising, 1226 __ETHTOOL_LINK_MODE_MASK_NBITS); 1227 if (bit_pos != __ETHTOOL_LINK_MODE_MASK_NBITS) 1228 *mode = bit_pos; 1229 } 1230 1231 static int otx2_set_link_ksettings(struct net_device *netdev, 1232 const struct ethtool_link_ksettings *cmd) 1233 { 1234 struct otx2_nic *pf = netdev_priv(netdev); 1235 struct ethtool_link_ksettings cur_ks; 1236 struct cgx_set_link_mode_req *req; 1237 struct mbox *mbox = &pf->mbox; 1238 int err = 0; 1239 1240 memset(&cur_ks, 0, sizeof(struct ethtool_link_ksettings)); 1241 1242 if (!ethtool_validate_speed(cmd->base.speed) || 1243 !ethtool_validate_duplex(cmd->base.duplex)) 1244 return -EINVAL; 1245 1246 if (cmd->base.autoneg != AUTONEG_ENABLE && 1247 cmd->base.autoneg != AUTONEG_DISABLE) 1248 return -EINVAL; 1249 1250 otx2_get_link_ksettings(netdev, &cur_ks); 1251 1252 /* Check requested modes against supported modes by hardware */ 1253 if (!linkmode_subset(cmd->link_modes.advertising, 1254 cur_ks.link_modes.supported)) 1255 return -EINVAL; 1256 1257 mutex_lock(&mbox->lock); 1258 req = otx2_mbox_alloc_msg_cgx_set_link_mode(&pf->mbox); 1259 if (!req) { 1260 err = -ENOMEM; 1261 goto end; 1262 } 1263 1264 req->args.speed = cmd->base.speed; 1265 /* firmware expects 1 for half duplex and 0 for full duplex 1266 * hence inverting 1267 */ 1268 req->args.duplex = cmd->base.duplex ^ 0x1; 1269 req->args.an = cmd->base.autoneg; 1270 otx2_get_advertised_mode(cmd, &req->args.mode); 1271 1272 err = otx2_sync_mbox_msg(&pf->mbox); 1273 end: 1274 mutex_unlock(&mbox->lock); 1275 return err; 1276 } 1277 1278 static void otx2_get_fec_stats(struct net_device *netdev, 1279 struct ethtool_fec_stats *fec_stats) 1280 { 1281 struct otx2_nic *pfvf = netdev_priv(netdev); 1282 struct cgx_fw_data *rsp; 1283 1284 otx2_update_lmac_fec_stats(pfvf); 1285 1286 /* Report MAC FEC stats */ 1287 fec_stats->corrected_blocks.total = pfvf->hw.cgx_fec_corr_blks; 1288 fec_stats->uncorrectable_blocks.total = pfvf->hw.cgx_fec_uncorr_blks; 1289 1290 rsp = otx2_get_fwdata(pfvf); 1291 if (!IS_ERR(rsp) && rsp->fwdata.phy.misc.has_fec_stats && 1292 !otx2_get_phy_fec_stats(pfvf)) { 1293 /* Fetch fwdata again because it's been recently populated with 1294 * latest PHY FEC stats. 1295 */ 1296 rsp = otx2_get_fwdata(pfvf); 1297 if (!IS_ERR(rsp)) { 1298 struct fec_stats_s *p = &rsp->fwdata.phy.fec_stats; 1299 1300 if (pfvf->linfo.fec == OTX2_FEC_BASER) { 1301 fec_stats->corrected_blocks.total = p->brfec_corr_blks; 1302 fec_stats->uncorrectable_blocks.total = p->brfec_uncorr_blks; 1303 } else { 1304 fec_stats->corrected_blocks.total = p->rsfec_corr_cws; 1305 fec_stats->uncorrectable_blocks.total = p->rsfec_uncorr_cws; 1306 } 1307 } 1308 } 1309 } 1310 1311 static const struct ethtool_ops otx2_ethtool_ops = { 1312 .cap_rss_ctx_supported = true, 1313 .supported_coalesce_params = ETHTOOL_COALESCE_USECS | 1314 ETHTOOL_COALESCE_MAX_FRAMES | 1315 ETHTOOL_COALESCE_USE_ADAPTIVE, 1316 .supported_ring_params = ETHTOOL_RING_USE_RX_BUF_LEN | 1317 ETHTOOL_RING_USE_CQE_SIZE, 1318 .get_link = otx2_get_link, 1319 .get_drvinfo = otx2_get_drvinfo, 1320 .get_strings = otx2_get_strings, 1321 .get_ethtool_stats = otx2_get_ethtool_stats, 1322 .get_sset_count = otx2_get_sset_count, 1323 .set_channels = otx2_set_channels, 1324 .get_channels = otx2_get_channels, 1325 .get_ringparam = otx2_get_ringparam, 1326 .set_ringparam = otx2_set_ringparam, 1327 .get_coalesce = otx2_get_coalesce, 1328 .set_coalesce = otx2_set_coalesce, 1329 .get_rxnfc = otx2_get_rxnfc, 1330 .set_rxnfc = otx2_set_rxnfc, 1331 .get_rxfh_key_size = otx2_get_rxfh_key_size, 1332 .get_rxfh_indir_size = otx2_get_rxfh_indir_size, 1333 .get_rxfh = otx2_get_rxfh, 1334 .set_rxfh = otx2_set_rxfh, 1335 .get_rxfh_fields = otx2_get_rss_hash_opts, 1336 .set_rxfh_fields = otx2_set_rss_hash_opts, 1337 .get_msglevel = otx2_get_msglevel, 1338 .set_msglevel = otx2_set_msglevel, 1339 .get_pauseparam = otx2_get_pauseparam, 1340 .set_pauseparam = otx2_set_pauseparam, 1341 .get_ts_info = otx2_get_ts_info, 1342 .get_fec_stats = otx2_get_fec_stats, 1343 .get_fecparam = otx2_get_fecparam, 1344 .set_fecparam = otx2_set_fecparam, 1345 .get_link_ksettings = otx2_get_link_ksettings, 1346 .set_link_ksettings = otx2_set_link_ksettings, 1347 }; 1348 1349 void otx2_set_ethtool_ops(struct net_device *netdev) 1350 { 1351 netdev->ethtool_ops = &otx2_ethtool_ops; 1352 } 1353 1354 /* VF's ethtool APIs */ 1355 static void otx2vf_get_drvinfo(struct net_device *netdev, 1356 struct ethtool_drvinfo *info) 1357 { 1358 struct otx2_nic *vf = netdev_priv(netdev); 1359 1360 strscpy(info->driver, DRV_VF_NAME, sizeof(info->driver)); 1361 strscpy(info->bus_info, pci_name(vf->pdev), sizeof(info->bus_info)); 1362 } 1363 1364 static void otx2vf_get_strings(struct net_device *netdev, u32 sset, u8 *data) 1365 { 1366 struct otx2_nic *vf = netdev_priv(netdev); 1367 int stats; 1368 1369 if (sset != ETH_SS_STATS) 1370 return; 1371 1372 for (stats = 0; stats < otx2_n_dev_stats; stats++) 1373 ethtool_puts(&data, otx2_dev_stats[stats].name); 1374 1375 for (stats = 0; stats < otx2_n_drv_stats; stats++) 1376 ethtool_puts(&data, otx2_drv_stats[stats].name); 1377 1378 otx2_get_qset_strings(vf, &data, 0); 1379 1380 ethtool_puts(&data, "reset_count"); 1381 } 1382 1383 static void otx2vf_get_ethtool_stats(struct net_device *netdev, 1384 struct ethtool_stats *stats, u64 *data) 1385 { 1386 struct otx2_nic *vf = netdev_priv(netdev); 1387 int stat; 1388 1389 otx2_get_dev_stats(vf); 1390 for (stat = 0; stat < otx2_n_dev_stats; stat++) 1391 *(data++) = ((u64 *)&vf->hw.dev_stats) 1392 [otx2_dev_stats[stat].index]; 1393 1394 for (stat = 0; stat < otx2_n_drv_stats; stat++) 1395 *(data++) = atomic_read(&((atomic_t *)&vf->hw.drv_stats) 1396 [otx2_drv_stats[stat].index]); 1397 1398 otx2_get_qset_stats(vf, stats, &data); 1399 *(data++) = vf->reset_count; 1400 } 1401 1402 static int otx2vf_get_sset_count(struct net_device *netdev, int sset) 1403 { 1404 struct otx2_nic *vf = netdev_priv(netdev); 1405 int qstats_count; 1406 1407 if (sset != ETH_SS_STATS) 1408 return -EINVAL; 1409 1410 qstats_count = otx2_n_queue_stats * 1411 (vf->hw.rx_queues + otx2_get_total_tx_queues(vf)); 1412 1413 return otx2_n_dev_stats + otx2_n_drv_stats + qstats_count + 1; 1414 } 1415 1416 static int otx2vf_get_link_ksettings(struct net_device *netdev, 1417 struct ethtool_link_ksettings *cmd) 1418 { 1419 struct otx2_nic *pfvf = netdev_priv(netdev); 1420 1421 if (is_otx2_lbkvf(pfvf->pdev) || is_otx2_sdp_rep(pfvf->pdev)) { 1422 cmd->base.duplex = DUPLEX_FULL; 1423 cmd->base.speed = SPEED_100000; 1424 } else { 1425 return otx2_get_link_ksettings(netdev, cmd); 1426 } 1427 return 0; 1428 } 1429 1430 static const struct ethtool_ops otx2vf_ethtool_ops = { 1431 .cap_rss_ctx_supported = true, 1432 .supported_coalesce_params = ETHTOOL_COALESCE_USECS | 1433 ETHTOOL_COALESCE_MAX_FRAMES | 1434 ETHTOOL_COALESCE_USE_ADAPTIVE, 1435 .supported_ring_params = ETHTOOL_RING_USE_RX_BUF_LEN | 1436 ETHTOOL_RING_USE_CQE_SIZE, 1437 .get_link = otx2_get_link, 1438 .get_drvinfo = otx2vf_get_drvinfo, 1439 .get_strings = otx2vf_get_strings, 1440 .get_ethtool_stats = otx2vf_get_ethtool_stats, 1441 .get_sset_count = otx2vf_get_sset_count, 1442 .set_channels = otx2_set_channels, 1443 .get_channels = otx2_get_channels, 1444 .get_rxnfc = otx2_get_rxnfc, 1445 .set_rxnfc = otx2_set_rxnfc, 1446 .get_rxfh_key_size = otx2_get_rxfh_key_size, 1447 .get_rxfh_indir_size = otx2_get_rxfh_indir_size, 1448 .get_rxfh = otx2_get_rxfh, 1449 .set_rxfh = otx2_set_rxfh, 1450 .get_rxfh_fields = otx2_get_rss_hash_opts, 1451 .set_rxfh_fields = otx2_set_rss_hash_opts, 1452 .get_ringparam = otx2_get_ringparam, 1453 .set_ringparam = otx2_set_ringparam, 1454 .get_coalesce = otx2_get_coalesce, 1455 .set_coalesce = otx2_set_coalesce, 1456 .get_msglevel = otx2_get_msglevel, 1457 .set_msglevel = otx2_set_msglevel, 1458 .get_pauseparam = otx2_get_pauseparam, 1459 .set_pauseparam = otx2_set_pauseparam, 1460 .get_link_ksettings = otx2vf_get_link_ksettings, 1461 .get_ts_info = otx2_get_ts_info, 1462 }; 1463 1464 void otx2vf_set_ethtool_ops(struct net_device *netdev) 1465 { 1466 netdev->ethtool_ops = &otx2vf_ethtool_ops; 1467 } 1468 EXPORT_SYMBOL(otx2vf_set_ethtool_ops); 1469