]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/net/ethernet/hisilicon/hns3/hns3pf/hns3_ethtool.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
net: hns3: Add mac loopback selftest support in hns3 driver
[mirror_ubuntu-bionic-kernel.git] / drivers / net / ethernet / hisilicon / hns3 / hns3pf / hns3_ethtool.c
1 /*
2 * Copyright (c) 2016~2017 Hisilicon Limited.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 */
9
10 #include <linux/etherdevice.h>
11 #include <linux/string.h>
12
13 #include "hns3_enet.h"
14
15 struct hns3_stats {
16 char stats_string[ETH_GSTRING_LEN];
17 int stats_size;
18 int stats_offset;
19 };
20
21 /* tqp related stats */
22 #define HNS3_TQP_STAT(_string, _member) { \
23 .stats_string = _string, \
24 .stats_size = FIELD_SIZEOF(struct ring_stats, _member), \
25 .stats_offset = offsetof(struct hns3_enet_ring, stats), \
26 } \
27
28 static const struct hns3_stats hns3_txq_stats[] = {
29 /* Tx per-queue statistics */
30 HNS3_TQP_STAT("tx_io_err_cnt", io_err_cnt),
31 HNS3_TQP_STAT("tx_sw_err_cnt", sw_err_cnt),
32 HNS3_TQP_STAT("tx_seg_pkt_cnt", seg_pkt_cnt),
33 HNS3_TQP_STAT("tx_pkts", tx_pkts),
34 HNS3_TQP_STAT("tx_bytes", tx_bytes),
35 HNS3_TQP_STAT("tx_err_cnt", tx_err_cnt),
36 HNS3_TQP_STAT("tx_restart_queue", restart_queue),
37 HNS3_TQP_STAT("tx_busy", tx_busy),
38 };
39
40 #define HNS3_TXQ_STATS_COUNT ARRAY_SIZE(hns3_txq_stats)
41
42 static const struct hns3_stats hns3_rxq_stats[] = {
43 /* Rx per-queue statistics */
44 HNS3_TQP_STAT("rx_io_err_cnt", io_err_cnt),
45 HNS3_TQP_STAT("rx_sw_err_cnt", sw_err_cnt),
46 HNS3_TQP_STAT("rx_seg_pkt_cnt", seg_pkt_cnt),
47 HNS3_TQP_STAT("rx_pkts", rx_pkts),
48 HNS3_TQP_STAT("rx_bytes", rx_bytes),
49 HNS3_TQP_STAT("rx_err_cnt", rx_err_cnt),
50 HNS3_TQP_STAT("rx_reuse_pg_cnt", reuse_pg_cnt),
51 HNS3_TQP_STAT("rx_err_pkt_len", err_pkt_len),
52 HNS3_TQP_STAT("rx_non_vld_descs", non_vld_descs),
53 HNS3_TQP_STAT("rx_err_bd_num", err_bd_num),
54 HNS3_TQP_STAT("rx_l2_err", l2_err),
55 HNS3_TQP_STAT("rx_l3l4_csum_err", l3l4_csum_err),
56 };
57
58 #define HNS3_RXQ_STATS_COUNT ARRAY_SIZE(hns3_rxq_stats)
59
60 #define HNS3_TQP_STATS_COUNT (HNS3_TXQ_STATS_COUNT + HNS3_RXQ_STATS_COUNT)
61
62 #define HNS3_SELF_TEST_TPYE_NUM 1
63 #define HNS3_NIC_LB_TEST_PKT_NUM 1
64 #define HNS3_NIC_LB_TEST_RING_ID 0
65 #define HNS3_NIC_LB_TEST_PACKET_SIZE 128
66
67 /* Nic loopback test err */
68 #define HNS3_NIC_LB_TEST_NO_MEM_ERR 1
69 #define HNS3_NIC_LB_TEST_TX_CNT_ERR 2
70 #define HNS3_NIC_LB_TEST_RX_CNT_ERR 3
71
72 struct hns3_link_mode_mapping {
73 u32 hns3_link_mode;
74 u32 ethtool_link_mode;
75 };
76
77 static const struct hns3_link_mode_mapping hns3_lm_map[] = {
78 {HNS3_LM_FIBRE_BIT, ETHTOOL_LINK_MODE_FIBRE_BIT},
79 {HNS3_LM_AUTONEG_BIT, ETHTOOL_LINK_MODE_Autoneg_BIT},
80 {HNS3_LM_TP_BIT, ETHTOOL_LINK_MODE_TP_BIT},
81 {HNS3_LM_PAUSE_BIT, ETHTOOL_LINK_MODE_Pause_BIT},
82 {HNS3_LM_BACKPLANE_BIT, ETHTOOL_LINK_MODE_Backplane_BIT},
83 {HNS3_LM_10BASET_HALF_BIT, ETHTOOL_LINK_MODE_10baseT_Half_BIT},
84 {HNS3_LM_10BASET_FULL_BIT, ETHTOOL_LINK_MODE_10baseT_Full_BIT},
85 {HNS3_LM_100BASET_HALF_BIT, ETHTOOL_LINK_MODE_100baseT_Half_BIT},
86 {HNS3_LM_100BASET_FULL_BIT, ETHTOOL_LINK_MODE_100baseT_Full_BIT},
87 {HNS3_LM_1000BASET_FULL_BIT, ETHTOOL_LINK_MODE_1000baseT_Full_BIT},
88 };
89
90 static int hns3_lp_setup(struct net_device *ndev, enum hnae3_loop loop)
91 {
92 struct hnae3_handle *h = hns3_get_handle(ndev);
93 int ret;
94
95 if (!h->ae_algo->ops->set_loopback ||
96 !h->ae_algo->ops->set_promisc_mode)
97 return -EOPNOTSUPP;
98
99 switch (loop) {
100 case HNAE3_MAC_INTER_LOOP_MAC:
101 ret = h->ae_algo->ops->set_loopback(h, loop, true);
102 break;
103 case HNAE3_MAC_LOOP_NONE:
104 ret = h->ae_algo->ops->set_loopback(h,
105 HNAE3_MAC_INTER_LOOP_MAC, false);
106 break;
107 default:
108 ret = -ENOTSUPP;
109 break;
110 }
111
112 if (ret)
113 return ret;
114
115 if (loop == HNAE3_MAC_LOOP_NONE)
116 h->ae_algo->ops->set_promisc_mode(h, ndev->flags & IFF_PROMISC);
117 else
118 h->ae_algo->ops->set_promisc_mode(h, 1);
119
120 return ret;
121 }
122
123 static int hns3_lp_up(struct net_device *ndev, enum hnae3_loop loop_mode)
124 {
125 struct hnae3_handle *h = hns3_get_handle(ndev);
126 int ret;
127
128 if (!h->ae_algo->ops->start)
129 return -EOPNOTSUPP;
130
131 ret = h->ae_algo->ops->start(h);
132 if (ret) {
133 netdev_err(ndev,
134 "hns3_lb_up ae start return error: %d\n", ret);
135 return ret;
136 }
137
138 ret = hns3_lp_setup(ndev, loop_mode);
139 usleep_range(10000, 20000);
140
141 return ret;
142 }
143
144 static int hns3_lp_down(struct net_device *ndev)
145 {
146 struct hnae3_handle *h = hns3_get_handle(ndev);
147 int ret;
148
149 if (!h->ae_algo->ops->stop)
150 return -EOPNOTSUPP;
151
152 ret = hns3_lp_setup(ndev, HNAE3_MAC_LOOP_NONE);
153 if (ret) {
154 netdev_err(ndev, "lb_setup return error: %d\n", ret);
155 return ret;
156 }
157
158 h->ae_algo->ops->stop(h);
159 usleep_range(10000, 20000);
160
161 return 0;
162 }
163
164 static void hns3_lp_setup_skb(struct sk_buff *skb)
165 {
166 struct net_device *ndev = skb->dev;
167 unsigned char *packet;
168 struct ethhdr *ethh;
169 unsigned int i;
170
171 skb_reserve(skb, NET_IP_ALIGN);
172 ethh = skb_put(skb, sizeof(struct ethhdr));
173 packet = skb_put(skb, HNS3_NIC_LB_TEST_PACKET_SIZE);
174
175 memcpy(ethh->h_dest, ndev->dev_addr, ETH_ALEN);
176 eth_zero_addr(ethh->h_source);
177 ethh->h_proto = htons(ETH_P_ARP);
178 skb_reset_mac_header(skb);
179
180 for (i = 0; i < HNS3_NIC_LB_TEST_PACKET_SIZE; i++)
181 packet[i] = (unsigned char)(i & 0xff);
182 }
183
184 static void hns3_lb_check_skb_data(struct hns3_enet_ring *ring,
185 struct sk_buff *skb)
186 {
187 struct hns3_enet_tqp_vector *tqp_vector = ring->tqp_vector;
188 unsigned char *packet = skb->data;
189 u32 i;
190
191 for (i = 0; i < skb->len; i++)
192 if (packet[i] != (unsigned char)(i & 0xff))
193 break;
194
195 /* The packet is correctly received */
196 if (i == skb->len)
197 tqp_vector->rx_group.total_packets++;
198 else
199 print_hex_dump(KERN_ERR, "selftest:", DUMP_PREFIX_OFFSET, 16, 1,
200 skb->data, skb->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_data[i].ring;
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 hns3_clean_rx_ring(ring, budget, hns3_lb_check_skb_data);
221
222 rcv_good_pkt_total += (rx_group->total_packets - pre_rx_pkt);
223 rx_group->total_packets = pre_rx_pkt;
224 }
225 return rcv_good_pkt_total;
226 }
227
228 static void hns3_lb_clear_tx_ring(struct hns3_nic_priv *priv, u32 start_ringid,
229 u32 end_ringid, u32 budget)
230 {
231 u32 i;
232
233 for (i = start_ringid; i <= end_ringid; i++) {
234 struct hns3_enet_ring *ring = priv->ring_data[i].ring;
235
236 hns3_clean_tx_ring(ring, budget);
237 }
238 }
239
240 /**
241 * hns3_lp_run_test - run loopback test
242 * @ndev: net device
243 * @mode: loopback type
244 */
245 static int hns3_lp_run_test(struct net_device *ndev, enum hnae3_loop mode)
246 {
247 struct hns3_nic_priv *priv = netdev_priv(ndev);
248 struct sk_buff *skb;
249 u32 i, good_cnt;
250 int ret_val = 0;
251
252 skb = alloc_skb(HNS3_NIC_LB_TEST_PACKET_SIZE + ETH_HLEN + NET_IP_ALIGN,
253 GFP_KERNEL);
254 if (!skb)
255 return HNS3_NIC_LB_TEST_NO_MEM_ERR;
256
257 skb->dev = ndev;
258 hns3_lp_setup_skb(skb);
259 skb->queue_mapping = HNS3_NIC_LB_TEST_RING_ID;
260
261 good_cnt = 0;
262 for (i = 0; i < HNS3_NIC_LB_TEST_PKT_NUM; i++) {
263 netdev_tx_t tx_ret;
264
265 skb_get(skb);
266 tx_ret = hns3_nic_net_xmit(skb, ndev);
267 if (tx_ret == NETDEV_TX_OK)
268 good_cnt++;
269 else
270 netdev_err(ndev, "hns3_lb_run_test xmit failed: %d\n",
271 tx_ret);
272 }
273 if (good_cnt != HNS3_NIC_LB_TEST_PKT_NUM) {
274 ret_val = HNS3_NIC_LB_TEST_TX_CNT_ERR;
275 netdev_err(ndev, "mode %d sent fail, cnt=0x%x, budget=0x%x\n",
276 mode, good_cnt, HNS3_NIC_LB_TEST_PKT_NUM);
277 goto out;
278 }
279
280 /* Allow 200 milliseconds for packets to go from Tx to Rx */
281 msleep(200);
282
283 good_cnt = hns3_lb_check_rx_ring(priv, HNS3_NIC_LB_TEST_PKT_NUM);
284 if (good_cnt != HNS3_NIC_LB_TEST_PKT_NUM) {
285 ret_val = HNS3_NIC_LB_TEST_RX_CNT_ERR;
286 netdev_err(ndev, "mode %d recv fail, cnt=0x%x, budget=0x%x\n",
287 mode, good_cnt, HNS3_NIC_LB_TEST_PKT_NUM);
288 }
289
290 out:
291 hns3_lb_clear_tx_ring(priv, HNS3_NIC_LB_TEST_RING_ID,
292 HNS3_NIC_LB_TEST_RING_ID,
293 HNS3_NIC_LB_TEST_PKT_NUM);
294
295 kfree_skb(skb);
296 return ret_val;
297 }
298
299 /**
300 * hns3_nic_self_test - self test
301 * @ndev: net device
302 * @eth_test: test cmd
303 * @data: test result
304 */
305 static void hns3_self_test(struct net_device *ndev,
306 struct ethtool_test *eth_test, u64 *data)
307 {
308 struct hns3_nic_priv *priv = netdev_priv(ndev);
309 struct hnae3_handle *h = priv->ae_handle;
310 int st_param[HNS3_SELF_TEST_TPYE_NUM][2];
311 bool if_running = netif_running(ndev);
312 int test_index = 0;
313 u32 i;
314
315 /* Only do offline selftest, or pass by default */
316 if (eth_test->flags != ETH_TEST_FL_OFFLINE)
317 return;
318
319 st_param[HNAE3_MAC_INTER_LOOP_MAC][0] = HNAE3_MAC_INTER_LOOP_MAC;
320 st_param[HNAE3_MAC_INTER_LOOP_MAC][1] =
321 h->flags & HNAE3_SUPPORT_MAC_LOOPBACK;
322
323 if (if_running)
324 dev_close(ndev);
325
326 set_bit(HNS3_NIC_STATE_TESTING, &priv->state);
327
328 for (i = 0; i < HNS3_SELF_TEST_TPYE_NUM; i++) {
329 enum hnae3_loop loop_type = (enum hnae3_loop)st_param[i][0];
330
331 if (!st_param[i][1])
332 continue;
333
334 data[test_index] = hns3_lp_up(ndev, loop_type);
335 if (!data[test_index]) {
336 data[test_index] = hns3_lp_run_test(ndev, loop_type);
337 hns3_lp_down(ndev);
338 }
339
340 if (data[test_index])
341 eth_test->flags |= ETH_TEST_FL_FAILED;
342
343 test_index++;
344 }
345
346 clear_bit(HNS3_NIC_STATE_TESTING, &priv->state);
347
348 if (if_running)
349 dev_open(ndev);
350 }
351
352 static void hns3_driv_to_eth_caps(u32 caps, struct ethtool_link_ksettings *cmd,
353 bool is_advertised)
354 {
355 int i;
356
357 for (i = 0; i < ARRAY_SIZE(hns3_lm_map); i++) {
358 if (!(caps & hns3_lm_map[i].hns3_link_mode))
359 continue;
360
361 if (is_advertised) {
362 ethtool_link_ksettings_zero_link_mode(cmd,
363 advertising);
364 __set_bit(hns3_lm_map[i].ethtool_link_mode,
365 cmd->link_modes.advertising);
366 } else {
367 ethtool_link_ksettings_zero_link_mode(cmd,
368 supported);
369 __set_bit(hns3_lm_map[i].ethtool_link_mode,
370 cmd->link_modes.supported);
371 }
372 }
373 }
374
375 static int hns3_get_sset_count(struct net_device *netdev, int stringset)
376 {
377 struct hnae3_handle *h = hns3_get_handle(netdev);
378 const struct hnae3_ae_ops *ops = h->ae_algo->ops;
379
380 if (!ops->get_sset_count)
381 return -EOPNOTSUPP;
382
383 switch (stringset) {
384 case ETH_SS_STATS:
385 return ((HNS3_TQP_STATS_COUNT * h->kinfo.num_tqps) +
386 ops->get_sset_count(h, stringset));
387
388 case ETH_SS_TEST:
389 return ops->get_sset_count(h, stringset);
390 }
391
392 return 0;
393 }
394
395 static void *hns3_update_strings(u8 *data, const struct hns3_stats *stats,
396 u32 stat_count, u32 num_tqps)
397 {
398 #define MAX_PREFIX_SIZE (8 + 4)
399 u32 size_left;
400 u32 i, j;
401 u32 n1;
402
403 for (i = 0; i < num_tqps; i++) {
404 for (j = 0; j < stat_count; j++) {
405 data[ETH_GSTRING_LEN - 1] = '\0';
406
407 /* first, prepend the prefix string */
408 n1 = snprintf(data, MAX_PREFIX_SIZE, "rcb_q%d_", i);
409 n1 = min_t(uint, n1, MAX_PREFIX_SIZE - 1);
410 size_left = (ETH_GSTRING_LEN - 1) - n1;
411
412 /* now, concatenate the stats string to it */
413 strncat(data, stats[j].stats_string, size_left);
414 data += ETH_GSTRING_LEN;
415 }
416 }
417
418 return data;
419 }
420
421 static u8 *hns3_get_strings_tqps(struct hnae3_handle *handle, u8 *data)
422 {
423 struct hnae3_knic_private_info *kinfo = &handle->kinfo;
424
425 /* get strings for Tx */
426 data = hns3_update_strings(data, hns3_txq_stats, HNS3_TXQ_STATS_COUNT,
427 kinfo->num_tqps);
428
429 /* get strings for Rx */
430 data = hns3_update_strings(data, hns3_rxq_stats, HNS3_RXQ_STATS_COUNT,
431 kinfo->num_tqps);
432
433 return data;
434 }
435
436 static void hns3_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
437 {
438 struct hnae3_handle *h = hns3_get_handle(netdev);
439 const struct hnae3_ae_ops *ops = h->ae_algo->ops;
440 char *buff = (char *)data;
441
442 if (!ops->get_strings)
443 return;
444
445 switch (stringset) {
446 case ETH_SS_STATS:
447 buff = hns3_get_strings_tqps(h, buff);
448 h->ae_algo->ops->get_strings(h, stringset, (u8 *)buff);
449 break;
450 case ETH_SS_TEST:
451 ops->get_strings(h, stringset, data);
452 break;
453 }
454 }
455
456 static u64 *hns3_get_stats_tqps(struct hnae3_handle *handle, u64 *data)
457 {
458 struct hns3_nic_priv *nic_priv = (struct hns3_nic_priv *)handle->priv;
459 struct hnae3_knic_private_info *kinfo = &handle->kinfo;
460 struct hns3_enet_ring *ring;
461 u8 *stat;
462 u32 i;
463
464 /* get stats for Tx */
465 for (i = 0; i < kinfo->num_tqps; i++) {
466 ring = nic_priv->ring_data[i].ring;
467 for (i = 0; i < HNS3_TXQ_STATS_COUNT; i++) {
468 stat = (u8 *)ring + hns3_txq_stats[i].stats_offset;
469 *data++ = *(u64 *)stat;
470 }
471 }
472
473 /* get stats for Rx */
474 for (i = 0; i < kinfo->num_tqps; i++) {
475 ring = nic_priv->ring_data[i + kinfo->num_tqps].ring;
476 for (i = 0; i < HNS3_RXQ_STATS_COUNT; i++) {
477 stat = (u8 *)ring + hns3_rxq_stats[i].stats_offset;
478 *data++ = *(u64 *)stat;
479 }
480 }
481
482 return data;
483 }
484
485 /* hns3_get_stats - get detail statistics.
486 * @netdev: net device
487 * @stats: statistics info.
488 * @data: statistics data.
489 */
490 static void hns3_get_stats(struct net_device *netdev,
491 struct ethtool_stats *stats, u64 *data)
492 {
493 struct hnae3_handle *h = hns3_get_handle(netdev);
494 u64 *p = data;
495
496 if (!h->ae_algo->ops->get_stats || !h->ae_algo->ops->update_stats) {
497 netdev_err(netdev, "could not get any statistics\n");
498 return;
499 }
500
501 h->ae_algo->ops->update_stats(h, &netdev->stats);
502
503 /* get per-queue stats */
504 p = hns3_get_stats_tqps(h, p);
505
506 /* get MAC & other misc hardware stats */
507 h->ae_algo->ops->get_stats(h, p);
508 }
509
510 static void hns3_get_drvinfo(struct net_device *netdev,
511 struct ethtool_drvinfo *drvinfo)
512 {
513 struct hns3_nic_priv *priv = netdev_priv(netdev);
514 struct hnae3_handle *h = priv->ae_handle;
515
516 strncpy(drvinfo->version, hns3_driver_version,
517 sizeof(drvinfo->version));
518 drvinfo->version[sizeof(drvinfo->version) - 1] = '\0';
519
520 strncpy(drvinfo->driver, h->pdev->driver->name,
521 sizeof(drvinfo->driver));
522 drvinfo->driver[sizeof(drvinfo->driver) - 1] = '\0';
523
524 strncpy(drvinfo->bus_info, pci_name(h->pdev),
525 sizeof(drvinfo->bus_info));
526 drvinfo->bus_info[ETHTOOL_BUSINFO_LEN - 1] = '\0';
527
528 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), "0x%08x",
529 priv->ae_handle->ae_algo->ops->get_fw_version(h));
530 }
531
532 static u32 hns3_get_link(struct net_device *netdev)
533 {
534 struct hnae3_handle *h = hns3_get_handle(netdev);
535
536 if (h->ae_algo && h->ae_algo->ops && h->ae_algo->ops->get_status)
537 return h->ae_algo->ops->get_status(h);
538 else
539 return 0;
540 }
541
542 static void hns3_get_ringparam(struct net_device *netdev,
543 struct ethtool_ringparam *param)
544 {
545 struct hns3_nic_priv *priv = netdev_priv(netdev);
546 struct hnae3_handle *h = priv->ae_handle;
547 int queue_num = h->kinfo.num_tqps;
548
549 param->tx_max_pending = HNS3_RING_MAX_PENDING;
550 param->rx_max_pending = HNS3_RING_MAX_PENDING;
551
552 param->tx_pending = priv->ring_data[0].ring->desc_num;
553 param->rx_pending = priv->ring_data[queue_num].ring->desc_num;
554 }
555
556 static void hns3_get_pauseparam(struct net_device *netdev,
557 struct ethtool_pauseparam *param)
558 {
559 struct hnae3_handle *h = hns3_get_handle(netdev);
560
561 if (h->ae_algo && h->ae_algo->ops && h->ae_algo->ops->get_pauseparam)
562 h->ae_algo->ops->get_pauseparam(h, &param->autoneg,
563 &param->rx_pause, &param->tx_pause);
564 }
565
566 static int hns3_get_link_ksettings(struct net_device *netdev,
567 struct ethtool_link_ksettings *cmd)
568 {
569 struct hnae3_handle *h = hns3_get_handle(netdev);
570 u32 supported_caps;
571 u32 advertised_caps;
572 u8 media_type = HNAE3_MEDIA_TYPE_UNKNOWN;
573 u8 link_stat;
574 u8 auto_neg;
575 u8 duplex;
576 u32 speed;
577
578 if (!h->ae_algo || !h->ae_algo->ops)
579 return -EOPNOTSUPP;
580
581 /* 1.auto_neg & speed & duplex from cmd */
582 if (h->ae_algo->ops->get_ksettings_an_result) {
583 h->ae_algo->ops->get_ksettings_an_result(h, &auto_neg,
584 &speed, &duplex);
585 cmd->base.autoneg = auto_neg;
586 cmd->base.speed = speed;
587 cmd->base.duplex = duplex;
588
589 link_stat = hns3_get_link(netdev);
590 if (!link_stat) {
591 cmd->base.speed = (u32)SPEED_UNKNOWN;
592 cmd->base.duplex = DUPLEX_UNKNOWN;
593 }
594 }
595
596 /* 2.media_type get from bios parameter block */
597 if (h->ae_algo->ops->get_media_type) {
598 h->ae_algo->ops->get_media_type(h, &media_type);
599
600 switch (media_type) {
601 case HNAE3_MEDIA_TYPE_FIBER:
602 cmd->base.port = PORT_FIBRE;
603 supported_caps = HNS3_LM_FIBRE_BIT |
604 HNS3_LM_AUTONEG_BIT |
605 HNS3_LM_PAUSE_BIT |
606 HNS3_LM_1000BASET_FULL_BIT;
607
608 advertised_caps = supported_caps;
609 break;
610 case HNAE3_MEDIA_TYPE_COPPER:
611 cmd->base.port = PORT_TP;
612 supported_caps = HNS3_LM_TP_BIT |
613 HNS3_LM_AUTONEG_BIT |
614 HNS3_LM_PAUSE_BIT |
615 HNS3_LM_1000BASET_FULL_BIT |
616 HNS3_LM_100BASET_FULL_BIT |
617 HNS3_LM_100BASET_HALF_BIT |
618 HNS3_LM_10BASET_FULL_BIT |
619 HNS3_LM_10BASET_HALF_BIT;
620 advertised_caps = supported_caps;
621 break;
622 case HNAE3_MEDIA_TYPE_BACKPLANE:
623 cmd->base.port = PORT_NONE;
624 supported_caps = HNS3_LM_BACKPLANE_BIT |
625 HNS3_LM_PAUSE_BIT |
626 HNS3_LM_AUTONEG_BIT |
627 HNS3_LM_1000BASET_FULL_BIT |
628 HNS3_LM_100BASET_FULL_BIT |
629 HNS3_LM_100BASET_HALF_BIT |
630 HNS3_LM_10BASET_FULL_BIT |
631 HNS3_LM_10BASET_HALF_BIT;
632
633 advertised_caps = supported_caps;
634 break;
635 case HNAE3_MEDIA_TYPE_UNKNOWN:
636 default:
637 cmd->base.port = PORT_OTHER;
638 supported_caps = 0;
639 advertised_caps = 0;
640 break;
641 }
642
643 /* now, map driver link modes to ethtool link modes */
644 hns3_driv_to_eth_caps(supported_caps, cmd, false);
645 hns3_driv_to_eth_caps(advertised_caps, cmd, true);
646 }
647
648 /* 3.mdix_ctrl&mdix get from phy reg */
649 if (h->ae_algo->ops->get_mdix_mode)
650 h->ae_algo->ops->get_mdix_mode(h, &cmd->base.eth_tp_mdix_ctrl,
651 &cmd->base.eth_tp_mdix);
652 /* 4.mdio_support */
653 cmd->base.mdio_support = ETH_MDIO_SUPPORTS_C22;
654
655 return 0;
656 }
657
658 static u32 hns3_get_rss_key_size(struct net_device *netdev)
659 {
660 struct hnae3_handle *h = hns3_get_handle(netdev);
661
662 if (!h->ae_algo || !h->ae_algo->ops ||
663 !h->ae_algo->ops->get_rss_key_size)
664 return -EOPNOTSUPP;
665
666 return h->ae_algo->ops->get_rss_key_size(h);
667 }
668
669 static u32 hns3_get_rss_indir_size(struct net_device *netdev)
670 {
671 struct hnae3_handle *h = hns3_get_handle(netdev);
672
673 if (!h->ae_algo || !h->ae_algo->ops ||
674 !h->ae_algo->ops->get_rss_indir_size)
675 return -EOPNOTSUPP;
676
677 return h->ae_algo->ops->get_rss_indir_size(h);
678 }
679
680 static int hns3_get_rss(struct net_device *netdev, u32 *indir, u8 *key,
681 u8 *hfunc)
682 {
683 struct hnae3_handle *h = hns3_get_handle(netdev);
684
685 if (!h->ae_algo || !h->ae_algo->ops || !h->ae_algo->ops->get_rss)
686 return -EOPNOTSUPP;
687
688 return h->ae_algo->ops->get_rss(h, indir, key, hfunc);
689 }
690
691 static int hns3_set_rss(struct net_device *netdev, const u32 *indir,
692 const u8 *key, const u8 hfunc)
693 {
694 struct hnae3_handle *h = hns3_get_handle(netdev);
695
696 if (!h->ae_algo || !h->ae_algo->ops || !h->ae_algo->ops->set_rss)
697 return -EOPNOTSUPP;
698
699 /* currently we only support Toeplitz hash */
700 if ((hfunc != ETH_RSS_HASH_NO_CHANGE) && (hfunc != ETH_RSS_HASH_TOP)) {
701 netdev_err(netdev,
702 "hash func not supported (only Toeplitz hash)\n");
703 return -EOPNOTSUPP;
704 }
705 if (!indir) {
706 netdev_err(netdev,
707 "set rss failed for indir is empty\n");
708 return -EOPNOTSUPP;
709 }
710
711 return h->ae_algo->ops->set_rss(h, indir, key, hfunc);
712 }
713
714 static int hns3_get_rxnfc(struct net_device *netdev,
715 struct ethtool_rxnfc *cmd,
716 u32 *rule_locs)
717 {
718 struct hnae3_handle *h = hns3_get_handle(netdev);
719
720 if (!h->ae_algo || !h->ae_algo->ops || !h->ae_algo->ops->get_tc_size)
721 return -EOPNOTSUPP;
722
723 switch (cmd->cmd) {
724 case ETHTOOL_GRXRINGS:
725 cmd->data = h->kinfo.num_tc * h->kinfo.rss_size;
726 break;
727 case ETHTOOL_GRXFH:
728 return h->ae_algo->ops->get_rss_tuple(h, cmd);
729 default:
730 return -EOPNOTSUPP;
731 }
732
733 return 0;
734 }
735
736 static int hns3_change_all_ring_bd_num(struct hns3_nic_priv *priv,
737 u32 new_desc_num)
738 {
739 struct hnae3_handle *h = priv->ae_handle;
740 int i;
741
742 h->kinfo.num_desc = new_desc_num;
743
744 for (i = 0; i < h->kinfo.num_tqps * 2; i++)
745 priv->ring_data[i].ring->desc_num = new_desc_num;
746
747 return hns3_init_all_ring(priv);
748 }
749
750 static int hns3_set_ringparam(struct net_device *ndev,
751 struct ethtool_ringparam *param)
752 {
753 struct hns3_nic_priv *priv = netdev_priv(ndev);
754 struct hnae3_handle *h = priv->ae_handle;
755 bool if_running = netif_running(ndev);
756 u32 old_desc_num, new_desc_num;
757 int ret;
758
759 if (param->rx_mini_pending || param->rx_jumbo_pending)
760 return -EINVAL;
761
762 if (param->tx_pending != param->rx_pending) {
763 netdev_err(ndev,
764 "Descriptors of tx and rx must be equal");
765 return -EINVAL;
766 }
767
768 if (param->tx_pending > HNS3_RING_MAX_PENDING ||
769 param->tx_pending < HNS3_RING_MIN_PENDING) {
770 netdev_err(ndev,
771 "Descriptors requested (Tx/Rx: %d) out of range [%d-%d]\n",
772 param->tx_pending, HNS3_RING_MIN_PENDING,
773 HNS3_RING_MAX_PENDING);
774 return -EINVAL;
775 }
776
777 new_desc_num = param->tx_pending;
778
779 /* Hardware requires that its descriptors must be multiple of eight */
780 new_desc_num = ALIGN(new_desc_num, HNS3_RING_BD_MULTIPLE);
781 old_desc_num = h->kinfo.num_desc;
782 if (old_desc_num == new_desc_num)
783 return 0;
784
785 netdev_info(ndev,
786 "Changing descriptor count from %d to %d.\n",
787 old_desc_num, new_desc_num);
788
789 if (if_running)
790 dev_close(ndev);
791
792 ret = hns3_uninit_all_ring(priv);
793 if (ret)
794 return ret;
795
796 ret = hns3_change_all_ring_bd_num(priv, new_desc_num);
797 if (ret) {
798 ret = hns3_change_all_ring_bd_num(priv, old_desc_num);
799 if (ret) {
800 netdev_err(ndev,
801 "Revert to old bd num fail, ret=%d.\n", ret);
802 return ret;
803 }
804 }
805
806 if (if_running)
807 ret = dev_open(ndev);
808
809 return ret;
810 }
811
812 static int hns3_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd)
813 {
814 struct hnae3_handle *h = hns3_get_handle(netdev);
815
816 if (!h->ae_algo || !h->ae_algo->ops || !h->ae_algo->ops->set_rss_tuple)
817 return -EOPNOTSUPP;
818
819 switch (cmd->cmd) {
820 case ETHTOOL_SRXFH:
821 return h->ae_algo->ops->set_rss_tuple(h, cmd);
822 default:
823 return -EOPNOTSUPP;
824 }
825 }
826
827 static const struct ethtool_ops hns3_ethtool_ops = {
828 .self_test = hns3_self_test,
829 .get_drvinfo = hns3_get_drvinfo,
830 .get_link = hns3_get_link,
831 .get_ringparam = hns3_get_ringparam,
832 .set_ringparam = hns3_set_ringparam,
833 .get_pauseparam = hns3_get_pauseparam,
834 .get_strings = hns3_get_strings,
835 .get_ethtool_stats = hns3_get_stats,
836 .get_sset_count = hns3_get_sset_count,
837 .get_rxnfc = hns3_get_rxnfc,
838 .set_rxnfc = hns3_set_rxnfc,
839 .get_rxfh_key_size = hns3_get_rss_key_size,
840 .get_rxfh_indir_size = hns3_get_rss_indir_size,
841 .get_rxfh = hns3_get_rss,
842 .set_rxfh = hns3_set_rss,
843 .get_link_ksettings = hns3_get_link_ksettings,
844 };
845
846 void hns3_ethtool_set_ops(struct net_device *netdev)
847 {
848 netdev->ethtool_ops = &hns3_ethtool_ops;
849 }
ubuntu-bionic-kernel mirror