1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (C) 2013 Google, Inc
4  */
5 
6 #include <common.h>
7 #include <fdtdec.h>
8 #include <dm.h>
9 #include <log.h>
10 #include <malloc.h>
11 #include <acpi/acpi_device.h>
12 #include <asm/gpio.h>
13 #include <dm/device-internal.h>
14 #include <dm/root.h>
15 #include <dm/test.h>
16 #include <dm/util.h>
17 #include <test/test.h>
18 #include <test/ut.h>
19 
20 /* Test that sandbox GPIOs work correctly */
dm_test_gpio(struct unit_test_state * uts)21 static int dm_test_gpio(struct unit_test_state *uts)
22 {
23 	unsigned int offset, gpio;
24 	struct dm_gpio_ops *ops;
25 	struct udevice *dev;
26 	struct gpio_desc *desc;
27 	const char *name;
28 	int offset_count;
29 	char buf[80];
30 
31 	/*
32 	 * We expect to get 4 banks. One is anonymous (just numbered) and
33 	 * comes from plat. The other are named a (20 gpios),
34 	 * b (10 gpios) and c (10 gpios) and come from the device tree. See
35 	 * test/dm/test.dts.
36 	 */
37 	ut_assertok(gpio_lookup_name("b4", &dev, &offset, &gpio));
38 	ut_asserteq_str(dev->name, "extra-gpios");
39 	ut_asserteq(4, offset);
40 	ut_asserteq(CONFIG_SANDBOX_GPIO_COUNT + 20 + 4, gpio);
41 
42 	name = gpio_get_bank_info(dev, &offset_count);
43 	ut_asserteq_str("b", name);
44 	ut_asserteq(10, offset_count);
45 
46 	/* Get the operations for this device */
47 	ops = gpio_get_ops(dev);
48 	ut_assert(ops->get_function);
49 
50 	/* Cannot get a value until it is reserved */
51 	ut_asserteq(-EBUSY, gpio_get_value(gpio + 1));
52 	/*
53 	 * Now some tests that use the 'sandbox' back door. All GPIOs
54 	 * should default to input, include b4 that we are using here.
55 	 */
56 	ut_assertok(gpio_get_status(dev, offset, buf, sizeof(buf)));
57 	ut_asserteq_str("b4: input: 0 [ ]", buf);
58 
59 	/* Change it to an output */
60 	sandbox_gpio_set_direction(dev, offset, 1);
61 	ut_assertok(gpio_get_status(dev, offset, buf, sizeof(buf)));
62 	ut_asserteq_str("b4: output: 0 [ ]", buf);
63 
64 	sandbox_gpio_set_value(dev, offset, 1);
65 	ut_assertok(gpio_get_status(dev, offset, buf, sizeof(buf)));
66 	ut_asserteq_str("b4: output: 1 [ ]", buf);
67 
68 	ut_assertok(gpio_request(gpio, "testing"));
69 	ut_assertok(gpio_get_status(dev, offset, buf, sizeof(buf)));
70 	ut_asserteq_str("b4: output: 1 [x] testing", buf);
71 
72 	/* Change the value a bit */
73 	ut_asserteq(1, ops->get_value(dev, offset));
74 	ut_assertok(ops->set_value(dev, offset, 0));
75 	ut_asserteq(0, ops->get_value(dev, offset));
76 	ut_assertok(gpio_get_status(dev, offset, buf, sizeof(buf)));
77 	ut_asserteq_str("b4: output: 0 [x] testing", buf);
78 	ut_assertok(ops->set_value(dev, offset, 1));
79 	ut_asserteq(1, ops->get_value(dev, offset));
80 
81 	/* Make it an open drain output, and reset it */
82 	ut_asserteq(GPIOD_IS_OUT | GPIOD_IS_OUT_ACTIVE,
83 		    sandbox_gpio_get_dir_flags(dev, offset));
84 	ut_assertok(ops->set_dir_flags(dev, offset,
85 				       GPIOD_IS_OUT | GPIOD_OPEN_DRAIN));
86 	ut_asserteq(GPIOD_IS_OUT | GPIOD_OPEN_DRAIN,
87 		    sandbox_gpio_get_dir_flags(dev, offset));
88 	ut_assertok(ops->set_dir_flags(dev, offset,
89 				       GPIOD_IS_OUT | GPIOD_IS_OUT_ACTIVE));
90 	ut_asserteq(GPIOD_IS_OUT | GPIOD_IS_OUT_ACTIVE,
91 		    sandbox_gpio_get_dir_flags(dev, offset));
92 
93 	/* Make it an input */
94 	ut_assertok(ops->direction_input(dev, offset));
95 	ut_assertok(gpio_get_status(dev, offset, buf, sizeof(buf)));
96 	ut_asserteq_str("b4: input: 1 [x] testing", buf);
97 	sandbox_gpio_set_value(dev, offset, 0);
98 	ut_asserteq(0, sandbox_gpio_get_value(dev, offset));
99 	ut_assertok(gpio_get_status(dev, offset, buf, sizeof(buf)));
100 	ut_asserteq_str("b4: input: 0 [x] testing", buf);
101 
102 	ut_assertok(gpio_free(gpio));
103 	ut_assertok(gpio_get_status(dev, offset, buf, sizeof(buf)));
104 	ut_asserteq_str("b4: input: 0 [ ]", buf);
105 
106 	/* Check the 'a' bank also */
107 	ut_assertok(gpio_lookup_name("a15", &dev, &offset, &gpio));
108 	ut_asserteq_str(dev->name, "base-gpios");
109 	ut_asserteq(15, offset);
110 	ut_asserteq(CONFIG_SANDBOX_GPIO_COUNT + 15, gpio);
111 
112 	name = gpio_get_bank_info(dev, &offset_count);
113 	ut_asserteq_str("a", name);
114 	ut_asserteq(20, offset_count);
115 
116 	/* add gpio hog tests */
117 	ut_assertok(gpio_hog_lookup_name("hog_input_active_low", &desc));
118 	ut_asserteq(GPIOD_IS_IN | GPIOD_ACTIVE_LOW, desc->flags);
119 	ut_asserteq(10, desc->offset);
120 	ut_asserteq(1, dm_gpio_get_value(desc));
121 	ut_assertok(gpio_hog_lookup_name("hog_input_active_high", &desc));
122 	ut_asserteq(GPIOD_IS_IN, desc->flags);
123 	ut_asserteq(11, desc->offset);
124 	ut_asserteq(0, dm_gpio_get_value(desc));
125 	ut_assertok(gpio_hog_lookup_name("hog_output_low", &desc));
126 	ut_asserteq(GPIOD_IS_OUT, desc->flags);
127 	ut_asserteq(12, desc->offset);
128 	ut_asserteq(0, dm_gpio_get_value(desc));
129 	ut_assertok(dm_gpio_set_value(desc, 1));
130 	ut_asserteq(1, dm_gpio_get_value(desc));
131 	ut_assertok(gpio_hog_lookup_name("hog_output_high", &desc));
132 	ut_asserteq(GPIOD_IS_OUT, desc->flags);
133 	ut_asserteq(13, desc->offset);
134 	ut_asserteq(1, dm_gpio_get_value(desc));
135 	ut_assertok(dm_gpio_set_value(desc, 0));
136 	ut_asserteq(0, dm_gpio_get_value(desc));
137 
138 	/* Check if lookup for labels work */
139 	ut_assertok(gpio_lookup_name("hog_input_active_low", &dev, &offset,
140 				     &gpio));
141 	ut_asserteq_str(dev->name, "base-gpios");
142 	ut_asserteq(10, offset);
143 	ut_asserteq(CONFIG_SANDBOX_GPIO_COUNT + 10, gpio);
144 	ut_assert(gpio_lookup_name("hog_not_exist", &dev, &offset,
145 				   &gpio));
146 
147 	return 0;
148 }
149 DM_TEST(dm_test_gpio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
150 
151 /* Test that GPIO open-drain/open-source emulation works correctly */
dm_test_gpio_opendrain_opensource(struct unit_test_state * uts)152 static int dm_test_gpio_opendrain_opensource(struct unit_test_state *uts)
153 {
154 	struct gpio_desc desc_list[8];
155 	struct udevice *dev, *gpio_c;
156 	char buf[80];
157 
158 	ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 0, &dev));
159 	ut_asserteq_str("a-test", dev->name);
160 
161 	ut_assertok(uclass_get_device(UCLASS_GPIO, 3, &gpio_c));
162 	ut_asserteq_str("pinmux-gpios", gpio_c->name);
163 
164 	ut_asserteq(8, gpio_request_list_by_name(dev, "test3-gpios", desc_list,
165 						 ARRAY_SIZE(desc_list), 0))
166 
167 	ut_asserteq(true, !!device_active(gpio_c));
168 	ut_asserteq_ptr(gpio_c, desc_list[0].dev);
169 	ut_asserteq_ptr(gpio_c, desc_list[1].dev);
170 	ut_asserteq_ptr(gpio_c, desc_list[2].dev);
171 	ut_asserteq_ptr(gpio_c, desc_list[3].dev);
172 	ut_asserteq_ptr(gpio_c, desc_list[4].dev);
173 	ut_asserteq_ptr(gpio_c, desc_list[5].dev);
174 	ut_asserteq_ptr(gpio_c, desc_list[6].dev);
175 	ut_asserteq_ptr(gpio_c, desc_list[7].dev);
176 
177 	/* GPIO 0 is (GPIO_OUT|GPIO_OPEN_DRAIN) */
178 	ut_asserteq(GPIOD_IS_OUT | GPIOD_OPEN_DRAIN,
179 		    sandbox_gpio_get_dir_flags(gpio_c, 0));
180 
181 	/* Set it as output high, should become an input */
182 	ut_assertok(dm_gpio_set_value(&desc_list[0], 1));
183 	ut_assertok(gpio_get_status(gpio_c, 0, buf, sizeof(buf)));
184 	ut_asserteq_str("c0: input: 0 [x] a-test.test3-gpios0", buf);
185 
186 	/* Set it as output low, should become output low */
187 	ut_assertok(dm_gpio_set_value(&desc_list[0], 0));
188 	ut_assertok(gpio_get_status(gpio_c, 0, buf, sizeof(buf)));
189 	ut_asserteq_str("c0: output: 0 [x] a-test.test3-gpios0", buf);
190 
191 	/* GPIO 1 is (GPIO_OUT|GPIO_OPEN_SOURCE) */
192 	ut_asserteq(GPIOD_IS_OUT | GPIOD_OPEN_SOURCE,
193 		    sandbox_gpio_get_dir_flags(gpio_c, 1));
194 
195 	/* Set it as output high, should become output high */
196 	ut_assertok(dm_gpio_set_value(&desc_list[1], 1));
197 	ut_assertok(gpio_get_status(gpio_c, 1, buf, sizeof(buf)));
198 	ut_asserteq_str("c1: output: 1 [x] a-test.test3-gpios1", buf);
199 
200 	/* Set it as output low, should become an input */
201 	ut_assertok(dm_gpio_set_value(&desc_list[1], 0));
202 	ut_assertok(gpio_get_status(gpio_c, 1, buf, sizeof(buf)));
203 	ut_asserteq_str("c1: input: 1 [x] a-test.test3-gpios1", buf);
204 
205 	/* GPIO 6 is (GPIO_ACTIVE_LOW|GPIO_OUT|GPIO_OPEN_DRAIN) */
206 	ut_asserteq(GPIOD_ACTIVE_LOW | GPIOD_IS_OUT | GPIOD_OPEN_DRAIN,
207 		    sandbox_gpio_get_dir_flags(gpio_c, 6));
208 
209 	/* Set it as output high, should become output low */
210 	ut_assertok(dm_gpio_set_value(&desc_list[6], 1));
211 	ut_assertok(gpio_get_status(gpio_c, 6, buf, sizeof(buf)));
212 	ut_asserteq_str("c6: output: 0 [x] a-test.test3-gpios6", buf);
213 
214 	/* Set it as output low, should become an input */
215 	ut_assertok(dm_gpio_set_value(&desc_list[6], 0));
216 	ut_assertok(gpio_get_status(gpio_c, 6, buf, sizeof(buf)));
217 	ut_asserteq_str("c6: input: 0 [x] a-test.test3-gpios6", buf);
218 
219 	/* GPIO 7 is (GPIO_ACTIVE_LOW|GPIO_OUT|GPIO_OPEN_SOURCE) */
220 	ut_asserteq(GPIOD_ACTIVE_LOW | GPIOD_IS_OUT | GPIOD_OPEN_SOURCE,
221 		    sandbox_gpio_get_dir_flags(gpio_c, 7));
222 
223 	/* Set it as output high, should become an input */
224 	ut_assertok(dm_gpio_set_value(&desc_list[7], 1));
225 	ut_assertok(gpio_get_status(gpio_c, 7, buf, sizeof(buf)));
226 	ut_asserteq_str("c7: input: 0 [x] a-test.test3-gpios7", buf);
227 
228 	/* Set it as output low, should become output high */
229 	ut_assertok(dm_gpio_set_value(&desc_list[7], 0));
230 	ut_assertok(gpio_get_status(gpio_c, 7, buf, sizeof(buf)));
231 	ut_asserteq_str("c7: output: 1 [x] a-test.test3-gpios7", buf);
232 
233 	ut_assertok(gpio_free_list(dev, desc_list, 8));
234 
235 	return 0;
236 }
237 DM_TEST(dm_test_gpio_opendrain_opensource,
238 	UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
239 
240 /* Test that sandbox anonymous GPIOs work correctly */
dm_test_gpio_anon(struct unit_test_state * uts)241 static int dm_test_gpio_anon(struct unit_test_state *uts)
242 {
243 	unsigned int offset, gpio;
244 	struct udevice *dev;
245 	const char *name;
246 	int offset_count;
247 
248 	/* And the anonymous bank */
249 	ut_assertok(gpio_lookup_name("14", &dev, &offset, &gpio));
250 	ut_asserteq_str(dev->name, "sandbox_gpio");
251 	ut_asserteq(14, offset);
252 	ut_asserteq(14, gpio);
253 
254 	name = gpio_get_bank_info(dev, &offset_count);
255 	ut_asserteq_ptr(NULL, name);
256 	ut_asserteq(CONFIG_SANDBOX_GPIO_COUNT, offset_count);
257 
258 	return 0;
259 }
260 DM_TEST(dm_test_gpio_anon, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
261 
262 /* Test that gpio_requestf() works as expected */
dm_test_gpio_requestf(struct unit_test_state * uts)263 static int dm_test_gpio_requestf(struct unit_test_state *uts)
264 {
265 	unsigned int offset, gpio;
266 	struct udevice *dev;
267 	char buf[80];
268 
269 	ut_assertok(gpio_lookup_name("b5", &dev, &offset, &gpio));
270 	ut_assertok(gpio_requestf(gpio, "testing %d %s", 1, "hi"));
271 	sandbox_gpio_set_direction(dev, offset, 1);
272 	sandbox_gpio_set_value(dev, offset, 1);
273 	ut_assertok(gpio_get_status(dev, offset, buf, sizeof(buf)));
274 	ut_asserteq_str("b5: output: 1 [x] testing 1 hi", buf);
275 
276 	return 0;
277 }
278 DM_TEST(dm_test_gpio_requestf, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
279 
280 /* Test that gpio_request() copies its string */
dm_test_gpio_copy(struct unit_test_state * uts)281 static int dm_test_gpio_copy(struct unit_test_state *uts)
282 {
283 	unsigned int offset, gpio;
284 	struct udevice *dev;
285 	char buf[80], name[10];
286 
287 	ut_assertok(gpio_lookup_name("b6", &dev, &offset, &gpio));
288 	strcpy(name, "odd_name");
289 	ut_assertok(gpio_request(gpio, name));
290 	sandbox_gpio_set_direction(dev, offset, 1);
291 	sandbox_gpio_set_value(dev, offset, 1);
292 	ut_assertok(gpio_get_status(dev, offset, buf, sizeof(buf)));
293 	ut_asserteq_str("b6: output: 1 [x] odd_name", buf);
294 	strcpy(name, "nothing");
295 	ut_assertok(gpio_get_status(dev, offset, buf, sizeof(buf)));
296 	ut_asserteq_str("b6: output: 1 [x] odd_name", buf);
297 
298 	return 0;
299 }
300 DM_TEST(dm_test_gpio_copy, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
301 
302 /* Test that we don't leak memory with GPIOs */
dm_test_gpio_leak(struct unit_test_state * uts)303 static int dm_test_gpio_leak(struct unit_test_state *uts)
304 {
305 	ut_assertok(dm_test_gpio(uts));
306 	ut_assertok(dm_test_gpio_anon(uts));
307 	ut_assertok(dm_test_gpio_requestf(uts));
308 	ut_assertok(dm_leak_check_end(uts));
309 
310 	return 0;
311 }
312 DM_TEST(dm_test_gpio_leak, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
313 
314 /* Test that we can find GPIOs using phandles */
dm_test_gpio_phandles(struct unit_test_state * uts)315 static int dm_test_gpio_phandles(struct unit_test_state *uts)
316 {
317 	struct gpio_desc desc, desc_list[8], desc_list2[8];
318 	struct udevice *dev, *gpio_a, *gpio_b;
319 
320 	ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 0, &dev));
321 	ut_asserteq_str("a-test", dev->name);
322 
323 	ut_assertok(gpio_request_by_name(dev, "test-gpios", 1, &desc, 0));
324 	ut_assertok(uclass_get_device(UCLASS_GPIO, 1, &gpio_a));
325 	ut_assertok(uclass_get_device(UCLASS_GPIO, 2, &gpio_b));
326 	ut_asserteq_str("base-gpios", gpio_a->name);
327 	ut_asserteq(true, !!device_active(gpio_a));
328 	ut_asserteq_ptr(gpio_a, desc.dev);
329 	ut_asserteq(4, desc.offset);
330 	/* GPIOF_INPUT is the sandbox GPIO driver default */
331 	ut_asserteq(GPIOF_INPUT, gpio_get_function(gpio_a, 4, NULL));
332 	ut_assertok(dm_gpio_free(dev, &desc));
333 
334 	ut_asserteq(-ENOENT, gpio_request_by_name(dev, "test-gpios", 3, &desc,
335 						  0));
336 	ut_asserteq_ptr(NULL, desc.dev);
337 	ut_asserteq(desc.offset, 0);
338 	ut_asserteq(-ENOENT, gpio_request_by_name(dev, "test-gpios", 5, &desc,
339 						  0));
340 
341 	/* Last GPIO is ignord as it comes after <0> */
342 	ut_asserteq(3, gpio_request_list_by_name(dev, "test-gpios", desc_list,
343 						 ARRAY_SIZE(desc_list), 0));
344 	ut_asserteq(-EBUSY, gpio_request_list_by_name(dev, "test-gpios",
345 						      desc_list2,
346 						      ARRAY_SIZE(desc_list2),
347 						      0));
348 	ut_asserteq(GPIOF_INPUT, gpio_get_function(gpio_a, 4, NULL));
349 	ut_assertok(gpio_free_list(dev, desc_list, 3));
350 	ut_asserteq(GPIOF_UNUSED, gpio_get_function(gpio_a, 4, NULL));
351 	ut_asserteq(3, gpio_request_list_by_name(dev,  "test-gpios", desc_list,
352 						 ARRAY_SIZE(desc_list),
353 						 GPIOD_IS_OUT |
354 						 GPIOD_IS_OUT_ACTIVE));
355 	ut_asserteq(GPIOF_OUTPUT, gpio_get_function(gpio_a, 4, NULL));
356 	ut_asserteq_ptr(gpio_a, desc_list[0].dev);
357 	ut_asserteq(1, desc_list[0].offset);
358 	ut_asserteq_ptr(gpio_a, desc_list[1].dev);
359 	ut_asserteq(4, desc_list[1].offset);
360 	ut_asserteq_ptr(gpio_b, desc_list[2].dev);
361 	ut_asserteq(5, desc_list[2].offset);
362 	ut_asserteq(1, dm_gpio_get_value(desc_list));
363 	ut_assertok(gpio_free_list(dev, desc_list, 3));
364 
365 	ut_asserteq(GPIOD_IS_OUT | GPIOD_IS_OUT_ACTIVE,
366 		    sandbox_gpio_get_dir_flags(gpio_a, 1));
367 	ut_asserteq(6, gpio_request_list_by_name(dev, "test2-gpios", desc_list,
368 						 ARRAY_SIZE(desc_list), 0));
369 
370 	/* This was set to output previously but flags resetted to 0 = INPUT */
371 	ut_asserteq(0, sandbox_gpio_get_dir_flags(gpio_a, 1));
372 	ut_asserteq(GPIOF_INPUT, gpio_get_function(gpio_a, 1, NULL));
373 
374 	/* Active low should invert the input value */
375 	ut_asserteq(GPIOF_INPUT, gpio_get_function(gpio_b, 6, NULL));
376 	ut_asserteq(1, dm_gpio_get_value(&desc_list[2]));
377 
378 	ut_asserteq(GPIOF_INPUT, gpio_get_function(gpio_b, 7, NULL));
379 	ut_asserteq(GPIOF_OUTPUT, gpio_get_function(gpio_b, 8, NULL));
380 	ut_asserteq(0, dm_gpio_get_value(&desc_list[4]));
381 	ut_asserteq(GPIOF_OUTPUT, gpio_get_function(gpio_b, 9, NULL));
382 	ut_asserteq(1, dm_gpio_get_value(&desc_list[5]));
383 
384 	return 0;
385 }
386 DM_TEST(dm_test_gpio_phandles, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
387 
388 /* Check the gpio pin configuration get from device tree information */
dm_test_gpio_get_dir_flags(struct unit_test_state * uts)389 static int dm_test_gpio_get_dir_flags(struct unit_test_state *uts)
390 {
391 	struct gpio_desc desc_list[6];
392 	struct udevice *dev;
393 	ulong flags;
394 
395 	ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 0, &dev));
396 
397 	ut_asserteq(6, gpio_request_list_by_name(dev, "test3-gpios", desc_list,
398 						 ARRAY_SIZE(desc_list), 0));
399 
400 	ut_assertok(dm_gpio_get_dir_flags(&desc_list[0], &flags));
401 	ut_asserteq(GPIOD_IS_OUT | GPIOD_OPEN_DRAIN, flags);
402 
403 	ut_assertok(dm_gpio_get_dir_flags(&desc_list[1], &flags));
404 	ut_asserteq(GPIOD_IS_OUT | GPIOD_OPEN_SOURCE, flags);
405 
406 	ut_assertok(dm_gpio_get_dir_flags(&desc_list[2], &flags));
407 	ut_asserteq(GPIOD_IS_OUT, flags);
408 
409 	ut_assertok(dm_gpio_get_dir_flags(&desc_list[3], &flags));
410 	ut_asserteq(GPIOD_IS_IN | GPIOD_PULL_UP, flags);
411 
412 	ut_assertok(dm_gpio_get_dir_flags(&desc_list[4], &flags));
413 	ut_asserteq(GPIOD_IS_IN | GPIOD_PULL_DOWN, flags);
414 
415 	ut_assertok(dm_gpio_get_dir_flags(&desc_list[5], &flags));
416 	ut_asserteq(GPIOD_IS_IN, flags);
417 
418 	ut_assertok(gpio_free_list(dev, desc_list, 6));
419 
420 	return 0;
421 }
422 DM_TEST(dm_test_gpio_get_dir_flags, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
423 
424 /* Test of gpio_get_acpi() */
dm_test_gpio_get_acpi(struct unit_test_state * uts)425 static int dm_test_gpio_get_acpi(struct unit_test_state *uts)
426 {
427 	struct acpi_gpio agpio;
428 	struct udevice *dev;
429 	struct gpio_desc desc;
430 
431 	ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 0, &dev));
432 	ut_asserteq_str("a-test", dev->name);
433 	ut_assertok(gpio_request_by_name(dev, "test-gpios", 1, &desc, 0));
434 
435 	/* See sb_gpio_get_acpi() */
436 	ut_assertok(gpio_get_acpi(&desc, &agpio));
437 	ut_asserteq(1, agpio.pin_count);
438 	ut_asserteq(4, agpio.pins[0]);
439 	ut_asserteq(ACPI_GPIO_TYPE_IO, agpio.type);
440 	ut_asserteq(ACPI_GPIO_PULL_UP, agpio.pull);
441 	ut_asserteq_str("\\_SB.PINC", agpio.resource);
442 	ut_asserteq(0, agpio.interrupt_debounce_timeout);
443 	ut_asserteq(0, agpio.irq.pin);
444 	ut_asserteq(1234, agpio.output_drive_strength);
445 	ut_asserteq(true, agpio.io_shared);
446 	ut_asserteq(ACPI_GPIO_IO_RESTRICT_INPUT, agpio.io_restrict);
447 	ut_asserteq(ACPI_GPIO_ACTIVE_HIGH, agpio.polarity);
448 
449 	return 0;
450 }
451 DM_TEST(dm_test_gpio_get_acpi, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
452 
453 /* Test of gpio_get_acpi() with an interrupt GPIO */
dm_test_gpio_get_acpi_irq(struct unit_test_state * uts)454 static int dm_test_gpio_get_acpi_irq(struct unit_test_state *uts)
455 {
456 	struct acpi_gpio agpio;
457 	struct udevice *dev;
458 	struct gpio_desc desc;
459 
460 	ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 0, &dev));
461 	ut_asserteq_str("a-test", dev->name);
462 	ut_assertok(gpio_request_by_name(dev, "test2-gpios", 2, &desc, 0));
463 
464 	/* See sb_gpio_get_acpi() */
465 	ut_assertok(gpio_get_acpi(&desc, &agpio));
466 	ut_asserteq(1, agpio.pin_count);
467 	ut_asserteq(6, agpio.pins[0]);
468 	ut_asserteq(ACPI_GPIO_TYPE_INTERRUPT, agpio.type);
469 	ut_asserteq(ACPI_GPIO_PULL_DOWN, agpio.pull);
470 	ut_asserteq_str("\\_SB.PINC", agpio.resource);
471 	ut_asserteq(4321, agpio.interrupt_debounce_timeout);
472 	ut_asserteq(6, agpio.irq.pin);
473 	ut_asserteq(ACPI_IRQ_ACTIVE_BOTH, agpio.irq.polarity);
474 	ut_asserteq(ACPI_IRQ_SHARED, agpio.irq.shared);
475 	ut_asserteq(true, agpio.irq.wake);
476 	ut_asserteq(0, agpio.output_drive_strength);
477 	ut_asserteq(false, agpio.io_shared);
478 	ut_asserteq(0, agpio.io_restrict);
479 	ut_asserteq(ACPI_GPIO_ACTIVE_LOW, agpio.polarity);
480 
481 	return 0;
482 }
483 DM_TEST(dm_test_gpio_get_acpi_irq, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
484 
485 /* Test that we can get/release GPIOs using managed API */
dm_test_gpio_devm(struct unit_test_state * uts)486 static int dm_test_gpio_devm(struct unit_test_state *uts)
487 {
488 	static const u32 flags = GPIOD_IS_OUT | GPIOD_IS_OUT_ACTIVE;
489 	struct gpio_desc *desc1, *desc2, *desc3, *desc_err;
490 	struct udevice *dev;
491 	struct udevice *dev2;
492 
493 	ut_assertok(uclass_get_device_by_name(UCLASS_TEST_FDT, "a-test",
494 					      &dev));
495 	ut_assertok(uclass_get_device_by_name(UCLASS_TEST_FDT, "another-test",
496 					      &dev2));
497 
498 	/* Get 3 GPIOs from 'a-test' dev */
499 	desc1 = devm_gpiod_get_index(dev, "test4", 0, flags);
500 	ut_assert(!IS_ERR(desc1));
501 	desc2 = devm_gpiod_get_index(dev, "test4", 1, flags);
502 	ut_assert(!IS_ERR(desc2));
503 	desc3 = devm_gpiod_get_index_optional(dev, "test5", 0, flags);
504 	ut_assert(!IS_ERR(desc3));
505 	ut_assert(desc3);
506 
507 	/*
508 	 * Try get the same 3 GPIOs from 'a-test' and 'another-test' devices.
509 	 * check that it fails
510 	 */
511 	desc_err = devm_gpiod_get_index(dev, "test4", 0, flags);
512 	ut_asserteq(-EBUSY, PTR_ERR(desc_err));
513 	desc_err = devm_gpiod_get_index(dev2, "test4", 0, flags);
514 	ut_asserteq(-EBUSY, PTR_ERR(desc_err));
515 	desc_err = devm_gpiod_get_index(dev, "test4", 1, flags);
516 	ut_asserteq(-EBUSY, PTR_ERR(desc_err));
517 	desc_err = devm_gpiod_get_index(dev2, "test4", 1, flags);
518 	ut_asserteq(-EBUSY, PTR_ERR(desc_err));
519 	desc_err = devm_gpiod_get_index_optional(dev, "test5", 0, flags);
520 	ut_asserteq_ptr(NULL, desc_err);
521 	desc_err = devm_gpiod_get_index_optional(dev2, "test5", 0, flags);
522 	ut_asserteq_ptr(NULL, desc_err);
523 
524 	/* Try get GPIOs outside of the list */
525 	desc_err = devm_gpiod_get_index(dev, "test4", 2, flags);
526 	ut_assert(IS_ERR(desc_err));
527 	desc_err = devm_gpiod_get_index_optional(dev, "test5", 1, flags);
528 	ut_asserteq_ptr(NULL, desc_err);
529 
530 	/* Manipulate the GPIOs */
531 	ut_assertok(dm_gpio_set_value(desc1, 1));
532 	ut_asserteq(1, dm_gpio_get_value(desc1));
533 	ut_assertok(dm_gpio_set_value(desc1, 0));
534 	ut_asserteq(0, dm_gpio_get_value(desc1));
535 
536 	ut_assertok(dm_gpio_set_value(desc2, 1));
537 	ut_asserteq(1, dm_gpio_get_value(desc2));
538 	ut_assertok(dm_gpio_set_value(desc2, 0));
539 	ut_asserteq(0, dm_gpio_get_value(desc2));
540 
541 	ut_assertok(dm_gpio_set_value(desc3, 1));
542 	ut_asserteq(1, dm_gpio_get_value(desc3));
543 	ut_assertok(dm_gpio_set_value(desc3, 0));
544 	ut_asserteq(0, dm_gpio_get_value(desc3));
545 
546 	/* Check that the GPIO cannot be owned by more than one device */
547 	desc_err = devm_gpiod_get_index(dev2, "test4", 0, flags);
548 	ut_asserteq(-EBUSY, PTR_ERR(desc_err));
549 	desc_err = devm_gpiod_get_index(dev2, "test4", 1, flags);
550 	ut_asserteq(-EBUSY, PTR_ERR(desc_err));
551 	desc_err = devm_gpiod_get_index_optional(dev2, "test5", 0, flags);
552 	ut_asserteq_ptr(NULL, desc_err);
553 
554 	/*
555 	 * Release one GPIO and check that we can get it back using
556 	 * 'another-test' and then 'a-test'
557 	 */
558 	devm_gpiod_put(dev, desc2);
559 	desc2 = devm_gpiod_get_index(dev2, "test4", 1, flags);
560 	ut_assert(!IS_ERR(desc2));
561 
562 	devm_gpiod_put(dev2, desc2);
563 	desc2 = devm_gpiod_get_index(dev, "test4", 1, flags);
564 	ut_assert(!IS_ERR(desc2));
565 
566 	/* Release one GPIO before removing the 'a-test' dev. */
567 	devm_gpiod_put(dev, desc2);
568 	device_remove(dev, DM_REMOVE_NORMAL);
569 
570 	/* All the GPIOs must have been freed. We should be able to claim
571 	 * them with the 'another-test' device.
572 	 */
573 	desc1 = devm_gpiod_get_index(dev2, "test4", 0, flags);
574 	ut_assert(!IS_ERR(desc1));
575 	desc2 = devm_gpiod_get_index(dev2, "test4", 1, flags);
576 	ut_assert(!IS_ERR(desc2));
577 	desc3 = devm_gpiod_get_index_optional(dev2, "test5", 0, flags);
578 	ut_assert(!IS_ERR(desc3));
579 	ut_assert(desc3);
580 
581 	device_remove(dev2, DM_REMOVE_NORMAL);
582 	return 0;
583 }
584 DM_TEST(dm_test_gpio_devm, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
585