drivers/raw/skeleton/skeleton_rawdev_test.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2017 NXP
   3  */
   4
   5 #include <rte_common.h>
   6 #include <rte_mbuf.h>
   7 #include <rte_malloc.h>
   8 #include <rte_memcpy.h>
   9 #include <rte_dev.h>
  10 #include <rte_rawdev.h>
  11 #include <rte_bus_vdev.h>
  12 #include <rte_test.h>
  13
  14 /* Using relative path as skeleton_rawdev is not part of exported headers */
  15 #include "skeleton_rawdev.h"
  16
  17 #define TEST_DEV_NAME "rawdev_skeleton"
  18
  19 #define SKELDEV_LOGS(level, fmt, args...) \
  20         rte_log(RTE_LOG_ ## level, skeleton_pmd_logtype, fmt "\n", \
  21                 ##args)
  22
  23 #define SKELDEV_TEST_INFO(fmt, args...) \
  24         SKELDEV_LOGS(INFO, fmt, ## args)
  25 #define SKELDEV_TEST_DEBUG(fmt, args...) \
  26         SKELDEV_LOGS(DEBUG, fmt, ## args)
  27
  28 #define SKELDEV_TEST_RUN(setup, teardown, test) \
  29         skeldev_test_run(setup, teardown, test, #test)
  30
  31 #define TEST_SUCCESS 0
  32 #define TEST_FAILED  -1
  33
  34 static int total;
  35 static int passed;
  36 static int failed;
  37 static int unsupported;
  38
  39 static uint16_t test_dev_id;
  40
  41 static int
  42 testsuite_setup(void)
  43 {
  44         uint8_t count;
  45
  46         total = 0;
  47         passed = 0;
  48         failed = 0;
  49         unsupported = 0;
  50
  51         count = rte_rawdev_count();
  52         if (!count) {
  53                 SKELDEV_TEST_INFO("\tNo existing rawdev; "
  54                                   "Creating 'skeldev_rawdev'");
  55                 return rte_vdev_init(TEST_DEV_NAME, NULL);
  56         }
  57
  58         return TEST_SUCCESS;
  59 }
  60
  61 static void local_teardown(void);
  62
  63 static void
  64 testsuite_teardown(void)
  65 {
  66         local_teardown();
  67 }
  68
  69 static void
  70 local_teardown(void)
  71 {
  72         rte_vdev_uninit(TEST_DEV_NAME);
  73 }
  74
  75 static int
  76 test_rawdev_count(void)
  77 {
  78         uint8_t count;
  79         count = rte_rawdev_count();
  80         RTE_TEST_ASSERT(count > 0, "Invalid rawdev count %" PRIu8, count);
  81         return TEST_SUCCESS;
  82 }
  83
  84 static int
  85 test_rawdev_get_dev_id(void)
  86 {
  87         int ret;
  88         ret = rte_rawdev_get_dev_id("invalid_rawdev_device");
  89         RTE_TEST_ASSERT_FAIL(ret, "Expected <0 for invalid dev name ret=%d",
  90                              ret);
  91         return TEST_SUCCESS;
  92 }
  93
  94 static int
  95 test_rawdev_socket_id(void)
  96 {
  97         int socket_id;
  98         socket_id = rte_rawdev_socket_id(test_dev_id);
  99         RTE_TEST_ASSERT(socket_id != -EINVAL,
 100                         "Failed to get socket_id %d", socket_id);
 101         socket_id = rte_rawdev_socket_id(RTE_RAWDEV_MAX_DEVS);
 102         RTE_TEST_ASSERT(socket_id == -EINVAL,
 103                         "Expected -EINVAL %d", socket_id);
 104
 105         return TEST_SUCCESS;
 106 }
 107
 108 static int
 109 test_rawdev_info_get(void)
 110 {
 111         int ret;
 112         struct rte_rawdev_info rdev_info = {0};
 113         struct skeleton_rawdev_conf skel_conf = {0};
 114
 115         ret = rte_rawdev_info_get(test_dev_id, NULL, 0);
 116         RTE_TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 117
 118         rdev_info.dev_private = &skel_conf;
 119
 120         ret = rte_rawdev_info_get(test_dev_id, &rdev_info, sizeof(skel_conf));
 121         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to get raw dev info");
 122
 123         return TEST_SUCCESS;
 124 }
 125
 126 static int
 127 test_rawdev_configure(void)
 128 {
 129         int ret;
 130         struct rte_rawdev_info rdev_info = {0};
 131         struct skeleton_rawdev_conf rdev_conf_set = {0};
 132         struct skeleton_rawdev_conf rdev_conf_get = {0};
 133
 134         /* Check invalid configuration */
 135         ret = rte_rawdev_configure(test_dev_id, NULL, 0);
 136         RTE_TEST_ASSERT(ret == -EINVAL,
 137                         "Null configure; Expected -EINVAL, got %d", ret);
 138
 139         /* Valid configuration test */
 140         rdev_conf_set.num_queues = 1;
 141         rdev_conf_set.capabilities = SKELETON_CAPA_FW_LOAD |
 142                                      SKELETON_CAPA_FW_RESET;
 143
 144         rdev_info.dev_private = &rdev_conf_set;
 145         ret = rte_rawdev_configure(test_dev_id,
 146                                    (rte_rawdev_obj_t)&rdev_info,
 147                                    sizeof(rdev_conf_set));
 148         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to configure rawdev (%d)", ret);
 149
 150         rdev_info.dev_private = &rdev_conf_get;
 151         ret = rte_rawdev_info_get(test_dev_id,
 152                                   (rte_rawdev_obj_t)&rdev_info,
 153                                   sizeof(rdev_conf_get));
 154         RTE_TEST_ASSERT_SUCCESS(ret,
 155                                 "Failed to obtain rawdev configuration (%d)",
 156                                 ret);
 157
 158         RTE_TEST_ASSERT_EQUAL(rdev_conf_set.num_queues,
 159                               rdev_conf_get.num_queues,
 160                               "Configuration test failed; num_queues (%d)(%d)",
 161                               rdev_conf_set.num_queues,
 162                               rdev_conf_get.num_queues);
 163         RTE_TEST_ASSERT_EQUAL(rdev_conf_set.capabilities,
 164                           rdev_conf_get.capabilities,
 165                           "Configuration test failed; capabilities");
 166
 167         return TEST_SUCCESS;
 168 }
 169
 170 static int
 171 test_rawdev_queue_default_conf_get(void)
 172 {
 173         int ret, i;
 174         struct rte_rawdev_info rdev_info = {0};
 175         struct skeleton_rawdev_conf rdev_conf_get = {0};
 176         struct skeleton_rawdev_queue q = {0};
 177
 178         /* Get the current configuration */
 179         rdev_info.dev_private = &rdev_conf_get;
 180         ret = rte_rawdev_info_get(test_dev_id,
 181                                   (rte_rawdev_obj_t)&rdev_info,
 182                                   sizeof(rdev_conf_get));
 183         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to obtain rawdev configuration (%d)",
 184                                 ret);
 185
 186         /* call to test_rawdev_configure would have set the num_queues = 1 */
 187         RTE_TEST_ASSERT_SUCCESS(!(rdev_conf_get.num_queues > 0),
 188                                 "Invalid number of queues (%d). Expected 1",
 189                                 rdev_conf_get.num_queues);
 190         /* All queues by default should have state = DETACH and
 191          * depth = DEF_DEPTH
 192          */
 193         for (i = 0; i < rdev_conf_get.num_queues; i++) {
 194                 rte_rawdev_queue_conf_get(test_dev_id, i, &q, sizeof(q));
 195                 RTE_TEST_ASSERT_EQUAL(q.depth, SKELETON_QUEUE_DEF_DEPTH,
 196                                       "Invalid default depth of queue (%d)",
 197                                       q.depth);
 198                 RTE_TEST_ASSERT_EQUAL(q.state, SKELETON_QUEUE_DETACH,
 199                                       "Invalid default state of queue (%d)",
 200                                       q.state);
 201         }
 202
 203         return TEST_SUCCESS;
 204 }
 205
 206 static int
 207 test_rawdev_queue_count(void)
 208 {
 209         unsigned int q_count;
 210
 211         /* Get the current configuration */
 212         q_count = rte_rawdev_queue_count(test_dev_id);
 213         RTE_TEST_ASSERT_EQUAL(q_count, 1, "Invalid queue count (%d)", q_count);
 214
 215         return TEST_SUCCESS;
 216 }
 217
 218 static int
 219 test_rawdev_queue_setup(void)
 220 {
 221         int ret;
 222         struct rte_rawdev_info rdev_info = {0};
 223         struct skeleton_rawdev_conf rdev_conf_get = {0};
 224         struct skeleton_rawdev_queue qset = {0};
 225         struct skeleton_rawdev_queue qget = {0};
 226
 227         /* Get the current configuration */
 228         rdev_info.dev_private = &rdev_conf_get;
 229         ret = rte_rawdev_info_get(test_dev_id,
 230                                   (rte_rawdev_obj_t)&rdev_info,
 231                                   sizeof(rdev_conf_get));
 232         RTE_TEST_ASSERT_SUCCESS(ret,
 233                                 "Failed to obtain rawdev configuration (%d)",
 234                                 ret);
 235
 236         /* call to test_rawdev_configure would have set the num_queues = 1 */
 237         RTE_TEST_ASSERT_SUCCESS(!(rdev_conf_get.num_queues > 0),
 238                                 "Invalid number of queues (%d). Expected 1",
 239                                 rdev_conf_get.num_queues);
 240
 241         /* Modify the queue depth for Queue 0 and attach it */
 242         qset.depth = 15;
 243         qset.state = SKELETON_QUEUE_ATTACH;
 244         ret = rte_rawdev_queue_setup(test_dev_id, 0, &qset, sizeof(qset));
 245         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to setup queue (%d)", ret);
 246
 247         /* Now, fetching the queue 0 should show depth as 15 */
 248         ret = rte_rawdev_queue_conf_get(test_dev_id, 0, &qget, sizeof(qget));
 249         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to get queue config (%d)", ret);
 250
 251         RTE_TEST_ASSERT_EQUAL(qset.depth, qget.depth,
 252                               "Failed to set queue depth: Need(%d), has(%d)",
 253                               qset.depth, qget.depth);
 254
 255         return TEST_SUCCESS;
 256 }
 257
 258 /* After executing test_rawdev_queue_setup, queue_id=0 would have depth as 15.
 259  * Releasing should set it back to default. state would set to DETACH
 260  */
 261 static int
 262 test_rawdev_queue_release(void)
 263 {
 264         int ret;
 265         struct skeleton_rawdev_queue qget = {0};
 266
 267         /* Now, fetching the queue 0 should show depth as 100 */
 268         ret = rte_rawdev_queue_release(test_dev_id, 0);
 269         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to release queue 0; (%d)", ret);
 270
 271         /* Now, fetching the queue 0 should show depth as default */
 272         ret = rte_rawdev_queue_conf_get(test_dev_id, 0, &qget, sizeof(qget));
 273         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to get queue config (%d)", ret);
 274
 275         RTE_TEST_ASSERT_EQUAL(qget.depth, SKELETON_QUEUE_DEF_DEPTH,
 276                               "Release of Queue 0 failed; (depth)");
 277
 278         RTE_TEST_ASSERT_EQUAL(qget.state, SKELETON_QUEUE_DETACH,
 279                               "Release of Queue 0 failed; (state)");
 280
 281         return TEST_SUCCESS;
 282 }
 283
 284 static int
 285 test_rawdev_attr_set_get(void)
 286 {
 287         int ret;
 288         int *dummy_value, set_value;
 289         uint64_t ret_value;
 290
 291         /* Set an attribute and fetch it */
 292         ret = rte_rawdev_set_attr(test_dev_id, "Test1", 100);
 293         RTE_TEST_ASSERT(!ret, "Unable to set an attribute (Test1)");
 294
 295         dummy_value = &set_value;
 296         *dummy_value = 200;
 297         ret = rte_rawdev_set_attr(test_dev_id, "Test2", (uintptr_t)dummy_value);
 298
 299         /* Check if attributes have been set */
 300         ret = rte_rawdev_get_attr(test_dev_id, "Test1", &ret_value);
 301         RTE_TEST_ASSERT_EQUAL(ret_value, 100,
 302                               "Attribute (Test1) not set correctly (%" PRIu64 ")",
 303                               ret_value);
 304
 305         ret_value = 0;
 306         ret = rte_rawdev_get_attr(test_dev_id, "Test2", &ret_value);
 307         RTE_TEST_ASSERT_EQUAL(*((int *)(uintptr_t)ret_value), set_value,
 308                               "Attribute (Test2) not set correctly (%" PRIu64 ")",
 309                               ret_value);
 310
 311         return TEST_SUCCESS;
 312 }
 313
 314 static int
 315 test_rawdev_start_stop(void)
 316 {
 317         int ret;
 318         struct rte_rawdev_info rdev_info = {0};
 319         struct skeleton_rawdev_conf rdev_conf_get = {0};
 320         char *dummy_firmware = NULL;
 321
 322         /* Get the current configuration */
 323         rdev_info.dev_private = &rdev_conf_get;
 324
 325         /* Load a firmware using a dummy address area */
 326         dummy_firmware = rte_zmalloc("RAWDEV SKELETON", sizeof(int) * 10, 0);
 327         RTE_TEST_ASSERT(dummy_firmware != NULL,
 328                         "Failed to create firmware memory backing");
 329
 330         ret = rte_rawdev_firmware_load(test_dev_id, dummy_firmware);
 331         RTE_TEST_ASSERT_SUCCESS(ret, "Firmware loading failed (%d)", ret);
 332
 333         /* Skeleton doesn't do anything with the firmware area - that is dummy
 334          * and can be removed.
 335          */
 336         rte_free(dummy_firmware);
 337         dummy_firmware = NULL;
 338
 339         rte_rawdev_start(test_dev_id);
 340         ret = rte_rawdev_info_get(test_dev_id, (rte_rawdev_obj_t)&rdev_info,
 341                         sizeof(rdev_conf_get));
 342         RTE_TEST_ASSERT_SUCCESS(ret,
 343                                 "Failed to obtain rawdev configuration (%d)",
 344                                 ret);
 345         RTE_TEST_ASSERT_EQUAL(rdev_conf_get.device_state, SKELETON_DEV_RUNNING,
 346                               "Device start failed. State is (%d)",
 347                               rdev_conf_get.device_state);
 348
 349         rte_rawdev_stop(test_dev_id);
 350         ret = rte_rawdev_info_get(test_dev_id, (rte_rawdev_obj_t)&rdev_info,
 351                         sizeof(rdev_conf_get));
 352         RTE_TEST_ASSERT_SUCCESS(ret,
 353                                 "Failed to obtain rawdev configuration (%d)",
 354                                 ret);
 355         RTE_TEST_ASSERT_EQUAL(rdev_conf_get.device_state, SKELETON_DEV_STOPPED,
 356                               "Device stop failed. State is (%d)",
 357                               rdev_conf_get.device_state);
 358
 359         /* Unloading the firmware once device is stopped */
 360         ret = rte_rawdev_firmware_unload(test_dev_id);
 361         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to unload firmware (%d)", ret);
 362
 363         return TEST_SUCCESS;
 364 }
 365
 366 static int
 367 test_rawdev_enqdeq(void)
 368 {
 369         int ret;
 370         unsigned int count = 1;
 371         uint16_t queue_id = 0;
 372         struct rte_rawdev_buf buffers[1];
 373         struct rte_rawdev_buf *deq_buffers = NULL;
 374
 375         buffers[0].buf_addr = malloc(strlen(TEST_DEV_NAME) + 3);
 376         if (!buffers[0].buf_addr)
 377                 goto cleanup;
 378         snprintf(buffers[0].buf_addr, strlen(TEST_DEV_NAME) + 2, "%s%d",
 379                  TEST_DEV_NAME, 0);
 380
 381         ret = rte_rawdev_enqueue_buffers(test_dev_id,
 382                                          (struct rte_rawdev_buf **)&buffers,
 383                                          count, &queue_id);
 384         RTE_TEST_ASSERT_EQUAL((unsigned int)ret, count,
 385                               "Unable to enqueue buffers");
 386
 387         deq_buffers = malloc(sizeof(struct rte_rawdev_buf) * count);
 388         if (!deq_buffers)
 389                 goto cleanup;
 390
 391         ret = rte_rawdev_dequeue_buffers(test_dev_id,
 392                                         (struct rte_rawdev_buf **)&deq_buffers,
 393                                         count, &queue_id);
 394         RTE_TEST_ASSERT_EQUAL((unsigned int)ret, count,
 395                               "Unable to dequeue buffers");
 396
 397         if (deq_buffers)
 398                 free(deq_buffers);
 399
 400         return TEST_SUCCESS;
 401 cleanup:
 402         if (buffers[0].buf_addr)
 403                 free(buffers[0].buf_addr);
 404
 405         return TEST_FAILED;
 406 }
 407
 408 static void skeldev_test_run(int (*setup)(void),
 409                              void (*teardown)(void),
 410                              int (*test)(void),
 411                              const char *name)
 412 {
 413         int ret = 0;
 414
 415         if (setup) {
 416                 ret = setup();
 417                 if (ret < 0) {
 418                         SKELDEV_TEST_INFO("Error setting up test %s", name);
 419                         unsupported++;
 420                 }
 421         }
 422
 423         if (test) {
 424                 ret = test();
 425                 if (ret < 0) {
 426                         failed++;
 427                         SKELDEV_TEST_INFO("%s Failed", name);
 428                 } else {
 429                         passed++;
 430                         SKELDEV_TEST_DEBUG("%s Passed", name);
 431                 }
 432         }
 433
 434         if (teardown)
 435                 teardown();
 436
 437         total++;
 438 }
 439
 440 int
 441 test_rawdev_skeldev(uint16_t dev_id)
 442 {
 443         test_dev_id = dev_id;
 444         testsuite_setup();
 445
 446         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_count);
 447         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_get_dev_id);
 448         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_socket_id);
 449         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_info_get);
 450         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_configure);
 451         SKELDEV_TEST_RUN(test_rawdev_configure, NULL,
 452                          test_rawdev_queue_default_conf_get);
 453         SKELDEV_TEST_RUN(test_rawdev_configure, NULL, test_rawdev_queue_setup);
 454         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_queue_count);
 455         SKELDEV_TEST_RUN(test_rawdev_queue_setup, NULL,
 456                          test_rawdev_queue_release);
 457         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_attr_set_get);
 458         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_start_stop);
 459         SKELDEV_TEST_RUN(test_rawdev_queue_setup, NULL, test_rawdev_enqdeq);
 460
 461         testsuite_teardown();
 462
 463         SKELDEV_TEST_INFO("Total tests   : %d", total);
 464         SKELDEV_TEST_INFO("Passed        : %d", passed);
 465         SKELDEV_TEST_INFO("Failed        : %d", failed);
 466         SKELDEV_TEST_INFO("Not supported : %d", unsupported);
 467
 468         if (failed)
 469                 return -1;
 470
 471         return 0;
 472 };