tools: binman: change shebang from python into python2
[oweals/u-boot.git] / test / dm / usb.c
1 /*
2  * Copyright (C) 2015 Google, Inc
3  *
4  * SPDX-License-Identifier:     GPL-2.0+
5  */
6
7 #include <common.h>
8 #include <console.h>
9 #include <dm.h>
10 #include <usb.h>
11 #include <asm/io.h>
12 #include <asm/state.h>
13 #include <asm/test.h>
14 #include <dm/device-internal.h>
15 #include <dm/test.h>
16 #include <dm/uclass-internal.h>
17 #include <test/ut.h>
18
19 DECLARE_GLOBAL_DATA_PTR;
20
21 /* Test that sandbox USB works correctly */
22 static int dm_test_usb_base(struct unit_test_state *uts)
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  */
39 static int dm_test_usb_flash(struct unit_test_state *uts)
40 {
41         struct udevice *dev;
42         struct blk_desc *dev_desc;
43         char cmp[1024];
44
45         state_set_skip_delays(true);
46         ut_assertok(usb_init());
47         ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &dev));
48         ut_assertok(blk_get_device_by_str("usb", "0", &dev_desc));
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));
53         ut_asserteq(2, blk_dread(dev_desc, 0, 2, cmp));
54         ut_assertok(strcmp(cmp, "this is a test"));
55         ut_assertok(usb_stop());
56
57         return 0;
58 }
59 DM_TEST(dm_test_usb_flash, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
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));
71         ut_assertok(usb_stop());
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
102 /* test that we can remove an emulated device and it is then not found */
103 static int dm_test_usb_remove(struct unit_test_state *uts)
104 {
105         struct udevice *dev, *emul;
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));
113         ut_asserteq(6, count_usb_devices());
114         ut_assertok(usb_stop());
115         ut_asserteq(6, count_usb_devices());
116
117         /* Remove the second emulation device */
118         ut_assertok(uclass_find_device_by_name(UCLASS_USB_EMUL, "flash-stick@1",
119                                                &dev));
120         ut_assertok(device_unbind(dev));
121
122         /* Rescan - only the first and third should be present */
123         ut_assertok(usb_init());
124         ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &dev));
125         ut_assertok(usb_emul_find_for_dev(dev, &emul));
126         ut_asserteq_str("flash-stick@0", emul->name);
127         ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 1, &dev));
128         ut_assertok(usb_emul_find_for_dev(dev, &emul));
129         ut_asserteq_str("flash-stick@2", emul->name);
130
131         ut_asserteq(-ENODEV, uclass_get_device(UCLASS_MASS_STORAGE, 2, &dev));
132
133         ut_asserteq(5, count_usb_devices());
134         ut_assertok(usb_stop());
135         ut_asserteq(5, count_usb_devices());
136
137         return 0;
138 }
139 DM_TEST(dm_test_usb_remove, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
140
141 const char usb_tree_base[] =
142 "  1  Hub (12 Mb/s, 100mA)\n"
143 "  |  sandbox hub 2345\n"
144 "  |\n"
145 "  |\b+-2  Mass Storage (12 Mb/s, 100mA)\n"
146 "  |    sandbox flash flash-stick@0\n"
147 "  |  \n"
148 "  |\b+-3  Mass Storage (12 Mb/s, 100mA)\n"
149 "  |    sandbox flash flash-stick@1\n"
150 "  |  \n"
151 "  |\b+-4  Mass Storage (12 Mb/s, 100mA)\n"
152 "  |    sandbox flash flash-stick@2\n"
153 "  |  \n"
154 "  |\b+-5  Human Interface (12 Mb/s, 100mA)\n"
155 "       sandbox keyboard keyb@3\n"
156 "     \n";
157
158 /* test that the 'usb tree' command output looks correct */
159 static int dm_test_usb_tree(struct unit_test_state *uts)
160 {
161         char *data;
162         int len;
163
164         state_set_skip_delays(true);
165         ut_assertok(usb_init());
166         console_record_reset_enable();
167         usb_show_tree();
168         len = membuff_getraw(&gd->console_out, -1, true, &data);
169         if (len)
170                 data[len] = '\0';
171         ut_asserteq_str(usb_tree_base, data);
172         ut_assertok(usb_stop());
173
174         return 0;
175 }
176 DM_TEST(dm_test_usb_tree, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
177
178 const char usb_tree_remove[] =
179 "  1  Hub (12 Mb/s, 100mA)\n"
180 "  |  sandbox hub 2345\n"
181 "  |\n"
182 "  |\b+-2  Mass Storage (12 Mb/s, 100mA)\n"
183 "  |    sandbox flash flash-stick@0\n"
184 "  |  \n"
185 "  |\b+-3  Mass Storage (12 Mb/s, 100mA)\n"
186 "  |    sandbox flash flash-stick@2\n"
187 "  |  \n"
188 "  |\b+-4  Human Interface (12 Mb/s, 100mA)\n"
189 "       sandbox keyboard keyb@3\n"
190 "     \n";
191
192 /*
193  * test that the 'usb tree' command output looks correct when we remove a
194  * device
195  */
196 static int dm_test_usb_tree_remove(struct unit_test_state *uts)
197 {
198         struct udevice *dev;
199         char *data;
200         int len;
201
202         /* Remove the second emulation device */
203         ut_assertok(uclass_find_device_by_name(UCLASS_USB_EMUL, "flash-stick@1",
204                                                &dev));
205         ut_assertok(device_unbind(dev));
206
207         state_set_skip_delays(true);
208         ut_assertok(usb_init());
209         console_record_reset_enable();
210         usb_show_tree();
211         len = membuff_getraw(&gd->console_out, -1, true, &data);
212         if (len)
213                 data[len] = '\0';
214         ut_asserteq_str(usb_tree_remove, data);
215         ut_assertok(usb_stop());
216
217         return 0;
218 }
219 DM_TEST(dm_test_usb_tree_remove, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
220
221 const char usb_tree_reorder[] =
222 "  1  Hub (12 Mb/s, 100mA)\n"
223 "  |  sandbox hub 2345\n"
224 "  |\n"
225 "  |\b+-2  Mass Storage (12 Mb/s, 100mA)\n"
226 "  |    sandbox flash flash-stick@0\n"
227 "  |  \n"
228 "  |\b+-3  Mass Storage (12 Mb/s, 100mA)\n"
229 "  |    sandbox flash flash-stick@2\n"
230 "  |  \n"
231 "  |\b+-4  Human Interface (12 Mb/s, 100mA)\n"
232 "  |    sandbox keyboard keyb@3\n"
233 "  |  \n"
234 "  |\b+-5  Mass Storage (12 Mb/s, 100mA)\n"
235 "       sandbox flash flash-stick@1\n"
236 "     \n";
237
238 /*
239  * test that the 'usb tree' command output looks correct when we reorder two
240  * devices.
241  */
242 static int dm_test_usb_tree_reorder(struct unit_test_state *uts)
243 {
244         struct udevice *dev, *parent;
245         char *data;
246         int len;
247
248         /* Remove the second emulation device */
249         ut_assertok(uclass_find_device_by_name(UCLASS_USB_EMUL, "flash-stick@1",
250                                                &dev));
251         parent = dev->parent;
252
253         /* Reorder the devices in the parent list and uclass list */
254         list_del(&dev->sibling_node);
255         list_add_tail(&dev->sibling_node, &parent->child_head);
256
257         list_del(&dev->uclass_node);
258         list_add_tail(&dev->uclass_node, &dev->uclass->dev_head);
259
260         state_set_skip_delays(true);
261         ut_assertok(usb_init());
262         console_record_reset_enable();
263         usb_show_tree();
264         len = membuff_getraw(&gd->console_out, -1, true, &data);
265         if (len)
266                 data[len] = '\0';
267         ut_asserteq_str(usb_tree_reorder, data);
268         ut_assertok(usb_stop());
269
270         return 0;
271 }
272 DM_TEST(dm_test_usb_tree_reorder, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
273
274 static int dm_test_usb_keyb(struct unit_test_state *uts)
275 {
276         struct udevice *dev;
277
278         state_set_skip_delays(true);
279         ut_assertok(usb_init());
280
281         /* Initially there should be no characters */
282         ut_asserteq(0, tstc());
283
284         ut_assertok(uclass_get_device_by_name(UCLASS_USB_EMUL, "keyb",
285                                               &dev));
286
287         /*
288          * Add a string to the USB keyboard buffer - it should appear in
289          * stdin
290          */
291         ut_assertok(sandbox_usb_keyb_add_string(dev, "ab"));
292         ut_asserteq(1, tstc());
293         ut_asserteq('a', getc());
294         ut_asserteq(1, tstc());
295         ut_asserteq('b', getc());
296         ut_asserteq(0, tstc());
297
298         ut_assertok(usb_stop());
299
300         return 0;
301 }
302 DM_TEST(dm_test_usb_keyb, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);