1 /*
2 * Copyright (c) 2020 Demant
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 #include <string.h>
8 #include <zephyr/types.h>
9 #include <zephyr/ztest.h>
10
11 #include <stdio.h>
12 #include <stdlib.h>
13
14 #include "util/util.h"
15 #include "util/memq.h"
16 #include "util/dbuf.h"
17
18 #include "pdu_df.h"
19 #include "lll/pdu_vendor.h"
20 #include "hal/ccm.h"
21
22 #include "pdu.h"
23 #include "lll.h"
24 #include "lll/lll_df_types.h"
25 #include "lll_conn.h"
26
27 #include "ull_tx_queue.h"
28
29 #define SIZE 10U
30
ZTEST(tx_q,test_init)31 ZTEST(tx_q, test_init)
32 {
33 struct ull_tx_q tx_q;
34 struct node_tx *node;
35
36 ull_tx_q_init(&tx_q);
37 zassert_equal(0U, tx_q.pause_data, "pause_data must be zero on init");
38
39 /* Tx Queue shall be empty */
40 node = ull_tx_q_dequeue(&tx_q);
41 zassert_equal_ptr(node, NULL, "");
42 }
43
44 /*
45 * (1) Enqueue ctrl nodes.
46 * Dequeue and verify order of the ctrl nodes from (1).
47 * Verify Tx Queue is empty.
48 */
ZTEST(tx_q,test_ctrl)49 ZTEST(tx_q, test_ctrl)
50 {
51 struct ull_tx_q tx_q;
52 struct node_tx *node;
53 struct node_tx ctrl_nodes1[SIZE] = { 0 };
54
55 ull_tx_q_init(&tx_q);
56
57 /* Enqueue ctrl nodes */
58 for (int i = 0U; i < SIZE; i++) {
59 ull_tx_q_enqueue_ctrl(&tx_q, &ctrl_nodes1[i]);
60 }
61
62 /* Dequeue ctrl nodes */
63 for (int i = 0U; i < SIZE; i++) {
64 node = ull_tx_q_dequeue(&tx_q);
65 zassert_equal_ptr(node, &ctrl_nodes1[i], NULL);
66 }
67
68 /* Tx Queue shall be empty */
69 node = ull_tx_q_dequeue(&tx_q);
70 zassert_equal_ptr(node, NULL, "");
71 }
72
73 /*
74 * (1) Enqueue data nodes.
75 * Dequeue and verify order of the data nodes from (1).
76 * Verify Tx Queue is empty.
77 */
ZTEST(tx_q,test_data)78 ZTEST(tx_q, test_data)
79 {
80 struct ull_tx_q tx_q;
81 struct node_tx *node;
82 struct node_tx nodes[SIZE] = { 0 };
83
84 ull_tx_q_init(&tx_q);
85
86 /* Enqueue data nodes */
87 for (int i = 0U; i < SIZE; i++) {
88 ull_tx_q_enqueue_data(&tx_q, &nodes[i]);
89 }
90
91 /* Dequeue data nodes */
92 for (int i = 0U; i < SIZE; i++) {
93 node = ull_tx_q_dequeue(&tx_q);
94 zassert_equal_ptr(node, &nodes[i], NULL);
95 }
96
97 /* Tx Queue shall be empty */
98 node = ull_tx_q_dequeue(&tx_q);
99 zassert_equal_ptr(node, NULL, "");
100 }
101
102 /*
103 * (1) Enqueue ctrl and data nodes interleaved.
104 * Dequeue and verify order of the data and ctrl nodes from (1).
105 * Verify Tx Queue is empty.
106 */
ZTEST(tx_q,test_ctrl_and_data_1)107 ZTEST(tx_q, test_ctrl_and_data_1)
108 {
109 struct ull_tx_q tx_q;
110 struct node_tx *node;
111 struct node_tx ctrl_nodes1[SIZE] = { 0 };
112 struct node_tx data_nodes1[SIZE] = { 0 };
113
114 ull_tx_q_init(&tx_q);
115
116 /* Enqueue ctrl and data nodes */
117 for (int i = 0U; i < SIZE; i++) {
118 ull_tx_q_enqueue_ctrl(&tx_q, &ctrl_nodes1[i]);
119 ull_tx_q_enqueue_data(&tx_q, &data_nodes1[i]);
120 }
121
122 /* Dequeue ctrl and data nodes */
123 for (int i = 0U; i < SIZE; i++) {
124 node = ull_tx_q_dequeue(&tx_q);
125 zassert_equal_ptr(node, &ctrl_nodes1[i], NULL);
126
127 node = ull_tx_q_dequeue(&tx_q);
128 zassert_equal_ptr(node, &data_nodes1[i], NULL);
129 }
130
131 /* Tx Queue shall be empty */
132 node = ull_tx_q_dequeue(&tx_q);
133 zassert_equal_ptr(node, NULL, "");
134 }
135
136 /*
137 * (1) Enqueue ctrl and data nodes interleaved.
138 * Pause Tx Queue.
139 * (2) Enqueue data nodes.
140 * Dequeue and verify order of the data and ctrl nodes from (1).
141 * Verify Tx Queue is empty.
142 */
ZTEST(tx_q,test_ctrl_and_data_2)143 ZTEST(tx_q, test_ctrl_and_data_2)
144 {
145 struct ull_tx_q tx_q;
146 struct node_tx *node;
147 struct node_tx ctrl_nodes1[SIZE] = { 0 };
148 struct node_tx data_nodes1[SIZE] = { 0 };
149 struct node_tx data_nodes2[SIZE] = { 0 };
150
151 ull_tx_q_init(&tx_q);
152
153 /* Enqueue ctrl and data nodes */
154 for (int i = 0U; i < SIZE; i++) {
155 ull_tx_q_enqueue_ctrl(&tx_q, &ctrl_nodes1[i]);
156 ull_tx_q_enqueue_data(&tx_q, &data_nodes1[i]);
157 }
158
159 /* Pause Tx Queue */
160 ull_tx_q_pause_data(&tx_q);
161
162 /* Enqueue data nodes */
163 for (int i = 0U; i < SIZE; i++) {
164 ull_tx_q_enqueue_data(&tx_q, &data_nodes2[i]);
165 }
166
167 /* Dequeue ctrl and data nodes */
168 for (int i = 0U; i < SIZE; i++) {
169 node = ull_tx_q_dequeue(&tx_q);
170 zassert_equal_ptr(node, &ctrl_nodes1[i], NULL);
171
172 node = ull_tx_q_dequeue(&tx_q);
173 zassert_equal_ptr(node, &data_nodes1[i], NULL);
174 }
175
176 /* Tx Queue shall be empty */
177 node = ull_tx_q_dequeue(&tx_q);
178 zassert_equal_ptr(node, NULL, "");
179 }
180
181 /*
182 * (1) Enqueue ctrl and data nodes interleaved.
183 * Pause Tx Queue.
184 * (2) Enqueue ctrl and data nodes interleaved.
185 * Dequeue and verify order of ctrl and data nodes from (1).
186 * Dequeue and verify order of ctrl nodes from (2).
187 * Verify Tx Queue is empty.
188 */
ZTEST(tx_q,test_ctrl_and_data_3)189 ZTEST(tx_q, test_ctrl_and_data_3)
190 {
191 struct ull_tx_q tx_q;
192 struct node_tx *node;
193 struct node_tx ctrl_nodes1[SIZE] = { 0 };
194 struct node_tx ctrl_nodes2[SIZE] = { 0 };
195 struct node_tx data_nodes1[SIZE] = { 0 };
196 struct node_tx data_nodes2[SIZE] = { 0 };
197
198 ull_tx_q_init(&tx_q);
199
200 /* Enqueue ctrl and data nodes */
201 for (int i = 0U; i < SIZE; i++) {
202 ull_tx_q_enqueue_ctrl(&tx_q, &ctrl_nodes1[i]);
203 ull_tx_q_enqueue_data(&tx_q, &data_nodes1[i]);
204 }
205
206 /* Pause Tx Queue */
207 ull_tx_q_pause_data(&tx_q);
208
209 /* Enqueue ctrl and data nodes */
210 for (int i = 0U; i < SIZE; i++) {
211 ull_tx_q_enqueue_ctrl(&tx_q, &ctrl_nodes2[i]);
212 ull_tx_q_enqueue_data(&tx_q, &data_nodes2[i]);
213 }
214
215 /* Dequeue ctrl and data nodes */
216 for (int i = 0U; i < SIZE; i++) {
217 node = ull_tx_q_dequeue(&tx_q);
218 zassert_equal_ptr(node, &ctrl_nodes1[i], NULL);
219
220 node = ull_tx_q_dequeue(&tx_q);
221 zassert_equal_ptr(node, &data_nodes1[i], NULL);
222 }
223
224 /* Dequeue ctrl nodes */
225 for (int i = 0U; i < SIZE; i++) {
226 node = ull_tx_q_dequeue(&tx_q);
227 zassert_equal_ptr(node, &ctrl_nodes2[i], NULL);
228 }
229
230 /* Tx Queue shall be empty */
231 node = ull_tx_q_dequeue(&tx_q);
232 zassert_equal_ptr(node, NULL, "");
233 }
234
235 /*
236 * (1) Enqueue ctrl and data nodes interleaved.
237 * Pause Tx Queue.
238 * (2) Enqueue ctrl and data nodes interleaved.
239 * Resume Tx Queue.
240 * Dequeue and verify order of ctrl and data nodes from (1).
241 * Dequeue and verify order of ctrl nodes from (2).
242 * Dequeue and verify order of data nodes from (2).
243 * Verify Tx Queue is empty.
244 */
ZTEST(tx_q,test_ctrl_and_data_4)245 ZTEST(tx_q, test_ctrl_and_data_4)
246 {
247 struct ull_tx_q tx_q;
248 struct node_tx *node;
249 struct node_tx ctrl_nodes1[SIZE] = { 0 };
250 struct node_tx ctrl_nodes2[SIZE] = { 0 };
251 struct node_tx data_nodes1[SIZE] = { 0 };
252 struct node_tx data_nodes2[SIZE] = { 0 };
253
254 ull_tx_q_init(&tx_q);
255
256 /* Enqueue ctrl and data nodes */
257 for (int i = 0U; i < SIZE; i++) {
258 ull_tx_q_enqueue_ctrl(&tx_q, &ctrl_nodes1[i]);
259 ull_tx_q_enqueue_data(&tx_q, &data_nodes1[i]);
260 }
261
262 /* Pause Tx Queue */
263 ull_tx_q_pause_data(&tx_q);
264
265 /* Enqueue ctrl and data nodes */
266 for (int i = 0U; i < SIZE; i++) {
267 ull_tx_q_enqueue_ctrl(&tx_q, &ctrl_nodes2[i]);
268 ull_tx_q_enqueue_data(&tx_q, &data_nodes2[i]);
269 }
270
271 /* Resume Tx Queue */
272 ull_tx_q_resume_data(&tx_q);
273
274 /* Dequeue ctrl and data nodes */
275 for (int i = 0U; i < SIZE; i++) {
276 node = ull_tx_q_dequeue(&tx_q);
277 zassert_equal_ptr(node, &ctrl_nodes1[i], NULL);
278
279 node = ull_tx_q_dequeue(&tx_q);
280 zassert_equal_ptr(node, &data_nodes1[i], NULL);
281 }
282
283 /* Dequeue ctrl nodes */
284 for (int i = 0U; i < SIZE; i++) {
285 node = ull_tx_q_dequeue(&tx_q);
286 zassert_equal_ptr(node, &ctrl_nodes2[i], NULL);
287 }
288
289 /* Dequeue data nodes */
290 for (int i = 0U; i < SIZE; i++) {
291 node = ull_tx_q_dequeue(&tx_q);
292 zassert_equal_ptr(node, &data_nodes2[i], NULL);
293 }
294
295 /* Tx Queue shall be empty */
296 node = ull_tx_q_dequeue(&tx_q);
297 zassert_equal_ptr(node, NULL, "");
298 }
299
300 /*
301 * (1) Enqueue ctrl and data nodes interleaved.
302 * Pause Tx Queue.
303 * (2) Enqueue ctrl and data nodes interleaved.
304 * Resume Tx Queue.
305 * (3) Enqueue ctrl and data nodes interleaved.
306 * Dequeue and verify order of ctrl and data nodes from (1).
307 * Dequeue and verify order of ctrl nodes from (2).
308 * Dequeue and verify order of data nodes from (2).
309 * Dequeue and verify order of ctrl and data nodes from (3).
310 * Verify Tx Queue is empty.
311 */
ZTEST(tx_q,test_ctrl_and_data_5)312 ZTEST(tx_q, test_ctrl_and_data_5)
313 {
314 struct ull_tx_q tx_q;
315 struct node_tx *node;
316 struct node_tx ctrl_nodes1[SIZE] = { 0 };
317 struct node_tx ctrl_nodes2[SIZE] = { 0 };
318 struct node_tx ctrl_nodes3[SIZE] = { 0 };
319 struct node_tx data_nodes1[SIZE] = { 0 };
320 struct node_tx data_nodes2[SIZE] = { 0 };
321 struct node_tx data_nodes3[SIZE] = { 0 };
322
323 ull_tx_q_init(&tx_q);
324
325 /* Enqueue ctrl and data nodes */
326 for (int i = 0U; i < SIZE; i++) {
327 ull_tx_q_enqueue_ctrl(&tx_q, &ctrl_nodes1[i]);
328 ull_tx_q_enqueue_data(&tx_q, &data_nodes1[i]);
329 }
330
331 /* Pause Tx Queue */
332 ull_tx_q_pause_data(&tx_q);
333
334 /* Enqueue ctrl and data nodes */
335 for (int i = 0U; i < SIZE; i++) {
336 ull_tx_q_enqueue_ctrl(&tx_q, &ctrl_nodes2[i]);
337 ull_tx_q_enqueue_data(&tx_q, &data_nodes2[i]);
338 }
339
340 /* Resume Tx Queue */
341 ull_tx_q_resume_data(&tx_q);
342
343 /* Enqueue ctrl and data nodes */
344 for (int i = 0U; i < SIZE; i++) {
345 ull_tx_q_enqueue_ctrl(&tx_q, &ctrl_nodes3[i]);
346 ull_tx_q_enqueue_data(&tx_q, &data_nodes3[i]);
347 }
348
349 /* Dequeue ctrl and data nodes */
350 for (int i = 0U; i < SIZE; i++) {
351 node = ull_tx_q_dequeue(&tx_q);
352 zassert_equal_ptr(node, &ctrl_nodes1[i], NULL);
353
354 node = ull_tx_q_dequeue(&tx_q);
355 zassert_equal_ptr(node, &data_nodes1[i], NULL);
356 }
357
358 /* Dequeue ctrl nodes */
359 for (int i = 0U; i < SIZE; i++) {
360 node = ull_tx_q_dequeue(&tx_q);
361
362 zassert_equal_ptr(node, &ctrl_nodes2[i], NULL);
363 }
364
365 /* Dequeue data nodes */
366 for (int i = 0U; i < SIZE; i++) {
367 node = ull_tx_q_dequeue(&tx_q);
368
369 zassert_equal_ptr(node, &data_nodes2[i], NULL);
370 }
371
372 /* Dequeue ctrl and data nodes */
373 for (int i = 0U; i < SIZE; i++) {
374 node = ull_tx_q_dequeue(&tx_q);
375 zassert_equal_ptr(node, &ctrl_nodes3[i], NULL);
376
377 node = ull_tx_q_dequeue(&tx_q);
378 zassert_equal_ptr(node, &data_nodes3[i], NULL);
379 }
380
381 /* Tx Queue shall be empty */
382 node = ull_tx_q_dequeue(&tx_q);
383 zassert_equal_ptr(node, NULL, "");
384 }
385
386 /*
387 * (1) Enqueue data nodes.
388 * Pause Tx Queue TWICE.
389 * (2) Enqueue data nodes.
390 * Dequeue and verify order of data nodes from (1).
391 * Verify Tx Queue is empty.
392 * Resume Tx Queue.
393 * Verify Tx Queue is empty.
394 * Resume Tx Queue.
395 * Dequeue and verify order of data nodes from (2).
396 */
ZTEST(tx_q,test_multiple_pause_resume)397 ZTEST(tx_q, test_multiple_pause_resume)
398 {
399 struct ull_tx_q tx_q;
400 struct node_tx *node;
401 struct node_tx data_nodes1[SIZE] = { 0 };
402 struct node_tx data_nodes2[SIZE] = { 0 };
403
404 ull_tx_q_init(&tx_q);
405
406 /* Enqueue data 1 nodes */
407 for (int i = 0U; i < SIZE; i++) {
408 ull_tx_q_enqueue_data(&tx_q, &data_nodes1[i]);
409 }
410
411 /* Pause Tx Queue Twice */
412 ull_tx_q_pause_data(&tx_q);
413 ull_tx_q_pause_data(&tx_q);
414
415 /* Enqueue data 2 nodes */
416 for (int i = 0U; i < SIZE; i++) {
417 ull_tx_q_enqueue_data(&tx_q, &data_nodes2[i]);
418 }
419
420 /* Dequeue data 1 nodes */
421 for (int i = 0U; i < SIZE; i++) {
422 node = ull_tx_q_dequeue(&tx_q);
423 zassert_equal_ptr(node, &data_nodes1[i], NULL);
424 }
425
426 /* Tx Queue shall be empty */
427 node = ull_tx_q_dequeue(&tx_q);
428 zassert_equal_ptr(node, NULL, "");
429
430 /* Resume Tx Queue */
431 ull_tx_q_resume_data(&tx_q);
432
433 /* Tx Queue shall be empty */
434 node = ull_tx_q_dequeue(&tx_q);
435 zassert_equal_ptr(node, NULL, "");
436
437 /* Resume Tx Queue */
438 ull_tx_q_resume_data(&tx_q);
439
440 /* Dequeue data 2 nodes */
441 for (int i = 0U; i < SIZE; i++) {
442 node = ull_tx_q_dequeue(&tx_q);
443 zassert_equal_ptr(node, &data_nodes2[i], NULL);
444 }
445
446 /* Tx Queue shall be empty */
447 node = ull_tx_q_dequeue(&tx_q);
448 zassert_equal_ptr(node, NULL, "");
449 }
450
451 ZTEST_SUITE(tx_q, NULL, NULL, NULL, NULL, NULL);
452
