1
2
3
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
21static 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
33
34
35
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
47 ops = gpio_get_ops(dev);
48 ut_assert(ops->get_function);
49
50
51 ut_asserteq(-EBUSY, gpio_get_value(gpio + 1));
52
53
54
55
56 ut_assertok(gpio_get_status(dev, offset, buf, sizeof(buf)));
57 ut_asserteq_str("b4: input: 0 [ ]", buf);
58
59
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
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
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
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
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
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
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}
149DM_TEST(dm_test_gpio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
150
151
152static 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
178 ut_asserteq(GPIOD_IS_OUT | GPIOD_OPEN_DRAIN,
179 sandbox_gpio_get_dir_flags(gpio_c, 0));
180
181
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
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
192 ut_asserteq(GPIOD_IS_OUT | GPIOD_OPEN_SOURCE,
193 sandbox_gpio_get_dir_flags(gpio_c, 1));
194
195
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
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
206 ut_asserteq(GPIOD_ACTIVE_LOW | GPIOD_IS_OUT | GPIOD_OPEN_DRAIN,
207 sandbox_gpio_get_dir_flags(gpio_c, 6));
208
209
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
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
220 ut_asserteq(GPIOD_ACTIVE_LOW | GPIOD_IS_OUT | GPIOD_OPEN_SOURCE,
221 sandbox_gpio_get_dir_flags(gpio_c, 7));
222
223
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
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}
237DM_TEST(dm_test_gpio_opendrain_opensource,
238 UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
239
240
241static 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
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}
260DM_TEST(dm_test_gpio_anon, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
261
262
263static 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}
278DM_TEST(dm_test_gpio_requestf, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
279
280
281static 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}
300DM_TEST(dm_test_gpio_copy, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
301
302
303static 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}
312DM_TEST(dm_test_gpio_leak, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
313
314
315static 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
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
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
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
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}
386DM_TEST(dm_test_gpio_phandles, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
387
388
389static 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}
422DM_TEST(dm_test_gpio_get_dir_flags, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
423
424
425static 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
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}
451DM_TEST(dm_test_gpio_get_acpi, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
452
453
454static 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
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}
483DM_TEST(dm_test_gpio_get_acpi_irq, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
484
485
486static 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
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
509
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
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
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
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
556
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
567 devm_gpiod_put(dev, desc2);
568 device_remove(dev, DM_REMOVE_NORMAL);
569
570
571
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}
584DM_TEST(dm_test_gpio_devm, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
585