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