]>
Commit | Line | Data |
---|---|---|
e00cb223 SG |
1 | /* |
2 | * Copyright (C) 2015 Google, Inc | |
3 | * | |
4 | * SPDX-License-Identifier: GPL-2.0+ | |
5 | */ | |
6 | ||
7 | #include <common.h> | |
24b852a7 | 8 | #include <console.h> |
e00cb223 SG |
9 | #include <dm.h> |
10 | #include <usb.h> | |
11 | #include <asm/io.h> | |
3884c98c | 12 | #include <asm/state.h> |
bff1a71e | 13 | #include <asm/test.h> |
3884c98c | 14 | #include <dm/device-internal.h> |
e00cb223 | 15 | #include <dm/test.h> |
431cbd6d | 16 | #include <dm/uclass-internal.h> |
e721b882 | 17 | #include <test/ut.h> |
e00cb223 | 18 | |
431cbd6d SG |
19 | DECLARE_GLOBAL_DATA_PTR; |
20 | ||
e00cb223 | 21 | /* Test that sandbox USB works correctly */ |
e721b882 | 22 | static int dm_test_usb_base(struct unit_test_state *uts) |
e00cb223 SG |
23 | { |
24 | struct udevice *bus; | |
25 | ||
26 | ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_USB, 0, &bus)); | |
27 | ut_assertok(uclass_get_device(UCLASS_USB, 0, &bus)); | |
28 | ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_USB, 2, &bus)); | |
29 | ||
30 | return 0; | |
31 | } | |
32 | DM_TEST(dm_test_usb_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); | |
33 | ||
34 | /* | |
35 | * Test that we can use the flash stick. This is more of a functional test. It | |
36 | * covers scanning the bug, setting up a hub and a flash stick and reading | |
37 | * data from the flash stick. | |
38 | */ | |
e721b882 | 39 | static int dm_test_usb_flash(struct unit_test_state *uts) |
e00cb223 SG |
40 | { |
41 | struct udevice *dev; | |
4101f687 | 42 | struct blk_desc *dev_desc; |
e00cb223 SG |
43 | char cmp[1024]; |
44 | ||
3884c98c | 45 | state_set_skip_delays(true); |
e00cb223 SG |
46 | ut_assertok(usb_init()); |
47 | ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &dev)); | |
ebac37cf | 48 | ut_assertok(blk_get_device_by_str("usb", "0", &dev_desc)); |
e00cb223 SG |
49 | |
50 | /* Read a few blocks and look for the string we expect */ | |
51 | ut_asserteq(512, dev_desc->blksz); | |
52 | memset(cmp, '\0', sizeof(cmp)); | |
2a981dc2 | 53 | ut_asserteq(2, blk_dread(dev_desc, 0, 2, cmp)); |
e00cb223 | 54 | ut_assertok(strcmp(cmp, "this is a test")); |
61ccd886 | 55 | ut_assertok(usb_stop()); |
e00cb223 SG |
56 | |
57 | return 0; | |
58 | } | |
59 | DM_TEST(dm_test_usb_flash, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); | |
431cbd6d SG |
60 | |
61 | /* test that we can handle multiple storage devices */ | |
62 | static int dm_test_usb_multi(struct unit_test_state *uts) | |
63 | { | |
64 | struct udevice *dev; | |
65 | ||
66 | state_set_skip_delays(true); | |
67 | ut_assertok(usb_init()); | |
68 | ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &dev)); | |
69 | ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 1, &dev)); | |
70 | ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 2, &dev)); | |
61ccd886 | 71 | ut_assertok(usb_stop()); |
431cbd6d SG |
72 | |
73 | return 0; | |
74 | } | |
75 | DM_TEST(dm_test_usb_multi, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); | |
76 | ||
77 | static int count_usb_devices(void) | |
78 | { | |
79 | struct udevice *hub; | |
80 | struct uclass *uc; | |
81 | int count = 0; | |
82 | int ret; | |
83 | ||
84 | ret = uclass_get(UCLASS_USB_HUB, &uc); | |
85 | if (ret) | |
86 | return ret; | |
87 | ||
88 | uclass_foreach_dev(hub, uc) { | |
89 | struct udevice *dev; | |
90 | ||
91 | count++; | |
92 | for (device_find_first_child(hub, &dev); | |
93 | dev; | |
94 | device_find_next_child(&dev)) { | |
95 | count++; | |
96 | } | |
97 | } | |
98 | ||
99 | return count; | |
100 | } | |
101 | ||
f4d4f7d4 BM |
102 | /* test that no USB devices are found after we stop the stack */ |
103 | static int dm_test_usb_stop(struct unit_test_state *uts) | |
431cbd6d | 104 | { |
f4d4f7d4 | 105 | struct udevice *dev; |
431cbd6d SG |
106 | |
107 | /* Scan and check that all devices are present */ | |
108 | state_set_skip_delays(true); | |
109 | ut_assertok(usb_init()); | |
110 | ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &dev)); | |
111 | ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 1, &dev)); | |
112 | ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 2, &dev)); | |
a57a8174 | 113 | ut_asserteq(6, count_usb_devices()); |
431cbd6d | 114 | ut_assertok(usb_stop()); |
f4d4f7d4 | 115 | ut_asserteq(0, count_usb_devices()); |
cd716372 SG |
116 | |
117 | return 0; | |
118 | } | |
f4d4f7d4 | 119 | DM_TEST(dm_test_usb_stop, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); |
bff1a71e SG |
120 | |
121 | static int dm_test_usb_keyb(struct unit_test_state *uts) | |
122 | { | |
123 | struct udevice *dev; | |
124 | ||
125 | state_set_skip_delays(true); | |
126 | ut_assertok(usb_init()); | |
127 | ||
128 | /* Initially there should be no characters */ | |
129 | ut_asserteq(0, tstc()); | |
130 | ||
131 | ut_assertok(uclass_get_device_by_name(UCLASS_USB_EMUL, "keyb", | |
132 | &dev)); | |
133 | ||
134 | /* | |
135 | * Add a string to the USB keyboard buffer - it should appear in | |
136 | * stdin | |
137 | */ | |
138 | ut_assertok(sandbox_usb_keyb_add_string(dev, "ab")); | |
139 | ut_asserteq(1, tstc()); | |
140 | ut_asserteq('a', getc()); | |
141 | ut_asserteq(1, tstc()); | |
142 | ut_asserteq('b', getc()); | |
143 | ut_asserteq(0, tstc()); | |
144 | ||
145 | ut_assertok(usb_stop()); | |
146 | ||
147 | return 0; | |
148 | } | |
149 | DM_TEST(dm_test_usb_keyb, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); |