1 // SPDX-License-Identifier: GPL-2.0+ 2 // Copyright (c) 2016-2017 Hisilicon Limited. 3 4 #include <linux/etherdevice.h> 5 #include <linux/string.h> 6 #include <linux/phy.h> 7 #include <linux/sfp.h> 8 9 #include "hns3_enet.h" 10 #include "hns3_ethtool.h" 11 12 /* tqp related stats */ 13 #define HNS3_TQP_STAT(_string, _member) { \ 14 .stats_string = _string, \ 15 .stats_offset = offsetof(struct hns3_enet_ring, stats) +\ 16 offsetof(struct ring_stats, _member), \ 17 } 18 19 static const struct hns3_stats hns3_txq_stats[] = { 20 /* Tx per-queue statistics */ 21 HNS3_TQP_STAT("dropped", sw_err_cnt), 22 HNS3_TQP_STAT("seg_pkt_cnt", seg_pkt_cnt), 23 HNS3_TQP_STAT("packets", tx_pkts), 24 HNS3_TQP_STAT("bytes", tx_bytes), 25 HNS3_TQP_STAT("more", tx_more), 26 HNS3_TQP_STAT("push", tx_push), 27 HNS3_TQP_STAT("mem_doorbell", tx_mem_doorbell), 28 HNS3_TQP_STAT("wake", restart_queue), 29 HNS3_TQP_STAT("busy", tx_busy), 30 HNS3_TQP_STAT("copy", tx_copy), 31 HNS3_TQP_STAT("vlan_err", tx_vlan_err), 32 HNS3_TQP_STAT("l4_proto_err", tx_l4_proto_err), 33 HNS3_TQP_STAT("l2l3l4_err", tx_l2l3l4_err), 34 HNS3_TQP_STAT("tso_err", tx_tso_err), 35 HNS3_TQP_STAT("over_max_recursion", over_max_recursion), 36 HNS3_TQP_STAT("hw_limitation", hw_limitation), 37 HNS3_TQP_STAT("bounce", tx_bounce), 38 HNS3_TQP_STAT("spare_full", tx_spare_full), 39 HNS3_TQP_STAT("copy_bits_err", copy_bits_err), 40 HNS3_TQP_STAT("sgl", tx_sgl), 41 HNS3_TQP_STAT("skb2sgl_err", skb2sgl_err), 42 HNS3_TQP_STAT("map_sg_err", map_sg_err), 43 }; 44 45 #define HNS3_TXQ_STATS_COUNT ARRAY_SIZE(hns3_txq_stats) 46 47 static const struct hns3_stats hns3_rxq_stats[] = { 48 /* Rx per-queue statistics */ 49 HNS3_TQP_STAT("dropped", sw_err_cnt), 50 HNS3_TQP_STAT("seg_pkt_cnt", seg_pkt_cnt), 51 HNS3_TQP_STAT("packets", rx_pkts), 52 HNS3_TQP_STAT("bytes", rx_bytes), 53 HNS3_TQP_STAT("errors", rx_err_cnt), 54 HNS3_TQP_STAT("reuse_pg_cnt", reuse_pg_cnt), 55 HNS3_TQP_STAT("err_pkt_len", err_pkt_len), 56 HNS3_TQP_STAT("err_bd_num", err_bd_num), 57 HNS3_TQP_STAT("l2_err", l2_err), 58 HNS3_TQP_STAT("l3l4_csum_err", l3l4_csum_err), 59 HNS3_TQP_STAT("csum_complete", csum_complete), 60 HNS3_TQP_STAT("multicast", rx_multicast), 61 HNS3_TQP_STAT("non_reuse_pg", non_reuse_pg), 62 HNS3_TQP_STAT("frag_alloc_err", frag_alloc_err), 63 HNS3_TQP_STAT("frag_alloc", frag_alloc), 64 }; 65 66 #define HNS3_PRIV_FLAGS_LEN ARRAY_SIZE(hns3_priv_flags) 67 68 #define HNS3_RXQ_STATS_COUNT ARRAY_SIZE(hns3_rxq_stats) 69 70 #define HNS3_TQP_STATS_COUNT (HNS3_TXQ_STATS_COUNT + HNS3_RXQ_STATS_COUNT) 71 72 #define HNS3_SELF_TEST_TYPE_NUM 4 73 #define HNS3_NIC_LB_TEST_PKT_NUM 1 74 #define HNS3_NIC_LB_TEST_RING_ID 0 75 #define HNS3_NIC_LB_TEST_PACKET_SIZE 128 76 #define HNS3_NIC_LB_SETUP_USEC 10000 77 78 /* Nic loopback test err */ 79 #define HNS3_NIC_LB_TEST_NO_MEM_ERR 1 80 #define HNS3_NIC_LB_TEST_TX_CNT_ERR 2 81 #define HNS3_NIC_LB_TEST_RX_CNT_ERR 3 82 83 static int hns3_lp_setup(struct net_device *ndev, enum hnae3_loop loop, bool en) 84 { 85 struct hnae3_handle *h = hns3_get_handle(ndev); 86 struct hnae3_ae_dev *ae_dev = pci_get_drvdata(h->pdev); 87 int ret; 88 89 if (!h->ae_algo->ops->set_loopback || 90 !h->ae_algo->ops->set_promisc_mode) 91 return -EOPNOTSUPP; 92 93 switch (loop) { 94 case HNAE3_LOOP_SERIAL_SERDES: 95 case HNAE3_LOOP_PARALLEL_SERDES: 96 case HNAE3_LOOP_APP: 97 case HNAE3_LOOP_PHY: 98 ret = h->ae_algo->ops->set_loopback(h, loop, en); 99 break; 100 default: 101 ret = -ENOTSUPP; 102 break; 103 } 104 105 if (ret || ae_dev->dev_version >= HNAE3_DEVICE_VERSION_V2) 106 return ret; 107 108 if (en) 109 h->ae_algo->ops->set_promisc_mode(h, true, true); 110 else 111 /* recover promisc mode before loopback test */ 112 hns3_request_update_promisc_mode(h); 113 114 return ret; 115 } 116 117 static int hns3_lp_up(struct net_device *ndev, enum hnae3_loop loop_mode) 118 { 119 struct hnae3_handle *h = hns3_get_handle(ndev); 120 int ret; 121 122 ret = hns3_nic_reset_all_ring(h); 123 if (ret) 124 return ret; 125 126 ret = hns3_lp_setup(ndev, loop_mode, true); 127 usleep_range(HNS3_NIC_LB_SETUP_USEC, HNS3_NIC_LB_SETUP_USEC * 2); 128 129 return ret; 130 } 131 132 static int hns3_lp_down(struct net_device *ndev, enum hnae3_loop loop_mode) 133 { 134 int ret; 135 136 ret = hns3_lp_setup(ndev, loop_mode, false); 137 if (ret) { 138 netdev_err(ndev, "lb_setup return error: %d\n", ret); 139 return ret; 140 } 141 142 usleep_range(HNS3_NIC_LB_SETUP_USEC, HNS3_NIC_LB_SETUP_USEC * 2); 143 144 return 0; 145 } 146 147 static void hns3_lp_setup_skb(struct sk_buff *skb) 148 { 149 #define HNS3_NIC_LB_DST_MAC_ADDR 0x1f 150 151 struct net_device *ndev = skb->dev; 152 struct hnae3_handle *handle; 153 struct hnae3_ae_dev *ae_dev; 154 unsigned char *packet; 155 struct ethhdr *ethh; 156 unsigned int i; 157 158 skb_reserve(skb, NET_IP_ALIGN); 159 ethh = skb_put(skb, sizeof(struct ethhdr)); 160 packet = skb_put(skb, HNS3_NIC_LB_TEST_PACKET_SIZE); 161 162 memcpy(ethh->h_dest, ndev->dev_addr, ETH_ALEN); 163 164 /* The dst mac addr of loopback packet is the same as the host' 165 * mac addr, the SSU component may loop back the packet to host 166 * before the packet reaches mac or serdes, which will defect 167 * the purpose of mac or serdes selftest. 168 */ 169 handle = hns3_get_handle(ndev); 170 ae_dev = pci_get_drvdata(handle->pdev); 171 if (ae_dev->dev_version < HNAE3_DEVICE_VERSION_V2) 172 ethh->h_dest[5] += HNS3_NIC_LB_DST_MAC_ADDR; 173 eth_zero_addr(ethh->h_source); 174 ethh->h_proto = htons(ETH_P_ARP); 175 skb_reset_mac_header(skb); 176 177 for (i = 0; i < HNS3_NIC_LB_TEST_PACKET_SIZE; i++) 178 packet[i] = (unsigned char)(i & 0xff); 179 } 180 181 static void hns3_lb_check_skb_data(struct hns3_enet_ring *ring, 182 struct sk_buff *skb) 183 { 184 struct hns3_enet_tqp_vector *tqp_vector = ring->tqp_vector; 185 unsigned char *packet = skb->data; 186 u32 len = skb_headlen(skb); 187 u32 i; 188 189 len = min_t(u32, len, HNS3_NIC_LB_TEST_PACKET_SIZE); 190 191 for (i = 0; i < len; i++) 192 if (packet[i] != (unsigned char)(i & 0xff)) 193 break; 194 195 /* The packet is correctly received */ 196 if (i == HNS3_NIC_LB_TEST_PACKET_SIZE) 197 tqp_vector->rx_group.total_packets++; 198 else 199 print_hex_dump(KERN_ERR, "selftest:", DUMP_PREFIX_OFFSET, 16, 1, 200 skb->data, len, true); 201 202 dev_kfree_skb_any(skb); 203 } 204 205 static u32 hns3_lb_check_rx_ring(struct hns3_nic_priv *priv, u32 budget) 206 { 207 struct hnae3_handle *h = priv->ae_handle; 208 struct hnae3_knic_private_info *kinfo; 209 u32 i, rcv_good_pkt_total = 0; 210 211 kinfo = &h->kinfo; 212 for (i = kinfo->num_tqps; i < kinfo->num_tqps * 2; i++) { 213 struct hns3_enet_ring *ring = &priv->ring[i]; 214 struct hns3_enet_ring_group *rx_group; 215 u64 pre_rx_pkt; 216 217 rx_group = &ring->tqp_vector->rx_group; 218 pre_rx_pkt = rx_group->total_packets; 219 220 preempt_disable(); 221 hns3_clean_rx_ring(ring, budget, hns3_lb_check_skb_data); 222 preempt_enable(); 223 224 rcv_good_pkt_total += (rx_group->total_packets - pre_rx_pkt); 225 rx_group->total_packets = pre_rx_pkt; 226 } 227 return rcv_good_pkt_total; 228 } 229 230 static void hns3_lb_clear_tx_ring(struct hns3_nic_priv *priv, u32 start_ringid, 231 u32 end_ringid, u32 budget) 232 { 233 u32 i; 234 235 for (i = start_ringid; i <= end_ringid; i++) { 236 struct hns3_enet_ring *ring = &priv->ring[i]; 237 238 hns3_clean_tx_ring(ring, 0); 239 } 240 } 241 242 /** 243 * hns3_lp_run_test - run loopback test 244 * @ndev: net device 245 * @mode: loopback type 246 * 247 * Return: %0 for success or a NIC loopback test error code on failure 248 */ 249 static int hns3_lp_run_test(struct net_device *ndev, enum hnae3_loop mode) 250 { 251 struct hns3_nic_priv *priv = netdev_priv(ndev); 252 struct sk_buff *skb; 253 u32 i, good_cnt; 254 int ret_val = 0; 255 256 skb = alloc_skb(HNS3_NIC_LB_TEST_PACKET_SIZE + ETH_HLEN + NET_IP_ALIGN, 257 GFP_KERNEL); 258 if (!skb) 259 return HNS3_NIC_LB_TEST_NO_MEM_ERR; 260 261 skb->dev = ndev; 262 hns3_lp_setup_skb(skb); 263 skb->queue_mapping = HNS3_NIC_LB_TEST_RING_ID; 264 265 good_cnt = 0; 266 for (i = 0; i < HNS3_NIC_LB_TEST_PKT_NUM; i++) { 267 netdev_tx_t tx_ret; 268 269 skb_get(skb); 270 tx_ret = hns3_nic_net_xmit(skb, ndev); 271 if (tx_ret == NETDEV_TX_OK) { 272 good_cnt++; 273 } else { 274 kfree_skb(skb); 275 netdev_err(ndev, "hns3_lb_run_test xmit failed: %d\n", 276 tx_ret); 277 } 278 } 279 if (good_cnt != HNS3_NIC_LB_TEST_PKT_NUM) { 280 ret_val = HNS3_NIC_LB_TEST_TX_CNT_ERR; 281 netdev_err(ndev, "mode %d sent fail, cnt=0x%x, budget=0x%x\n", 282 mode, good_cnt, HNS3_NIC_LB_TEST_PKT_NUM); 283 goto out; 284 } 285 286 /* Allow 200 milliseconds for packets to go from Tx to Rx */ 287 msleep(200); 288 289 good_cnt = hns3_lb_check_rx_ring(priv, HNS3_NIC_LB_TEST_PKT_NUM); 290 if (good_cnt != HNS3_NIC_LB_TEST_PKT_NUM) { 291 ret_val = HNS3_NIC_LB_TEST_RX_CNT_ERR; 292 netdev_err(ndev, "mode %d recv fail, cnt=0x%x, budget=0x%x\n", 293 mode, good_cnt, HNS3_NIC_LB_TEST_PKT_NUM); 294 } 295 296 out: 297 hns3_lb_clear_tx_ring(priv, HNS3_NIC_LB_TEST_RING_ID, 298 HNS3_NIC_LB_TEST_RING_ID, 299 HNS3_NIC_LB_TEST_PKT_NUM); 300 301 kfree_skb(skb); 302 return ret_val; 303 } 304 305 static void hns3_set_selftest_param(struct hnae3_handle *h, int (*st_param)[2]) 306 { 307 st_param[HNAE3_LOOP_APP][0] = HNAE3_LOOP_APP; 308 st_param[HNAE3_LOOP_APP][1] = 309 h->flags & HNAE3_SUPPORT_APP_LOOPBACK; 310 311 st_param[HNAE3_LOOP_SERIAL_SERDES][0] = HNAE3_LOOP_SERIAL_SERDES; 312 st_param[HNAE3_LOOP_SERIAL_SERDES][1] = 313 h->flags & HNAE3_SUPPORT_SERDES_SERIAL_LOOPBACK; 314 315 st_param[HNAE3_LOOP_PARALLEL_SERDES][0] = 316 HNAE3_LOOP_PARALLEL_SERDES; 317 st_param[HNAE3_LOOP_PARALLEL_SERDES][1] = 318 h->flags & HNAE3_SUPPORT_SERDES_PARALLEL_LOOPBACK; 319 320 st_param[HNAE3_LOOP_PHY][0] = HNAE3_LOOP_PHY; 321 st_param[HNAE3_LOOP_PHY][1] = 322 h->flags & HNAE3_SUPPORT_PHY_LOOPBACK; 323 } 324 325 static void hns3_selftest_prepare(struct net_device *ndev, 326 bool if_running, int (*st_param)[2]) 327 { 328 struct hns3_nic_priv *priv = netdev_priv(ndev); 329 struct hnae3_handle *h = priv->ae_handle; 330 331 if (netif_msg_ifdown(h)) 332 netdev_info(ndev, "self test start\n"); 333 334 hns3_set_selftest_param(h, st_param); 335 336 if (if_running) 337 ndev->netdev_ops->ndo_stop(ndev); 338 339 #if IS_ENABLED(CONFIG_VLAN_8021Q) 340 /* Disable the vlan filter for selftest does not support it */ 341 if (h->ae_algo->ops->enable_vlan_filter && 342 ndev->features & NETIF_F_HW_VLAN_CTAG_FILTER) 343 h->ae_algo->ops->enable_vlan_filter(h, false); 344 #endif 345 346 /* Tell firmware to stop mac autoneg before loopback test start, 347 * otherwise loopback test may be failed when the port is still 348 * negotiating. 349 */ 350 if (h->ae_algo->ops->halt_autoneg) 351 h->ae_algo->ops->halt_autoneg(h, true); 352 353 set_bit(HNS3_NIC_STATE_TESTING, &priv->state); 354 } 355 356 static void hns3_selftest_restore(struct net_device *ndev, bool if_running) 357 { 358 struct hns3_nic_priv *priv = netdev_priv(ndev); 359 struct hnae3_handle *h = priv->ae_handle; 360 361 clear_bit(HNS3_NIC_STATE_TESTING, &priv->state); 362 363 if (h->ae_algo->ops->halt_autoneg) 364 h->ae_algo->ops->halt_autoneg(h, false); 365 366 #if IS_ENABLED(CONFIG_VLAN_8021Q) 367 if (h->ae_algo->ops->enable_vlan_filter && 368 ndev->features & NETIF_F_HW_VLAN_CTAG_FILTER) 369 h->ae_algo->ops->enable_vlan_filter(h, true); 370 #endif 371 372 if (if_running) 373 ndev->netdev_ops->ndo_open(ndev); 374 375 if (netif_msg_ifdown(h)) 376 netdev_info(ndev, "self test end\n"); 377 } 378 379 static void hns3_do_selftest(struct net_device *ndev, int (*st_param)[2], 380 struct ethtool_test *eth_test, u64 *data) 381 { 382 int test_index = 0; 383 u32 i; 384 385 for (i = 0; i < HNS3_SELF_TEST_TYPE_NUM; i++) { 386 enum hnae3_loop loop_type = (enum hnae3_loop)st_param[i][0]; 387 388 if (!st_param[i][1]) 389 continue; 390 391 data[test_index] = hns3_lp_up(ndev, loop_type); 392 if (!data[test_index]) 393 data[test_index] = hns3_lp_run_test(ndev, loop_type); 394 395 hns3_lp_down(ndev, loop_type); 396 397 if (data[test_index]) 398 eth_test->flags |= ETH_TEST_FL_FAILED; 399 400 test_index++; 401 } 402 } 403 404 /** 405 * hns3_self_test - self test 406 * @ndev: net device 407 * @eth_test: test cmd 408 * @data: test result 409 */ 410 static void hns3_self_test(struct net_device *ndev, 411 struct ethtool_test *eth_test, u64 *data) 412 { 413 int st_param[HNS3_SELF_TEST_TYPE_NUM][2]; 414 bool if_running = netif_running(ndev); 415 416 if (hns3_nic_resetting(ndev)) { 417 netdev_err(ndev, "dev resetting!"); 418 return; 419 } 420 421 /* Only do offline selftest, or pass by default */ 422 if (eth_test->flags != ETH_TEST_FL_OFFLINE) 423 return; 424 425 hns3_selftest_prepare(ndev, if_running, st_param); 426 hns3_do_selftest(ndev, st_param, eth_test, data); 427 hns3_selftest_restore(ndev, if_running); 428 } 429 430 static void hns3_update_limit_promisc_mode(struct net_device *netdev, 431 bool enable) 432 { 433 struct hnae3_handle *handle = hns3_get_handle(netdev); 434 435 if (enable) 436 set_bit(HNAE3_PFLAG_LIMIT_PROMISC, &handle->priv_flags); 437 else 438 clear_bit(HNAE3_PFLAG_LIMIT_PROMISC, &handle->priv_flags); 439 440 hns3_request_update_promisc_mode(handle); 441 } 442 443 static const struct hns3_pflag_desc hns3_priv_flags[HNAE3_PFLAG_MAX] = { 444 { "limit_promisc", hns3_update_limit_promisc_mode } 445 }; 446 447 static int hns3_get_sset_count(struct net_device *netdev, int stringset) 448 { 449 struct hnae3_handle *h = hns3_get_handle(netdev); 450 const struct hnae3_ae_ops *ops = h->ae_algo->ops; 451 452 if (!ops->get_sset_count) 453 return -EOPNOTSUPP; 454 455 switch (stringset) { 456 case ETH_SS_STATS: 457 return ((HNS3_TQP_STATS_COUNT * h->kinfo.num_tqps) + 458 ops->get_sset_count(h, stringset)); 459 460 case ETH_SS_TEST: 461 return ops->get_sset_count(h, stringset); 462 463 case ETH_SS_PRIV_FLAGS: 464 return HNAE3_PFLAG_MAX; 465 466 default: 467 return -EOPNOTSUPP; 468 } 469 } 470 471 static void *hns3_update_strings(u8 *data, const struct hns3_stats *stats, 472 u32 stat_count, u32 num_tqps, const char *prefix) 473 { 474 #define MAX_PREFIX_SIZE (6 + 4) 475 u32 size_left; 476 u32 i, j; 477 u32 n1; 478 479 for (i = 0; i < num_tqps; i++) { 480 for (j = 0; j < stat_count; j++) { 481 data[ETH_GSTRING_LEN - 1] = '\0'; 482 483 /* first, prepend the prefix string */ 484 n1 = scnprintf(data, MAX_PREFIX_SIZE, "%s%u_", 485 prefix, i); 486 size_left = (ETH_GSTRING_LEN - 1) - n1; 487 488 /* now, concatenate the stats string to it */ 489 strncat(data, stats[j].stats_string, size_left); 490 data += ETH_GSTRING_LEN; 491 } 492 } 493 494 return data; 495 } 496 497 static u8 *hns3_get_strings_tqps(struct hnae3_handle *handle, u8 *data) 498 { 499 struct hnae3_knic_private_info *kinfo = &handle->kinfo; 500 const char tx_prefix[] = "txq"; 501 const char rx_prefix[] = "rxq"; 502 503 /* get strings for Tx */ 504 data = hns3_update_strings(data, hns3_txq_stats, HNS3_TXQ_STATS_COUNT, 505 kinfo->num_tqps, tx_prefix); 506 507 /* get strings for Rx */ 508 data = hns3_update_strings(data, hns3_rxq_stats, HNS3_RXQ_STATS_COUNT, 509 kinfo->num_tqps, rx_prefix); 510 511 return data; 512 } 513 514 static void hns3_get_strings(struct net_device *netdev, u32 stringset, u8 *data) 515 { 516 struct hnae3_handle *h = hns3_get_handle(netdev); 517 const struct hnae3_ae_ops *ops = h->ae_algo->ops; 518 char *buff = (char *)data; 519 int i; 520 521 if (!ops->get_strings) 522 return; 523 524 switch (stringset) { 525 case ETH_SS_STATS: 526 buff = hns3_get_strings_tqps(h, buff); 527 ops->get_strings(h, stringset, (u8 *)buff); 528 break; 529 case ETH_SS_TEST: 530 ops->get_strings(h, stringset, data); 531 break; 532 case ETH_SS_PRIV_FLAGS: 533 for (i = 0; i < HNS3_PRIV_FLAGS_LEN; i++) { 534 snprintf(buff, ETH_GSTRING_LEN, "%s", 535 hns3_priv_flags[i].name); 536 buff += ETH_GSTRING_LEN; 537 } 538 break; 539 default: 540 break; 541 } 542 } 543 544 static u64 *hns3_get_stats_tqps(struct hnae3_handle *handle, u64 *data) 545 { 546 struct hns3_nic_priv *nic_priv = (struct hns3_nic_priv *)handle->priv; 547 struct hnae3_knic_private_info *kinfo = &handle->kinfo; 548 struct hns3_enet_ring *ring; 549 u8 *stat; 550 int i, j; 551 552 /* get stats for Tx */ 553 for (i = 0; i < kinfo->num_tqps; i++) { 554 ring = &nic_priv->ring[i]; 555 for (j = 0; j < HNS3_TXQ_STATS_COUNT; j++) { 556 stat = (u8 *)ring + hns3_txq_stats[j].stats_offset; 557 *data++ = *(u64 *)stat; 558 } 559 } 560 561 /* get stats for Rx */ 562 for (i = 0; i < kinfo->num_tqps; i++) { 563 ring = &nic_priv->ring[i + kinfo->num_tqps]; 564 for (j = 0; j < HNS3_RXQ_STATS_COUNT; j++) { 565 stat = (u8 *)ring + hns3_rxq_stats[j].stats_offset; 566 *data++ = *(u64 *)stat; 567 } 568 } 569 570 return data; 571 } 572 573 /* hns3_get_stats - get detail statistics. 574 * @netdev: net device 575 * @stats: statistics info. 576 * @data: statistics data. 577 */ 578 static void hns3_get_stats(struct net_device *netdev, 579 struct ethtool_stats *stats, u64 *data) 580 { 581 struct hnae3_handle *h = hns3_get_handle(netdev); 582 u64 *p = data; 583 584 if (hns3_nic_resetting(netdev)) { 585 netdev_err(netdev, "dev resetting, could not get stats\n"); 586 return; 587 } 588 589 if (!h->ae_algo->ops->get_stats || !h->ae_algo->ops->update_stats) { 590 netdev_err(netdev, "could not get any statistics\n"); 591 return; 592 } 593 594 h->ae_algo->ops->update_stats(h, &netdev->stats); 595 596 /* get per-queue stats */ 597 p = hns3_get_stats_tqps(h, p); 598 599 /* get MAC & other misc hardware stats */ 600 h->ae_algo->ops->get_stats(h, p); 601 } 602 603 static void hns3_get_drvinfo(struct net_device *netdev, 604 struct ethtool_drvinfo *drvinfo) 605 { 606 struct hns3_nic_priv *priv = netdev_priv(netdev); 607 struct hnae3_handle *h = priv->ae_handle; 608 u32 fw_version; 609 610 if (!h->ae_algo->ops->get_fw_version) { 611 netdev_err(netdev, "could not get fw version!\n"); 612 return; 613 } 614 615 strncpy(drvinfo->driver, dev_driver_string(&h->pdev->dev), 616 sizeof(drvinfo->driver)); 617 drvinfo->driver[sizeof(drvinfo->driver) - 1] = '\0'; 618 619 strncpy(drvinfo->bus_info, pci_name(h->pdev), 620 sizeof(drvinfo->bus_info)); 621 drvinfo->bus_info[ETHTOOL_BUSINFO_LEN - 1] = '\0'; 622 623 fw_version = priv->ae_handle->ae_algo->ops->get_fw_version(h); 624 625 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), 626 "%lu.%lu.%lu.%lu", 627 hnae3_get_field(fw_version, HNAE3_FW_VERSION_BYTE3_MASK, 628 HNAE3_FW_VERSION_BYTE3_SHIFT), 629 hnae3_get_field(fw_version, HNAE3_FW_VERSION_BYTE2_MASK, 630 HNAE3_FW_VERSION_BYTE2_SHIFT), 631 hnae3_get_field(fw_version, HNAE3_FW_VERSION_BYTE1_MASK, 632 HNAE3_FW_VERSION_BYTE1_SHIFT), 633 hnae3_get_field(fw_version, HNAE3_FW_VERSION_BYTE0_MASK, 634 HNAE3_FW_VERSION_BYTE0_SHIFT)); 635 } 636 637 static u32 hns3_get_link(struct net_device *netdev) 638 { 639 struct hnae3_handle *h = hns3_get_handle(netdev); 640 641 if (h->ae_algo->ops->get_status) 642 return h->ae_algo->ops->get_status(h); 643 else 644 return 0; 645 } 646 647 static void hns3_get_ringparam(struct net_device *netdev, 648 struct ethtool_ringparam *param, 649 struct kernel_ethtool_ringparam *kernel_param, 650 struct netlink_ext_ack *extack) 651 { 652 struct hns3_nic_priv *priv = netdev_priv(netdev); 653 struct hnae3_handle *h = priv->ae_handle; 654 int rx_queue_index = h->kinfo.num_tqps; 655 656 if (hns3_nic_resetting(netdev) || !priv->ring) { 657 netdev_err(netdev, "failed to get ringparam value, due to dev resetting or uninited\n"); 658 return; 659 } 660 661 param->tx_max_pending = HNS3_RING_MAX_PENDING; 662 param->rx_max_pending = HNS3_RING_MAX_PENDING; 663 664 param->tx_pending = priv->ring[0].desc_num; 665 param->rx_pending = priv->ring[rx_queue_index].desc_num; 666 kernel_param->rx_buf_len = priv->ring[rx_queue_index].buf_size; 667 } 668 669 static void hns3_get_pauseparam(struct net_device *netdev, 670 struct ethtool_pauseparam *param) 671 { 672 struct hnae3_handle *h = hns3_get_handle(netdev); 673 struct hnae3_ae_dev *ae_dev = pci_get_drvdata(h->pdev); 674 675 if (!test_bit(HNAE3_DEV_SUPPORT_PAUSE_B, ae_dev->caps)) 676 return; 677 678 if (h->ae_algo->ops->get_pauseparam) 679 h->ae_algo->ops->get_pauseparam(h, ¶m->autoneg, 680 ¶m->rx_pause, ¶m->tx_pause); 681 } 682 683 static int hns3_set_pauseparam(struct net_device *netdev, 684 struct ethtool_pauseparam *param) 685 { 686 struct hnae3_handle *h = hns3_get_handle(netdev); 687 struct hnae3_ae_dev *ae_dev = pci_get_drvdata(h->pdev); 688 689 if (!test_bit(HNAE3_DEV_SUPPORT_PAUSE_B, ae_dev->caps)) 690 return -EOPNOTSUPP; 691 692 netif_dbg(h, drv, netdev, 693 "set pauseparam: autoneg=%u, rx:%u, tx:%u\n", 694 param->autoneg, param->rx_pause, param->tx_pause); 695 696 if (h->ae_algo->ops->set_pauseparam) 697 return h->ae_algo->ops->set_pauseparam(h, param->autoneg, 698 param->rx_pause, 699 param->tx_pause); 700 return -EOPNOTSUPP; 701 } 702 703 static void hns3_get_ksettings(struct hnae3_handle *h, 704 struct ethtool_link_ksettings *cmd) 705 { 706 const struct hnae3_ae_ops *ops = h->ae_algo->ops; 707 708 /* 1.auto_neg & speed & duplex from cmd */ 709 if (ops->get_ksettings_an_result) 710 ops->get_ksettings_an_result(h, 711 &cmd->base.autoneg, 712 &cmd->base.speed, 713 &cmd->base.duplex); 714 715 /* 2.get link mode */ 716 if (ops->get_link_mode) 717 ops->get_link_mode(h, 718 cmd->link_modes.supported, 719 cmd->link_modes.advertising); 720 721 /* 3.mdix_ctrl&mdix get from phy reg */ 722 if (ops->get_mdix_mode) 723 ops->get_mdix_mode(h, &cmd->base.eth_tp_mdix_ctrl, 724 &cmd->base.eth_tp_mdix); 725 } 726 727 static int hns3_get_link_ksettings(struct net_device *netdev, 728 struct ethtool_link_ksettings *cmd) 729 { 730 struct hnae3_handle *h = hns3_get_handle(netdev); 731 struct hnae3_ae_dev *ae_dev = pci_get_drvdata(h->pdev); 732 const struct hnae3_ae_ops *ops; 733 u8 module_type; 734 u8 media_type; 735 u8 link_stat; 736 737 ops = h->ae_algo->ops; 738 if (ops->get_media_type) 739 ops->get_media_type(h, &media_type, &module_type); 740 else 741 return -EOPNOTSUPP; 742 743 switch (media_type) { 744 case HNAE3_MEDIA_TYPE_NONE: 745 cmd->base.port = PORT_NONE; 746 hns3_get_ksettings(h, cmd); 747 break; 748 case HNAE3_MEDIA_TYPE_FIBER: 749 if (module_type == HNAE3_MODULE_TYPE_CR) 750 cmd->base.port = PORT_DA; 751 else 752 cmd->base.port = PORT_FIBRE; 753 754 hns3_get_ksettings(h, cmd); 755 break; 756 case HNAE3_MEDIA_TYPE_BACKPLANE: 757 cmd->base.port = PORT_NONE; 758 hns3_get_ksettings(h, cmd); 759 break; 760 case HNAE3_MEDIA_TYPE_COPPER: 761 cmd->base.port = PORT_TP; 762 if (test_bit(HNAE3_DEV_SUPPORT_PHY_IMP_B, ae_dev->caps) && 763 ops->get_phy_link_ksettings) 764 ops->get_phy_link_ksettings(h, cmd); 765 else if (!netdev->phydev) 766 hns3_get_ksettings(h, cmd); 767 else 768 phy_ethtool_ksettings_get(netdev->phydev, cmd); 769 break; 770 default: 771 772 netdev_warn(netdev, "Unknown media type"); 773 return 0; 774 } 775 776 /* mdio_support */ 777 cmd->base.mdio_support = ETH_MDIO_SUPPORTS_C22; 778 779 link_stat = hns3_get_link(netdev); 780 if (!link_stat) { 781 cmd->base.speed = SPEED_UNKNOWN; 782 cmd->base.duplex = DUPLEX_UNKNOWN; 783 } 784 785 return 0; 786 } 787 788 static int hns3_check_ksettings_param(const struct net_device *netdev, 789 const struct ethtool_link_ksettings *cmd) 790 { 791 struct hnae3_handle *handle = hns3_get_handle(netdev); 792 const struct hnae3_ae_ops *ops = handle->ae_algo->ops; 793 u8 module_type = HNAE3_MODULE_TYPE_UNKNOWN; 794 u8 media_type = HNAE3_MEDIA_TYPE_UNKNOWN; 795 u8 autoneg; 796 u32 speed; 797 u8 duplex; 798 int ret; 799 800 /* hw doesn't support use specified speed and duplex to negotiate, 801 * unnecessary to check them when autoneg on. 802 */ 803 if (cmd->base.autoneg) 804 return 0; 805 806 if (ops->get_ksettings_an_result) { 807 ops->get_ksettings_an_result(handle, &autoneg, &speed, &duplex); 808 if (cmd->base.autoneg == autoneg && cmd->base.speed == speed && 809 cmd->base.duplex == duplex) 810 return 0; 811 } 812 813 if (ops->get_media_type) 814 ops->get_media_type(handle, &media_type, &module_type); 815 816 if (cmd->base.duplex == DUPLEX_HALF && 817 media_type != HNAE3_MEDIA_TYPE_COPPER) { 818 netdev_err(netdev, 819 "only copper port supports half duplex!"); 820 return -EINVAL; 821 } 822 823 if (ops->check_port_speed) { 824 ret = ops->check_port_speed(handle, cmd->base.speed); 825 if (ret) { 826 netdev_err(netdev, "unsupported speed\n"); 827 return ret; 828 } 829 } 830 831 return 0; 832 } 833 834 static int hns3_set_link_ksettings(struct net_device *netdev, 835 const struct ethtool_link_ksettings *cmd) 836 { 837 struct hnae3_handle *handle = hns3_get_handle(netdev); 838 struct hnae3_ae_dev *ae_dev = pci_get_drvdata(handle->pdev); 839 const struct hnae3_ae_ops *ops = handle->ae_algo->ops; 840 int ret; 841 842 /* Chip don't support this mode. */ 843 if (cmd->base.speed == SPEED_1000 && cmd->base.duplex == DUPLEX_HALF) 844 return -EINVAL; 845 846 netif_dbg(handle, drv, netdev, 847 "set link(%s): autoneg=%u, speed=%u, duplex=%u\n", 848 netdev->phydev ? "phy" : "mac", 849 cmd->base.autoneg, cmd->base.speed, cmd->base.duplex); 850 851 /* Only support ksettings_set for netdev with phy attached for now */ 852 if (netdev->phydev) { 853 if (cmd->base.speed == SPEED_1000 && 854 cmd->base.autoneg == AUTONEG_DISABLE) 855 return -EINVAL; 856 857 return phy_ethtool_ksettings_set(netdev->phydev, cmd); 858 } else if (test_bit(HNAE3_DEV_SUPPORT_PHY_IMP_B, ae_dev->caps) && 859 ops->set_phy_link_ksettings) { 860 return ops->set_phy_link_ksettings(handle, cmd); 861 } 862 863 if (ae_dev->dev_version < HNAE3_DEVICE_VERSION_V2) 864 return -EOPNOTSUPP; 865 866 ret = hns3_check_ksettings_param(netdev, cmd); 867 if (ret) 868 return ret; 869 870 if (ops->set_autoneg) { 871 ret = ops->set_autoneg(handle, cmd->base.autoneg); 872 if (ret) 873 return ret; 874 } 875 876 /* hw doesn't support use specified speed and duplex to negotiate, 877 * ignore them when autoneg on. 878 */ 879 if (cmd->base.autoneg) { 880 netdev_info(netdev, 881 "autoneg is on, ignore the speed and duplex\n"); 882 return 0; 883 } 884 885 if (ops->cfg_mac_speed_dup_h) 886 ret = ops->cfg_mac_speed_dup_h(handle, cmd->base.speed, 887 cmd->base.duplex); 888 889 return ret; 890 } 891 892 static u32 hns3_get_rss_key_size(struct net_device *netdev) 893 { 894 struct hnae3_handle *h = hns3_get_handle(netdev); 895 896 if (!h->ae_algo->ops->get_rss_key_size) 897 return 0; 898 899 return h->ae_algo->ops->get_rss_key_size(h); 900 } 901 902 static u32 hns3_get_rss_indir_size(struct net_device *netdev) 903 { 904 struct hnae3_handle *h = hns3_get_handle(netdev); 905 struct hnae3_ae_dev *ae_dev = pci_get_drvdata(h->pdev); 906 907 return ae_dev->dev_specs.rss_ind_tbl_size; 908 } 909 910 static int hns3_get_rss(struct net_device *netdev, u32 *indir, u8 *key, 911 u8 *hfunc) 912 { 913 struct hnae3_handle *h = hns3_get_handle(netdev); 914 915 if (!h->ae_algo->ops->get_rss) 916 return -EOPNOTSUPP; 917 918 return h->ae_algo->ops->get_rss(h, indir, key, hfunc); 919 } 920 921 static int hns3_set_rss(struct net_device *netdev, const u32 *indir, 922 const u8 *key, const u8 hfunc) 923 { 924 struct hnae3_handle *h = hns3_get_handle(netdev); 925 struct hnae3_ae_dev *ae_dev = pci_get_drvdata(h->pdev); 926 927 if (!h->ae_algo->ops->set_rss) 928 return -EOPNOTSUPP; 929 930 if ((ae_dev->dev_version < HNAE3_DEVICE_VERSION_V2 && 931 hfunc != ETH_RSS_HASH_TOP) || (hfunc != ETH_RSS_HASH_NO_CHANGE && 932 hfunc != ETH_RSS_HASH_TOP && hfunc != ETH_RSS_HASH_XOR)) { 933 netdev_err(netdev, "hash func not supported\n"); 934 return -EOPNOTSUPP; 935 } 936 937 if (!indir) { 938 netdev_err(netdev, 939 "set rss failed for indir is empty\n"); 940 return -EOPNOTSUPP; 941 } 942 943 return h->ae_algo->ops->set_rss(h, indir, key, hfunc); 944 } 945 946 static int hns3_get_rxnfc(struct net_device *netdev, 947 struct ethtool_rxnfc *cmd, 948 u32 *rule_locs) 949 { 950 struct hnae3_handle *h = hns3_get_handle(netdev); 951 952 switch (cmd->cmd) { 953 case ETHTOOL_GRXRINGS: 954 cmd->data = h->kinfo.num_tqps; 955 return 0; 956 case ETHTOOL_GRXFH: 957 if (h->ae_algo->ops->get_rss_tuple) 958 return h->ae_algo->ops->get_rss_tuple(h, cmd); 959 return -EOPNOTSUPP; 960 case ETHTOOL_GRXCLSRLCNT: 961 if (h->ae_algo->ops->get_fd_rule_cnt) 962 return h->ae_algo->ops->get_fd_rule_cnt(h, cmd); 963 return -EOPNOTSUPP; 964 case ETHTOOL_GRXCLSRULE: 965 if (h->ae_algo->ops->get_fd_rule_info) 966 return h->ae_algo->ops->get_fd_rule_info(h, cmd); 967 return -EOPNOTSUPP; 968 case ETHTOOL_GRXCLSRLALL: 969 if (h->ae_algo->ops->get_fd_all_rules) 970 return h->ae_algo->ops->get_fd_all_rules(h, cmd, 971 rule_locs); 972 return -EOPNOTSUPP; 973 default: 974 return -EOPNOTSUPP; 975 } 976 } 977 978 static const struct hns3_reset_type_map hns3_reset_type[] = { 979 {ETH_RESET_MGMT, HNAE3_IMP_RESET}, 980 {ETH_RESET_ALL, HNAE3_GLOBAL_RESET}, 981 {ETH_RESET_DEDICATED, HNAE3_FUNC_RESET}, 982 }; 983 984 static const struct hns3_reset_type_map hns3vf_reset_type[] = { 985 {ETH_RESET_DEDICATED, HNAE3_VF_FUNC_RESET}, 986 }; 987 988 static int hns3_set_reset(struct net_device *netdev, u32 *flags) 989 { 990 enum hnae3_reset_type rst_type = HNAE3_NONE_RESET; 991 struct hnae3_handle *h = hns3_get_handle(netdev); 992 struct hnae3_ae_dev *ae_dev = pci_get_drvdata(h->pdev); 993 const struct hnae3_ae_ops *ops = h->ae_algo->ops; 994 const struct hns3_reset_type_map *rst_type_map; 995 enum ethtool_reset_flags rst_flags; 996 u32 i, size; 997 998 if (ops->ae_dev_resetting && ops->ae_dev_resetting(h)) 999 return -EBUSY; 1000 1001 if (!ops->set_default_reset_request || !ops->reset_event) 1002 return -EOPNOTSUPP; 1003 1004 if (h->flags & HNAE3_SUPPORT_VF) { 1005 rst_type_map = hns3vf_reset_type; 1006 size = ARRAY_SIZE(hns3vf_reset_type); 1007 } else { 1008 rst_type_map = hns3_reset_type; 1009 size = ARRAY_SIZE(hns3_reset_type); 1010 } 1011 1012 for (i = 0; i < size; i++) { 1013 if (rst_type_map[i].rst_flags == *flags) { 1014 rst_type = rst_type_map[i].rst_type; 1015 rst_flags = rst_type_map[i].rst_flags; 1016 break; 1017 } 1018 } 1019 1020 if (rst_type == HNAE3_NONE_RESET || 1021 (rst_type == HNAE3_IMP_RESET && 1022 ae_dev->dev_version <= HNAE3_DEVICE_VERSION_V2)) 1023 return -EOPNOTSUPP; 1024 1025 netdev_info(netdev, "Setting reset type %d\n", rst_type); 1026 1027 ops->set_default_reset_request(ae_dev, rst_type); 1028 1029 ops->reset_event(h->pdev, h); 1030 1031 *flags &= ~rst_flags; 1032 1033 return 0; 1034 } 1035 1036 static void hns3_change_all_ring_bd_num(struct hns3_nic_priv *priv, 1037 u32 tx_desc_num, u32 rx_desc_num) 1038 { 1039 struct hnae3_handle *h = priv->ae_handle; 1040 int i; 1041 1042 h->kinfo.num_tx_desc = tx_desc_num; 1043 h->kinfo.num_rx_desc = rx_desc_num; 1044 1045 for (i = 0; i < h->kinfo.num_tqps; i++) { 1046 priv->ring[i].desc_num = tx_desc_num; 1047 priv->ring[i + h->kinfo.num_tqps].desc_num = rx_desc_num; 1048 } 1049 } 1050 1051 static struct hns3_enet_ring *hns3_backup_ringparam(struct hns3_nic_priv *priv) 1052 { 1053 struct hnae3_handle *handle = priv->ae_handle; 1054 struct hns3_enet_ring *tmp_rings; 1055 int i; 1056 1057 tmp_rings = kcalloc(handle->kinfo.num_tqps * 2, 1058 sizeof(struct hns3_enet_ring), GFP_KERNEL); 1059 if (!tmp_rings) 1060 return NULL; 1061 1062 for (i = 0; i < handle->kinfo.num_tqps * 2; i++) { 1063 memcpy(&tmp_rings[i], &priv->ring[i], 1064 sizeof(struct hns3_enet_ring)); 1065 tmp_rings[i].skb = NULL; 1066 } 1067 1068 return tmp_rings; 1069 } 1070 1071 static int hns3_check_ringparam(struct net_device *ndev, 1072 struct ethtool_ringparam *param, 1073 struct kernel_ethtool_ringparam *kernel_param) 1074 { 1075 #define RX_BUF_LEN_2K 2048 1076 #define RX_BUF_LEN_4K 4096 1077 1078 struct hns3_nic_priv *priv = netdev_priv(ndev); 1079 1080 if (hns3_nic_resetting(ndev) || !priv->ring) { 1081 netdev_err(ndev, "failed to set ringparam value, due to dev resetting or uninited\n"); 1082 return -EBUSY; 1083 } 1084 1085 1086 if (param->rx_mini_pending || param->rx_jumbo_pending) 1087 return -EINVAL; 1088 1089 if (kernel_param->rx_buf_len != RX_BUF_LEN_2K && 1090 kernel_param->rx_buf_len != RX_BUF_LEN_4K) { 1091 netdev_err(ndev, "Rx buf len only support 2048 and 4096\n"); 1092 return -EINVAL; 1093 } 1094 1095 if (param->tx_pending > HNS3_RING_MAX_PENDING || 1096 param->tx_pending < HNS3_RING_MIN_PENDING || 1097 param->rx_pending > HNS3_RING_MAX_PENDING || 1098 param->rx_pending < HNS3_RING_MIN_PENDING) { 1099 netdev_err(ndev, "Queue depth out of range [%d-%d]\n", 1100 HNS3_RING_MIN_PENDING, HNS3_RING_MAX_PENDING); 1101 return -EINVAL; 1102 } 1103 1104 return 0; 1105 } 1106 1107 static int hns3_change_rx_buf_len(struct net_device *ndev, u32 rx_buf_len) 1108 { 1109 struct hns3_nic_priv *priv = netdev_priv(ndev); 1110 struct hnae3_handle *h = priv->ae_handle; 1111 int i; 1112 1113 h->kinfo.rx_buf_len = rx_buf_len; 1114 1115 for (i = 0; i < h->kinfo.num_tqps; i++) { 1116 h->kinfo.tqp[i]->buf_size = rx_buf_len; 1117 priv->ring[i + h->kinfo.num_tqps].buf_size = rx_buf_len; 1118 } 1119 1120 return 0; 1121 } 1122 1123 static int hns3_set_ringparam(struct net_device *ndev, 1124 struct ethtool_ringparam *param, 1125 struct kernel_ethtool_ringparam *kernel_param, 1126 struct netlink_ext_ack *extack) 1127 { 1128 struct hns3_nic_priv *priv = netdev_priv(ndev); 1129 struct hnae3_handle *h = priv->ae_handle; 1130 struct hns3_enet_ring *tmp_rings; 1131 bool if_running = netif_running(ndev); 1132 u32 old_tx_desc_num, new_tx_desc_num; 1133 u32 old_rx_desc_num, new_rx_desc_num; 1134 u16 queue_num = h->kinfo.num_tqps; 1135 u32 old_rx_buf_len; 1136 int ret, i; 1137 1138 ret = hns3_check_ringparam(ndev, param, kernel_param); 1139 if (ret) 1140 return ret; 1141 1142 /* Hardware requires that its descriptors must be multiple of eight */ 1143 new_tx_desc_num = ALIGN(param->tx_pending, HNS3_RING_BD_MULTIPLE); 1144 new_rx_desc_num = ALIGN(param->rx_pending, HNS3_RING_BD_MULTIPLE); 1145 old_tx_desc_num = priv->ring[0].desc_num; 1146 old_rx_desc_num = priv->ring[queue_num].desc_num; 1147 old_rx_buf_len = priv->ring[queue_num].buf_size; 1148 if (old_tx_desc_num == new_tx_desc_num && 1149 old_rx_desc_num == new_rx_desc_num && 1150 kernel_param->rx_buf_len == old_rx_buf_len) 1151 return 0; 1152 1153 tmp_rings = hns3_backup_ringparam(priv); 1154 if (!tmp_rings) { 1155 netdev_err(ndev, 1156 "backup ring param failed by allocating memory fail\n"); 1157 return -ENOMEM; 1158 } 1159 1160 netdev_info(ndev, 1161 "Changing Tx/Rx ring depth from %u/%u to %u/%u, Changing rx buffer len from %d to %d\n", 1162 old_tx_desc_num, old_rx_desc_num, 1163 new_tx_desc_num, new_rx_desc_num, 1164 old_rx_buf_len, kernel_param->rx_buf_len); 1165 1166 if (if_running) 1167 ndev->netdev_ops->ndo_stop(ndev); 1168 1169 hns3_change_all_ring_bd_num(priv, new_tx_desc_num, new_rx_desc_num); 1170 hns3_change_rx_buf_len(ndev, kernel_param->rx_buf_len); 1171 ret = hns3_init_all_ring(priv); 1172 if (ret) { 1173 netdev_err(ndev, "set ringparam fail, revert to old value(%d)\n", 1174 ret); 1175 1176 hns3_change_rx_buf_len(ndev, old_rx_buf_len); 1177 hns3_change_all_ring_bd_num(priv, old_tx_desc_num, 1178 old_rx_desc_num); 1179 for (i = 0; i < h->kinfo.num_tqps * 2; i++) 1180 memcpy(&priv->ring[i], &tmp_rings[i], 1181 sizeof(struct hns3_enet_ring)); 1182 } else { 1183 for (i = 0; i < h->kinfo.num_tqps * 2; i++) 1184 hns3_fini_ring(&tmp_rings[i]); 1185 } 1186 1187 kfree(tmp_rings); 1188 1189 if (if_running) 1190 ret = ndev->netdev_ops->ndo_open(ndev); 1191 1192 return ret; 1193 } 1194 1195 static int hns3_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd) 1196 { 1197 struct hnae3_handle *h = hns3_get_handle(netdev); 1198 1199 switch (cmd->cmd) { 1200 case ETHTOOL_SRXFH: 1201 if (h->ae_algo->ops->set_rss_tuple) 1202 return h->ae_algo->ops->set_rss_tuple(h, cmd); 1203 return -EOPNOTSUPP; 1204 case ETHTOOL_SRXCLSRLINS: 1205 if (h->ae_algo->ops->add_fd_entry) 1206 return h->ae_algo->ops->add_fd_entry(h, cmd); 1207 return -EOPNOTSUPP; 1208 case ETHTOOL_SRXCLSRLDEL: 1209 if (h->ae_algo->ops->del_fd_entry) 1210 return h->ae_algo->ops->del_fd_entry(h, cmd); 1211 return -EOPNOTSUPP; 1212 default: 1213 return -EOPNOTSUPP; 1214 } 1215 } 1216 1217 static int hns3_nway_reset(struct net_device *netdev) 1218 { 1219 struct hnae3_handle *handle = hns3_get_handle(netdev); 1220 const struct hnae3_ae_ops *ops = handle->ae_algo->ops; 1221 struct phy_device *phy = netdev->phydev; 1222 int autoneg; 1223 1224 if (!netif_running(netdev)) 1225 return 0; 1226 1227 if (hns3_nic_resetting(netdev)) { 1228 netdev_err(netdev, "dev resetting!"); 1229 return -EBUSY; 1230 } 1231 1232 if (!ops->get_autoneg || !ops->restart_autoneg) 1233 return -EOPNOTSUPP; 1234 1235 autoneg = ops->get_autoneg(handle); 1236 if (autoneg != AUTONEG_ENABLE) { 1237 netdev_err(netdev, 1238 "Autoneg is off, don't support to restart it\n"); 1239 return -EINVAL; 1240 } 1241 1242 netif_dbg(handle, drv, netdev, 1243 "nway reset (using %s)\n", phy ? "phy" : "mac"); 1244 1245 if (phy) 1246 return genphy_restart_aneg(phy); 1247 1248 return ops->restart_autoneg(handle); 1249 } 1250 1251 static void hns3_get_channels(struct net_device *netdev, 1252 struct ethtool_channels *ch) 1253 { 1254 struct hnae3_handle *h = hns3_get_handle(netdev); 1255 1256 if (h->ae_algo->ops->get_channels) 1257 h->ae_algo->ops->get_channels(h, ch); 1258 } 1259 1260 static int hns3_get_coalesce(struct net_device *netdev, 1261 struct ethtool_coalesce *cmd, 1262 struct kernel_ethtool_coalesce *kernel_coal, 1263 struct netlink_ext_ack *extack) 1264 { 1265 struct hns3_nic_priv *priv = netdev_priv(netdev); 1266 struct hns3_enet_coalesce *tx_coal = &priv->tx_coal; 1267 struct hns3_enet_coalesce *rx_coal = &priv->rx_coal; 1268 struct hnae3_handle *h = priv->ae_handle; 1269 1270 if (hns3_nic_resetting(netdev)) 1271 return -EBUSY; 1272 1273 cmd->use_adaptive_tx_coalesce = tx_coal->adapt_enable; 1274 cmd->use_adaptive_rx_coalesce = rx_coal->adapt_enable; 1275 1276 cmd->tx_coalesce_usecs = tx_coal->int_gl; 1277 cmd->rx_coalesce_usecs = rx_coal->int_gl; 1278 1279 cmd->tx_coalesce_usecs_high = h->kinfo.int_rl_setting; 1280 cmd->rx_coalesce_usecs_high = h->kinfo.int_rl_setting; 1281 1282 cmd->tx_max_coalesced_frames = tx_coal->int_ql; 1283 cmd->rx_max_coalesced_frames = rx_coal->int_ql; 1284 1285 kernel_coal->use_cqe_mode_tx = (priv->tx_cqe_mode == 1286 DIM_CQ_PERIOD_MODE_START_FROM_CQE); 1287 kernel_coal->use_cqe_mode_rx = (priv->rx_cqe_mode == 1288 DIM_CQ_PERIOD_MODE_START_FROM_CQE); 1289 1290 return 0; 1291 } 1292 1293 static int hns3_check_gl_coalesce_para(struct net_device *netdev, 1294 struct ethtool_coalesce *cmd) 1295 { 1296 struct hnae3_handle *handle = hns3_get_handle(netdev); 1297 struct hnae3_ae_dev *ae_dev = pci_get_drvdata(handle->pdev); 1298 u32 rx_gl, tx_gl; 1299 1300 if (cmd->rx_coalesce_usecs > ae_dev->dev_specs.max_int_gl) { 1301 netdev_err(netdev, 1302 "invalid rx-usecs value, rx-usecs range is 0-%u\n", 1303 ae_dev->dev_specs.max_int_gl); 1304 return -EINVAL; 1305 } 1306 1307 if (cmd->tx_coalesce_usecs > ae_dev->dev_specs.max_int_gl) { 1308 netdev_err(netdev, 1309 "invalid tx-usecs value, tx-usecs range is 0-%u\n", 1310 ae_dev->dev_specs.max_int_gl); 1311 return -EINVAL; 1312 } 1313 1314 /* device version above V3(include V3), GL uses 1us unit, 1315 * so the round down is not needed. 1316 */ 1317 if (ae_dev->dev_version >= HNAE3_DEVICE_VERSION_V3) 1318 return 0; 1319 1320 rx_gl = hns3_gl_round_down(cmd->rx_coalesce_usecs); 1321 if (rx_gl != cmd->rx_coalesce_usecs) { 1322 netdev_info(netdev, 1323 "rx_usecs(%u) rounded down to %u, because it must be multiple of 2.\n", 1324 cmd->rx_coalesce_usecs, rx_gl); 1325 } 1326 1327 tx_gl = hns3_gl_round_down(cmd->tx_coalesce_usecs); 1328 if (tx_gl != cmd->tx_coalesce_usecs) { 1329 netdev_info(netdev, 1330 "tx_usecs(%u) rounded down to %u, because it must be multiple of 2.\n", 1331 cmd->tx_coalesce_usecs, tx_gl); 1332 } 1333 1334 return 0; 1335 } 1336 1337 static int hns3_check_rl_coalesce_para(struct net_device *netdev, 1338 struct ethtool_coalesce *cmd) 1339 { 1340 u32 rl; 1341 1342 if (cmd->tx_coalesce_usecs_high != cmd->rx_coalesce_usecs_high) { 1343 netdev_err(netdev, 1344 "tx_usecs_high must be same as rx_usecs_high.\n"); 1345 return -EINVAL; 1346 } 1347 1348 if (cmd->rx_coalesce_usecs_high > HNS3_INT_RL_MAX) { 1349 netdev_err(netdev, 1350 "Invalid usecs_high value, usecs_high range is 0-%d\n", 1351 HNS3_INT_RL_MAX); 1352 return -EINVAL; 1353 } 1354 1355 rl = hns3_rl_round_down(cmd->rx_coalesce_usecs_high); 1356 if (rl != cmd->rx_coalesce_usecs_high) { 1357 netdev_info(netdev, 1358 "usecs_high(%u) rounded down to %u, because it must be multiple of 4.\n", 1359 cmd->rx_coalesce_usecs_high, rl); 1360 } 1361 1362 return 0; 1363 } 1364 1365 static int hns3_check_ql_coalesce_param(struct net_device *netdev, 1366 struct ethtool_coalesce *cmd) 1367 { 1368 struct hnae3_handle *handle = hns3_get_handle(netdev); 1369 struct hnae3_ae_dev *ae_dev = pci_get_drvdata(handle->pdev); 1370 1371 if ((cmd->tx_max_coalesced_frames || cmd->rx_max_coalesced_frames) && 1372 !ae_dev->dev_specs.int_ql_max) { 1373 netdev_err(netdev, "coalesced frames is not supported\n"); 1374 return -EOPNOTSUPP; 1375 } 1376 1377 if (cmd->tx_max_coalesced_frames > ae_dev->dev_specs.int_ql_max || 1378 cmd->rx_max_coalesced_frames > ae_dev->dev_specs.int_ql_max) { 1379 netdev_err(netdev, 1380 "invalid coalesced_frames value, range is 0-%u\n", 1381 ae_dev->dev_specs.int_ql_max); 1382 return -ERANGE; 1383 } 1384 1385 return 0; 1386 } 1387 1388 static int hns3_check_coalesce_para(struct net_device *netdev, 1389 struct ethtool_coalesce *cmd) 1390 { 1391 int ret; 1392 1393 ret = hns3_check_gl_coalesce_para(netdev, cmd); 1394 if (ret) { 1395 netdev_err(netdev, 1396 "Check gl coalesce param fail. ret = %d\n", ret); 1397 return ret; 1398 } 1399 1400 ret = hns3_check_rl_coalesce_para(netdev, cmd); 1401 if (ret) { 1402 netdev_err(netdev, 1403 "Check rl coalesce param fail. ret = %d\n", ret); 1404 return ret; 1405 } 1406 1407 return hns3_check_ql_coalesce_param(netdev, cmd); 1408 } 1409 1410 static void hns3_set_coalesce_per_queue(struct net_device *netdev, 1411 struct ethtool_coalesce *cmd, 1412 u32 queue) 1413 { 1414 struct hns3_enet_tqp_vector *tx_vector, *rx_vector; 1415 struct hns3_nic_priv *priv = netdev_priv(netdev); 1416 struct hnae3_handle *h = priv->ae_handle; 1417 int queue_num = h->kinfo.num_tqps; 1418 1419 tx_vector = priv->ring[queue].tqp_vector; 1420 rx_vector = priv->ring[queue_num + queue].tqp_vector; 1421 1422 tx_vector->tx_group.coal.adapt_enable = 1423 cmd->use_adaptive_tx_coalesce; 1424 rx_vector->rx_group.coal.adapt_enable = 1425 cmd->use_adaptive_rx_coalesce; 1426 1427 tx_vector->tx_group.coal.int_gl = cmd->tx_coalesce_usecs; 1428 rx_vector->rx_group.coal.int_gl = cmd->rx_coalesce_usecs; 1429 1430 tx_vector->tx_group.coal.int_ql = cmd->tx_max_coalesced_frames; 1431 rx_vector->rx_group.coal.int_ql = cmd->rx_max_coalesced_frames; 1432 1433 hns3_set_vector_coalesce_tx_gl(tx_vector, 1434 tx_vector->tx_group.coal.int_gl); 1435 hns3_set_vector_coalesce_rx_gl(rx_vector, 1436 rx_vector->rx_group.coal.int_gl); 1437 1438 hns3_set_vector_coalesce_rl(tx_vector, h->kinfo.int_rl_setting); 1439 hns3_set_vector_coalesce_rl(rx_vector, h->kinfo.int_rl_setting); 1440 1441 if (tx_vector->tx_group.coal.ql_enable) 1442 hns3_set_vector_coalesce_tx_ql(tx_vector, 1443 tx_vector->tx_group.coal.int_ql); 1444 if (rx_vector->rx_group.coal.ql_enable) 1445 hns3_set_vector_coalesce_rx_ql(rx_vector, 1446 rx_vector->rx_group.coal.int_ql); 1447 } 1448 1449 static int hns3_set_coalesce(struct net_device *netdev, 1450 struct ethtool_coalesce *cmd, 1451 struct kernel_ethtool_coalesce *kernel_coal, 1452 struct netlink_ext_ack *extack) 1453 { 1454 struct hnae3_handle *h = hns3_get_handle(netdev); 1455 struct hns3_nic_priv *priv = netdev_priv(netdev); 1456 struct hns3_enet_coalesce *tx_coal = &priv->tx_coal; 1457 struct hns3_enet_coalesce *rx_coal = &priv->rx_coal; 1458 u16 queue_num = h->kinfo.num_tqps; 1459 enum dim_cq_period_mode tx_mode; 1460 enum dim_cq_period_mode rx_mode; 1461 int ret; 1462 int i; 1463 1464 if (hns3_nic_resetting(netdev)) 1465 return -EBUSY; 1466 1467 ret = hns3_check_coalesce_para(netdev, cmd); 1468 if (ret) 1469 return ret; 1470 1471 h->kinfo.int_rl_setting = 1472 hns3_rl_round_down(cmd->rx_coalesce_usecs_high); 1473 1474 tx_coal->adapt_enable = cmd->use_adaptive_tx_coalesce; 1475 rx_coal->adapt_enable = cmd->use_adaptive_rx_coalesce; 1476 1477 tx_coal->int_gl = cmd->tx_coalesce_usecs; 1478 rx_coal->int_gl = cmd->rx_coalesce_usecs; 1479 1480 tx_coal->int_ql = cmd->tx_max_coalesced_frames; 1481 rx_coal->int_ql = cmd->rx_max_coalesced_frames; 1482 1483 for (i = 0; i < queue_num; i++) 1484 hns3_set_coalesce_per_queue(netdev, cmd, i); 1485 1486 tx_mode = kernel_coal->use_cqe_mode_tx ? 1487 DIM_CQ_PERIOD_MODE_START_FROM_CQE : 1488 DIM_CQ_PERIOD_MODE_START_FROM_EQE; 1489 rx_mode = kernel_coal->use_cqe_mode_rx ? 1490 DIM_CQ_PERIOD_MODE_START_FROM_CQE : 1491 DIM_CQ_PERIOD_MODE_START_FROM_EQE; 1492 hns3_cq_period_mode_init(priv, tx_mode, rx_mode); 1493 1494 return 0; 1495 } 1496 1497 static int hns3_get_regs_len(struct net_device *netdev) 1498 { 1499 struct hnae3_handle *h = hns3_get_handle(netdev); 1500 1501 if (!h->ae_algo->ops->get_regs_len) 1502 return -EOPNOTSUPP; 1503 1504 return h->ae_algo->ops->get_regs_len(h); 1505 } 1506 1507 static void hns3_get_regs(struct net_device *netdev, 1508 struct ethtool_regs *cmd, void *data) 1509 { 1510 struct hnae3_handle *h = hns3_get_handle(netdev); 1511 1512 if (!h->ae_algo->ops->get_regs) 1513 return; 1514 1515 h->ae_algo->ops->get_regs(h, &cmd->version, data); 1516 } 1517 1518 static int hns3_set_phys_id(struct net_device *netdev, 1519 enum ethtool_phys_id_state state) 1520 { 1521 struct hnae3_handle *h = hns3_get_handle(netdev); 1522 1523 if (!h->ae_algo->ops->set_led_id) 1524 return -EOPNOTSUPP; 1525 1526 return h->ae_algo->ops->set_led_id(h, state); 1527 } 1528 1529 static u32 hns3_get_msglevel(struct net_device *netdev) 1530 { 1531 struct hnae3_handle *h = hns3_get_handle(netdev); 1532 1533 return h->msg_enable; 1534 } 1535 1536 static void hns3_set_msglevel(struct net_device *netdev, u32 msg_level) 1537 { 1538 struct hnae3_handle *h = hns3_get_handle(netdev); 1539 1540 h->msg_enable = msg_level; 1541 } 1542 1543 /* Translate local fec value into ethtool value. */ 1544 static unsigned int loc_to_eth_fec(u8 loc_fec) 1545 { 1546 u32 eth_fec = 0; 1547 1548 if (loc_fec & BIT(HNAE3_FEC_AUTO)) 1549 eth_fec |= ETHTOOL_FEC_AUTO; 1550 if (loc_fec & BIT(HNAE3_FEC_RS)) 1551 eth_fec |= ETHTOOL_FEC_RS; 1552 if (loc_fec & BIT(HNAE3_FEC_BASER)) 1553 eth_fec |= ETHTOOL_FEC_BASER; 1554 1555 /* if nothing is set, then FEC is off */ 1556 if (!eth_fec) 1557 eth_fec = ETHTOOL_FEC_OFF; 1558 1559 return eth_fec; 1560 } 1561 1562 /* Translate ethtool fec value into local value. */ 1563 static unsigned int eth_to_loc_fec(unsigned int eth_fec) 1564 { 1565 u32 loc_fec = 0; 1566 1567 if (eth_fec & ETHTOOL_FEC_OFF) 1568 return loc_fec; 1569 1570 if (eth_fec & ETHTOOL_FEC_AUTO) 1571 loc_fec |= BIT(HNAE3_FEC_AUTO); 1572 if (eth_fec & ETHTOOL_FEC_RS) 1573 loc_fec |= BIT(HNAE3_FEC_RS); 1574 if (eth_fec & ETHTOOL_FEC_BASER) 1575 loc_fec |= BIT(HNAE3_FEC_BASER); 1576 1577 return loc_fec; 1578 } 1579 1580 static int hns3_get_fecparam(struct net_device *netdev, 1581 struct ethtool_fecparam *fec) 1582 { 1583 struct hnae3_handle *handle = hns3_get_handle(netdev); 1584 struct hnae3_ae_dev *ae_dev = pci_get_drvdata(handle->pdev); 1585 const struct hnae3_ae_ops *ops = handle->ae_algo->ops; 1586 u8 fec_ability; 1587 u8 fec_mode; 1588 1589 if (!test_bit(HNAE3_DEV_SUPPORT_FEC_B, ae_dev->caps)) 1590 return -EOPNOTSUPP; 1591 1592 if (!ops->get_fec) 1593 return -EOPNOTSUPP; 1594 1595 ops->get_fec(handle, &fec_ability, &fec_mode); 1596 1597 fec->fec = loc_to_eth_fec(fec_ability); 1598 fec->active_fec = loc_to_eth_fec(fec_mode); 1599 1600 return 0; 1601 } 1602 1603 static int hns3_set_fecparam(struct net_device *netdev, 1604 struct ethtool_fecparam *fec) 1605 { 1606 struct hnae3_handle *handle = hns3_get_handle(netdev); 1607 struct hnae3_ae_dev *ae_dev = pci_get_drvdata(handle->pdev); 1608 const struct hnae3_ae_ops *ops = handle->ae_algo->ops; 1609 u32 fec_mode; 1610 1611 if (!test_bit(HNAE3_DEV_SUPPORT_FEC_B, ae_dev->caps)) 1612 return -EOPNOTSUPP; 1613 1614 if (!ops->set_fec) 1615 return -EOPNOTSUPP; 1616 fec_mode = eth_to_loc_fec(fec->fec); 1617 1618 netif_dbg(handle, drv, netdev, "set fecparam: mode=%u\n", fec_mode); 1619 1620 return ops->set_fec(handle, fec_mode); 1621 } 1622 1623 static int hns3_get_module_info(struct net_device *netdev, 1624 struct ethtool_modinfo *modinfo) 1625 { 1626 #define HNS3_SFF_8636_V1_3 0x03 1627 1628 struct hnae3_handle *handle = hns3_get_handle(netdev); 1629 struct hnae3_ae_dev *ae_dev = pci_get_drvdata(handle->pdev); 1630 const struct hnae3_ae_ops *ops = handle->ae_algo->ops; 1631 struct hns3_sfp_type sfp_type; 1632 int ret; 1633 1634 if (ae_dev->dev_version < HNAE3_DEVICE_VERSION_V2 || 1635 !ops->get_module_eeprom) 1636 return -EOPNOTSUPP; 1637 1638 memset(&sfp_type, 0, sizeof(sfp_type)); 1639 ret = ops->get_module_eeprom(handle, 0, sizeof(sfp_type) / sizeof(u8), 1640 (u8 *)&sfp_type); 1641 if (ret) 1642 return ret; 1643 1644 switch (sfp_type.type) { 1645 case SFF8024_ID_SFP: 1646 modinfo->type = ETH_MODULE_SFF_8472; 1647 modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN; 1648 break; 1649 case SFF8024_ID_QSFP_8438: 1650 modinfo->type = ETH_MODULE_SFF_8436; 1651 modinfo->eeprom_len = ETH_MODULE_SFF_8436_MAX_LEN; 1652 break; 1653 case SFF8024_ID_QSFP_8436_8636: 1654 if (sfp_type.ext_type < HNS3_SFF_8636_V1_3) { 1655 modinfo->type = ETH_MODULE_SFF_8436; 1656 modinfo->eeprom_len = ETH_MODULE_SFF_8436_MAX_LEN; 1657 } else { 1658 modinfo->type = ETH_MODULE_SFF_8636; 1659 modinfo->eeprom_len = ETH_MODULE_SFF_8636_MAX_LEN; 1660 } 1661 break; 1662 case SFF8024_ID_QSFP28_8636: 1663 modinfo->type = ETH_MODULE_SFF_8636; 1664 modinfo->eeprom_len = ETH_MODULE_SFF_8636_MAX_LEN; 1665 break; 1666 default: 1667 netdev_err(netdev, "Optical module unknown: %#x\n", 1668 sfp_type.type); 1669 return -EINVAL; 1670 } 1671 1672 return 0; 1673 } 1674 1675 static int hns3_get_module_eeprom(struct net_device *netdev, 1676 struct ethtool_eeprom *ee, u8 *data) 1677 { 1678 struct hnae3_handle *handle = hns3_get_handle(netdev); 1679 struct hnae3_ae_dev *ae_dev = pci_get_drvdata(handle->pdev); 1680 const struct hnae3_ae_ops *ops = handle->ae_algo->ops; 1681 1682 if (ae_dev->dev_version < HNAE3_DEVICE_VERSION_V2 || 1683 !ops->get_module_eeprom) 1684 return -EOPNOTSUPP; 1685 1686 if (!ee->len) 1687 return -EINVAL; 1688 1689 memset(data, 0, ee->len); 1690 1691 return ops->get_module_eeprom(handle, ee->offset, ee->len, data); 1692 } 1693 1694 static u32 hns3_get_priv_flags(struct net_device *netdev) 1695 { 1696 struct hnae3_handle *handle = hns3_get_handle(netdev); 1697 1698 return handle->priv_flags; 1699 } 1700 1701 static int hns3_check_priv_flags(struct hnae3_handle *h, u32 changed) 1702 { 1703 u32 i; 1704 1705 for (i = 0; i < HNAE3_PFLAG_MAX; i++) 1706 if ((changed & BIT(i)) && !test_bit(i, &h->supported_pflags)) { 1707 netdev_err(h->netdev, "%s is unsupported\n", 1708 hns3_priv_flags[i].name); 1709 return -EOPNOTSUPP; 1710 } 1711 1712 return 0; 1713 } 1714 1715 static int hns3_set_priv_flags(struct net_device *netdev, u32 pflags) 1716 { 1717 struct hnae3_handle *handle = hns3_get_handle(netdev); 1718 u32 changed = pflags ^ handle->priv_flags; 1719 int ret; 1720 u32 i; 1721 1722 ret = hns3_check_priv_flags(handle, changed); 1723 if (ret) 1724 return ret; 1725 1726 for (i = 0; i < HNAE3_PFLAG_MAX; i++) { 1727 if (changed & BIT(i)) { 1728 bool enable = !(handle->priv_flags & BIT(i)); 1729 1730 if (enable) 1731 handle->priv_flags |= BIT(i); 1732 else 1733 handle->priv_flags &= ~BIT(i); 1734 hns3_priv_flags[i].handler(netdev, enable); 1735 } 1736 } 1737 1738 return 0; 1739 } 1740 1741 static int hns3_get_tunable(struct net_device *netdev, 1742 const struct ethtool_tunable *tuna, 1743 void *data) 1744 { 1745 struct hns3_nic_priv *priv = netdev_priv(netdev); 1746 struct hnae3_handle *h = priv->ae_handle; 1747 int ret = 0; 1748 1749 switch (tuna->id) { 1750 case ETHTOOL_TX_COPYBREAK: 1751 /* all the tx rings have the same tx_copybreak */ 1752 *(u32 *)data = priv->tx_copybreak; 1753 break; 1754 case ETHTOOL_RX_COPYBREAK: 1755 *(u32 *)data = priv->rx_copybreak; 1756 break; 1757 case ETHTOOL_TX_COPYBREAK_BUF_SIZE: 1758 *(u32 *)data = h->kinfo.tx_spare_buf_size; 1759 break; 1760 default: 1761 ret = -EOPNOTSUPP; 1762 break; 1763 } 1764 1765 return ret; 1766 } 1767 1768 static int hns3_set_tx_spare_buf_size(struct net_device *netdev, 1769 u32 data) 1770 { 1771 struct hns3_nic_priv *priv = netdev_priv(netdev); 1772 struct hnae3_handle *h = priv->ae_handle; 1773 int ret; 1774 1775 h->kinfo.tx_spare_buf_size = data; 1776 1777 ret = hns3_reset_notify(h, HNAE3_DOWN_CLIENT); 1778 if (ret) 1779 return ret; 1780 1781 ret = hns3_reset_notify(h, HNAE3_UNINIT_CLIENT); 1782 if (ret) 1783 return ret; 1784 1785 ret = hns3_reset_notify(h, HNAE3_INIT_CLIENT); 1786 if (ret) 1787 return ret; 1788 1789 ret = hns3_reset_notify(h, HNAE3_UP_CLIENT); 1790 if (ret) 1791 hns3_reset_notify(h, HNAE3_UNINIT_CLIENT); 1792 1793 return ret; 1794 } 1795 1796 static int hns3_set_tunable(struct net_device *netdev, 1797 const struct ethtool_tunable *tuna, 1798 const void *data) 1799 { 1800 struct hns3_nic_priv *priv = netdev_priv(netdev); 1801 u32 old_tx_spare_buf_size, new_tx_spare_buf_size; 1802 struct hnae3_handle *h = priv->ae_handle; 1803 int i, ret = 0; 1804 1805 if (hns3_nic_resetting(netdev) || !priv->ring) { 1806 netdev_err(netdev, "failed to set tunable value, dev resetting!"); 1807 return -EBUSY; 1808 } 1809 1810 switch (tuna->id) { 1811 case ETHTOOL_TX_COPYBREAK: 1812 priv->tx_copybreak = *(u32 *)data; 1813 1814 for (i = 0; i < h->kinfo.num_tqps; i++) 1815 priv->ring[i].tx_copybreak = priv->tx_copybreak; 1816 1817 break; 1818 case ETHTOOL_RX_COPYBREAK: 1819 priv->rx_copybreak = *(u32 *)data; 1820 1821 for (i = h->kinfo.num_tqps; i < h->kinfo.num_tqps * 2; i++) 1822 priv->ring[i].rx_copybreak = priv->rx_copybreak; 1823 1824 break; 1825 case ETHTOOL_TX_COPYBREAK_BUF_SIZE: 1826 old_tx_spare_buf_size = h->kinfo.tx_spare_buf_size; 1827 new_tx_spare_buf_size = *(u32 *)data; 1828 ret = hns3_set_tx_spare_buf_size(netdev, new_tx_spare_buf_size); 1829 if (ret || 1830 (!priv->ring->tx_spare && new_tx_spare_buf_size != 0)) { 1831 int ret1; 1832 1833 netdev_warn(netdev, 1834 "change tx spare buf size fail, revert to old value\n"); 1835 ret1 = hns3_set_tx_spare_buf_size(netdev, 1836 old_tx_spare_buf_size); 1837 if (ret1) { 1838 netdev_err(netdev, 1839 "revert to old tx spare buf size fail\n"); 1840 return ret1; 1841 } 1842 1843 return ret; 1844 } 1845 break; 1846 default: 1847 ret = -EOPNOTSUPP; 1848 break; 1849 } 1850 1851 return ret; 1852 } 1853 1854 #define HNS3_ETHTOOL_COALESCE (ETHTOOL_COALESCE_USECS | \ 1855 ETHTOOL_COALESCE_USE_ADAPTIVE | \ 1856 ETHTOOL_COALESCE_RX_USECS_HIGH | \ 1857 ETHTOOL_COALESCE_TX_USECS_HIGH | \ 1858 ETHTOOL_COALESCE_MAX_FRAMES | \ 1859 ETHTOOL_COALESCE_USE_CQE) 1860 1861 #define HNS3_ETHTOOL_RING ETHTOOL_RING_USE_RX_BUF_LEN 1862 1863 static int hns3_get_ts_info(struct net_device *netdev, 1864 struct ethtool_ts_info *info) 1865 { 1866 struct hnae3_handle *handle = hns3_get_handle(netdev); 1867 1868 if (handle->ae_algo->ops->get_ts_info) 1869 return handle->ae_algo->ops->get_ts_info(handle, info); 1870 1871 return ethtool_op_get_ts_info(netdev, info); 1872 } 1873 1874 static const struct hns3_ethtool_link_ext_state_mapping 1875 hns3_link_ext_state_map[] = { 1876 {1, ETHTOOL_LINK_EXT_STATE_AUTONEG, 1877 ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_HCD}, 1878 {2, ETHTOOL_LINK_EXT_STATE_AUTONEG, 1879 ETHTOOL_LINK_EXT_SUBSTATE_AN_ACK_NOT_RECEIVED}, 1880 1881 {256, ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE, 1882 ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_LINK_INHIBIT_TIMEOUT}, 1883 {257, ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE, 1884 ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_LINK_PARTNER_DID_NOT_SET_RECEIVER_READY}, 1885 {512, ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE, 1886 ETHTOOL_LINK_EXT_SUBSTATE_LT_REMOTE_FAULT}, 1887 1888 {513, ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH, 1889 ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_ACQUIRE_BLOCK_LOCK}, 1890 {514, ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH, 1891 ETHTOOL_LINK_EXT_SUBSTATE_LLM_FC_FEC_IS_NOT_LOCKED}, 1892 {515, ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH, 1893 ETHTOOL_LINK_EXT_SUBSTATE_LLM_RS_FEC_IS_NOT_LOCKED}, 1894 1895 {768, ETHTOOL_LINK_EXT_STATE_BAD_SIGNAL_INTEGRITY, 1896 ETHTOOL_LINK_EXT_SUBSTATE_BSI_LARGE_NUMBER_OF_PHYSICAL_ERRORS}, 1897 {769, ETHTOOL_LINK_EXT_STATE_BAD_SIGNAL_INTEGRITY, 1898 ETHTOOL_LINK_EXT_SUBSTATE_BSI_SERDES_REFERENCE_CLOCK_LOST}, 1899 {770, ETHTOOL_LINK_EXT_STATE_BAD_SIGNAL_INTEGRITY, 1900 ETHTOOL_LINK_EXT_SUBSTATE_BSI_SERDES_ALOS}, 1901 1902 {1024, ETHTOOL_LINK_EXT_STATE_NO_CABLE, 0}, 1903 {1025, ETHTOOL_LINK_EXT_STATE_CABLE_ISSUE, 1904 ETHTOOL_LINK_EXT_SUBSTATE_CI_UNSUPPORTED_CABLE}, 1905 1906 {1026, ETHTOOL_LINK_EXT_STATE_EEPROM_ISSUE, 0}, 1907 }; 1908 1909 static int hns3_get_link_ext_state(struct net_device *netdev, 1910 struct ethtool_link_ext_state_info *info) 1911 { 1912 const struct hns3_ethtool_link_ext_state_mapping *map; 1913 struct hnae3_handle *h = hns3_get_handle(netdev); 1914 u32 status_code, i; 1915 int ret; 1916 1917 if (netif_carrier_ok(netdev)) 1918 return -ENODATA; 1919 1920 if (!h->ae_algo->ops->get_link_diagnosis_info) 1921 return -EOPNOTSUPP; 1922 1923 ret = h->ae_algo->ops->get_link_diagnosis_info(h, &status_code); 1924 if (ret) 1925 return ret; 1926 1927 for (i = 0; i < ARRAY_SIZE(hns3_link_ext_state_map); i++) { 1928 map = &hns3_link_ext_state_map[i]; 1929 if (map->status_code == status_code) { 1930 info->link_ext_state = map->link_ext_state; 1931 info->__link_ext_substate = map->link_ext_substate; 1932 return 0; 1933 } 1934 } 1935 1936 return -ENODATA; 1937 } 1938 1939 static const struct ethtool_ops hns3vf_ethtool_ops = { 1940 .supported_coalesce_params = HNS3_ETHTOOL_COALESCE, 1941 .supported_ring_params = HNS3_ETHTOOL_RING, 1942 .get_drvinfo = hns3_get_drvinfo, 1943 .get_ringparam = hns3_get_ringparam, 1944 .set_ringparam = hns3_set_ringparam, 1945 .get_strings = hns3_get_strings, 1946 .get_ethtool_stats = hns3_get_stats, 1947 .get_sset_count = hns3_get_sset_count, 1948 .get_rxnfc = hns3_get_rxnfc, 1949 .set_rxnfc = hns3_set_rxnfc, 1950 .get_rxfh_key_size = hns3_get_rss_key_size, 1951 .get_rxfh_indir_size = hns3_get_rss_indir_size, 1952 .get_rxfh = hns3_get_rss, 1953 .set_rxfh = hns3_set_rss, 1954 .get_link_ksettings = hns3_get_link_ksettings, 1955 .get_channels = hns3_get_channels, 1956 .set_channels = hns3_set_channels, 1957 .get_coalesce = hns3_get_coalesce, 1958 .set_coalesce = hns3_set_coalesce, 1959 .get_regs_len = hns3_get_regs_len, 1960 .get_regs = hns3_get_regs, 1961 .get_link = hns3_get_link, 1962 .get_msglevel = hns3_get_msglevel, 1963 .set_msglevel = hns3_set_msglevel, 1964 .get_priv_flags = hns3_get_priv_flags, 1965 .set_priv_flags = hns3_set_priv_flags, 1966 .get_tunable = hns3_get_tunable, 1967 .set_tunable = hns3_set_tunable, 1968 .reset = hns3_set_reset, 1969 }; 1970 1971 static const struct ethtool_ops hns3_ethtool_ops = { 1972 .supported_coalesce_params = HNS3_ETHTOOL_COALESCE, 1973 .supported_ring_params = HNS3_ETHTOOL_RING, 1974 .self_test = hns3_self_test, 1975 .get_drvinfo = hns3_get_drvinfo, 1976 .get_link = hns3_get_link, 1977 .get_ringparam = hns3_get_ringparam, 1978 .set_ringparam = hns3_set_ringparam, 1979 .get_pauseparam = hns3_get_pauseparam, 1980 .set_pauseparam = hns3_set_pauseparam, 1981 .get_strings = hns3_get_strings, 1982 .get_ethtool_stats = hns3_get_stats, 1983 .get_sset_count = hns3_get_sset_count, 1984 .get_rxnfc = hns3_get_rxnfc, 1985 .set_rxnfc = hns3_set_rxnfc, 1986 .get_rxfh_key_size = hns3_get_rss_key_size, 1987 .get_rxfh_indir_size = hns3_get_rss_indir_size, 1988 .get_rxfh = hns3_get_rss, 1989 .set_rxfh = hns3_set_rss, 1990 .get_link_ksettings = hns3_get_link_ksettings, 1991 .set_link_ksettings = hns3_set_link_ksettings, 1992 .nway_reset = hns3_nway_reset, 1993 .get_channels = hns3_get_channels, 1994 .set_channels = hns3_set_channels, 1995 .get_coalesce = hns3_get_coalesce, 1996 .set_coalesce = hns3_set_coalesce, 1997 .get_regs_len = hns3_get_regs_len, 1998 .get_regs = hns3_get_regs, 1999 .set_phys_id = hns3_set_phys_id, 2000 .get_msglevel = hns3_get_msglevel, 2001 .set_msglevel = hns3_set_msglevel, 2002 .get_fecparam = hns3_get_fecparam, 2003 .set_fecparam = hns3_set_fecparam, 2004 .get_module_info = hns3_get_module_info, 2005 .get_module_eeprom = hns3_get_module_eeprom, 2006 .get_priv_flags = hns3_get_priv_flags, 2007 .set_priv_flags = hns3_set_priv_flags, 2008 .get_ts_info = hns3_get_ts_info, 2009 .get_tunable = hns3_get_tunable, 2010 .set_tunable = hns3_set_tunable, 2011 .reset = hns3_set_reset, 2012 .get_link_ext_state = hns3_get_link_ext_state, 2013 }; 2014 2015 void hns3_ethtool_set_ops(struct net_device *netdev) 2016 { 2017 struct hnae3_handle *h = hns3_get_handle(netdev); 2018 2019 if (h->flags & HNAE3_SUPPORT_VF) 2020 netdev->ethtool_ops = &hns3vf_ethtool_ops; 2021 else 2022 netdev->ethtool_ops = &hns3_ethtool_ops; 2023 } 2024