projects/linux·blob master · refs

917 lines · 32.1 KiB

1// SPDX-License-Identifier: GPL-2.0-or-later
2//
3// packet-serdes-test.c - An application of Kunit to check serialization/deserialization of packets
4// defined by IEEE 1394.
5//
6// Copyright (c) 2024 Takashi Sakamoto
7
8#include <kunit/test.h>
9
10#include <linux/firewire-constants.h>
11
12#include "packet-header-definitions.h"
13#include "phy-packet-definitions.h"
14
15static void serialize_async_header_common(u32 header[ASYNC_HEADER_QUADLET_COUNT],
16 unsigned int dst_id, unsigned int tlabel,
17 unsigned int retry, unsigned int tcode,
18 unsigned int priority, unsigned int src_id)
19{
20 async_header_set_destination(header, dst_id);
21 async_header_set_tlabel(header, tlabel);
22 async_header_set_retry(header, retry);
23 async_header_set_tcode(header, tcode);
24 async_header_set_priority(header, priority);
25 async_header_set_source(header, src_id);
26}
27
28static void serialize_async_header_request(u32 header[ASYNC_HEADER_QUADLET_COUNT],
29 unsigned int dst_id, unsigned int tlabel,
30 unsigned int retry, unsigned int tcode,
31 unsigned int priority, unsigned int src_id, u64 offset)
32{
33 serialize_async_header_common(header, dst_id, tlabel, retry, tcode, priority, src_id);
34 async_header_set_offset(header, offset);
35}
36
37static void serialize_async_header_quadlet_request(u32 header[ASYNC_HEADER_QUADLET_COUNT],
38 unsigned int dst_id, unsigned int tlabel,
39 unsigned int retry, unsigned int tcode,
40 unsigned int priority, unsigned int src_id,
41 u64 offset)
42{
43 serialize_async_header_request(header, dst_id, tlabel, retry, tcode, priority, src_id,
44 offset);
45}
46
47static void serialize_async_header_block_request(u32 header[ASYNC_HEADER_QUADLET_COUNT],
48 unsigned int dst_id, unsigned int tlabel,
49 unsigned int retry, unsigned int tcode,
50 unsigned int priority, unsigned int src_id,
51 u64 offset, unsigned int data_length,
52 unsigned int extended_tcode)
53{
54 serialize_async_header_request(header, dst_id, tlabel, retry, tcode, priority, src_id,
55 offset);
56 async_header_set_data_length(header, data_length);
57 async_header_set_extended_tcode(header, extended_tcode);
58}
59
60static void serialize_async_header_response(u32 header[ASYNC_HEADER_QUADLET_COUNT],
61 unsigned int dst_id, unsigned int tlabel,
62 unsigned int retry, unsigned int tcode,
63 unsigned int priority, unsigned int src_id,
64 unsigned int rcode)
65{
66 serialize_async_header_common(header, dst_id, tlabel, retry, tcode, priority, src_id);
67 async_header_set_rcode(header, rcode);
68}
69
70static void serialize_async_header_quadlet_response(u32 header[ASYNC_HEADER_QUADLET_COUNT],
71 unsigned int dst_id, unsigned int tlabel,
72 unsigned int retry, unsigned int tcode,
73 unsigned int priority, unsigned int src_id,
74 unsigned int rcode)
75{
76 serialize_async_header_response(header, dst_id, tlabel, retry, tcode, priority, src_id,
77 rcode);
78}
79
80static void serialize_async_header_block_response(u32 header[ASYNC_HEADER_QUADLET_COUNT],
81 unsigned int dst_id, unsigned int tlabel,
82 unsigned int retry, unsigned int tcode,
83 unsigned int priority, unsigned int src_id,
84 unsigned int rcode, unsigned int data_length,
85 unsigned int extended_tcode)
86{
87 serialize_async_header_response(header, dst_id, tlabel, retry, tcode, priority, src_id,
88 rcode);
89 async_header_set_data_length(header, data_length);
90 async_header_set_extended_tcode(header, extended_tcode);
91}
92
93static void deserialize_async_header_common(const u32 header[ASYNC_HEADER_QUADLET_COUNT],
94 unsigned int *dst_id, unsigned int *tlabel,
95 unsigned int *retry, unsigned int *tcode,
96 unsigned int *priority, unsigned int *src_id)
97{
98 *dst_id = async_header_get_destination(header);
99 *tlabel = async_header_get_tlabel(header);
100 *retry = async_header_get_retry(header);
101 *tcode = async_header_get_tcode(header);
102 *priority = async_header_get_priority(header);
103 *src_id = async_header_get_source(header);
104}
105
106static void deserialize_async_header_request(const u32 header[ASYNC_HEADER_QUADLET_COUNT],
107 unsigned int *dst_id, unsigned int *tlabel,
108 unsigned int *retry, unsigned int *tcode,
109 unsigned int *priority, unsigned int *src_id,
110 u64 *offset)
111{
112 deserialize_async_header_common(header, dst_id, tlabel, retry, tcode, priority, src_id);
113 *offset = async_header_get_offset(header);
114}
115
116static void deserialize_async_header_quadlet_request(const u32 header[ASYNC_HEADER_QUADLET_COUNT],
117 unsigned int *dst_id, unsigned int *tlabel,
118 unsigned int *retry, unsigned int *tcode,
119 unsigned int *priority, unsigned int *src_id,
120 u64 *offset)
121{
122 deserialize_async_header_request(header, dst_id, tlabel, retry, tcode, priority, src_id,
123 offset);
124}
125
126static void deserialize_async_header_block_request(const u32 header[ASYNC_HEADER_QUADLET_COUNT],
127 unsigned int *dst_id, unsigned int *tlabel,
128 unsigned int *retry, unsigned int *tcode,
129 unsigned int *priority, unsigned int *src_id,
130 u64 *offset,
131 unsigned int *data_length,
132 unsigned int *extended_tcode)
133{
134 deserialize_async_header_request(header, dst_id, tlabel, retry, tcode, priority, src_id,
135 offset);
136 *data_length = async_header_get_data_length(header);
137 *extended_tcode = async_header_get_extended_tcode(header);
138}
139
140static void deserialize_async_header_response(const u32 header[ASYNC_HEADER_QUADLET_COUNT],
141 unsigned int *dst_id, unsigned int *tlabel,
142 unsigned int *retry, unsigned int *tcode,
143 unsigned int *priority, unsigned int *src_id,
144 unsigned int *rcode)
145{
146 deserialize_async_header_common(header, dst_id, tlabel, retry, tcode, priority, src_id);
147 *rcode = async_header_get_rcode(header);
148}
149
150static void deserialize_async_header_quadlet_response(const u32 header[ASYNC_HEADER_QUADLET_COUNT],
151 unsigned int *dst_id, unsigned int *tlabel,
152 unsigned int *retry, unsigned int *tcode,
153 unsigned int *priority, unsigned int *src_id,
154 unsigned int *rcode)
155{
156 deserialize_async_header_response(header, dst_id, tlabel, retry, tcode, priority, src_id, rcode);
157}
158
159static void deserialize_async_header_block_response(const u32 header[ASYNC_HEADER_QUADLET_COUNT],
160 unsigned int *dst_id, unsigned int *tlabel,
161 unsigned int *retry, unsigned int *tcode,
162 unsigned int *priority, unsigned int *src_id,
163 unsigned int *rcode, unsigned int *data_length,
164 unsigned int *extended_tcode)
165{
166 deserialize_async_header_response(header, dst_id, tlabel, retry, tcode, priority, src_id, rcode);
167 *data_length = async_header_get_data_length(header);
168 *extended_tcode = async_header_get_extended_tcode(header);
169}
170
171static void serialize_isoc_header(u32 *header, unsigned int data_length, unsigned int tag,
172 unsigned int channel, unsigned int tcode, unsigned int sy)
173{
174 isoc_header_set_data_length(header, data_length);
175 isoc_header_set_tag(header, tag);
176 isoc_header_set_channel(header, channel);
177 isoc_header_set_tcode(header, tcode);
178 isoc_header_set_sy(header, sy);
179}
180
181static void deserialize_isoc_header(u32 header, unsigned int *data_length, unsigned int *tag,
182 unsigned int *channel, unsigned int *tcode, unsigned int *sy)
183{
184 *data_length = isoc_header_get_data_length(header);
185 *tag = isoc_header_get_tag(header);
186 *channel = isoc_header_get_channel(header);
187 *tcode = isoc_header_get_tcode(header);
188 *sy = isoc_header_get_sy(header);
189}
190
191static void serialize_phy_packet_self_id_zero(u32 *quadlet, unsigned int packet_identifier,
192 unsigned int phy_id, bool extended,
193 bool link_is_active, unsigned int gap_count,
194 unsigned int scode, bool is_contender,
195 unsigned int power_class, bool is_initiated_reset,
196 bool has_more_packets)
197{
198 phy_packet_set_packet_identifier(quadlet, packet_identifier);
199 phy_packet_self_id_set_phy_id(quadlet, phy_id);
200 phy_packet_self_id_set_extended(quadlet, extended);
201 phy_packet_self_id_zero_set_link_active(quadlet, link_is_active);
202 phy_packet_self_id_zero_set_gap_count(quadlet, gap_count);
203 phy_packet_self_id_zero_set_scode(quadlet, scode);
204 phy_packet_self_id_zero_set_contender(quadlet, is_contender);
205 phy_packet_self_id_zero_set_power_class(quadlet, power_class);
206 phy_packet_self_id_zero_set_initiated_reset(quadlet, is_initiated_reset);
207 phy_packet_self_id_set_more_packets(quadlet, has_more_packets);
208}
209
210static void deserialize_phy_packet_self_id_zero(u32 quadlet, unsigned int *packet_identifier,
211 unsigned int *phy_id, bool *extended,
212 bool *link_is_active, unsigned int *gap_count,
213 unsigned int *scode, bool *is_contender,
214 unsigned int *power_class,
215 bool *is_initiated_reset, bool *has_more_packets)
216{
217 *packet_identifier = phy_packet_get_packet_identifier(quadlet);
218 *phy_id = phy_packet_self_id_get_phy_id(quadlet);
219 *extended = phy_packet_self_id_get_extended(quadlet);
220 *link_is_active = phy_packet_self_id_zero_get_link_active(quadlet);
221 *gap_count = phy_packet_self_id_zero_get_gap_count(quadlet);
222 *scode = phy_packet_self_id_zero_get_scode(quadlet);
223 *is_contender = phy_packet_self_id_zero_get_contender(quadlet);
224 *power_class = phy_packet_self_id_zero_get_power_class(quadlet);
225 *is_initiated_reset = phy_packet_self_id_zero_get_initiated_reset(quadlet);
226 *has_more_packets = phy_packet_self_id_get_more_packets(quadlet);
227}
228
229static void serialize_phy_packet_self_id_extended(u32 *quadlet, unsigned int packet_identifier,
230 unsigned int phy_id, bool extended,
231 unsigned int sequence, bool has_more_packets)
232{
233 phy_packet_set_packet_identifier(quadlet, packet_identifier);
234 phy_packet_self_id_set_phy_id(quadlet, phy_id);
235 phy_packet_self_id_set_extended(quadlet, extended);
236 phy_packet_self_id_extended_set_sequence(quadlet, sequence);
237 phy_packet_self_id_set_more_packets(quadlet, has_more_packets);
238}
239
240static void deserialize_phy_packet_self_id_extended(u32 quadlet, unsigned int *packet_identifier,
241 unsigned int *phy_id, bool *extended,
242 unsigned int *sequence, bool *has_more_packets)
243{
244 *packet_identifier = phy_packet_get_packet_identifier(quadlet);
245 *phy_id = phy_packet_self_id_get_phy_id(quadlet);
246 *extended = phy_packet_self_id_get_extended(quadlet);
247 *sequence = phy_packet_self_id_extended_get_sequence(quadlet);
248 *has_more_packets = phy_packet_self_id_get_more_packets(quadlet);
249}
250
251static void serialize_phy_packet_phy_config(u32 *quadlet, unsigned int packet_identifier,
252 unsigned int root_id, bool has_force_root_node,
253 bool has_gap_count_optimization, unsigned int gap_count)
254{
255 phy_packet_set_packet_identifier(quadlet, packet_identifier);
256 phy_packet_phy_config_set_root_id(quadlet, root_id);
257 phy_packet_phy_config_set_force_root_node(quadlet, has_force_root_node);
258 phy_packet_phy_config_set_gap_count_optimization(quadlet, has_gap_count_optimization);
259 phy_packet_phy_config_set_gap_count(quadlet, gap_count);
260}
261
262static void deserialize_phy_packet_phy_config(u32 quadlet, unsigned int *packet_identifier,
263 unsigned int *root_id, bool *has_force_root_node,
264 bool *has_gap_count_optimization,
265 unsigned int *gap_count)
266{
267 *packet_identifier = phy_packet_get_packet_identifier(quadlet);
268 *root_id = phy_packet_phy_config_get_root_id(quadlet);
269 *has_force_root_node = phy_packet_phy_config_get_force_root_node(quadlet);
270 *has_gap_count_optimization = phy_packet_phy_config_get_gap_count_optimization(quadlet);
271 *gap_count = phy_packet_phy_config_get_gap_count(quadlet);
272}
273
274static void test_async_header_write_quadlet_request(struct kunit *test)
275{
276 static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
277 0xffc05100,
278 0xffc1ffff,
279 0xf0000234,
280 0x1f0000c0,
281 };
282 u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
283
284 unsigned int dst_id;
285 unsigned int tlabel;
286 unsigned int retry;
287 unsigned int tcode;
288 unsigned int priority;
289 unsigned int src_id;
290 u64 offset;
291 u32 quadlet_data;
292
293 deserialize_async_header_quadlet_request(expected, &dst_id, &tlabel, &retry, &tcode,
294 &priority, &src_id, &offset);
295 quadlet_data = async_header_get_quadlet_data(expected);
296
297 KUNIT_EXPECT_EQ(test, 0xffc0, dst_id);
298 KUNIT_EXPECT_EQ(test, 0x14, tlabel);
299 KUNIT_EXPECT_EQ(test, 0x01, retry);
300 KUNIT_EXPECT_EQ(test, TCODE_WRITE_QUADLET_REQUEST, tcode);
301 KUNIT_EXPECT_EQ(test, 0x00, priority);
302 KUNIT_EXPECT_EQ(test, 0xffc1, src_id);
303 KUNIT_EXPECT_EQ(test, 0xfffff0000234, offset);
304 KUNIT_EXPECT_EQ(test, 0x1f0000c0, quadlet_data);
305
306 serialize_async_header_quadlet_request(header, dst_id, tlabel, retry, tcode, priority,
307 src_id, offset);
308 async_header_set_quadlet_data(header, quadlet_data);
309
310 KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
311}
312
313static void test_async_header_write_block_request(struct kunit *test)
314{
315 static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
316 0xffc06510,
317 0xffc1ecc0,
318 0x00000000,
319 0x00180000,
320 };
321 u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
322
323 unsigned int dst_id;
324 unsigned int tlabel;
325 unsigned int retry;
326 unsigned int tcode;
327 unsigned int priority;
328 unsigned int src_id;
329 u64 offset;
330 unsigned int data_length;
331 unsigned int extended_tcode;
332
333 deserialize_async_header_block_request(expected, &dst_id, &tlabel, &retry, &tcode,
334 &priority, &src_id, &offset, &data_length,
335 &extended_tcode);
336
337 KUNIT_EXPECT_EQ(test, 0xffc0, dst_id);
338 KUNIT_EXPECT_EQ(test, 0x19, tlabel);
339 KUNIT_EXPECT_EQ(test, 0x01, retry);
340 KUNIT_EXPECT_EQ(test, TCODE_WRITE_BLOCK_REQUEST, tcode);
341 KUNIT_EXPECT_EQ(test, 0x00, priority);
342 KUNIT_EXPECT_EQ(test, 0xffc1, src_id);
343 KUNIT_EXPECT_EQ(test, 0xecc000000000, offset);
344 KUNIT_EXPECT_EQ(test, 0x0018, data_length);
345 KUNIT_EXPECT_EQ(test, 0x0000, extended_tcode);
346
347 serialize_async_header_block_request(header, dst_id, tlabel, retry, tcode, priority, src_id,
348 offset, data_length, extended_tcode);
349
350 KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
351}
352
353static void test_async_header_write_response(struct kunit *test)
354{
355 static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
356 0xffc15120,
357 0xffc00000,
358 0x00000000,
359 0x00000000,
360 };
361 u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
362
363 unsigned int dst_id;
364 unsigned int tlabel;
365 unsigned int retry;
366 unsigned int tcode;
367 unsigned int priority;
368 unsigned int src_id;
369 unsigned int rcode;
370
371 deserialize_async_header_quadlet_response(expected, &dst_id, &tlabel, &retry, &tcode,
372 &priority, &src_id, &rcode);
373
374 KUNIT_EXPECT_EQ(test, 0xffc1, dst_id);
375 KUNIT_EXPECT_EQ(test, 0x14, tlabel);
376 KUNIT_EXPECT_EQ(test, 0x01, retry);
377 KUNIT_EXPECT_EQ(test, TCODE_WRITE_RESPONSE, tcode);
378 KUNIT_EXPECT_EQ(test, 0x00, priority);
379 KUNIT_EXPECT_EQ(test, 0xffc0, src_id);
380 KUNIT_EXPECT_EQ(test, RCODE_COMPLETE, rcode);
381
382 serialize_async_header_quadlet_response(header, dst_id, tlabel, retry, tcode, priority,
383 src_id, rcode);
384
385 KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected) - sizeof(expected[0]));
386}
387
388static void test_async_header_read_quadlet_request(struct kunit *test)
389{
390 static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
391 0xffc0f140,
392 0xffc1ffff,
393 0xf0000984,
394 0x00000000,
395 };
396 u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
397
398 unsigned int dst_id;
399 unsigned int tlabel;
400 unsigned int retry;
401 unsigned int tcode;
402 unsigned int priority;
403 unsigned int src_id;
404 u64 offset;
405
406 deserialize_async_header_quadlet_request(expected, &dst_id, &tlabel, &retry, &tcode,
407 &priority, &src_id, &offset);
408
409 KUNIT_EXPECT_EQ(test, 0xffc0, dst_id);
410 KUNIT_EXPECT_EQ(test, 0x3c, tlabel);
411 KUNIT_EXPECT_EQ(test, 0x01, retry);
412 KUNIT_EXPECT_EQ(test, TCODE_READ_QUADLET_REQUEST, tcode);
413 KUNIT_EXPECT_EQ(test, 0x00, priority);
414 KUNIT_EXPECT_EQ(test, 0xffc1, src_id);
415 KUNIT_EXPECT_EQ(test, 0xfffff0000984, offset);
416
417 serialize_async_header_quadlet_request(header, dst_id, tlabel, retry, tcode, priority,
418 src_id, offset);
419
420 KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
421}
422
423static void test_async_header_read_quadlet_response(struct kunit *test)
424{
425 static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
426 0xffc1f160,
427 0xffc00000,
428 0x00000000,
429 0x00000180,
430 };
431 u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
432
433 unsigned int dst_id;
434 unsigned int tlabel;
435 unsigned int retry;
436 unsigned int tcode;
437 unsigned int priority;
438 unsigned int src_id;
439 unsigned int rcode;
440 u32 quadlet_data;
441
442 deserialize_async_header_quadlet_response(expected, &dst_id, &tlabel, &retry, &tcode,
443 &priority, &src_id, &rcode);
444 quadlet_data = async_header_get_quadlet_data(expected);
445
446 KUNIT_EXPECT_EQ(test, 0xffc1, dst_id);
447 KUNIT_EXPECT_EQ(test, 0x3c, tlabel);
448 KUNIT_EXPECT_EQ(test, 0x01, retry);
449 KUNIT_EXPECT_EQ(test, TCODE_READ_QUADLET_RESPONSE, tcode);
450 KUNIT_EXPECT_EQ(test, 0x00, priority);
451 KUNIT_EXPECT_EQ(test, 0xffc0, src_id);
452 KUNIT_EXPECT_EQ(test, RCODE_COMPLETE, rcode);
453 KUNIT_EXPECT_EQ(test, 0x00000180, quadlet_data);
454
455 serialize_async_header_quadlet_response(header, dst_id, tlabel, retry, tcode, priority,
456 src_id, rcode);
457 async_header_set_quadlet_data(header, quadlet_data);
458
459 KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
460}
461
462static void test_async_header_read_block_request(struct kunit *test)
463{
464 static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
465 0xffc0e150,
466 0xffc1ffff,
467 0xf0000400,
468 0x00200000,
469 };
470 u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
471
472 unsigned int dst_id;
473 unsigned int tlabel;
474 unsigned int retry;
475 unsigned int tcode;
476 unsigned int priority;
477 unsigned int src_id;
478 u64 offset;
479 unsigned int data_length;
480 unsigned int extended_tcode;
481
482 deserialize_async_header_block_request(expected, &dst_id, &tlabel, &retry, &tcode,
483 &priority, &src_id, &offset, &data_length,
484 &extended_tcode);
485
486 KUNIT_EXPECT_EQ(test, 0xffc0, dst_id);
487 KUNIT_EXPECT_EQ(test, 0x38, tlabel);
488 KUNIT_EXPECT_EQ(test, 0x01, retry);
489 KUNIT_EXPECT_EQ(test, TCODE_READ_BLOCK_REQUEST, tcode);
490 KUNIT_EXPECT_EQ(test, 0x00, priority);
491 KUNIT_EXPECT_EQ(test, 0xffc1, src_id);
492 KUNIT_EXPECT_EQ(test, 0xfffff0000400, offset);
493 KUNIT_EXPECT_EQ(test, 0x0020, data_length);
494 KUNIT_EXPECT_EQ(test, 0x0000, extended_tcode);
495
496 serialize_async_header_block_request(header, dst_id, tlabel, retry, tcode, priority, src_id,
497 offset, data_length, extended_tcode);
498
499 KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
500}
501
502static void test_async_header_read_block_response(struct kunit *test)
503{
504 static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
505 0xffc1e170,
506 0xffc00000,
507 0x00000000,
508 0x00200000,
509 };
510 u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
511
512 unsigned int dst_id;
513 unsigned int tlabel;
514 unsigned int retry;
515 unsigned int tcode;
516 unsigned int priority;
517 unsigned int src_id;
518 unsigned int rcode;
519 unsigned int data_length;
520 unsigned int extended_tcode;
521
522 deserialize_async_header_block_response(expected, &dst_id, &tlabel, &retry, &tcode,
523 &priority, &src_id, &rcode, &data_length,
524 &extended_tcode);
525
526 KUNIT_EXPECT_EQ(test, 0xffc1, dst_id);
527 KUNIT_EXPECT_EQ(test, 0x38, tlabel);
528 KUNIT_EXPECT_EQ(test, 0x01, retry);
529 KUNIT_EXPECT_EQ(test, TCODE_READ_BLOCK_RESPONSE, tcode);
530 KUNIT_EXPECT_EQ(test, 0x00, priority);
531 KUNIT_EXPECT_EQ(test, 0xffc0, src_id);
532 KUNIT_EXPECT_EQ(test, RCODE_COMPLETE, rcode);
533 KUNIT_EXPECT_EQ(test, 0x0020, data_length);
534 KUNIT_EXPECT_EQ(test, 0x0000, extended_tcode);
535
536 serialize_async_header_block_response(header, dst_id, tlabel, retry, tcode, priority,
537 src_id, rcode, data_length, extended_tcode);
538
539 KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
540}
541
542static void test_async_header_lock_request(struct kunit *test)
543{
544 static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
545 0xffc02d90,
546 0xffc1ffff,
547 0xf0000984,
548 0x00080002,
549 };
550 u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
551
552 unsigned int dst_id;
553 unsigned int tlabel;
554 unsigned int retry;
555 unsigned int tcode;
556 unsigned int priority;
557 unsigned int src_id;
558 u64 offset;
559 unsigned int data_length;
560 unsigned int extended_tcode;
561
562 deserialize_async_header_block_request(expected, &dst_id, &tlabel, &retry, &tcode,
563 &priority, &src_id, &offset, &data_length,
564 &extended_tcode);
565
566 KUNIT_EXPECT_EQ(test, 0xffc0, dst_id);
567 KUNIT_EXPECT_EQ(test, 0x0b, tlabel);
568 KUNIT_EXPECT_EQ(test, 0x01, retry);
569 KUNIT_EXPECT_EQ(test, TCODE_LOCK_REQUEST, tcode);
570 KUNIT_EXPECT_EQ(test, 0x00, priority);
571 KUNIT_EXPECT_EQ(test, 0xffc1, src_id);
572 KUNIT_EXPECT_EQ(test, 0xfffff0000984, offset);
573 KUNIT_EXPECT_EQ(test, 0x0008, data_length);
574 KUNIT_EXPECT_EQ(test, EXTCODE_COMPARE_SWAP, extended_tcode);
575
576 serialize_async_header_block_request(header, dst_id, tlabel, retry, tcode, priority, src_id,
577 offset, data_length, extended_tcode);
578
579 KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
580}
581
582static void test_async_header_lock_response(struct kunit *test)
583{
584 static const u32 expected[ASYNC_HEADER_QUADLET_COUNT] = {
585 0xffc12db0,
586 0xffc00000,
587 0x00000000,
588 0x00040002,
589 };
590 u32 header[ASYNC_HEADER_QUADLET_COUNT] = {0, 0, 0, 0};
591
592 unsigned int dst_id;
593 unsigned int tlabel;
594 unsigned int retry;
595 unsigned int tcode;
596 unsigned int priority;
597 unsigned int src_id;
598 unsigned int rcode;
599 unsigned int data_length;
600 unsigned int extended_tcode;
601
602 deserialize_async_header_block_response(expected, &dst_id, &tlabel, &retry, &tcode,
603 &priority, &src_id, &rcode, &data_length,
604 &extended_tcode);
605
606 KUNIT_EXPECT_EQ(test, 0xffc1, dst_id);
607 KUNIT_EXPECT_EQ(test, 0x0b, tlabel);
608 KUNIT_EXPECT_EQ(test, 0x01, retry);
609 KUNIT_EXPECT_EQ(test, TCODE_LOCK_RESPONSE, tcode);
610 KUNIT_EXPECT_EQ(test, 0x00, priority);
611 KUNIT_EXPECT_EQ(test, 0xffc0, src_id);
612 KUNIT_EXPECT_EQ(test, RCODE_COMPLETE, rcode);
613 KUNIT_EXPECT_EQ(test, 0x0004, data_length);
614 KUNIT_EXPECT_EQ(test, EXTCODE_COMPARE_SWAP, extended_tcode);
615
616 serialize_async_header_block_response(header, dst_id, tlabel, retry, tcode, priority,
617 src_id, rcode, data_length, extended_tcode);
618
619 KUNIT_EXPECT_MEMEQ(test, header, expected, sizeof(expected));
620}
621
622static void test_isoc_header(struct kunit *test)
623{
624 const u32 expected = 0x00d08dec;
625 u32 header = 0;
626
627 unsigned int data_length;
628 unsigned int tag;
629 unsigned int channel;
630 unsigned int tcode;
631 unsigned int sy;
632
633 deserialize_isoc_header(expected, &data_length, &tag, &channel, &tcode, &sy);
634
635 KUNIT_EXPECT_EQ(test, 0xd0, data_length);
636 KUNIT_EXPECT_EQ(test, 0x02, tag);
637 KUNIT_EXPECT_EQ(test, 0x0d, channel);
638 KUNIT_EXPECT_EQ(test, 0x0e, tcode);
639 KUNIT_EXPECT_EQ(test, 0x0c, sy);
640
641 serialize_isoc_header(&header, data_length, tag, channel, tcode, sy);
642
643 KUNIT_EXPECT_EQ(test, header, expected);
644}
645
646static void test_phy_packet_self_id_zero_case0(struct kunit *test)
647{
648 // TSB41AB1/2 with 1 port.
649 const u32 expected[] = {0x80458c80};
650 u32 quadlets[] = {0};
651
652 unsigned int packet_identifier;
653 unsigned int phy_id;
654 bool extended;
655 bool link_is_active;
656 unsigned int gap_count;
657 unsigned int scode;
658 bool is_contender;
659 unsigned int power_class;
660 enum phy_packet_self_id_port_status port_status[3];
661 bool is_initiated_reset;
662 bool has_more_packets;
663 unsigned int port_index;
664
665 deserialize_phy_packet_self_id_zero(expected[0], &packet_identifier, &phy_id, &extended,
666 &link_is_active, &gap_count, &scode, &is_contender,
667 &power_class, &is_initiated_reset, &has_more_packets);
668
669 KUNIT_EXPECT_EQ(test, PHY_PACKET_PACKET_IDENTIFIER_SELF_ID, packet_identifier);
670 KUNIT_EXPECT_EQ(test, 0, phy_id);
671 KUNIT_EXPECT_FALSE(test, extended);
672 KUNIT_EXPECT_TRUE(test, link_is_active);
673 KUNIT_EXPECT_EQ(test, 0x05, gap_count);
674 KUNIT_EXPECT_EQ(test, SCODE_400, scode);
675 KUNIT_EXPECT_TRUE(test, is_contender);
676 KUNIT_EXPECT_EQ(test, 0x4, power_class);
677 KUNIT_EXPECT_FALSE(test, is_initiated_reset);
678 KUNIT_EXPECT_FALSE(test, has_more_packets);
679
680 serialize_phy_packet_self_id_zero(quadlets, packet_identifier, phy_id, extended,
681 link_is_active, gap_count, scode, is_contender,
682 power_class, is_initiated_reset, has_more_packets);
683
684 for (port_index = 0; port_index < ARRAY_SIZE(port_status); ++port_index) {
685 port_status[port_index] =
686 self_id_sequence_get_port_status(expected, ARRAY_SIZE(expected), port_index);
687 }
688
689 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_PARENT, port_status[0]);
690 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NONE, port_status[1]);
691 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NONE, port_status[2]);
692
693 for (port_index = 0; port_index < ARRAY_SIZE(port_status); ++port_index) {
694 self_id_sequence_set_port_status(quadlets, ARRAY_SIZE(quadlets), port_index,
695 port_status[port_index]);
696 }
697
698 KUNIT_EXPECT_MEMEQ(test, quadlets, expected, sizeof(expected));
699}
700
701static void test_phy_packet_self_id_zero_case1(struct kunit *test)
702{
703 // XIO2213 and TSB81BA3E with 3 ports.
704 const u32 expected[] = {0x817fcc5e};
705 u32 quadlets[] = {0};
706
707 unsigned int packet_identifier;
708 unsigned int phy_id;
709 bool extended;
710 bool link_is_active;
711 unsigned int gap_count;
712 unsigned int scode;
713 bool is_contender;
714 unsigned int power_class;
715 enum phy_packet_self_id_port_status port_status[3];
716 bool is_initiated_reset;
717 bool has_more_packets;
718 unsigned int port_index;
719
720 deserialize_phy_packet_self_id_zero(expected[0], &packet_identifier, &phy_id, &extended,
721 &link_is_active, &gap_count, &scode, &is_contender,
722 &power_class, &is_initiated_reset, &has_more_packets);
723
724 KUNIT_EXPECT_EQ(test, PHY_PACKET_PACKET_IDENTIFIER_SELF_ID, packet_identifier);
725 KUNIT_EXPECT_EQ(test, 1, phy_id);
726 KUNIT_EXPECT_FALSE(test, extended);
727 KUNIT_EXPECT_TRUE(test, link_is_active);
728 KUNIT_EXPECT_EQ(test, 0x3f, gap_count);
729 KUNIT_EXPECT_EQ(test, SCODE_800, scode);
730 KUNIT_EXPECT_TRUE(test, is_contender);
731 KUNIT_EXPECT_EQ(test, 0x4, power_class);
732 KUNIT_EXPECT_TRUE(test, is_initiated_reset);
733 KUNIT_EXPECT_FALSE(test, has_more_packets);
734
735 serialize_phy_packet_self_id_zero(quadlets, packet_identifier, phy_id, extended,
736 link_is_active, gap_count, scode, is_contender,
737 power_class, is_initiated_reset, has_more_packets);
738
739 for (port_index = 0; port_index < ARRAY_SIZE(port_status); ++port_index) {
740 port_status[port_index] =
741 self_id_sequence_get_port_status(expected, ARRAY_SIZE(expected), port_index);
742 }
743
744 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NCONN, port_status[0]);
745 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NCONN, port_status[1]);
746 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_CHILD, port_status[2]);
747
748 for (port_index = 0; port_index < ARRAY_SIZE(port_status); ++port_index) {
749 self_id_sequence_set_port_status(quadlets, ARRAY_SIZE(quadlets), port_index,
750 port_status[port_index]);
751 }
752
753 KUNIT_EXPECT_MEMEQ(test, quadlets, expected, sizeof(expected));
754}
755
756static void test_phy_packet_self_id_zero_and_one(struct kunit *test)
757{
758 // TSB41LV06A with 6 ports.
759 const u32 expected[] = {
760 0x803f8459,
761 0x80815000,
762 };
763 u32 quadlets[] = {0, 0};
764
765 unsigned int packet_identifier;
766 unsigned int phy_id;
767 bool extended;
768 bool link_is_active;
769 unsigned int gap_count;
770 unsigned int scode;
771 bool is_contender;
772 unsigned int power_class;
773 enum phy_packet_self_id_port_status port_status[11];
774 bool is_initiated_reset;
775 bool has_more_packets;
776
777 unsigned int sequence;
778 unsigned int port_index;
779
780 deserialize_phy_packet_self_id_zero(expected[0], &packet_identifier, &phy_id, &extended,
781 &link_is_active, &gap_count, &scode, &is_contender,
782 &power_class, &is_initiated_reset, &has_more_packets);
783
784 KUNIT_EXPECT_EQ(test, PHY_PACKET_PACKET_IDENTIFIER_SELF_ID, packet_identifier);
785 KUNIT_EXPECT_EQ(test, 0, phy_id);
786 KUNIT_EXPECT_FALSE(test, extended);
787 KUNIT_EXPECT_FALSE(test, link_is_active);
788 KUNIT_EXPECT_EQ(test, 0x3f, gap_count);
789 KUNIT_EXPECT_EQ(test, SCODE_400, scode);
790 KUNIT_EXPECT_FALSE(test, is_contender);
791 KUNIT_EXPECT_EQ(test, 0x4, power_class);
792 KUNIT_EXPECT_FALSE(test, is_initiated_reset);
793 KUNIT_EXPECT_TRUE(test, has_more_packets);
794
795 serialize_phy_packet_self_id_zero(quadlets, packet_identifier, phy_id, extended,
796 link_is_active, gap_count, scode, is_contender,
797 power_class, is_initiated_reset, has_more_packets);
798
799 deserialize_phy_packet_self_id_extended(expected[1], &packet_identifier, &phy_id, &extended,
800 &sequence, &has_more_packets);
801
802 KUNIT_EXPECT_EQ(test, PHY_PACKET_PACKET_IDENTIFIER_SELF_ID, packet_identifier);
803 KUNIT_EXPECT_EQ(test, 0, phy_id);
804 KUNIT_EXPECT_TRUE(test, extended);
805 KUNIT_EXPECT_EQ(test, 0, sequence);
806 KUNIT_EXPECT_FALSE(test, has_more_packets);
807
808 serialize_phy_packet_self_id_extended(&quadlets[1], packet_identifier, phy_id, extended,
809 sequence, has_more_packets);
810
811
812 for (port_index = 0; port_index < ARRAY_SIZE(port_status); ++port_index) {
813 port_status[port_index] =
814 self_id_sequence_get_port_status(expected, ARRAY_SIZE(expected), port_index);
815 }
816
817 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NCONN, port_status[0]);
818 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NCONN, port_status[1]);
819 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_PARENT, port_status[2]);
820 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NCONN, port_status[3]);
821 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NCONN, port_status[4]);
822 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NCONN, port_status[5]);
823 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NONE, port_status[6]);
824 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NONE, port_status[7]);
825 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NONE, port_status[8]);
826 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NONE, port_status[9]);
827 KUNIT_EXPECT_EQ(test, PHY_PACKET_SELF_ID_PORT_STATUS_NONE, port_status[10]);
828
829 for (port_index = 0; port_index < ARRAY_SIZE(port_status); ++port_index) {
830 self_id_sequence_set_port_status(quadlets, ARRAY_SIZE(quadlets), port_index,
831 port_status[port_index]);
832 }
833
834 KUNIT_EXPECT_MEMEQ(test, quadlets, expected, sizeof(expected));
835}
836
837static void test_phy_packet_phy_config_force_root_node(struct kunit *test)
838{
839 const u32 expected = 0x02800000;
840 u32 quadlet = 0;
841
842 unsigned int packet_identifier;
843 unsigned int root_id;
844 bool has_force_root_node;
845 bool has_gap_count_optimization;
846 unsigned int gap_count;
847
848 deserialize_phy_packet_phy_config(expected, &packet_identifier, &root_id,
849 &has_force_root_node, &has_gap_count_optimization,
850 &gap_count);
851
852 KUNIT_EXPECT_EQ(test, PHY_PACKET_PACKET_IDENTIFIER_PHY_CONFIG, packet_identifier);
853 KUNIT_EXPECT_EQ(test, 0x02, root_id);
854 KUNIT_EXPECT_TRUE(test, has_force_root_node);
855 KUNIT_EXPECT_FALSE(test, has_gap_count_optimization);
856 KUNIT_EXPECT_EQ(test, 0, gap_count);
857
858 serialize_phy_packet_phy_config(&quadlet, packet_identifier, root_id, has_force_root_node,
859 has_gap_count_optimization, gap_count);
860
861 KUNIT_EXPECT_EQ(test, quadlet, expected);
862}
863
864static void test_phy_packet_phy_config_gap_count_optimization(struct kunit *test)
865{
866 const u32 expected = 0x034f0000;
867 u32 quadlet = 0;
868
869 unsigned int packet_identifier;
870 unsigned int root_id;
871 bool has_force_root_node;
872 bool has_gap_count_optimization;
873 unsigned int gap_count;
874
875 deserialize_phy_packet_phy_config(expected, &packet_identifier, &root_id,
876 &has_force_root_node, &has_gap_count_optimization,
877 &gap_count);
878
879 KUNIT_EXPECT_EQ(test, PHY_PACKET_PACKET_IDENTIFIER_PHY_CONFIG, packet_identifier);
880 KUNIT_EXPECT_EQ(test, 0x03, root_id);
881 KUNIT_EXPECT_FALSE(test, has_force_root_node);
882 KUNIT_EXPECT_TRUE(test, has_gap_count_optimization);
883 KUNIT_EXPECT_EQ(test, 0x0f, gap_count);
884
885 serialize_phy_packet_phy_config(&quadlet, packet_identifier, root_id, has_force_root_node,
886 has_gap_count_optimization, gap_count);
887
888 KUNIT_EXPECT_EQ(test, quadlet, expected);
889}
890
891static struct kunit_case packet_serdes_test_cases[] = {
892 KUNIT_CASE(test_async_header_write_quadlet_request),
893 KUNIT_CASE(test_async_header_write_block_request),
894 KUNIT_CASE(test_async_header_write_response),
895 KUNIT_CASE(test_async_header_read_quadlet_request),
896 KUNIT_CASE(test_async_header_read_quadlet_response),
897 KUNIT_CASE(test_async_header_read_block_request),
898 KUNIT_CASE(test_async_header_read_block_response),
899 KUNIT_CASE(test_async_header_lock_request),
900 KUNIT_CASE(test_async_header_lock_response),
901 KUNIT_CASE(test_isoc_header),
902 KUNIT_CASE(test_phy_packet_self_id_zero_case0),
903 KUNIT_CASE(test_phy_packet_self_id_zero_case1),
904 KUNIT_CASE(test_phy_packet_self_id_zero_and_one),
905 KUNIT_CASE(test_phy_packet_phy_config_force_root_node),
906 KUNIT_CASE(test_phy_packet_phy_config_gap_count_optimization),
907 {}
908};
909
910static struct kunit_suite packet_serdes_test_suite = {
911 .name = "firewire-packet-serdes",
912 .test_cases = packet_serdes_test_cases,
913};
914kunit_test_suite(packet_serdes_test_suite);
915
916MODULE_DESCRIPTION("FireWire packet serialization/deserialization unit test suite");
917MODULE_LICENSE("GPL");