drivers/net/hns3/hns3_rxtx.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018-2019 Hisilicon Limited.
   3  */
   4
   5 #include <stdarg.h>
   6 #include <stdbool.h>
   7 #include <stdint.h>
   8 #include <stdio.h>
   9 #include <unistd.h>
  10 #include <inttypes.h>
  11 #include <rte_bus_pci.h>
  12 #include <rte_byteorder.h>
  13 #include <rte_common.h>
  14 #include <rte_cycles.h>
  15 #include <rte_dev.h>
  16 #include <rte_eal.h>
  17 #include <rte_ether.h>
  18 #include <rte_vxlan.h>
  19 #include <rte_ethdev_driver.h>
  20 #include <rte_io.h>
  21 #include <rte_ip.h>
  22 #include <rte_gre.h>
  23 #include <rte_net.h>
  24 #include <rte_malloc.h>
  25 #include <rte_pci.h>
  26
  27 #include "hns3_ethdev.h"
  28 #include "hns3_rxtx.h"
  29 #include "hns3_regs.h"
  30 #include "hns3_logs.h"
  31
  32 #define HNS3_CFG_DESC_NUM(num)  ((num) / 8 - 1)
  33 #define DEFAULT_RX_FREE_THRESH  16
  34
  35 static void
  36 hns3_rx_queue_release_mbufs(struct hns3_rx_queue *rxq)
  37 {
  38         uint16_t i;
  39
  40         if (rxq->sw_ring) {
  41                 for (i = 0; i < rxq->nb_rx_desc; i++) {
  42                         if (rxq->sw_ring[i].mbuf) {
  43                                 rte_pktmbuf_free_seg(rxq->sw_ring[i].mbuf);
  44                                 rxq->sw_ring[i].mbuf = NULL;
  45                         }
  46                 }
  47         }
  48 }
  49
  50 static void
  51 hns3_tx_queue_release_mbufs(struct hns3_tx_queue *txq)
  52 {
  53         uint16_t i;
  54
  55         if (txq->sw_ring) {
  56                 for (i = 0; i < txq->nb_tx_desc; i++) {
  57                         if (txq->sw_ring[i].mbuf) {
  58                                 rte_pktmbuf_free_seg(txq->sw_ring[i].mbuf);
  59                                 txq->sw_ring[i].mbuf = NULL;
  60                         }
  61                 }
  62         }
  63 }
  64
  65 static void
  66 hns3_rx_queue_release(void *queue)
  67 {
  68         struct hns3_rx_queue *rxq = queue;
  69         if (rxq) {
  70                 hns3_rx_queue_release_mbufs(rxq);
  71                 if (rxq->mz)
  72                         rte_memzone_free(rxq->mz);
  73                 if (rxq->sw_ring)
  74                         rte_free(rxq->sw_ring);
  75                 rte_free(rxq);
  76         }
  77 }
  78
  79 static void
  80 hns3_tx_queue_release(void *queue)
  81 {
  82         struct hns3_tx_queue *txq = queue;
  83         if (txq) {
  84                 hns3_tx_queue_release_mbufs(txq);
  85                 if (txq->mz)
  86                         rte_memzone_free(txq->mz);
  87                 if (txq->sw_ring)
  88                         rte_free(txq->sw_ring);
  89                 rte_free(txq);
  90         }
  91 }
  92
  93 void
  94 hns3_dev_rx_queue_release(void *queue)
  95 {
  96         struct hns3_rx_queue *rxq = queue;
  97         struct hns3_adapter *hns;
  98
  99         if (rxq == NULL)
 100                 return;
 101
 102         hns = rxq->hns;
 103         rte_spinlock_lock(&hns->hw.lock);
 104         hns3_rx_queue_release(queue);
 105         rte_spinlock_unlock(&hns->hw.lock);
 106 }
 107
 108 void
 109 hns3_dev_tx_queue_release(void *queue)
 110 {
 111         struct hns3_tx_queue *txq = queue;
 112         struct hns3_adapter *hns;
 113
 114         if (txq == NULL)
 115                 return;
 116
 117         hns = txq->hns;
 118         rte_spinlock_lock(&hns->hw.lock);
 119         hns3_tx_queue_release(queue);
 120         rte_spinlock_unlock(&hns->hw.lock);
 121 }
 122
 123 void
 124 hns3_free_all_queues(struct rte_eth_dev *dev)
 125 {
 126         uint16_t i;
 127
 128         if (dev->data->rx_queues)
 129                 for (i = 0; i < dev->data->nb_rx_queues; i++) {
 130                         hns3_rx_queue_release(dev->data->rx_queues[i]);
 131                         dev->data->rx_queues[i] = NULL;
 132                 }
 133
 134         if (dev->data->tx_queues)
 135                 for (i = 0; i < dev->data->nb_tx_queues; i++) {
 136                         hns3_tx_queue_release(dev->data->tx_queues[i]);
 137                         dev->data->tx_queues[i] = NULL;
 138                 }
 139 }
 140
 141 static int
 142 hns3_alloc_rx_queue_mbufs(struct hns3_hw *hw, struct hns3_rx_queue *rxq)
 143 {
 144         struct rte_mbuf *mbuf;
 145         uint64_t dma_addr;
 146         uint16_t i;
 147
 148         for (i = 0; i < rxq->nb_rx_desc; i++) {
 149                 mbuf = rte_mbuf_raw_alloc(rxq->mb_pool);
 150                 if (unlikely(mbuf == NULL)) {
 151                         hns3_err(hw, "Failed to allocate RXD[%d] for rx queue!",
 152                                  i);
 153                         hns3_rx_queue_release_mbufs(rxq);
 154                         return -ENOMEM;
 155                 }
 156
 157                 rte_mbuf_refcnt_set(mbuf, 1);
 158                 mbuf->next = NULL;
 159                 mbuf->data_off = RTE_PKTMBUF_HEADROOM;
 160                 mbuf->nb_segs = 1;
 161                 mbuf->port = rxq->port_id;
 162
 163                 rxq->sw_ring[i].mbuf = mbuf;
 164                 dma_addr = rte_cpu_to_le_64(rte_mbuf_data_iova_default(mbuf));
 165                 rxq->rx_ring[i].addr = dma_addr;
 166                 rxq->rx_ring[i].rx.bd_base_info = 0;
 167         }
 168
 169         return 0;
 170 }
 171
 172 static int
 173 hns3_buf_size2type(uint32_t buf_size)
 174 {
 175         int bd_size_type;
 176
 177         switch (buf_size) {
 178         case 512:
 179                 bd_size_type = HNS3_BD_SIZE_512_TYPE;
 180                 break;
 181         case 1024:
 182                 bd_size_type = HNS3_BD_SIZE_1024_TYPE;
 183                 break;
 184         case 4096:
 185                 bd_size_type = HNS3_BD_SIZE_4096_TYPE;
 186                 break;
 187         default:
 188                 bd_size_type = HNS3_BD_SIZE_2048_TYPE;
 189         }
 190
 191         return bd_size_type;
 192 }
 193
 194 static void
 195 hns3_init_rx_queue_hw(struct hns3_rx_queue *rxq)
 196 {
 197         uint32_t rx_buf_len = rxq->rx_buf_len;
 198         uint64_t dma_addr = rxq->rx_ring_phys_addr;
 199
 200         hns3_write_dev(rxq, HNS3_RING_RX_BASEADDR_L_REG, (uint32_t)dma_addr);
 201         hns3_write_dev(rxq, HNS3_RING_RX_BASEADDR_H_REG,
 202                        (uint32_t)((dma_addr >> 31) >> 1));
 203
 204         hns3_write_dev(rxq, HNS3_RING_RX_BD_LEN_REG,
 205                        hns3_buf_size2type(rx_buf_len));
 206         hns3_write_dev(rxq, HNS3_RING_RX_BD_NUM_REG,
 207                        HNS3_CFG_DESC_NUM(rxq->nb_rx_desc));
 208 }
 209
 210 static void
 211 hns3_init_tx_queue_hw(struct hns3_tx_queue *txq)
 212 {
 213         uint64_t dma_addr = txq->tx_ring_phys_addr;
 214
 215         hns3_write_dev(txq, HNS3_RING_TX_BASEADDR_L_REG, (uint32_t)dma_addr);
 216         hns3_write_dev(txq, HNS3_RING_TX_BASEADDR_H_REG,
 217                        (uint32_t)((dma_addr >> 31) >> 1));
 218
 219         hns3_write_dev(txq, HNS3_RING_TX_BD_NUM_REG,
 220                        HNS3_CFG_DESC_NUM(txq->nb_tx_desc));
 221 }
 222
 223 static void
 224 hns3_enable_all_queues(struct hns3_hw *hw, bool en)
 225 {
 226         struct hns3_rx_queue *rxq;
 227         struct hns3_tx_queue *txq;
 228         uint32_t rcb_reg;
 229         int i;
 230
 231         for (i = 0; i < hw->data->nb_rx_queues; i++) {
 232                 rxq = hw->data->rx_queues[i];
 233                 txq = hw->data->tx_queues[i];
 234                 if (rxq == NULL || txq == NULL ||
 235                     (en && (rxq->rx_deferred_start || txq->tx_deferred_start)))
 236                         continue;
 237                 rcb_reg = hns3_read_dev(rxq, HNS3_RING_EN_REG);
 238                 if (en)
 239                         rcb_reg |= BIT(HNS3_RING_EN_B);
 240                 else
 241                         rcb_reg &= ~BIT(HNS3_RING_EN_B);
 242                 hns3_write_dev(rxq, HNS3_RING_EN_REG, rcb_reg);
 243         }
 244 }
 245
 246 static int
 247 hns3_tqp_enable(struct hns3_hw *hw, uint16_t queue_id, bool enable)
 248 {
 249         struct hns3_cfg_com_tqp_queue_cmd *req;
 250         struct hns3_cmd_desc desc;
 251         int ret;
 252
 253         req = (struct hns3_cfg_com_tqp_queue_cmd *)desc.data;
 254
 255         hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_CFG_COM_TQP_QUEUE, false);
 256         req->tqp_id = rte_cpu_to_le_16(queue_id & HNS3_RING_ID_MASK);
 257         req->stream_id = 0;
 258         hns3_set_bit(req->enable, HNS3_TQP_ENABLE_B, enable ? 1 : 0);
 259
 260         ret = hns3_cmd_send(hw, &desc, 1);
 261         if (ret)
 262                 hns3_err(hw, "TQP enable fail, ret = %d", ret);
 263
 264         return ret;
 265 }
 266
 267 static int
 268 hns3_send_reset_tqp_cmd(struct hns3_hw *hw, uint16_t queue_id, bool enable)
 269 {
 270         struct hns3_reset_tqp_queue_cmd *req;
 271         struct hns3_cmd_desc desc;
 272         int ret;
 273
 274         hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_RESET_TQP_QUEUE, false);
 275
 276         req = (struct hns3_reset_tqp_queue_cmd *)desc.data;
 277         req->tqp_id = rte_cpu_to_le_16(queue_id & HNS3_RING_ID_MASK);
 278         hns3_set_bit(req->reset_req, HNS3_TQP_RESET_B, enable ? 1 : 0);
 279
 280         ret = hns3_cmd_send(hw, &desc, 1);
 281         if (ret)
 282                 hns3_err(hw, "Send tqp reset cmd error, ret = %d", ret);
 283
 284         return ret;
 285 }
 286
 287 static int
 288 hns3_get_reset_status(struct hns3_hw *hw, uint16_t queue_id)
 289 {
 290         struct hns3_reset_tqp_queue_cmd *req;
 291         struct hns3_cmd_desc desc;
 292         int ret;
 293
 294         hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_RESET_TQP_QUEUE, true);
 295
 296         req = (struct hns3_reset_tqp_queue_cmd *)desc.data;
 297         req->tqp_id = rte_cpu_to_le_16(queue_id & HNS3_RING_ID_MASK);
 298
 299         ret = hns3_cmd_send(hw, &desc, 1);
 300         if (ret) {
 301                 hns3_err(hw, "Get reset status error, ret =%d", ret);
 302                 return ret;
 303         }
 304
 305         return hns3_get_bit(req->ready_to_reset, HNS3_TQP_RESET_B);
 306 }
 307
 308 static int
 309 hns3_reset_tqp(struct hns3_hw *hw, uint16_t queue_id)
 310 {
 311 #define HNS3_TQP_RESET_TRY_MS   200
 312         uint64_t end;
 313         int reset_status;
 314         int ret;
 315
 316         ret = hns3_tqp_enable(hw, queue_id, false);
 317         if (ret)
 318                 return ret;
 319
 320         /*
 321          * In current version VF is not supported when PF is driven by DPDK
 322          * driver, all task queue pairs are mapped to PF function, so PF's queue
 323          * id is equals to the global queue id in PF range.
 324          */
 325         ret = hns3_send_reset_tqp_cmd(hw, queue_id, true);
 326         if (ret) {
 327                 hns3_err(hw, "Send reset tqp cmd fail, ret = %d", ret);
 328                 return ret;
 329         }
 330         ret = -ETIMEDOUT;
 331         end = get_timeofday_ms() + HNS3_TQP_RESET_TRY_MS;
 332         do {
 333                 /* Wait for tqp hw reset */
 334                 rte_delay_ms(HNS3_POLL_RESPONE_MS);
 335                 reset_status = hns3_get_reset_status(hw, queue_id);
 336                 if (reset_status) {
 337                         ret = 0;
 338                         break;
 339                 }
 340         } while (get_timeofday_ms() < end);
 341
 342         if (ret) {
 343                 hns3_err(hw, "Reset TQP fail, ret = %d", ret);
 344                 return ret;
 345         }
 346
 347         ret = hns3_send_reset_tqp_cmd(hw, queue_id, false);
 348         if (ret)
 349                 hns3_err(hw, "Deassert the soft reset fail, ret = %d", ret);
 350
 351         return ret;
 352 }
 353
 354 static int
 355 hns3vf_reset_tqp(struct hns3_hw *hw, uint16_t queue_id)
 356 {
 357         uint8_t msg_data[2];
 358         int ret;
 359
 360         /* Disable VF's queue before send queue reset msg to PF */
 361         ret = hns3_tqp_enable(hw, queue_id, false);
 362         if (ret)
 363                 return ret;
 364
 365         memcpy(msg_data, &queue_id, sizeof(uint16_t));
 366
 367         return hns3_send_mbx_msg(hw, HNS3_MBX_QUEUE_RESET, 0, msg_data,
 368                                  sizeof(msg_data), true, NULL, 0);
 369 }
 370
 371 static int
 372 hns3_reset_queue(struct hns3_adapter *hns, uint16_t queue_id)
 373 {
 374         struct hns3_hw *hw = &hns->hw;
 375         if (hns->is_vf)
 376                 return hns3vf_reset_tqp(hw, queue_id);
 377         else
 378                 return hns3_reset_tqp(hw, queue_id);
 379 }
 380
 381 int
 382 hns3_reset_all_queues(struct hns3_adapter *hns)
 383 {
 384         struct hns3_hw *hw = &hns->hw;
 385         int ret;
 386         uint16_t i;
 387
 388         for (i = 0; i < hw->data->nb_rx_queues; i++) {
 389                 ret = hns3_reset_queue(hns, i);
 390                 if (ret) {
 391                         hns3_err(hw, "Failed to reset No.%d queue: %d", i, ret);
 392                         return ret;
 393                 }
 394         }
 395         return 0;
 396 }
 397
 398 static int
 399 hns3_dev_rx_queue_start(struct hns3_adapter *hns, uint16_t idx)
 400 {
 401         struct hns3_hw *hw = &hns->hw;
 402         struct hns3_rx_queue *rxq;
 403         int ret;
 404
 405         PMD_INIT_FUNC_TRACE();
 406
 407         rxq = hw->data->rx_queues[idx];
 408
 409         ret = hns3_alloc_rx_queue_mbufs(hw, rxq);
 410         if (ret) {
 411                 hns3_err(hw, "Failed to alloc mbuf for No.%d rx queue: %d",
 412                             idx, ret);
 413                 return ret;
 414         }
 415
 416         rxq->next_to_use = 0;
 417         rxq->next_to_clean = 0;
 418         hns3_init_rx_queue_hw(rxq);
 419
 420         return 0;
 421 }
 422
 423 static void
 424 hns3_dev_tx_queue_start(struct hns3_adapter *hns, uint16_t idx)
 425 {
 426         struct hns3_hw *hw = &hns->hw;
 427         struct hns3_tx_queue *txq;
 428         struct hns3_desc *desc;
 429         int i;
 430
 431         txq = hw->data->tx_queues[idx];
 432
 433         /* Clear tx bd */
 434         desc = txq->tx_ring;
 435         for (i = 0; i < txq->nb_tx_desc; i++) {
 436                 desc->tx.tp_fe_sc_vld_ra_ri = 0;
 437                 desc++;
 438         }
 439
 440         txq->next_to_use = 0;
 441         txq->next_to_clean = 0;
 442         txq->tx_bd_ready   = txq->nb_tx_desc;
 443         hns3_init_tx_queue_hw(txq);
 444 }
 445
 446 static void
 447 hns3_init_tx_ring_tc(struct hns3_adapter *hns)
 448 {
 449         struct hns3_hw *hw = &hns->hw;
 450         struct hns3_tx_queue *txq;
 451         int i, num;
 452
 453         for (i = 0; i < HNS3_MAX_TC_NUM; i++) {
 454                 struct hns3_tc_queue_info *tc_queue = &hw->tc_queue[i];
 455                 int j;
 456
 457                 if (!tc_queue->enable)
 458                         continue;
 459
 460                 for (j = 0; j < tc_queue->tqp_count; j++) {
 461                         num = tc_queue->tqp_offset + j;
 462                         txq = hw->data->tx_queues[num];
 463                         if (txq == NULL)
 464                                 continue;
 465
 466                         hns3_write_dev(txq, HNS3_RING_TX_TC_REG, tc_queue->tc);
 467                 }
 468         }
 469 }
 470
 471 int
 472 hns3_start_queues(struct hns3_adapter *hns, bool reset_queue)
 473 {
 474         struct hns3_hw *hw = &hns->hw;
 475         struct rte_eth_dev_data *dev_data = hw->data;
 476         struct hns3_rx_queue *rxq;
 477         struct hns3_tx_queue *txq;
 478         int ret;
 479         int i;
 480         int j;
 481
 482         /* Initialize RSS for queues */
 483         ret = hns3_config_rss(hns);
 484         if (ret) {
 485                 hns3_err(hw, "Failed to configure rss %d", ret);
 486                 return ret;
 487         }
 488
 489         if (reset_queue) {
 490                 ret = hns3_reset_all_queues(hns);
 491                 if (ret) {
 492                         hns3_err(hw, "Failed to reset all queues %d", ret);
 493                         return ret;
 494                 }
 495         }
 496
 497         /*
 498          * Hardware does not support where the number of rx and tx queues is
 499          * not equal in hip08. In .dev_configure callback function we will
 500          * check the two values, here we think that the number of rx and tx
 501          * queues is equal.
 502          */
 503         for (i = 0; i < hw->data->nb_rx_queues; i++) {
 504                 rxq = dev_data->rx_queues[i];
 505                 txq = dev_data->tx_queues[i];
 506                 if (rxq == NULL || txq == NULL || rxq->rx_deferred_start ||
 507                     txq->tx_deferred_start)
 508                         continue;
 509
 510                 ret = hns3_dev_rx_queue_start(hns, i);
 511                 if (ret) {
 512                         hns3_err(hw, "Failed to start No.%d rx queue: %d", i,
 513                                  ret);
 514                         goto out;
 515                 }
 516                 hns3_dev_tx_queue_start(hns, i);
 517         }
 518         hns3_init_tx_ring_tc(hns);
 519
 520         hns3_enable_all_queues(hw, true);
 521         return 0;
 522
 523 out:
 524         for (j = 0; j < i; j++) {
 525                 rxq = dev_data->rx_queues[j];
 526                 hns3_rx_queue_release_mbufs(rxq);
 527         }
 528
 529         return ret;
 530 }
 531
 532 int
 533 hns3_stop_queues(struct hns3_adapter *hns, bool reset_queue)
 534 {
 535         struct hns3_hw *hw = &hns->hw;
 536         int ret;
 537
 538         hns3_enable_all_queues(hw, false);
 539         if (reset_queue) {
 540                 ret = hns3_reset_all_queues(hns);
 541                 if (ret) {
 542                         hns3_err(hw, "Failed to reset all queues %d", ret);
 543                         return ret;
 544                 }
 545         }
 546         return 0;
 547 }
 548
 549 void
 550 hns3_dev_release_mbufs(struct hns3_adapter *hns)
 551 {
 552         struct rte_eth_dev_data *dev_data = hns->hw.data;
 553         struct hns3_rx_queue *rxq;
 554         struct hns3_tx_queue *txq;
 555         int i;
 556
 557         if (dev_data->rx_queues)
 558                 for (i = 0; i < dev_data->nb_rx_queues; i++) {
 559                         rxq = dev_data->rx_queues[i];
 560                         if (rxq == NULL || rxq->rx_deferred_start)
 561                                 continue;
 562                         hns3_rx_queue_release_mbufs(rxq);
 563                 }
 564
 565         if (dev_data->tx_queues)
 566                 for (i = 0; i < dev_data->nb_tx_queues; i++) {
 567                         txq = dev_data->tx_queues[i];
 568                         if (txq == NULL || txq->tx_deferred_start)
 569                                 continue;
 570                         hns3_tx_queue_release_mbufs(txq);
 571                 }
 572 }
 573
 574 int
 575 hns3_rx_queue_setup(struct rte_eth_dev *dev, uint16_t idx, uint16_t nb_desc,
 576                     unsigned int socket_id, const struct rte_eth_rxconf *conf,
 577                     struct rte_mempool *mp)
 578 {
 579         struct hns3_adapter *hns = dev->data->dev_private;
 580         const struct rte_memzone *rx_mz;
 581         struct hns3_hw *hw = &hns->hw;
 582         struct hns3_rx_queue *rxq;
 583         unsigned int desc_size = sizeof(struct hns3_desc);
 584         unsigned int rx_desc;
 585         int rx_entry_len;
 586
 587         if (dev->data->dev_started) {
 588                 hns3_err(hw, "rx_queue_setup after dev_start no supported");
 589                 return -EINVAL;
 590         }
 591
 592         if (nb_desc > HNS3_MAX_RING_DESC || nb_desc < HNS3_MIN_RING_DESC ||
 593             nb_desc % HNS3_ALIGN_RING_DESC) {
 594                 hns3_err(hw, "Number (%u) of rx descriptors is invalid",
 595                          nb_desc);
 596                 return -EINVAL;
 597         }
 598
 599         if (dev->data->rx_queues[idx]) {
 600                 hns3_rx_queue_release(dev->data->rx_queues[idx]);
 601                 dev->data->rx_queues[idx] = NULL;
 602         }
 603
 604         rxq = rte_zmalloc_socket("hns3 RX queue", sizeof(struct hns3_rx_queue),
 605                                  RTE_CACHE_LINE_SIZE, socket_id);
 606         if (rxq == NULL) {
 607                 hns3_err(hw, "Failed to allocate memory for rx queue!");
 608                 return -ENOMEM;
 609         }
 610
 611         rxq->hns = hns;
 612         rxq->mb_pool = mp;
 613         rxq->nb_rx_desc = nb_desc;
 614         rxq->queue_id = idx;
 615         if (conf->rx_free_thresh <= 0)
 616                 rxq->rx_free_thresh = DEFAULT_RX_FREE_THRESH;
 617         else
 618                 rxq->rx_free_thresh = conf->rx_free_thresh;
 619         rxq->rx_deferred_start = conf->rx_deferred_start;
 620
 621         rx_entry_len = sizeof(struct hns3_entry) * rxq->nb_rx_desc;
 622         rxq->sw_ring = rte_zmalloc_socket("hns3 RX sw ring", rx_entry_len,
 623                                           RTE_CACHE_LINE_SIZE, socket_id);
 624         if (rxq->sw_ring == NULL) {
 625                 hns3_err(hw, "Failed to allocate memory for rx sw ring!");
 626                 hns3_rx_queue_release(rxq);
 627                 return -ENOMEM;
 628         }
 629
 630         /* Allocate rx ring hardware descriptors. */
 631         rx_desc = rxq->nb_rx_desc * desc_size;
 632         rx_mz = rte_eth_dma_zone_reserve(dev, "rx_ring", idx, rx_desc,
 633                                          HNS3_RING_BASE_ALIGN, socket_id);
 634         if (rx_mz == NULL) {
 635                 hns3_err(hw, "Failed to reserve DMA memory for No.%d rx ring!",
 636                          idx);
 637                 hns3_rx_queue_release(rxq);
 638                 return -ENOMEM;
 639         }
 640         rxq->mz = rx_mz;
 641         rxq->rx_ring = (struct hns3_desc *)rx_mz->addr;
 642         rxq->rx_ring_phys_addr = rx_mz->iova;
 643
 644         hns3_dbg(hw, "No.%d rx descriptors iova 0x%" PRIx64, idx,
 645                  rxq->rx_ring_phys_addr);
 646
 647         rxq->next_to_use = 0;
 648         rxq->next_to_clean = 0;
 649         rxq->nb_rx_hold = 0;
 650         rxq->pkt_first_seg = NULL;
 651         rxq->pkt_last_seg = NULL;
 652         rxq->port_id = dev->data->port_id;
 653         rxq->configured = true;
 654         rxq->io_base = (void *)((char *)hw->io_base + HNS3_TQP_REG_OFFSET +
 655                                 idx * HNS3_TQP_REG_SIZE);
 656         rxq->rx_buf_len = hw->rx_buf_len;
 657         rxq->non_vld_descs = 0;
 658         rxq->l2_errors = 0;
 659         rxq->pkt_len_errors = 0;
 660         rxq->l3_csum_erros = 0;
 661         rxq->l4_csum_erros = 0;
 662         rxq->ol3_csum_erros = 0;
 663         rxq->ol4_csum_erros = 0;
 664
 665         rte_spinlock_lock(&hw->lock);
 666         dev->data->rx_queues[idx] = rxq;
 667         rte_spinlock_unlock(&hw->lock);
 668
 669         return 0;
 670 }
 671
 672 static inline uint32_t
 673 rxd_pkt_info_to_pkt_type(uint32_t pkt_info, uint32_t ol_info)
 674 {
 675 #define HNS3_L2TBL_NUM  4
 676 #define HNS3_L3TBL_NUM  16
 677 #define HNS3_L4TBL_NUM  16
 678 #define HNS3_OL3TBL_NUM 16
 679 #define HNS3_OL4TBL_NUM 16
 680         uint32_t pkt_type = 0;
 681         uint32_t l2id, l3id, l4id;
 682         uint32_t ol3id, ol4id;
 683
 684         static const uint32_t l2table[HNS3_L2TBL_NUM] = {
 685                 RTE_PTYPE_L2_ETHER,
 686                 RTE_PTYPE_L2_ETHER_VLAN,
 687                 RTE_PTYPE_L2_ETHER_QINQ,
 688                 0
 689         };
 690
 691         static const uint32_t l3table[HNS3_L3TBL_NUM] = {
 692                 RTE_PTYPE_L3_IPV4,
 693                 RTE_PTYPE_L3_IPV6,
 694                 RTE_PTYPE_L2_ETHER_ARP,
 695                 RTE_PTYPE_L2_ETHER,
 696                 RTE_PTYPE_L3_IPV4_EXT,
 697                 RTE_PTYPE_L3_IPV6_EXT,
 698                 RTE_PTYPE_L2_ETHER_LLDP,
 699                 0, 0, 0, 0, 0, 0, 0, 0, 0
 700         };
 701
 702         static const uint32_t l4table[HNS3_L4TBL_NUM] = {
 703                 RTE_PTYPE_L4_UDP,
 704                 RTE_PTYPE_L4_TCP,
 705                 RTE_PTYPE_TUNNEL_GRE,
 706                 RTE_PTYPE_L4_SCTP,
 707                 RTE_PTYPE_L4_IGMP,
 708                 RTE_PTYPE_L4_ICMP,
 709                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 710         };
 711
 712         static const uint32_t inner_l2table[HNS3_L2TBL_NUM] = {
 713                 RTE_PTYPE_INNER_L2_ETHER,
 714                 RTE_PTYPE_INNER_L2_ETHER_VLAN,
 715                 RTE_PTYPE_INNER_L2_ETHER_QINQ,
 716                 0
 717         };
 718
 719         static const uint32_t inner_l3table[HNS3_L3TBL_NUM] = {
 720                 RTE_PTYPE_INNER_L3_IPV4,
 721                 RTE_PTYPE_INNER_L3_IPV6,
 722                 0,
 723                 RTE_PTYPE_INNER_L2_ETHER,
 724                 RTE_PTYPE_INNER_L3_IPV4_EXT,
 725                 RTE_PTYPE_INNER_L3_IPV6_EXT,
 726                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 727         };
 728
 729         static const uint32_t inner_l4table[HNS3_L4TBL_NUM] = {
 730                 RTE_PTYPE_INNER_L4_UDP,
 731                 RTE_PTYPE_INNER_L4_TCP,
 732                 RTE_PTYPE_TUNNEL_GRE,
 733                 RTE_PTYPE_INNER_L4_SCTP,
 734                 RTE_PTYPE_L4_IGMP,
 735                 RTE_PTYPE_INNER_L4_ICMP,
 736                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 737         };
 738
 739         static const uint32_t ol3table[HNS3_OL3TBL_NUM] = {
 740                 RTE_PTYPE_L3_IPV4,
 741                 RTE_PTYPE_L3_IPV6,
 742                 0, 0,
 743                 RTE_PTYPE_L3_IPV4_EXT,
 744                 RTE_PTYPE_L3_IPV6_EXT,
 745                 0, 0, 0, 0, 0, 0, 0, 0, 0,
 746                 RTE_PTYPE_UNKNOWN
 747         };
 748
 749         static const uint32_t ol4table[HNS3_OL4TBL_NUM] = {
 750                 0,
 751                 RTE_PTYPE_TUNNEL_VXLAN,
 752                 RTE_PTYPE_TUNNEL_NVGRE,
 753                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 754         };
 755
 756         l2id = hns3_get_field(pkt_info, HNS3_RXD_STRP_TAGP_M,
 757                               HNS3_RXD_STRP_TAGP_S);
 758         l3id = hns3_get_field(pkt_info, HNS3_RXD_L3ID_M, HNS3_RXD_L3ID_S);
 759         l4id = hns3_get_field(pkt_info, HNS3_RXD_L4ID_M, HNS3_RXD_L4ID_S);
 760         ol3id = hns3_get_field(ol_info, HNS3_RXD_OL3ID_M, HNS3_RXD_OL3ID_S);
 761         ol4id = hns3_get_field(ol_info, HNS3_RXD_OL4ID_M, HNS3_RXD_OL4ID_S);
 762
 763         if (ol4table[ol4id])
 764                 pkt_type |= (inner_l2table[l2id] | inner_l3table[l3id] |
 765                              inner_l4table[l4id] | ol3table[ol3id] |
 766                              ol4table[ol4id]);
 767         else
 768                 pkt_type |= (l2table[l2id] | l3table[l3id] | l4table[l4id]);
 769         return pkt_type;
 770 }
 771
 772 const uint32_t *
 773 hns3_dev_supported_ptypes_get(struct rte_eth_dev *dev)
 774 {
 775         static const uint32_t ptypes[] = {
 776                 RTE_PTYPE_L2_ETHER,
 777                 RTE_PTYPE_L2_ETHER_VLAN,
 778                 RTE_PTYPE_L2_ETHER_QINQ,
 779                 RTE_PTYPE_L2_ETHER_LLDP,
 780                 RTE_PTYPE_L2_ETHER_ARP,
 781                 RTE_PTYPE_L3_IPV4,
 782                 RTE_PTYPE_L3_IPV4_EXT,
 783                 RTE_PTYPE_L3_IPV6,
 784                 RTE_PTYPE_L3_IPV6_EXT,
 785                 RTE_PTYPE_L4_IGMP,
 786                 RTE_PTYPE_L4_ICMP,
 787                 RTE_PTYPE_L4_SCTP,
 788                 RTE_PTYPE_L4_TCP,
 789                 RTE_PTYPE_L4_UDP,
 790                 RTE_PTYPE_TUNNEL_GRE,
 791                 RTE_PTYPE_UNKNOWN
 792         };
 793
 794         if (dev->rx_pkt_burst == hns3_recv_pkts)
 795                 return ptypes;
 796
 797         return NULL;
 798 }
 799
 800 static void
 801 hns3_clean_rx_buffers(struct hns3_rx_queue *rxq, int count)
 802 {
 803         rxq->next_to_use += count;
 804         if (rxq->next_to_use >= rxq->nb_rx_desc)
 805                 rxq->next_to_use -= rxq->nb_rx_desc;
 806
 807         hns3_write_dev(rxq, HNS3_RING_RX_HEAD_REG, count);
 808 }
 809
 810 static int
 811 hns3_handle_bdinfo(struct hns3_rx_queue *rxq, struct rte_mbuf *rxm,
 812                    uint32_t bd_base_info, uint32_t l234_info,
 813                    uint32_t *cksum_err)
 814 {
 815         uint32_t tmp = 0;
 816
 817         if (unlikely(l234_info & BIT(HNS3_RXD_L2E_B))) {
 818                 rxq->l2_errors++;
 819                 return -EINVAL;
 820         }
 821
 822         if (unlikely(rxm->pkt_len == 0 ||
 823                 (l234_info & BIT(HNS3_RXD_TRUNCAT_B)))) {
 824                 rxq->pkt_len_errors++;
 825                 return -EINVAL;
 826         }
 827
 828         if (bd_base_info & BIT(HNS3_RXD_L3L4P_B)) {
 829                 if (unlikely(l234_info & BIT(HNS3_RXD_L3E_B))) {
 830                         rxm->ol_flags |= PKT_RX_IP_CKSUM_BAD;
 831                         rxq->l3_csum_erros++;
 832                         tmp |= HNS3_L3_CKSUM_ERR;
 833                 }
 834
 835                 if (unlikely(l234_info & BIT(HNS3_RXD_L4E_B))) {
 836                         rxm->ol_flags |= PKT_RX_L4_CKSUM_BAD;
 837                         rxq->l4_csum_erros++;
 838                         tmp |= HNS3_L4_CKSUM_ERR;
 839                 }
 840
 841                 if (unlikely(l234_info & BIT(HNS3_RXD_OL3E_B))) {
 842                         rxq->ol3_csum_erros++;
 843                         tmp |= HNS3_OUTER_L3_CKSUM_ERR;
 844                 }
 845
 846                 if (unlikely(l234_info & BIT(HNS3_RXD_OL4E_B))) {
 847                         rxm->ol_flags |= PKT_RX_OUTER_L4_CKSUM_BAD;
 848                         rxq->ol4_csum_erros++;
 849                         tmp |= HNS3_OUTER_L4_CKSUM_ERR;
 850                 }
 851         }
 852         *cksum_err = tmp;
 853
 854         return 0;
 855 }
 856
 857 static void
 858 hns3_rx_set_cksum_flag(struct rte_mbuf *rxm, uint64_t packet_type,
 859                        const uint32_t cksum_err)
 860 {
 861         if (unlikely((packet_type & RTE_PTYPE_TUNNEL_MASK))) {
 862                 if (likely(packet_type & RTE_PTYPE_INNER_L3_MASK) &&
 863                     (cksum_err & HNS3_L3_CKSUM_ERR) == 0)
 864                         rxm->ol_flags |= PKT_RX_IP_CKSUM_GOOD;
 865                 if (likely(packet_type & RTE_PTYPE_INNER_L4_MASK) &&
 866                     (cksum_err & HNS3_L4_CKSUM_ERR) == 0)
 867                         rxm->ol_flags |= PKT_RX_L4_CKSUM_GOOD;
 868                 if (likely(packet_type & RTE_PTYPE_L4_MASK) &&
 869                     (cksum_err & HNS3_OUTER_L4_CKSUM_ERR) == 0)
 870                         rxm->ol_flags |= PKT_RX_OUTER_L4_CKSUM_GOOD;
 871         } else {
 872                 if (likely(packet_type & RTE_PTYPE_L3_MASK) &&
 873                     (cksum_err & HNS3_L3_CKSUM_ERR) == 0)
 874                         rxm->ol_flags |= PKT_RX_IP_CKSUM_GOOD;
 875                 if (likely(packet_type & RTE_PTYPE_L4_MASK) &&
 876                     (cksum_err & HNS3_L4_CKSUM_ERR) == 0)
 877                         rxm->ol_flags |= PKT_RX_L4_CKSUM_GOOD;
 878         }
 879 }
 880
 881 uint16_t
 882 hns3_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
 883 {
 884         struct hns3_rx_queue *rxq;      /* RX queue */
 885         struct hns3_desc *rx_ring;      /* RX ring (desc) */
 886         struct hns3_entry *sw_ring;
 887         struct hns3_entry *rxe;
 888         struct hns3_desc *rxdp;         /* pointer of the current desc */
 889         struct rte_mbuf *first_seg;
 890         struct rte_mbuf *last_seg;
 891         struct rte_mbuf *nmb;           /* pointer of the new mbuf */
 892         struct rte_mbuf *rxm;
 893         struct rte_eth_dev *dev;
 894         uint32_t bd_base_info;
 895         uint32_t cksum_err;
 896         uint32_t l234_info;
 897         uint32_t ol_info;
 898         uint64_t dma_addr;
 899         uint16_t data_len;
 900         uint16_t nb_rx_bd;
 901         uint16_t pkt_len;
 902         uint16_t nb_rx;
 903         uint16_t rx_id;
 904         int num;                        /* num of desc in ring */
 905         int ret;
 906
 907         nb_rx = 0;
 908         nb_rx_bd = 0;
 909         rxq = rx_queue;
 910         dev = &rte_eth_devices[rxq->port_id];
 911
 912         rx_id = rxq->next_to_clean;
 913         rx_ring = rxq->rx_ring;
 914         first_seg = rxq->pkt_first_seg;
 915         last_seg = rxq->pkt_last_seg;
 916         sw_ring = rxq->sw_ring;
 917
 918         /* Get num of packets in descriptor ring */
 919         num = hns3_read_dev(rxq, HNS3_RING_RX_FBDNUM_REG);
 920         while (nb_rx_bd < num && nb_rx < nb_pkts) {
 921                 rxdp = &rx_ring[rx_id];
 922                 bd_base_info = rte_le_to_cpu_32(rxdp->rx.bd_base_info);
 923                 if (unlikely(!hns3_get_bit(bd_base_info, HNS3_RXD_VLD_B))) {
 924                         rxq->non_vld_descs++;
 925                         break;
 926                 }
 927
 928                 nmb = rte_mbuf_raw_alloc(rxq->mb_pool);
 929                 if (unlikely(nmb == NULL)) {
 930                         dev->data->rx_mbuf_alloc_failed++;
 931                         break;
 932                 }
 933
 934                 nb_rx_bd++;
 935                 rxe = &sw_ring[rx_id];
 936                 rx_id++;
 937                 if (rx_id == rxq->nb_rx_desc)
 938                         rx_id = 0;
 939
 940                 rte_prefetch0(sw_ring[rx_id].mbuf);
 941                 if ((rx_id & 0x3) == 0) {
 942                         rte_prefetch0(&rx_ring[rx_id]);
 943                         rte_prefetch0(&sw_ring[rx_id]);
 944                 }
 945
 946                 rxm = rxe->mbuf;
 947                 rxe->mbuf = nmb;
 948
 949                 dma_addr = rte_cpu_to_le_64(rte_mbuf_data_iova_default(nmb));
 950                 rxdp->addr = dma_addr;
 951                 rxdp->rx.bd_base_info = 0;
 952
 953                 rte_cio_rmb();
 954                 /* Load remained descriptor data and extract necessary fields */
 955                 data_len = (uint16_t)(rte_le_to_cpu_16(rxdp->rx.size));
 956                 l234_info = rte_le_to_cpu_32(rxdp->rx.l234_info);
 957                 ol_info = rte_le_to_cpu_32(rxdp->rx.ol_info);
 958
 959                 if (first_seg == NULL) {
 960                         first_seg = rxm;
 961                         first_seg->nb_segs = 1;
 962                 } else {
 963                         first_seg->nb_segs++;
 964                         last_seg->next = rxm;
 965                 }
 966
 967                 rxm->data_off = RTE_PKTMBUF_HEADROOM;
 968                 rxm->data_len = data_len;
 969
 970                 if (!hns3_get_bit(bd_base_info, HNS3_RXD_FE_B)) {
 971                         last_seg = rxm;
 972                         continue;
 973                 }
 974
 975                 /* The last buffer of the received packet */
 976                 pkt_len = (uint16_t)(rte_le_to_cpu_16(rxdp->rx.pkt_len));
 977                 first_seg->pkt_len = pkt_len;
 978                 first_seg->port = rxq->port_id;
 979                 first_seg->hash.rss = rte_le_to_cpu_32(rxdp->rx.rss_hash);
 980                 first_seg->ol_flags |= PKT_RX_RSS_HASH;
 981                 if (unlikely(hns3_get_bit(bd_base_info, HNS3_RXD_LUM_B))) {
 982                         first_seg->hash.fdir.hi =
 983                                 rte_le_to_cpu_32(rxdp->rx.fd_id);
 984                         first_seg->ol_flags |= PKT_RX_FDIR | PKT_RX_FDIR_ID;
 985                 }
 986                 rxm->next = NULL;
 987
 988                 ret = hns3_handle_bdinfo(rxq, first_seg, bd_base_info,
 989                                          l234_info, &cksum_err);
 990                 if (unlikely(ret))
 991                         goto pkt_err;
 992
 993                 first_seg->packet_type = rxd_pkt_info_to_pkt_type(l234_info,
 994                                                                   ol_info);
 995
 996                 if (bd_base_info & BIT(HNS3_RXD_L3L4P_B))
 997                         hns3_rx_set_cksum_flag(rxm, first_seg->packet_type,
 998                                                cksum_err);
 999
1000                 first_seg->vlan_tci = rte_le_to_cpu_16(rxdp->rx.vlan_tag);
1001                 first_seg->vlan_tci_outer =
1002                         rte_le_to_cpu_16(rxdp->rx.ot_vlan_tag);
1003                 rx_pkts[nb_rx++] = first_seg;
1004                 first_seg = NULL;
1005                 continue;
1006 pkt_err:
1007                 rte_pktmbuf_free(first_seg);
1008                 first_seg = NULL;
1009         }
1010
1011         rxq->next_to_clean = rx_id;
1012         rxq->pkt_first_seg = first_seg;
1013         rxq->pkt_last_seg = last_seg;
1014         hns3_clean_rx_buffers(rxq, nb_rx_bd);
1015
1016         return nb_rx;
1017 }
1018
1019 int
1020 hns3_tx_queue_setup(struct rte_eth_dev *dev, uint16_t idx, uint16_t nb_desc,
1021                     unsigned int socket_id, const struct rte_eth_txconf *conf)
1022 {
1023         struct hns3_adapter *hns = dev->data->dev_private;
1024         const struct rte_memzone *tx_mz;
1025         struct hns3_hw *hw = &hns->hw;
1026         struct hns3_tx_queue *txq;
1027         struct hns3_desc *desc;
1028         unsigned int desc_size = sizeof(struct hns3_desc);
1029         unsigned int tx_desc;
1030         int tx_entry_len;
1031         int i;
1032
1033         if (dev->data->dev_started) {
1034                 hns3_err(hw, "tx_queue_setup after dev_start no supported");
1035                 return -EINVAL;
1036         }
1037
1038         if (nb_desc > HNS3_MAX_RING_DESC || nb_desc < HNS3_MIN_RING_DESC ||
1039             nb_desc % HNS3_ALIGN_RING_DESC) {
1040                 hns3_err(hw, "Number (%u) of tx descriptors is invalid",
1041                             nb_desc);
1042                 return -EINVAL;
1043         }
1044
1045         if (dev->data->tx_queues[idx] != NULL) {
1046                 hns3_tx_queue_release(dev->data->tx_queues[idx]);
1047                 dev->data->tx_queues[idx] = NULL;
1048         }
1049
1050         txq = rte_zmalloc_socket("hns3 TX queue", sizeof(struct hns3_tx_queue),
1051                                  RTE_CACHE_LINE_SIZE, socket_id);
1052         if (txq == NULL) {
1053                 hns3_err(hw, "Failed to allocate memory for tx queue!");
1054                 return -ENOMEM;
1055         }
1056
1057         txq->nb_tx_desc = nb_desc;
1058         txq->queue_id = idx;
1059         txq->tx_deferred_start = conf->tx_deferred_start;
1060
1061         tx_entry_len = sizeof(struct hns3_entry) * txq->nb_tx_desc;
1062         txq->sw_ring = rte_zmalloc_socket("hns3 TX sw ring", tx_entry_len,
1063                                           RTE_CACHE_LINE_SIZE, socket_id);
1064         if (txq->sw_ring == NULL) {
1065                 hns3_err(hw, "Failed to allocate memory for tx sw ring!");
1066                 hns3_tx_queue_release(txq);
1067                 return -ENOMEM;
1068         }
1069
1070         /* Allocate tx ring hardware descriptors. */
1071         tx_desc = txq->nb_tx_desc * desc_size;
1072         tx_mz = rte_eth_dma_zone_reserve(dev, "tx_ring", idx, tx_desc,
1073                                          HNS3_RING_BASE_ALIGN, socket_id);
1074         if (tx_mz == NULL) {
1075                 hns3_err(hw, "Failed to reserve DMA memory for No.%d tx ring!",
1076                          idx);
1077                 hns3_tx_queue_release(txq);
1078                 return -ENOMEM;
1079         }
1080         txq->mz = tx_mz;
1081         txq->tx_ring = (struct hns3_desc *)tx_mz->addr;
1082         txq->tx_ring_phys_addr = tx_mz->iova;
1083
1084         hns3_dbg(hw, "No.%d tx descriptors iova 0x%" PRIx64, idx,
1085                  txq->tx_ring_phys_addr);
1086
1087         /* Clear tx bd */
1088         desc = txq->tx_ring;
1089         for (i = 0; i < txq->nb_tx_desc; i++) {
1090                 desc->tx.tp_fe_sc_vld_ra_ri = 0;
1091                 desc++;
1092         }
1093
1094         txq->hns = hns;
1095         txq->next_to_use = 0;
1096         txq->next_to_clean = 0;
1097         txq->tx_bd_ready   = txq->nb_tx_desc;
1098         txq->port_id = dev->data->port_id;
1099         txq->configured = true;
1100         txq->io_base = (void *)((char *)hw->io_base + HNS3_TQP_REG_OFFSET +
1101                                 idx * HNS3_TQP_REG_SIZE);
1102         rte_spinlock_lock(&hw->lock);
1103         dev->data->tx_queues[idx] = txq;
1104         rte_spinlock_unlock(&hw->lock);
1105
1106         return 0;
1107 }
1108
1109 static inline int
1110 tx_ring_dist(struct hns3_tx_queue *txq, int begin, int end)
1111 {
1112         return (end - begin + txq->nb_tx_desc) % txq->nb_tx_desc;
1113 }
1114
1115 static inline int
1116 tx_ring_space(struct hns3_tx_queue *txq)
1117 {
1118         return txq->nb_tx_desc -
1119                 tx_ring_dist(txq, txq->next_to_clean, txq->next_to_use) - 1;
1120 }
1121
1122 static inline void
1123 hns3_queue_xmit(struct hns3_tx_queue *txq, uint32_t buf_num)
1124 {
1125         hns3_write_dev(txq, HNS3_RING_TX_TAIL_REG, buf_num);
1126 }
1127
1128 static void
1129 hns3_tx_free_useless_buffer(struct hns3_tx_queue *txq)
1130 {
1131         uint16_t tx_next_clean = txq->next_to_clean;
1132         uint16_t tx_next_use   = txq->next_to_use;
1133         uint16_t tx_bd_ready   = txq->tx_bd_ready;
1134         uint16_t tx_bd_max     = txq->nb_tx_desc;
1135         struct hns3_entry *tx_bak_pkt = &txq->sw_ring[tx_next_clean];
1136         struct hns3_desc *desc = &txq->tx_ring[tx_next_clean];
1137         struct rte_mbuf *mbuf;
1138
1139         while ((!hns3_get_bit(desc->tx.tp_fe_sc_vld_ra_ri, HNS3_TXD_VLD_B)) &&
1140                 (tx_next_use != tx_next_clean || tx_bd_ready < tx_bd_max)) {
1141                 mbuf = tx_bak_pkt->mbuf;
1142                 if (mbuf) {
1143                         mbuf->next = NULL;
1144                         rte_pktmbuf_free(mbuf);
1145                         tx_bak_pkt->mbuf = NULL;
1146                 }
1147
1148                 desc++;
1149                 tx_bak_pkt++;
1150                 tx_next_clean++;
1151                 tx_bd_ready++;
1152
1153                 if (tx_next_clean >= tx_bd_max) {
1154                         tx_next_clean = 0;
1155                         desc = txq->tx_ring;
1156                         tx_bak_pkt = txq->sw_ring;
1157                 }
1158         }
1159
1160         txq->next_to_clean = tx_next_clean;
1161         txq->tx_bd_ready   = tx_bd_ready;
1162 }
1163
1164 static void
1165 fill_desc(struct hns3_tx_queue *txq, uint16_t tx_desc_id, struct rte_mbuf *rxm,
1166           bool first, int offset)
1167 {
1168         struct hns3_desc *tx_ring = txq->tx_ring;
1169         struct hns3_desc *desc = &tx_ring[tx_desc_id];
1170         uint8_t frag_end = rxm->next == NULL ? 1 : 0;
1171         uint16_t size = rxm->data_len;
1172         uint16_t rrcfv = 0;
1173         uint64_t ol_flags = rxm->ol_flags;
1174         uint32_t hdr_len;
1175         uint32_t paylen;
1176         uint32_t tmp;
1177
1178         desc->addr = rte_mbuf_data_iova(rxm) + offset;
1179         desc->tx.send_size = rte_cpu_to_le_16(size);
1180         hns3_set_bit(rrcfv, HNS3_TXD_VLD_B, 1);
1181
1182         if (first) {
1183                 hdr_len = rxm->l2_len + rxm->l3_len + rxm->l4_len;
1184                 hdr_len += (ol_flags & PKT_TX_TUNNEL_MASK) ?
1185                            rxm->outer_l2_len + rxm->outer_l3_len : 0;
1186                 paylen = rxm->pkt_len - hdr_len;
1187                 desc->tx.paylen = rte_cpu_to_le_32(paylen);
1188         }
1189
1190         hns3_set_bit(rrcfv, HNS3_TXD_FE_B, frag_end);
1191         desc->tx.tp_fe_sc_vld_ra_ri = rte_cpu_to_le_16(rrcfv);
1192
1193         if (frag_end) {
1194                 if (ol_flags & (PKT_TX_VLAN_PKT | PKT_TX_QINQ_PKT)) {
1195                         tmp = rte_le_to_cpu_32(desc->tx.type_cs_vlan_tso_len);
1196                         hns3_set_bit(tmp, HNS3_TXD_VLAN_B, 1);
1197                         desc->tx.type_cs_vlan_tso_len = rte_cpu_to_le_32(tmp);
1198                         desc->tx.vlan_tag = rte_cpu_to_le_16(rxm->vlan_tci);
1199                 }
1200
1201                 if (ol_flags & PKT_TX_QINQ_PKT) {
1202                         tmp = rte_le_to_cpu_32(desc->tx.ol_type_vlan_len_msec);
1203                         hns3_set_bit(tmp, HNS3_TXD_OVLAN_B, 1);
1204                         desc->tx.ol_type_vlan_len_msec = rte_cpu_to_le_32(tmp);
1205                         desc->tx.outer_vlan_tag =
1206                                 rte_cpu_to_le_16(rxm->vlan_tci_outer);
1207                 }
1208         }
1209 }
1210
1211 static int
1212 hns3_tx_alloc_mbufs(struct hns3_tx_queue *txq, struct rte_mempool *mb_pool,
1213                     uint16_t nb_new_buf, struct rte_mbuf **alloc_mbuf)
1214 {
1215         struct rte_mbuf *new_mbuf = NULL;
1216         struct rte_eth_dev *dev;
1217         struct rte_mbuf *temp;
1218         struct hns3_hw *hw;
1219         uint16_t i;
1220
1221         /* Allocate enough mbufs */
1222         for (i = 0; i < nb_new_buf; i++) {
1223                 temp = rte_pktmbuf_alloc(mb_pool);
1224                 if (unlikely(temp == NULL)) {
1225                         dev = &rte_eth_devices[txq->port_id];
1226                         hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1227                         hns3_err(hw, "Failed to alloc TX mbuf port_id=%d,"
1228                                      "queue_id=%d in reassemble tx pkts.",
1229                                      txq->port_id, txq->queue_id);
1230                         rte_pktmbuf_free(new_mbuf);
1231                         return -ENOMEM;
1232                 }
1233                 temp->next = new_mbuf;
1234                 new_mbuf = temp;
1235         }
1236
1237         if (new_mbuf == NULL)
1238                 return -ENOMEM;
1239
1240         new_mbuf->nb_segs = nb_new_buf;
1241         *alloc_mbuf = new_mbuf;
1242
1243         return 0;
1244 }
1245
1246 static int
1247 hns3_reassemble_tx_pkts(void *tx_queue, struct rte_mbuf *tx_pkt,
1248                         struct rte_mbuf **new_pkt)
1249 {
1250         struct hns3_tx_queue *txq = tx_queue;
1251         struct rte_mempool *mb_pool;
1252         struct rte_mbuf *new_mbuf;
1253         struct rte_mbuf *temp_new;
1254         struct rte_mbuf *temp;
1255         uint16_t last_buf_len;
1256         uint16_t nb_new_buf;
1257         uint16_t buf_size;
1258         uint16_t buf_len;
1259         uint16_t len_s;
1260         uint16_t len_d;
1261         uint16_t len;
1262         uint16_t i;
1263         int ret;
1264         char *s;
1265         char *d;
1266
1267         mb_pool = tx_pkt->pool;
1268         buf_size = tx_pkt->buf_len - RTE_PKTMBUF_HEADROOM;
1269         nb_new_buf = (tx_pkt->pkt_len - 1) / buf_size + 1;
1270
1271         last_buf_len = tx_pkt->pkt_len % buf_size;
1272         if (last_buf_len == 0)
1273                 last_buf_len = buf_size;
1274
1275         /* Allocate enough mbufs */
1276         ret = hns3_tx_alloc_mbufs(txq, mb_pool, nb_new_buf, &new_mbuf);
1277         if (ret)
1278                 return ret;
1279
1280         /* Copy the original packet content to the new mbufs */
1281         temp = tx_pkt;
1282         s = rte_pktmbuf_mtod(temp, char *);
1283         len_s = temp->data_len;
1284         temp_new = new_mbuf;
1285         for (i = 0; i < nb_new_buf; i++) {
1286                 d = rte_pktmbuf_mtod(temp_new, char *);
1287                 if (i < nb_new_buf - 1)
1288                         buf_len = buf_size;
1289                 else
1290                         buf_len = last_buf_len;
1291                 len_d = buf_len;
1292
1293                 while (len_d) {
1294                         len = RTE_MIN(len_s, len_d);
1295                         memcpy(d, s, len);
1296                         s = s + len;
1297                         d = d + len;
1298                         len_d = len_d - len;
1299                         len_s = len_s - len;
1300
1301                         if (len_s == 0) {
1302                                 temp = temp->next;
1303                                 if (temp == NULL)
1304                                         break;
1305                                 s = rte_pktmbuf_mtod(temp, char *);
1306                                 len_s = temp->data_len;
1307                         }
1308                 }
1309
1310                 temp_new->data_len = buf_len;
1311                 temp_new = temp_new->next;
1312         }
1313
1314         /* free original mbufs */
1315         rte_pktmbuf_free(tx_pkt);
1316
1317         *new_pkt = new_mbuf;
1318
1319         return 0;
1320 }
1321
1322 static void
1323 hns3_parse_outer_params(uint64_t ol_flags, uint32_t *ol_type_vlan_len_msec)
1324 {
1325         uint32_t tmp = *ol_type_vlan_len_msec;
1326
1327         /* (outer) IP header type */
1328         if (ol_flags & PKT_TX_OUTER_IPV4) {
1329                 /* OL3 header size, defined in 4 bytes */
1330                 hns3_set_field(tmp, HNS3_TXD_L3LEN_M, HNS3_TXD_L3LEN_S,
1331                                sizeof(struct rte_ipv4_hdr) >> HNS3_L3_LEN_UNIT);
1332                 if (ol_flags & PKT_TX_OUTER_IP_CKSUM)
1333                         hns3_set_field(tmp, HNS3_TXD_OL3T_M,
1334                                        HNS3_TXD_OL3T_S, HNS3_OL3T_IPV4_CSUM);
1335                 else
1336                         hns3_set_field(tmp, HNS3_TXD_OL3T_M, HNS3_TXD_OL3T_S,
1337                                        HNS3_OL3T_IPV4_NO_CSUM);
1338         } else if (ol_flags & PKT_TX_OUTER_IPV6) {
1339                 hns3_set_field(tmp, HNS3_TXD_OL3T_M, HNS3_TXD_OL3T_S,
1340                                HNS3_OL3T_IPV6);
1341                 /* OL3 header size, defined in 4 bytes */
1342                 hns3_set_field(tmp, HNS3_TXD_L3LEN_M, HNS3_TXD_L3LEN_S,
1343                                sizeof(struct rte_ipv6_hdr) >> HNS3_L3_LEN_UNIT);
1344         }
1345
1346         *ol_type_vlan_len_msec = tmp;
1347 }
1348
1349 static int
1350 hns3_parse_inner_params(uint64_t ol_flags, uint32_t *ol_type_vlan_len_msec,
1351                         struct rte_net_hdr_lens *hdr_lens)
1352 {
1353         uint32_t tmp = *ol_type_vlan_len_msec;
1354         uint8_t l4_len;
1355
1356         /* OL2 header size, defined in 2 bytes */
1357         hns3_set_field(tmp, HNS3_TXD_L2LEN_M, HNS3_TXD_L2LEN_S,
1358                        sizeof(struct rte_ether_hdr) >> HNS3_L2_LEN_UNIT);
1359
1360         /* L4TUNT: L4 Tunneling Type */
1361         switch (ol_flags & PKT_TX_TUNNEL_MASK) {
1362         case PKT_TX_TUNNEL_GENEVE:
1363         case PKT_TX_TUNNEL_VXLAN:
1364                 /* MAC in UDP tunnelling packet, include VxLAN */
1365                 hns3_set_field(tmp, HNS3_TXD_TUNTYPE_M, HNS3_TXD_TUNTYPE_S,
1366                                HNS3_TUN_MAC_IN_UDP);
1367                 /*
1368                  * OL4 header size, defined in 4 Bytes, it contains outer
1369                  * L4(UDP) length and tunneling length.
1370                  */
1371                 hns3_set_field(tmp, HNS3_TXD_L4LEN_M, HNS3_TXD_L4LEN_S,
1372                                (uint8_t)RTE_ETHER_VXLAN_HLEN >>
1373                                HNS3_L4_LEN_UNIT);
1374                 break;
1375         case PKT_TX_TUNNEL_GRE:
1376                 hns3_set_field(tmp, HNS3_TXD_TUNTYPE_M, HNS3_TXD_TUNTYPE_S,
1377                                HNS3_TUN_NVGRE);
1378                 /*
1379                  * OL4 header size, defined in 4 Bytes, it contains outer
1380                  * L4(GRE) length and tunneling length.
1381                  */
1382                 l4_len = hdr_lens->l4_len + hdr_lens->tunnel_len;
1383                 hns3_set_field(tmp, HNS3_TXD_L4LEN_M, HNS3_TXD_L4LEN_S,
1384                                l4_len >> HNS3_L4_LEN_UNIT);
1385                 break;
1386         default:
1387                 /* For non UDP / GRE tunneling, drop the tunnel packet */
1388                 return -EINVAL;
1389         }
1390
1391         *ol_type_vlan_len_msec = tmp;
1392
1393         return 0;
1394 }
1395
1396 static int
1397 hns3_parse_tunneling_params(struct hns3_tx_queue *txq, uint16_t tx_desc_id,
1398                             uint64_t ol_flags,
1399                             struct rte_net_hdr_lens *hdr_lens)
1400 {
1401         struct hns3_desc *tx_ring = txq->tx_ring;
1402         struct hns3_desc *desc = &tx_ring[tx_desc_id];
1403         uint32_t value = 0;
1404         int ret;
1405
1406         hns3_parse_outer_params(ol_flags, &value);
1407         ret = hns3_parse_inner_params(ol_flags, &value, hdr_lens);
1408         if (ret)
1409                 return -EINVAL;
1410
1411         desc->tx.ol_type_vlan_len_msec |= rte_cpu_to_le_32(value);
1412
1413         return 0;
1414 }
1415
1416 static void
1417 hns3_parse_l3_cksum_params(uint64_t ol_flags, uint32_t *type_cs_vlan_tso_len)
1418 {
1419         uint32_t tmp;
1420
1421         /* Enable L3 checksum offloads */
1422         if (ol_flags & PKT_TX_IPV4) {
1423                 tmp = *type_cs_vlan_tso_len;
1424                 hns3_set_field(tmp, HNS3_TXD_L3T_M, HNS3_TXD_L3T_S,
1425                                HNS3_L3T_IPV4);
1426                 /* inner(/normal) L3 header size, defined in 4 bytes */
1427                 hns3_set_field(tmp, HNS3_TXD_L3LEN_M, HNS3_TXD_L3LEN_S,
1428                                sizeof(struct rte_ipv4_hdr) >> HNS3_L3_LEN_UNIT);
1429                 if (ol_flags & PKT_TX_IP_CKSUM)
1430                         hns3_set_bit(tmp, HNS3_TXD_L3CS_B, 1);
1431                 *type_cs_vlan_tso_len = tmp;
1432         } else if (ol_flags & PKT_TX_IPV6) {
1433                 tmp = *type_cs_vlan_tso_len;
1434                 /* L3T, IPv6 don't do checksum */
1435                 hns3_set_field(tmp, HNS3_TXD_L3T_M, HNS3_TXD_L3T_S,
1436                                HNS3_L3T_IPV6);
1437                 /* inner(/normal) L3 header size, defined in 4 bytes */
1438                 hns3_set_field(tmp, HNS3_TXD_L3LEN_M, HNS3_TXD_L3LEN_S,
1439                                sizeof(struct rte_ipv6_hdr) >> HNS3_L3_LEN_UNIT);
1440                 *type_cs_vlan_tso_len = tmp;
1441         }
1442 }
1443
1444 static void
1445 hns3_parse_l4_cksum_params(uint64_t ol_flags, uint32_t *type_cs_vlan_tso_len)
1446 {
1447         uint32_t tmp;
1448
1449         /* Enable L4 checksum offloads */
1450         switch (ol_flags & PKT_TX_L4_MASK) {
1451         case PKT_TX_TCP_CKSUM:
1452                 tmp = *type_cs_vlan_tso_len;
1453                 hns3_set_field(tmp, HNS3_TXD_L4T_M, HNS3_TXD_L4T_S,
1454                                HNS3_L4T_TCP);
1455                 hns3_set_bit(tmp, HNS3_TXD_L4CS_B, 1);
1456                 hns3_set_field(tmp, HNS3_TXD_L4LEN_M, HNS3_TXD_L4LEN_S,
1457                                sizeof(struct rte_tcp_hdr) >> HNS3_L4_LEN_UNIT);
1458                 *type_cs_vlan_tso_len = tmp;
1459                 break;
1460         case PKT_TX_UDP_CKSUM:
1461                 tmp = *type_cs_vlan_tso_len;
1462                 hns3_set_field(tmp, HNS3_TXD_L4T_M, HNS3_TXD_L4T_S,
1463                                HNS3_L4T_UDP);
1464                 hns3_set_bit(tmp, HNS3_TXD_L4CS_B, 1);
1465                 hns3_set_field(tmp, HNS3_TXD_L4LEN_M, HNS3_TXD_L4LEN_S,
1466                                sizeof(struct rte_udp_hdr) >> HNS3_L4_LEN_UNIT);
1467                 *type_cs_vlan_tso_len = tmp;
1468                 break;
1469         case PKT_TX_SCTP_CKSUM:
1470                 tmp = *type_cs_vlan_tso_len;
1471                 hns3_set_field(tmp, HNS3_TXD_L4T_M, HNS3_TXD_L4T_S,
1472                                HNS3_L4T_SCTP);
1473                 hns3_set_bit(tmp, HNS3_TXD_L4CS_B, 1);
1474                 hns3_set_field(tmp, HNS3_TXD_L4LEN_M, HNS3_TXD_L4LEN_S,
1475                                sizeof(struct rte_sctp_hdr) >> HNS3_L4_LEN_UNIT);
1476                 *type_cs_vlan_tso_len = tmp;
1477                 break;
1478         default:
1479                 break;
1480         }
1481 }
1482
1483 static void
1484 hns3_txd_enable_checksum(struct hns3_tx_queue *txq, uint16_t tx_desc_id,
1485                          uint64_t ol_flags)
1486 {
1487         struct hns3_desc *tx_ring = txq->tx_ring;
1488         struct hns3_desc *desc = &tx_ring[tx_desc_id];
1489         uint32_t value = 0;
1490
1491         /* inner(/normal) L2 header size, defined in 2 bytes */
1492         hns3_set_field(value, HNS3_TXD_L2LEN_M, HNS3_TXD_L2LEN_S,
1493                        sizeof(struct rte_ether_hdr) >> HNS3_L2_LEN_UNIT);
1494
1495         hns3_parse_l3_cksum_params(ol_flags, &value);
1496         hns3_parse_l4_cksum_params(ol_flags, &value);
1497
1498         desc->tx.type_cs_vlan_tso_len |= rte_cpu_to_le_32(value);
1499 }
1500
1501 uint16_t
1502 hns3_prep_pkts(__rte_unused void *tx_queue, struct rte_mbuf **tx_pkts,
1503                uint16_t nb_pkts)
1504 {
1505         struct rte_mbuf *m;
1506         uint16_t i;
1507         int ret;
1508
1509         for (i = 0; i < nb_pkts; i++) {
1510                 m = tx_pkts[i];
1511
1512                 /* check the size of packet */
1513                 if (m->pkt_len < HNS3_MIN_FRAME_LEN) {
1514                         rte_errno = EINVAL;
1515                         return i;
1516                 }
1517
1518 #ifdef RTE_LIBRTE_ETHDEV_DEBUG
1519                 ret = rte_validate_tx_offload(m);
1520                 if (ret != 0) {
1521                         rte_errno = -ret;
1522                         return i;
1523                 }
1524 #endif
1525                 ret = rte_net_intel_cksum_prepare(m);
1526                 if (ret != 0) {
1527                         rte_errno = -ret;
1528                         return i;
1529                 }
1530         }
1531
1532         return i;
1533 }
1534
1535 static int
1536 hns3_parse_cksum(struct hns3_tx_queue *txq, uint16_t tx_desc_id,
1537                  const struct rte_mbuf *m, struct rte_net_hdr_lens *hdr_lens)
1538 {
1539         /* Fill in tunneling parameters if necessary */
1540         if (m->ol_flags & PKT_TX_TUNNEL_MASK) {
1541                 (void)rte_net_get_ptype(m, hdr_lens, RTE_PTYPE_ALL_MASK);
1542                 if (hns3_parse_tunneling_params(txq, tx_desc_id, m->ol_flags,
1543                                                 hdr_lens))
1544                         return -EINVAL;
1545         }
1546         /* Enable checksum offloading */
1547         if (m->ol_flags & HNS3_TX_CKSUM_OFFLOAD_MASK)
1548                 hns3_txd_enable_checksum(txq, tx_desc_id, m->ol_flags);
1549
1550         return 0;
1551 }
1552
1553 uint16_t
1554 hns3_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
1555 {
1556         struct rte_net_hdr_lens hdr_lens = {0};
1557         struct hns3_tx_queue *txq = tx_queue;
1558         struct hns3_entry *tx_bak_pkt;
1559         struct rte_mbuf *new_pkt;
1560         struct rte_mbuf *tx_pkt;
1561         struct rte_mbuf *m_seg;
1562         struct rte_mbuf *temp;
1563         uint32_t nb_hold = 0;
1564         uint16_t tx_next_clean;
1565         uint16_t tx_next_use;
1566         uint16_t tx_bd_ready;
1567         uint16_t tx_pkt_num;
1568         uint16_t tx_bd_max;
1569         uint16_t nb_buf;
1570         uint16_t nb_tx;
1571         uint16_t i;
1572
1573         /* free useless buffer */
1574         hns3_tx_free_useless_buffer(txq);
1575         tx_bd_ready = txq->tx_bd_ready;
1576         if (tx_bd_ready == 0)
1577                 return 0;
1578
1579         tx_next_clean = txq->next_to_clean;
1580         tx_next_use   = txq->next_to_use;
1581         tx_bd_max     = txq->nb_tx_desc;
1582         tx_bak_pkt = &txq->sw_ring[tx_next_clean];
1583
1584         tx_pkt_num = (tx_bd_ready < nb_pkts) ? tx_bd_ready : nb_pkts;
1585
1586         /* send packets */
1587         tx_bak_pkt = &txq->sw_ring[tx_next_use];
1588         for (nb_tx = 0; nb_tx < tx_pkt_num; nb_tx++) {
1589                 tx_pkt = *tx_pkts++;
1590
1591                 nb_buf = tx_pkt->nb_segs;
1592
1593                 if (nb_buf > tx_ring_space(txq)) {
1594                         if (nb_tx == 0)
1595                                 return 0;
1596
1597                         goto end_of_tx;
1598                 }
1599
1600                 /*
1601                  * If packet length is greater than HNS3_MAX_FRAME_LEN
1602                  * driver support, the packet will be ignored.
1603                  */
1604                 if (unlikely(rte_pktmbuf_pkt_len(tx_pkt) > HNS3_MAX_FRAME_LEN))
1605                         break;
1606
1607                 /*
1608                  * If packet length is less than minimum packet size, driver
1609                  * need to pad it.
1610                  */
1611                 if (unlikely(rte_pktmbuf_pkt_len(tx_pkt) < HNS3_MIN_PKT_SIZE)) {
1612                         uint16_t add_len;
1613                         char *appended;
1614
1615                         add_len = HNS3_MIN_PKT_SIZE -
1616                                          rte_pktmbuf_pkt_len(tx_pkt);
1617                         appended = rte_pktmbuf_append(tx_pkt, add_len);
1618                         if (appended == NULL)
1619                                 break;
1620
1621                         memset(appended, 0, add_len);
1622                 }
1623
1624                 m_seg = tx_pkt;
1625                 if (unlikely(nb_buf > HNS3_MAX_TX_BD_PER_PKT)) {
1626                         if (hns3_reassemble_tx_pkts(txq, tx_pkt, &new_pkt))
1627                                 goto end_of_tx;
1628                         m_seg = new_pkt;
1629                         nb_buf = m_seg->nb_segs;
1630                 }
1631
1632                 if (hns3_parse_cksum(txq, tx_next_use, m_seg, &hdr_lens))
1633                         goto end_of_tx;
1634
1635                 i = 0;
1636                 do {
1637                         fill_desc(txq, tx_next_use, m_seg, (i == 0), 0);
1638                         temp = m_seg->next;
1639                         tx_bak_pkt->mbuf = m_seg;
1640                         m_seg = temp;
1641                         tx_next_use++;
1642                         tx_bak_pkt++;
1643                         if (tx_next_use >= tx_bd_max) {
1644                                 tx_next_use = 0;
1645                                 tx_bak_pkt = txq->sw_ring;
1646                         }
1647
1648                         i++;
1649                 } while (m_seg != NULL);
1650
1651                 nb_hold += i;
1652         }
1653
1654 end_of_tx:
1655
1656         if (likely(nb_tx)) {
1657                 hns3_queue_xmit(txq, nb_hold);
1658                 txq->next_to_clean = tx_next_clean;
1659                 txq->next_to_use   = tx_next_use;
1660                 txq->tx_bd_ready   = tx_bd_ready - nb_hold;
1661         }
1662
1663         return nb_tx;
1664 }
1665
1666 static uint16_t
1667 hns3_dummy_rxtx_burst(void *dpdk_txq __rte_unused,
1668                       struct rte_mbuf **pkts __rte_unused,
1669                       uint16_t pkts_n __rte_unused)
1670 {
1671         return 0;
1672 }
1673
1674 void hns3_set_rxtx_function(struct rte_eth_dev *eth_dev)
1675 {
1676         struct hns3_adapter *hns = eth_dev->data->dev_private;
1677
1678         if (hns->hw.adapter_state == HNS3_NIC_STARTED &&
1679             rte_atomic16_read(&hns->hw.reset.resetting) == 0) {
1680                 eth_dev->rx_pkt_burst = hns3_recv_pkts;
1681                 eth_dev->tx_pkt_burst = hns3_xmit_pkts;
1682                 eth_dev->tx_pkt_prepare = hns3_prep_pkts;
1683         } else {
1684                 eth_dev->rx_pkt_burst = hns3_dummy_rxtx_burst;
1685                 eth_dev->tx_pkt_burst = hns3_dummy_rxtx_burst;
1686                 eth_dev->tx_pkt_prepare = hns3_dummy_rxtx_burst;
1687         }
1688 }