drivers/raw/cnxk_bphy/cnxk_bphy_cgx_test.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2021 Marvell.
   3  */
   4 #include <stdint.h>
   5
   6 #include <rte_cycles.h>
   7 #include <rte_log.h>
   8 #include <rte_malloc.h>
   9 #include <rte_rawdev.h>
  10
  11 #include "cnxk_bphy_cgx.h"
  12 #include "rte_pmd_bphy.h"
  13
  14 static int
  15 cnxk_bphy_cgx_enq_msg(uint16_t dev_id, unsigned int queue, void *msg)
  16 {
  17         struct rte_rawdev_buf *bufs[1];
  18         struct rte_rawdev_buf buf;
  19         void *q;
  20         int ret;
  21
  22         q = (void *)(size_t)queue;
  23         buf.buf_addr = msg;
  24         bufs[0] = &buf;
  25
  26         ret = rte_rawdev_enqueue_buffers(dev_id, bufs, 1, q);
  27         if (ret < 0)
  28                 return ret;
  29         if (ret != 1)
  30                 return -EIO;
  31
  32         return 0;
  33 }
  34
  35 static int
  36 cnxk_bphy_cgx_deq_msg(uint16_t dev_id, unsigned int queue, void **msg)
  37 {
  38         struct rte_rawdev_buf *bufs[1];
  39         struct rte_rawdev_buf buf;
  40         void *q;
  41         int ret;
  42
  43         q = (void *)(size_t)queue;
  44         bufs[0] = &buf;
  45
  46         ret = rte_rawdev_dequeue_buffers(dev_id, bufs, 1, q);
  47         if (ret < 0)
  48                 return ret;
  49         if (ret != 1)
  50                 return -EIO;
  51
  52         *msg = buf.buf_addr;
  53
  54         return 0;
  55 }
  56
  57 static int
  58 cnxk_bphy_cgx_link_cond(uint16_t dev_id, unsigned int queue, int cond)
  59 {
  60         int tries = 10, ret;
  61
  62         do {
  63                 struct cnxk_bphy_cgx_msg_link_info *link_info = NULL;
  64                 struct cnxk_bphy_cgx_msg msg;
  65
  66                 msg.type = CNXK_BPHY_CGX_MSG_TYPE_GET_LINKINFO;
  67                 ret = cnxk_bphy_cgx_enq_msg(dev_id, queue, &msg);
  68                 if (ret)
  69                         return ret;
  70
  71                 ret = cnxk_bphy_cgx_deq_msg(dev_id, queue, (void **)&link_info);
  72                 if (ret)
  73                         return ret;
  74
  75                 if (link_info->link_up == cond) {
  76                         rte_free(link_info);
  77                         break;
  78                 }
  79
  80                 rte_free(link_info);
  81                 rte_delay_ms(500);
  82         } while (--tries);
  83
  84         if (tries)
  85                 return !!cond;
  86
  87         return -ETIMEDOUT;
  88 }
  89
  90 int
  91 cnxk_bphy_cgx_dev_selftest(uint16_t dev_id)
  92 {
  93         unsigned int queues, i;
  94         int ret;
  95
  96         queues = rte_rawdev_queue_count(dev_id);
  97         if (queues == 0)
  98                 return -ENODEV;
  99
 100         ret = rte_rawdev_start(dev_id);
 101         if (ret)
 102                 return ret;
 103
 104         for (i = 0; i < queues; i++) {
 105                 struct cnxk_bphy_cgx_msg_set_link_state link_state;
 106                 struct cnxk_bphy_cgx_msg msg;
 107                 unsigned int descs;
 108
 109                 ret = rte_rawdev_queue_conf_get(dev_id, i, &descs,
 110                                                 sizeof(descs));
 111                 if (ret)
 112                         break;
 113                 if (descs != 1) {
 114                         RTE_LOG(ERR, PMD, "Wrong number of descs reported\n");
 115                         ret = -ENODEV;
 116                         break;
 117                 }
 118
 119                 RTE_LOG(INFO, PMD, "Testing queue %d\n", i);
 120
 121                 /* stop rx/tx */
 122                 msg.type = CNXK_BPHY_CGX_MSG_TYPE_STOP_RXTX;
 123                 ret = cnxk_bphy_cgx_enq_msg(dev_id, i, &msg);
 124                 if (ret) {
 125                         RTE_LOG(ERR, PMD, "Failed to stop rx/tx\n");
 126                         break;
 127                 }
 128
 129                 /* start rx/tx */
 130                 msg.type = CNXK_BPHY_CGX_MSG_TYPE_START_RXTX;
 131                 ret = cnxk_bphy_cgx_enq_msg(dev_id, i, &msg);
 132                 if (ret) {
 133                         RTE_LOG(ERR, PMD, "Failed to start rx/tx\n");
 134                         break;
 135                 }
 136
 137                 /* set link down */
 138                 link_state.state = false;
 139                 msg.type = CNXK_BPHY_CGX_MSG_TYPE_SET_LINK_STATE;
 140                 msg.data = &link_state;
 141                 ret = cnxk_bphy_cgx_enq_msg(dev_id, i, &msg);
 142                 if (ret) {
 143                         RTE_LOG(ERR, PMD, "Failed to set link down\n");
 144                         break;
 145                 }
 146
 147                 ret = cnxk_bphy_cgx_link_cond(dev_id, i, 0);
 148                 if (ret != 0)
 149                         RTE_LOG(ERR, PMD,
 150                                 "Timed out waiting for a link down\n");
 151
 152                 /* set link up */
 153                 link_state.state = true;
 154                 msg.type = CNXK_BPHY_CGX_MSG_TYPE_SET_LINK_STATE;
 155                 msg.data = &link_state;
 156                 ret = cnxk_bphy_cgx_enq_msg(dev_id, i, &msg);
 157                 if (ret) {
 158                         RTE_LOG(ERR, PMD, "Failed to set link up\n");
 159                         break;
 160                 }
 161
 162                 ret = cnxk_bphy_cgx_link_cond(dev_id, i, 1);
 163                 if (ret != 1)
 164                         RTE_LOG(ERR, PMD, "Timed out waiting for a link up\n");
 165
 166                 /* enable internal loopback */
 167                 msg.type = CNXK_BPHY_CGX_MSG_TYPE_INTLBK_ENABLE;
 168                 ret = cnxk_bphy_cgx_enq_msg(dev_id, i, &msg);
 169                 if (ret) {
 170                         RTE_LOG(ERR, PMD, "Failed to enable internal lbk\n");
 171                         break;
 172                 }
 173
 174                 /* disable internal loopback */
 175                 msg.type = CNXK_BPHY_CGX_MSG_TYPE_INTLBK_DISABLE;
 176                 ret = cnxk_bphy_cgx_enq_msg(dev_id, i, &msg);
 177                 if (ret) {
 178                         RTE_LOG(ERR, PMD, "Failed to disable internal lbk\n");
 179                         break;
 180                 }
 181
 182                 /* enable ptp */
 183                 msg.type = CNXK_BPHY_CGX_MSG_TYPE_PTP_RX_ENABLE;
 184                 ret = cnxk_bphy_cgx_enq_msg(dev_id, i, &msg);
 185                 /* ptp not available on RPM */
 186                 if (ret < 0 && ret != -ENOTSUP) {
 187                         RTE_LOG(ERR, PMD, "Failed to enable ptp\n");
 188                         break;
 189                 }
 190                 ret = 0;
 191
 192                 /* disable ptp */
 193                 msg.type = CNXK_BPHY_CGX_MSG_TYPE_PTP_RX_DISABLE;
 194                 ret = cnxk_bphy_cgx_enq_msg(dev_id, i, &msg);
 195                 /* ptp not available on RPM */
 196                 if (ret < 0 && ret != -ENOTSUP) {
 197                         RTE_LOG(ERR, PMD, "Failed to disable ptp\n");
 198                         break;
 199                 }
 200                 ret = 0;
 201         }
 202
 203         rte_rawdev_stop(dev_id);
 204
 205         return ret;
 206 }