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 block_dev_desc_t *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(get_device("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, dev_desc->block_read(dev_desc, 0, 2, cmp)); 54 ut_assertok(strcmp(cmp, "this is a test")); 55 56 return 0; 57 } 58 DM_TEST(dm_test_usb_flash, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 59 60 /* test that we can handle multiple storage devices */ 61 static int dm_test_usb_multi(struct unit_test_state *uts) 62 { 63 struct udevice *dev; 64 65 state_set_skip_delays(true); 66 ut_assertok(usb_init()); 67 ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &dev)); 68 ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 1, &dev)); 69 ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 2, &dev)); 70 71 return 0; 72 } 73 DM_TEST(dm_test_usb_multi, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 74 75 static int count_usb_devices(void) 76 { 77 struct udevice *hub; 78 struct uclass *uc; 79 int count = 0; 80 int ret; 81 82 ret = uclass_get(UCLASS_USB_HUB, &uc); 83 if (ret) 84 return ret; 85 86 uclass_foreach_dev(hub, uc) { 87 struct udevice *dev; 88 89 count++; 90 for (device_find_first_child(hub, &dev); 91 dev; 92 device_find_next_child(&dev)) { 93 count++; 94 } 95 } 96 97 return count; 98 } 99 100 /* test that we can remove an emulated device and it is then not found */ 101 static int dm_test_usb_remove(struct unit_test_state *uts) 102 { 103 struct udevice *dev, *emul; 104 105 /* Scan and check that all devices are present */ 106 state_set_skip_delays(true); 107 ut_assertok(usb_init()); 108 ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &dev)); 109 ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 1, &dev)); 110 ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 2, &dev)); 111 ut_asserteq(6, count_usb_devices()); 112 ut_assertok(usb_stop()); 113 ut_asserteq(6, count_usb_devices()); 114 115 /* Remove the second emulation device */ 116 ut_assertok(uclass_find_device_by_name(UCLASS_USB_EMUL, "flash-stick@1", 117 &dev)); 118 ut_assertok(device_unbind(dev)); 119 120 /* Rescan - only the first and third should be present */ 121 ut_assertok(usb_init()); 122 ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &dev)); 123 ut_assertok(usb_emul_find_for_dev(dev, &emul)); 124 ut_asserteq_str("flash-stick@0", emul->name); 125 ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 1, &dev)); 126 ut_assertok(usb_emul_find_for_dev(dev, &emul)); 127 ut_asserteq_str("flash-stick@2", emul->name); 128 129 ut_asserteq(-ENODEV, uclass_get_device(UCLASS_MASS_STORAGE, 2, &dev)); 130 131 ut_asserteq(5, count_usb_devices()); 132 ut_assertok(usb_stop()); 133 ut_asserteq(5, count_usb_devices()); 134 135 return 0; 136 } 137 DM_TEST(dm_test_usb_remove, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 138 139 const char usb_tree_base[] = 140 " 1 Hub (12 Mb/s, 100mA)\n" 141 " | sandbox hub 2345\n" 142 " |\n" 143 " |\b+-2 Mass Storage (12 Mb/s, 100mA)\n" 144 " | sandbox flash flash-stick@0\n" 145 " | \n" 146 " |\b+-3 Mass Storage (12 Mb/s, 100mA)\n" 147 " | sandbox flash flash-stick@1\n" 148 " | \n" 149 " |\b+-4 Mass Storage (12 Mb/s, 100mA)\n" 150 " | sandbox flash flash-stick@2\n" 151 " | \n" 152 " |\b+-5 Human Interface (12 Mb/s, 100mA)\n" 153 " sandbox keyboard keyb@3\n" 154 " \n"; 155 156 /* test that the 'usb tree' command output looks correct */ 157 static int dm_test_usb_tree(struct unit_test_state *uts) 158 { 159 char *data; 160 int len; 161 162 state_set_skip_delays(true); 163 ut_assertok(usb_init()); 164 console_record_reset_enable(); 165 usb_show_tree(); 166 len = membuff_getraw(&gd->console_out, -1, true, &data); 167 if (len) 168 data[len] = '\0'; 169 ut_asserteq_str(usb_tree_base, data); 170 ut_assertok(usb_stop()); 171 172 return 0; 173 } 174 DM_TEST(dm_test_usb_tree, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 175 176 const char usb_tree_remove[] = 177 " 1 Hub (12 Mb/s, 100mA)\n" 178 " | sandbox hub 2345\n" 179 " |\n" 180 " |\b+-2 Mass Storage (12 Mb/s, 100mA)\n" 181 " | sandbox flash flash-stick@0\n" 182 " | \n" 183 " |\b+-3 Mass Storage (12 Mb/s, 100mA)\n" 184 " | sandbox flash flash-stick@2\n" 185 " | \n" 186 " |\b+-4 Human Interface (12 Mb/s, 100mA)\n" 187 " sandbox keyboard keyb@3\n" 188 " \n"; 189 190 /* 191 * test that the 'usb tree' command output looks correct when we remove a 192 * device 193 */ 194 static int dm_test_usb_tree_remove(struct unit_test_state *uts) 195 { 196 struct udevice *dev; 197 char *data; 198 int len; 199 200 /* Remove the second emulation device */ 201 ut_assertok(uclass_find_device_by_name(UCLASS_USB_EMUL, "flash-stick@1", 202 &dev)); 203 ut_assertok(device_unbind(dev)); 204 205 state_set_skip_delays(true); 206 ut_assertok(usb_init()); 207 console_record_reset_enable(); 208 usb_show_tree(); 209 len = membuff_getraw(&gd->console_out, -1, true, &data); 210 if (len) 211 data[len] = '\0'; 212 ut_asserteq_str(usb_tree_remove, data); 213 ut_assertok(usb_stop()); 214 215 return 0; 216 } 217 DM_TEST(dm_test_usb_tree_remove, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 218 219 const char usb_tree_reorder[] = 220 " 1 Hub (12 Mb/s, 100mA)\n" 221 " | sandbox hub 2345\n" 222 " |\n" 223 " |\b+-2 Mass Storage (12 Mb/s, 100mA)\n" 224 " | sandbox flash flash-stick@0\n" 225 " | \n" 226 " |\b+-3 Mass Storage (12 Mb/s, 100mA)\n" 227 " | sandbox flash flash-stick@2\n" 228 " | \n" 229 " |\b+-4 Human Interface (12 Mb/s, 100mA)\n" 230 " | sandbox keyboard keyb@3\n" 231 " | \n" 232 " |\b+-5 Mass Storage (12 Mb/s, 100mA)\n" 233 " sandbox flash flash-stick@1\n" 234 " \n"; 235 236 /* 237 * test that the 'usb tree' command output looks correct when we reorder two 238 * devices. 239 */ 240 static int dm_test_usb_tree_reorder(struct unit_test_state *uts) 241 { 242 struct udevice *dev, *parent; 243 char *data; 244 int len; 245 246 /* Remove the second emulation device */ 247 ut_assertok(uclass_find_device_by_name(UCLASS_USB_EMUL, "flash-stick@1", 248 &dev)); 249 parent = dev->parent; 250 251 /* Reorder the devices in the parent list and uclass list */ 252 list_del(&dev->sibling_node); 253 list_add_tail(&dev->sibling_node, &parent->child_head); 254 255 list_del(&dev->uclass_node); 256 list_add_tail(&dev->uclass_node, &dev->uclass->dev_head); 257 258 state_set_skip_delays(true); 259 ut_assertok(usb_init()); 260 console_record_reset_enable(); 261 usb_show_tree(); 262 len = membuff_getraw(&gd->console_out, -1, true, &data); 263 if (len) 264 data[len] = '\0'; 265 ut_asserteq_str(usb_tree_reorder, data); 266 ut_assertok(usb_stop()); 267 268 return 0; 269 } 270 DM_TEST(dm_test_usb_tree_reorder, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 271 272 static int dm_test_usb_keyb(struct unit_test_state *uts) 273 { 274 struct udevice *dev; 275 276 state_set_skip_delays(true); 277 ut_assertok(usb_init()); 278 279 /* Initially there should be no characters */ 280 ut_asserteq(0, tstc()); 281 282 ut_assertok(uclass_get_device_by_name(UCLASS_USB_EMUL, "keyb", 283 &dev)); 284 285 /* 286 * Add a string to the USB keyboard buffer - it should appear in 287 * stdin 288 */ 289 ut_assertok(sandbox_usb_keyb_add_string(dev, "ab")); 290 ut_asserteq(1, tstc()); 291 ut_asserteq('a', getc()); 292 ut_asserteq(1, tstc()); 293 ut_asserteq('b', getc()); 294 ut_asserteq(0, tstc()); 295 296 ut_assertok(usb_stop()); 297 298 return 0; 299 } 300 DM_TEST(dm_test_usb_keyb, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 301