1// SPDX-License-Identifier: GPL-2.0
2// Unit tests for property entries API
3//
4// Copyright 2019 Google LLC.
5
6#include <kunit/test.h>
7#include <linux/property.h>
8#include <linux/types.h>
9
10static void pe_test_uints(struct kunit *test)
11{
12	static const struct property_entry entries[] = {
13		PROPERTY_ENTRY_U8("prop-u8", 8),
14		PROPERTY_ENTRY_U16("prop-u16", 16),
15		PROPERTY_ENTRY_U32("prop-u32", 32),
16		PROPERTY_ENTRY_U64("prop-u64", 64),
17		{ }
18	};
19
20	struct fwnode_handle *node;
21	u8 val_u8, array_u8[2];
22	u16 val_u16, array_u16[2];
23	u32 val_u32, array_u32[2];
24	u64 val_u64, array_u64[2];
25	int error;
26
27	node = fwnode_create_software_node(entries, NULL);
28	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, node);
29
30	error = fwnode_property_count_u8(node, "prop-u8");
31	KUNIT_EXPECT_EQ(test, error, 1);
32
33	error = fwnode_property_read_u8(node, "prop-u8", &val_u8);
34	KUNIT_EXPECT_EQ(test, error, 0);
35	KUNIT_EXPECT_EQ(test, val_u8, 8);
36
37	error = fwnode_property_read_u8_array(node, "prop-u8", array_u8, 1);
38	KUNIT_EXPECT_EQ(test, error, 0);
39	KUNIT_EXPECT_EQ(test, array_u8[0], 8);
40
41	error = fwnode_property_read_u8_array(node, "prop-u8", array_u8, 2);
42	KUNIT_EXPECT_NE(test, error, 0);
43
44	error = fwnode_property_read_u8(node, "no-prop-u8", &val_u8);
45	KUNIT_EXPECT_NE(test, error, 0);
46
47	error = fwnode_property_read_u8_array(node, "no-prop-u8", array_u8, 1);
48	KUNIT_EXPECT_NE(test, error, 0);
49
50	error = fwnode_property_read_u16(node, "prop-u16", &val_u16);
51	KUNIT_EXPECT_EQ(test, error, 0);
52	KUNIT_EXPECT_EQ(test, val_u16, 16);
53
54	error = fwnode_property_count_u16(node, "prop-u16");
55	KUNIT_EXPECT_EQ(test, error, 1);
56
57	error = fwnode_property_read_u16_array(node, "prop-u16", array_u16, 1);
58	KUNIT_EXPECT_EQ(test, error, 0);
59	KUNIT_EXPECT_EQ(test, array_u16[0], 16);
60
61	error = fwnode_property_read_u16_array(node, "prop-u16", array_u16, 2);
62	KUNIT_EXPECT_NE(test, error, 0);
63
64	error = fwnode_property_read_u16(node, "no-prop-u16", &val_u16);
65	KUNIT_EXPECT_NE(test, error, 0);
66
67	error = fwnode_property_read_u16_array(node, "no-prop-u16", array_u16, 1);
68	KUNIT_EXPECT_NE(test, error, 0);
69
70	error = fwnode_property_read_u32(node, "prop-u32", &val_u32);
71	KUNIT_EXPECT_EQ(test, error, 0);
72	KUNIT_EXPECT_EQ(test, val_u32, 32);
73
74	error = fwnode_property_count_u32(node, "prop-u32");
75	KUNIT_EXPECT_EQ(test, error, 1);
76
77	error = fwnode_property_read_u32_array(node, "prop-u32", array_u32, 1);
78	KUNIT_EXPECT_EQ(test, error, 0);
79	KUNIT_EXPECT_EQ(test, array_u32[0], 32);
80
81	error = fwnode_property_read_u32_array(node, "prop-u32", array_u32, 2);
82	KUNIT_EXPECT_NE(test, error, 0);
83
84	error = fwnode_property_read_u32(node, "no-prop-u32", &val_u32);
85	KUNIT_EXPECT_NE(test, error, 0);
86
87	error = fwnode_property_read_u32_array(node, "no-prop-u32", array_u32, 1);
88	KUNIT_EXPECT_NE(test, error, 0);
89
90	error = fwnode_property_read_u64(node, "prop-u64", &val_u64);
91	KUNIT_EXPECT_EQ(test, error, 0);
92	KUNIT_EXPECT_EQ(test, val_u64, 64);
93
94	error = fwnode_property_count_u64(node, "prop-u64");
95	KUNIT_EXPECT_EQ(test, error, 1);
96
97	error = fwnode_property_read_u64_array(node, "prop-u64", array_u64, 1);
98	KUNIT_EXPECT_EQ(test, error, 0);
99	KUNIT_EXPECT_EQ(test, array_u64[0], 64);
100
101	error = fwnode_property_read_u64_array(node, "prop-u64", array_u64, 2);
102	KUNIT_EXPECT_NE(test, error, 0);
103
104	error = fwnode_property_read_u64(node, "no-prop-u64", &val_u64);
105	KUNIT_EXPECT_NE(test, error, 0);
106
107	error = fwnode_property_read_u64_array(node, "no-prop-u64", array_u64, 1);
108	KUNIT_EXPECT_NE(test, error, 0);
109
110	/* Count 64-bit values as 16-bit */
111	error = fwnode_property_count_u16(node, "prop-u64");
112	KUNIT_EXPECT_EQ(test, error, 4);
113
114	fwnode_remove_software_node(node);
115}
116
117static void pe_test_uint_arrays(struct kunit *test)
118{
119	static const u8 a_u8[10] = { 8, 9 };
120	static const u16 a_u16[10] = { 16, 17 };
121	static const u32 a_u32[10] = { 32, 33 };
122	static const u64 a_u64[10] = { 64, 65 };
123	static const struct property_entry entries[] = {
124		PROPERTY_ENTRY_U8_ARRAY("prop-u8", a_u8),
125		PROPERTY_ENTRY_U16_ARRAY("prop-u16", a_u16),
126		PROPERTY_ENTRY_U32_ARRAY("prop-u32", a_u32),
127		PROPERTY_ENTRY_U64_ARRAY("prop-u64", a_u64),
128		{ }
129	};
130
131	struct fwnode_handle *node;
132	u8 val_u8, array_u8[32];
133	u16 val_u16, array_u16[32];
134	u32 val_u32, array_u32[32];
135	u64 val_u64, array_u64[32];
136	int error;
137
138	node = fwnode_create_software_node(entries, NULL);
139	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, node);
140
141	error = fwnode_property_read_u8(node, "prop-u8", &val_u8);
142	KUNIT_EXPECT_EQ(test, error, 0);
143	KUNIT_EXPECT_EQ(test, val_u8, 8);
144
145	error = fwnode_property_count_u8(node, "prop-u8");
146	KUNIT_EXPECT_EQ(test, error, 10);
147
148	error = fwnode_property_read_u8_array(node, "prop-u8", array_u8, 1);
149	KUNIT_EXPECT_EQ(test, error, 0);
150	KUNIT_EXPECT_EQ(test, array_u8[0], 8);
151
152	error = fwnode_property_read_u8_array(node, "prop-u8", array_u8, 2);
153	KUNIT_EXPECT_EQ(test, error, 0);
154	KUNIT_EXPECT_EQ(test, array_u8[0], 8);
155	KUNIT_EXPECT_EQ(test, array_u8[1], 9);
156
157	error = fwnode_property_read_u8_array(node, "prop-u8", array_u8, 17);
158	KUNIT_EXPECT_NE(test, error, 0);
159
160	error = fwnode_property_read_u8(node, "no-prop-u8", &val_u8);
161	KUNIT_EXPECT_NE(test, error, 0);
162
163	error = fwnode_property_read_u8_array(node, "no-prop-u8", array_u8, 1);
164	KUNIT_EXPECT_NE(test, error, 0);
165
166	error = fwnode_property_read_u16(node, "prop-u16", &val_u16);
167	KUNIT_EXPECT_EQ(test, error, 0);
168	KUNIT_EXPECT_EQ(test, val_u16, 16);
169
170	error = fwnode_property_count_u16(node, "prop-u16");
171	KUNIT_EXPECT_EQ(test, error, 10);
172
173	error = fwnode_property_read_u16_array(node, "prop-u16", array_u16, 1);
174	KUNIT_EXPECT_EQ(test, error, 0);
175	KUNIT_EXPECT_EQ(test, array_u16[0], 16);
176
177	error = fwnode_property_read_u16_array(node, "prop-u16", array_u16, 2);
178	KUNIT_EXPECT_EQ(test, error, 0);
179	KUNIT_EXPECT_EQ(test, array_u16[0], 16);
180	KUNIT_EXPECT_EQ(test, array_u16[1], 17);
181
182	error = fwnode_property_read_u16_array(node, "prop-u16", array_u16, 17);
183	KUNIT_EXPECT_NE(test, error, 0);
184
185	error = fwnode_property_read_u16(node, "no-prop-u16", &val_u16);
186	KUNIT_EXPECT_NE(test, error, 0);
187
188	error = fwnode_property_read_u16_array(node, "no-prop-u16", array_u16, 1);
189	KUNIT_EXPECT_NE(test, error, 0);
190
191	error = fwnode_property_read_u32(node, "prop-u32", &val_u32);
192	KUNIT_EXPECT_EQ(test, error, 0);
193	KUNIT_EXPECT_EQ(test, val_u32, 32);
194
195	error = fwnode_property_count_u32(node, "prop-u32");
196	KUNIT_EXPECT_EQ(test, error, 10);
197
198	error = fwnode_property_read_u32_array(node, "prop-u32", array_u32, 1);
199	KUNIT_EXPECT_EQ(test, error, 0);
200	KUNIT_EXPECT_EQ(test, array_u32[0], 32);
201
202	error = fwnode_property_read_u32_array(node, "prop-u32", array_u32, 2);
203	KUNIT_EXPECT_EQ(test, error, 0);
204	KUNIT_EXPECT_EQ(test, array_u32[0], 32);
205	KUNIT_EXPECT_EQ(test, array_u32[1], 33);
206
207	error = fwnode_property_read_u32_array(node, "prop-u32", array_u32, 17);
208	KUNIT_EXPECT_NE(test, error, 0);
209
210	error = fwnode_property_read_u32(node, "no-prop-u32", &val_u32);
211	KUNIT_EXPECT_NE(test, error, 0);
212
213	error = fwnode_property_read_u32_array(node, "no-prop-u32", array_u32, 1);
214	KUNIT_EXPECT_NE(test, error, 0);
215
216	error = fwnode_property_read_u64(node, "prop-u64", &val_u64);
217	KUNIT_EXPECT_EQ(test, error, 0);
218	KUNIT_EXPECT_EQ(test, val_u64, 64);
219
220	error = fwnode_property_count_u64(node, "prop-u64");
221	KUNIT_EXPECT_EQ(test, error, 10);
222
223	error = fwnode_property_read_u64_array(node, "prop-u64", array_u64, 1);
224	KUNIT_EXPECT_EQ(test, error, 0);
225	KUNIT_EXPECT_EQ(test, array_u64[0], 64);
226
227	error = fwnode_property_read_u64_array(node, "prop-u64", array_u64, 2);
228	KUNIT_EXPECT_EQ(test, error, 0);
229	KUNIT_EXPECT_EQ(test, array_u64[0], 64);
230	KUNIT_EXPECT_EQ(test, array_u64[1], 65);
231
232	error = fwnode_property_read_u64_array(node, "prop-u64", array_u64, 17);
233	KUNIT_EXPECT_NE(test, error, 0);
234
235	error = fwnode_property_read_u64(node, "no-prop-u64", &val_u64);
236	KUNIT_EXPECT_NE(test, error, 0);
237
238	error = fwnode_property_read_u64_array(node, "no-prop-u64", array_u64, 1);
239	KUNIT_EXPECT_NE(test, error, 0);
240
241	/* Count 64-bit values as 16-bit */
242	error = fwnode_property_count_u16(node, "prop-u64");
243	KUNIT_EXPECT_EQ(test, error, 40);
244
245	/* Other way around */
246	error = fwnode_property_count_u64(node, "prop-u16");
247	KUNIT_EXPECT_EQ(test, error, 2);
248
249	fwnode_remove_software_node(node);
250}
251
252static void pe_test_strings(struct kunit *test)
253{
254	static const char *strings[] = {
255		"string-a",
256		"string-b",
257	};
258
259	static const struct property_entry entries[] = {
260		PROPERTY_ENTRY_STRING("str", "single"),
261		PROPERTY_ENTRY_STRING("empty", ""),
262		PROPERTY_ENTRY_STRING_ARRAY("strs", strings),
263		{ }
264	};
265
266	struct fwnode_handle *node;
267	const char *str;
268	const char *strs[10];
269	int error;
270
271	node = fwnode_create_software_node(entries, NULL);
272	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, node);
273
274	error = fwnode_property_read_string(node, "str", &str);
275	KUNIT_EXPECT_EQ(test, error, 0);
276	KUNIT_EXPECT_STREQ(test, str, "single");
277
278	error = fwnode_property_string_array_count(node, "str");
279	KUNIT_EXPECT_EQ(test, error, 1);
280
281	error = fwnode_property_read_string_array(node, "str", strs, 1);
282	KUNIT_EXPECT_EQ(test, error, 1);
283	KUNIT_EXPECT_STREQ(test, strs[0], "single");
284
285	/* asking for more data returns what we have */
286	error = fwnode_property_read_string_array(node, "str", strs, 2);
287	KUNIT_EXPECT_EQ(test, error, 1);
288	KUNIT_EXPECT_STREQ(test, strs[0], "single");
289
290	error = fwnode_property_read_string(node, "no-str", &str);
291	KUNIT_EXPECT_NE(test, error, 0);
292
293	error = fwnode_property_read_string_array(node, "no-str", strs, 1);
294	KUNIT_EXPECT_LT(test, error, 0);
295
296	error = fwnode_property_read_string(node, "empty", &str);
297	KUNIT_EXPECT_EQ(test, error, 0);
298	KUNIT_EXPECT_STREQ(test, str, "");
299
300	error = fwnode_property_string_array_count(node, "strs");
301	KUNIT_EXPECT_EQ(test, error, 2);
302
303	error = fwnode_property_read_string_array(node, "strs", strs, 3);
304	KUNIT_EXPECT_EQ(test, error, 2);
305	KUNIT_EXPECT_STREQ(test, strs[0], "string-a");
306	KUNIT_EXPECT_STREQ(test, strs[1], "string-b");
307
308	error = fwnode_property_read_string_array(node, "strs", strs, 1);
309	KUNIT_EXPECT_EQ(test, error, 1);
310	KUNIT_EXPECT_STREQ(test, strs[0], "string-a");
311
312	/* NULL argument -> returns size */
313	error = fwnode_property_read_string_array(node, "strs", NULL, 0);
314	KUNIT_EXPECT_EQ(test, error, 2);
315
316	/* accessing array as single value */
317	error = fwnode_property_read_string(node, "strs", &str);
318	KUNIT_EXPECT_EQ(test, error, 0);
319	KUNIT_EXPECT_STREQ(test, str, "string-a");
320
321	fwnode_remove_software_node(node);
322}
323
324static void pe_test_bool(struct kunit *test)
325{
326	static const struct property_entry entries[] = {
327		PROPERTY_ENTRY_BOOL("prop"),
328		{ }
329	};
330
331	struct fwnode_handle *node;
332
333	node = fwnode_create_software_node(entries, NULL);
334	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, node);
335
336	KUNIT_EXPECT_TRUE(test, fwnode_property_read_bool(node, "prop"));
337	KUNIT_EXPECT_FALSE(test, fwnode_property_read_bool(node, "not-prop"));
338
339	fwnode_remove_software_node(node);
340}
341
342/* Verifies that small U8 array is stored inline when property is copied */
343static void pe_test_move_inline_u8(struct kunit *test)
344{
345	static const u8 u8_array_small[8] = { 1, 2, 3, 4 };
346	static const u8 u8_array_big[128] = { 5, 6, 7, 8 };
347	static const struct property_entry entries[] = {
348		PROPERTY_ENTRY_U8_ARRAY("small", u8_array_small),
349		PROPERTY_ENTRY_U8_ARRAY("big", u8_array_big),
350		{ }
351	};
352
353	struct property_entry *copy;
354	const u8 *data_ptr;
355
356	copy = property_entries_dup(entries);
357	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, copy);
358
359	KUNIT_EXPECT_TRUE(test, copy[0].is_inline);
360	data_ptr = (u8 *)&copy[0].value;
361	KUNIT_EXPECT_EQ(test, data_ptr[0], 1);
362	KUNIT_EXPECT_EQ(test, data_ptr[1], 2);
363
364	KUNIT_EXPECT_FALSE(test, copy[1].is_inline);
365	data_ptr = copy[1].pointer;
366	KUNIT_EXPECT_EQ(test, data_ptr[0], 5);
367	KUNIT_EXPECT_EQ(test, data_ptr[1], 6);
368
369	property_entries_free(copy);
370}
371
372/* Verifies that single string array is stored inline when property is copied */
373static void pe_test_move_inline_str(struct kunit *test)
374{
375	static char *str_array_small[] = { "a" };
376	static char *str_array_big[] = { "b", "c", "d", "e" };
377	static char *str_array_small_empty[] = { "" };
378	static struct property_entry entries[] = {
379		PROPERTY_ENTRY_STRING_ARRAY("small", str_array_small),
380		PROPERTY_ENTRY_STRING_ARRAY("big", str_array_big),
381		PROPERTY_ENTRY_STRING_ARRAY("small-empty", str_array_small_empty),
382		{ }
383	};
384
385	struct property_entry *copy;
386	const char * const *data_ptr;
387
388	copy = property_entries_dup(entries);
389	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, copy);
390
391	KUNIT_EXPECT_TRUE(test, copy[0].is_inline);
392	KUNIT_EXPECT_STREQ(test, copy[0].value.str[0], "a");
393
394	KUNIT_EXPECT_FALSE(test, copy[1].is_inline);
395	data_ptr = copy[1].pointer;
396	KUNIT_EXPECT_STREQ(test, data_ptr[0], "b");
397	KUNIT_EXPECT_STREQ(test, data_ptr[1], "c");
398
399	KUNIT_EXPECT_TRUE(test, copy[2].is_inline);
400	KUNIT_EXPECT_STREQ(test, copy[2].value.str[0], "");
401
402	property_entries_free(copy);
403}
404
405/* Handling of reference properties */
406static void pe_test_reference(struct kunit *test)
407{
408	static const struct software_node node1 = { .name = "1" };
409	static const struct software_node node2 = { .name = "2" };
410	static const struct software_node *group[] = { &node1, &node2, NULL };
411
412	static const struct software_node_ref_args refs[] = {
413		SOFTWARE_NODE_REFERENCE(&node1),
414		SOFTWARE_NODE_REFERENCE(&node2, 3, 4),
415	};
416
417	const struct property_entry entries[] = {
418		PROPERTY_ENTRY_REF("ref-1", &node1),
419		PROPERTY_ENTRY_REF("ref-2", &node2, 1, 2),
420		PROPERTY_ENTRY_REF_ARRAY("ref-3", refs),
421		{ }
422	};
423
424	struct fwnode_handle *node;
425	struct fwnode_reference_args ref;
426	int error;
427
428	error = software_node_register_node_group(group);
429	KUNIT_ASSERT_EQ(test, error, 0);
430
431	node = fwnode_create_software_node(entries, NULL);
432	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, node);
433
434	error = fwnode_property_get_reference_args(node, "ref-1", NULL,
435						   0, 0, &ref);
436	KUNIT_ASSERT_EQ(test, error, 0);
437	KUNIT_EXPECT_PTR_EQ(test, to_software_node(ref.fwnode), &node1);
438	KUNIT_EXPECT_EQ(test, ref.nargs, 0U);
439
440	/* wrong index */
441	error = fwnode_property_get_reference_args(node, "ref-1", NULL,
442						   0, 1, &ref);
443	KUNIT_EXPECT_NE(test, error, 0);
444
445	error = fwnode_property_get_reference_args(node, "ref-2", NULL,
446						   1, 0, &ref);
447	KUNIT_ASSERT_EQ(test, error, 0);
448	KUNIT_EXPECT_PTR_EQ(test, to_software_node(ref.fwnode), &node2);
449	KUNIT_EXPECT_EQ(test, ref.nargs, 1U);
450	KUNIT_EXPECT_EQ(test, ref.args[0], 1LLU);
451
452	/* asking for more args, padded with zero data */
453	error = fwnode_property_get_reference_args(node, "ref-2", NULL,
454						   3, 0, &ref);
455	KUNIT_ASSERT_EQ(test, error, 0);
456	KUNIT_EXPECT_PTR_EQ(test, to_software_node(ref.fwnode), &node2);
457	KUNIT_EXPECT_EQ(test, ref.nargs, 3U);
458	KUNIT_EXPECT_EQ(test, ref.args[0], 1LLU);
459	KUNIT_EXPECT_EQ(test, ref.args[1], 2LLU);
460	KUNIT_EXPECT_EQ(test, ref.args[2], 0LLU);
461
462	/* wrong index */
463	error = fwnode_property_get_reference_args(node, "ref-2", NULL,
464						   2, 1, &ref);
465	KUNIT_EXPECT_NE(test, error, 0);
466
467	/* array of references */
468	error = fwnode_property_get_reference_args(node, "ref-3", NULL,
469						   0, 0, &ref);
470	KUNIT_ASSERT_EQ(test, error, 0);
471	KUNIT_EXPECT_PTR_EQ(test, to_software_node(ref.fwnode), &node1);
472	KUNIT_EXPECT_EQ(test, ref.nargs, 0U);
473
474	/* second reference in the array */
475	error = fwnode_property_get_reference_args(node, "ref-3", NULL,
476						   2, 1, &ref);
477	KUNIT_ASSERT_EQ(test, error, 0);
478	KUNIT_EXPECT_PTR_EQ(test, to_software_node(ref.fwnode), &node2);
479	KUNIT_EXPECT_EQ(test, ref.nargs, 2U);
480	KUNIT_EXPECT_EQ(test, ref.args[0], 3LLU);
481	KUNIT_EXPECT_EQ(test, ref.args[1], 4LLU);
482
483	/* wrong index */
484	error = fwnode_property_get_reference_args(node, "ref-1", NULL,
485						   0, 2, &ref);
486	KUNIT_EXPECT_NE(test, error, 0);
487
488	fwnode_remove_software_node(node);
489	software_node_unregister_node_group(group);
490}
491
492static struct kunit_case property_entry_test_cases[] = {
493	KUNIT_CASE(pe_test_uints),
494	KUNIT_CASE(pe_test_uint_arrays),
495	KUNIT_CASE(pe_test_strings),
496	KUNIT_CASE(pe_test_bool),
497	KUNIT_CASE(pe_test_move_inline_u8),
498	KUNIT_CASE(pe_test_move_inline_str),
499	KUNIT_CASE(pe_test_reference),
500	{ }
501};
502
503static struct kunit_suite property_entry_test_suite = {
504	.name = "property-entry",
505	.test_cases = property_entry_test_cases,
506};
507
508kunit_test_suite(property_entry_test_suite);
509
510MODULE_DESCRIPTION("Test module for the property entry API");
511MODULE_AUTHOR("Dmitry Torokhov <dtor@chromium.org>");
512MODULE_LICENSE("GPL");
513