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