CoCalc -- packet-serdes-test.c

GitHub Repository: torvalds/linux
Path: blob/master/drivers/firewire/packet-serdes-test.c
²⁶³⁷⁸ views
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

15
static 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

28
static 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

37
static 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

47
static 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

60
static 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

70
static 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

80
static 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

93
static 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

106
static 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

116
static 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

126
static 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

140
static 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

150
static 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

159
static 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

171
static 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

181
static 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

191
static 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

210
static 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

229
static 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

240
static 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

251
static 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

262
static 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

274
static 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

313
static 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

353
static 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

388
static 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

423
static 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

462
static 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

502
static 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

542
static 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

582
static 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

622
static 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

646
static 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

701
static 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

756
static 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

837
static 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

864
static 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

891
static 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

910
static struct kunit_suite packet_serdes_test_suite = {
911
	.name = "firewire-packet-serdes",
912
	.test_cases = packet_serdes_test_cases,
913
};
914
kunit_test_suite(packet_serdes_test_suite);
915

916
MODULE_DESCRIPTION("FireWire packet serialization/deserialization unit test suite");
917
MODULE_LICENSE("GPL");
918

919
Product

Resources

Company
