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); 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); 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); 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 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to configure rawdev (%d)", ret); 148 149 rdev_info.dev_private = &rdev_conf_get; 150 ret = rte_rawdev_info_get(test_dev_id, 151 (rte_rawdev_obj_t)&rdev_info); 152 RTE_TEST_ASSERT_SUCCESS(ret, 153 "Failed to obtain rawdev configuration (%d)", 154 ret); 155 156 RTE_TEST_ASSERT_EQUAL(rdev_conf_set.num_queues, 157 rdev_conf_get.num_queues, 158 "Configuration test failed; num_queues (%d)(%d)", 159 rdev_conf_set.num_queues, 160 rdev_conf_get.num_queues); 161 RTE_TEST_ASSERT_EQUAL(rdev_conf_set.capabilities, 162 rdev_conf_get.capabilities, 163 "Configuration test failed; capabilities"); 164 165 return TEST_SUCCESS; 166 } 167 168 static int 169 test_rawdev_queue_default_conf_get(void) 170 { 171 int ret, i; 172 struct rte_rawdev_info rdev_info = {0}; 173 struct skeleton_rawdev_conf rdev_conf_get = {0}; 174 struct skeleton_rawdev_queue q = {0}; 175 176 /* Get the current configuration */ 177 rdev_info.dev_private = &rdev_conf_get; 178 ret = rte_rawdev_info_get(test_dev_id, 179 (rte_rawdev_obj_t)&rdev_info); 180 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to obtain rawdev configuration (%d)", 181 ret); 182 183 /* call to test_rawdev_configure would have set the num_queues = 1 */ 184 RTE_TEST_ASSERT_SUCCESS(!(rdev_conf_get.num_queues > 0), 185 "Invalid number of queues (%d). Expected 1", 186 rdev_conf_get.num_queues); 187 /* All queues by default should have state = DETACH and 188 * depth = DEF_DEPTH 189 */ 190 for (i = 0; i < rdev_conf_get.num_queues; i++) { 191 rte_rawdev_queue_conf_get(test_dev_id, i, &q); 192 RTE_TEST_ASSERT_EQUAL(q.depth, SKELETON_QUEUE_DEF_DEPTH, 193 "Invalid default depth of queue (%d)", 194 q.depth); 195 RTE_TEST_ASSERT_EQUAL(q.state, SKELETON_QUEUE_DETACH, 196 "Invalid default state of queue (%d)", 197 q.state); 198 } 199 200 return TEST_SUCCESS; 201 } 202 203 static int 204 test_rawdev_queue_count(void) 205 { 206 unsigned int q_count; 207 208 /* Get the current configuration */ 209 q_count = rte_rawdev_queue_count(test_dev_id); 210 RTE_TEST_ASSERT_EQUAL(q_count, 1, "Invalid queue count (%d)", q_count); 211 212 return TEST_SUCCESS; 213 } 214 215 static int 216 test_rawdev_queue_setup(void) 217 { 218 int ret; 219 struct rte_rawdev_info rdev_info = {0}; 220 struct skeleton_rawdev_conf rdev_conf_get = {0}; 221 struct skeleton_rawdev_queue qset = {0}; 222 struct skeleton_rawdev_queue qget = {0}; 223 224 /* Get the current configuration */ 225 rdev_info.dev_private = &rdev_conf_get; 226 ret = rte_rawdev_info_get(test_dev_id, 227 (rte_rawdev_obj_t)&rdev_info); 228 RTE_TEST_ASSERT_SUCCESS(ret, 229 "Failed to obtain rawdev configuration (%d)", 230 ret); 231 232 /* call to test_rawdev_configure would have set the num_queues = 1 */ 233 RTE_TEST_ASSERT_SUCCESS(!(rdev_conf_get.num_queues > 0), 234 "Invalid number of queues (%d). Expected 1", 235 rdev_conf_get.num_queues); 236 237 /* Modify the queue depth for Queue 0 and attach it */ 238 qset.depth = 15; 239 qset.state = SKELETON_QUEUE_ATTACH; 240 ret = rte_rawdev_queue_setup(test_dev_id, 0, &qset); 241 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to setup queue (%d)", ret); 242 243 /* Now, fetching the queue 0 should show depth as 15 */ 244 ret = rte_rawdev_queue_conf_get(test_dev_id, 0, &qget); 245 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to get queue config (%d)", ret); 246 247 RTE_TEST_ASSERT_EQUAL(qset.depth, qget.depth, 248 "Failed to set queue depth: Need(%d), has(%d)", 249 qset.depth, qget.depth); 250 251 return TEST_SUCCESS; 252 } 253 254 /* After executing test_rawdev_queue_setup, queue_id=0 would have depth as 15. 255 * Releasing should set it back to default. state would set to DETACH 256 */ 257 static int 258 test_rawdev_queue_release(void) 259 { 260 int ret; 261 struct skeleton_rawdev_queue qget = {0}; 262 263 /* Now, fetching the queue 0 should show depth as 100 */ 264 ret = rte_rawdev_queue_release(test_dev_id, 0); 265 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to release queue 0; (%d)", ret); 266 267 /* Now, fetching the queue 0 should show depth as default */ 268 ret = rte_rawdev_queue_conf_get(test_dev_id, 0, &qget); 269 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to get queue config (%d)", ret); 270 271 RTE_TEST_ASSERT_EQUAL(qget.depth, SKELETON_QUEUE_DEF_DEPTH, 272 "Release of Queue 0 failed; (depth)"); 273 274 RTE_TEST_ASSERT_EQUAL(qget.state, SKELETON_QUEUE_DETACH, 275 "Release of Queue 0 failed; (state)"); 276 277 return TEST_SUCCESS; 278 } 279 280 static int 281 test_rawdev_attr_set_get(void) 282 { 283 int ret; 284 int *dummy_value, set_value; 285 uint64_t ret_value; 286 287 /* Set an attribute and fetch it */ 288 ret = rte_rawdev_set_attr(test_dev_id, "Test1", 100); 289 RTE_TEST_ASSERT(!ret, "Unable to set an attribute (Test1)"); 290 291 dummy_value = &set_value; 292 *dummy_value = 200; 293 ret = rte_rawdev_set_attr(test_dev_id, "Test2", (uintptr_t)dummy_value); 294 295 /* Check if attributes have been set */ 296 ret = rte_rawdev_get_attr(test_dev_id, "Test1", &ret_value); 297 RTE_TEST_ASSERT_EQUAL(ret_value, 100, 298 "Attribute (Test1) not set correctly (%" PRIu64 ")", 299 ret_value); 300 301 ret_value = 0; 302 ret = rte_rawdev_get_attr(test_dev_id, "Test2", &ret_value); 303 RTE_TEST_ASSERT_EQUAL(*((int *)(uintptr_t)ret_value), set_value, 304 "Attribute (Test2) not set correctly (%" PRIu64 ")", 305 ret_value); 306 307 return TEST_SUCCESS; 308 } 309 310 static int 311 test_rawdev_start_stop(void) 312 { 313 int ret; 314 struct rte_rawdev_info rdev_info = {0}; 315 struct skeleton_rawdev_conf rdev_conf_get = {0}; 316 char *dummy_firmware = NULL; 317 318 /* Get the current configuration */ 319 rdev_info.dev_private = &rdev_conf_get; 320 321 /* Load a firmware using a dummy address area */ 322 dummy_firmware = rte_zmalloc("RAWDEV SKELETON", sizeof(int) * 10, 0); 323 RTE_TEST_ASSERT(dummy_firmware != NULL, 324 "Failed to create firmware memory backing"); 325 326 ret = rte_rawdev_firmware_load(test_dev_id, dummy_firmware); 327 RTE_TEST_ASSERT_SUCCESS(ret, "Firmware loading failed (%d)", ret); 328 329 /* Skeleton doesn't do anything with the firmware area - that is dummy 330 * and can be removed. 331 */ 332 rte_free(dummy_firmware); 333 dummy_firmware = NULL; 334 335 rte_rawdev_start(test_dev_id); 336 ret = rte_rawdev_info_get(test_dev_id, (rte_rawdev_obj_t)&rdev_info); 337 RTE_TEST_ASSERT_SUCCESS(ret, 338 "Failed to obtain rawdev configuration (%d)", 339 ret); 340 RTE_TEST_ASSERT_EQUAL(rdev_conf_get.device_state, SKELETON_DEV_RUNNING, 341 "Device start failed. State is (%d)", 342 rdev_conf_get.device_state); 343 344 rte_rawdev_stop(test_dev_id); 345 ret = rte_rawdev_info_get(test_dev_id, (rte_rawdev_obj_t)&rdev_info); 346 RTE_TEST_ASSERT_SUCCESS(ret, 347 "Failed to obtain rawdev configuration (%d)", 348 ret); 349 RTE_TEST_ASSERT_EQUAL(rdev_conf_get.device_state, SKELETON_DEV_STOPPED, 350 "Device stop failed. State is (%d)", 351 rdev_conf_get.device_state); 352 353 /* Unloading the firmware once device is stopped */ 354 ret = rte_rawdev_firmware_unload(test_dev_id); 355 RTE_TEST_ASSERT_SUCCESS(ret, "Failed to unload firmware (%d)", ret); 356 357 return TEST_SUCCESS; 358 } 359 360 static int 361 test_rawdev_enqdeq(void) 362 { 363 int ret; 364 unsigned int count = 1; 365 uint16_t queue_id = 0; 366 struct rte_rawdev_buf buffers[1]; 367 struct rte_rawdev_buf *deq_buffers = NULL; 368 369 buffers[0].buf_addr = malloc(strlen(TEST_DEV_NAME) + 3); 370 if (!buffers[0].buf_addr) 371 goto cleanup; 372 snprintf(buffers[0].buf_addr, strlen(TEST_DEV_NAME) + 2, "%s%d", 373 TEST_DEV_NAME, 0); 374 375 ret = rte_rawdev_enqueue_buffers(test_dev_id, 376 (struct rte_rawdev_buf **)&buffers, 377 count, &queue_id); 378 RTE_TEST_ASSERT_EQUAL((unsigned int)ret, count, 379 "Unable to enqueue buffers"); 380 381 deq_buffers = malloc(sizeof(struct rte_rawdev_buf) * count); 382 if (!deq_buffers) 383 goto cleanup; 384 385 ret = rte_rawdev_dequeue_buffers(test_dev_id, 386 (struct rte_rawdev_buf **)&deq_buffers, 387 count, &queue_id); 388 RTE_TEST_ASSERT_EQUAL((unsigned int)ret, count, 389 "Unable to dequeue buffers"); 390 391 if (deq_buffers) 392 free(deq_buffers); 393 394 return TEST_SUCCESS; 395 cleanup: 396 if (buffers[0].buf_addr) 397 free(buffers[0].buf_addr); 398 399 return TEST_FAILED; 400 } 401 402 static void skeldev_test_run(int (*setup)(void), 403 void (*teardown)(void), 404 int (*test)(void), 405 const char *name) 406 { 407 int ret = 0; 408 409 if (setup) { 410 ret = setup(); 411 if (ret < 0) { 412 SKELDEV_TEST_INFO("Error setting up test %s", name); 413 unsupported++; 414 } 415 } 416 417 if (test) { 418 ret = test(); 419 if (ret < 0) { 420 failed++; 421 SKELDEV_TEST_INFO("%s Failed", name); 422 } else { 423 passed++; 424 SKELDEV_TEST_DEBUG("%s Passed", name); 425 } 426 } 427 428 if (teardown) 429 teardown(); 430 431 total++; 432 } 433 434 int 435 test_rawdev_skeldev(uint16_t dev_id) 436 { 437 test_dev_id = dev_id; 438 testsuite_setup(); 439 440 SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_count); 441 SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_get_dev_id); 442 SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_socket_id); 443 SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_info_get); 444 SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_configure); 445 SKELDEV_TEST_RUN(test_rawdev_configure, NULL, 446 test_rawdev_queue_default_conf_get); 447 SKELDEV_TEST_RUN(test_rawdev_configure, NULL, test_rawdev_queue_setup); 448 SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_queue_count); 449 SKELDEV_TEST_RUN(test_rawdev_queue_setup, NULL, 450 test_rawdev_queue_release); 451 SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_attr_set_get); 452 SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_start_stop); 453 SKELDEV_TEST_RUN(test_rawdev_queue_setup, NULL, test_rawdev_enqdeq); 454 455 testsuite_teardown(); 456 457 SKELDEV_TEST_INFO("Total tests : %d", total); 458 SKELDEV_TEST_INFO("Passed : %d", passed); 459 SKELDEV_TEST_INFO("Failed : %d", failed); 460 SKELDEV_TEST_INFO("Not supported : %d", unsupported); 461 462 if (failed) 463 return -1; 464 465 return 0; 466 }; 467