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->dev, 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(5, count_usb_devices()); 112 ut_assertok(usb_stop()); 113 ut_asserteq(5, 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(4, count_usb_devices()); 132 ut_assertok(usb_stop()); 133 ut_asserteq(4, 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 153 /* test that the 'usb tree' command output looks correct */ 154 static int dm_test_usb_tree(struct unit_test_state *uts) 155 { 156 char *data; 157 int len; 158 159 state_set_skip_delays(true); 160 ut_assertok(usb_init()); 161 console_record_reset_enable(); 162 usb_show_tree(); 163 len = membuff_getraw(&gd->console_out, -1, true, &data); 164 if (len) 165 data[len] = '\0'; 166 ut_asserteq_str(usb_tree_base, data); 167 ut_assertok(usb_stop()); 168 169 return 0; 170 } 171 DM_TEST(dm_test_usb_tree, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 172 173 const char usb_tree_remove[] = 174 " 1 Hub (12 Mb/s, 100mA)\n" 175 " | sandbox hub 2345\n" 176 " |\n" 177 " |\b+-2 Mass Storage (12 Mb/s, 100mA)\n" 178 " | sandbox flash flash-stick@0\n" 179 " | \n" 180 " |\b+-3 Mass Storage (12 Mb/s, 100mA)\n" 181 " sandbox flash flash-stick@2\n" 182 " \n"; 183 184 /* 185 * test that the 'usb tree' command output looks correct when we remove a 186 * device 187 */ 188 static int dm_test_usb_tree_remove(struct unit_test_state *uts) 189 { 190 struct udevice *dev; 191 char *data; 192 int len; 193 194 /* Remove the second emulation device */ 195 ut_assertok(uclass_find_device_by_name(UCLASS_USB_EMUL, "flash-stick@1", 196 &dev)); 197 ut_assertok(device_unbind(dev)); 198 199 state_set_skip_delays(true); 200 ut_assertok(usb_init()); 201 console_record_reset_enable(); 202 usb_show_tree(); 203 len = membuff_getraw(&gd->console_out, -1, true, &data); 204 if (len) 205 data[len] = '\0'; 206 ut_asserteq_str(usb_tree_remove, data); 207 ut_assertok(usb_stop()); 208 209 return 0; 210 } 211 DM_TEST(dm_test_usb_tree_remove, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 212 213 const char usb_tree_reorder[] = 214 " 1 Hub (12 Mb/s, 100mA)\n" 215 " | sandbox hub 2345\n" 216 " |\n" 217 " |\b+-2 Mass Storage (12 Mb/s, 100mA)\n" 218 " | sandbox flash flash-stick@0\n" 219 " | \n" 220 " |\b+-3 Mass Storage (12 Mb/s, 100mA)\n" 221 " | sandbox flash flash-stick@2\n" 222 " | \n" 223 " |\b+-4 Mass Storage (12 Mb/s, 100mA)\n" 224 " sandbox flash flash-stick@1\n" 225 " \n"; 226 227 /* 228 * test that the 'usb tree' command output looks correct when we reorder two 229 * devices. 230 */ 231 static int dm_test_usb_tree_reorder(struct unit_test_state *uts) 232 { 233 struct udevice *dev, *parent; 234 char *data; 235 int len; 236 237 /* Remove the second emulation device */ 238 ut_assertok(uclass_find_device_by_name(UCLASS_USB_EMUL, "flash-stick@1", 239 &dev)); 240 parent = dev->parent; 241 242 /* Reorder the devices in the parent list and uclass list */ 243 list_del(&dev->sibling_node); 244 list_add_tail(&dev->sibling_node, &parent->child_head); 245 246 list_del(&dev->uclass_node); 247 list_add_tail(&dev->uclass_node, &dev->uclass->dev_head); 248 249 state_set_skip_delays(true); 250 ut_assertok(usb_init()); 251 console_record_reset_enable(); 252 usb_show_tree(); 253 len = membuff_getraw(&gd->console_out, -1, true, &data); 254 if (len) 255 data[len] = '\0'; 256 ut_asserteq_str(usb_tree_reorder, data); 257 ut_assertok(usb_stop()); 258 259 return 0; 260 } 261 DM_TEST(dm_test_usb_tree_reorder, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 262 263 static int dm_test_usb_keyb(struct unit_test_state *uts) 264 { 265 struct udevice *dev; 266 267 state_set_skip_delays(true); 268 ut_assertok(usb_init()); 269 270 /* Initially there should be no characters */ 271 ut_asserteq(0, tstc()); 272 273 ut_assertok(uclass_get_device_by_name(UCLASS_USB_EMUL, "keyb", 274 &dev)); 275 276 /* 277 * Add a string to the USB keyboard buffer - it should appear in 278 * stdin 279 */ 280 ut_assertok(sandbox_usb_keyb_add_string(dev, "ab")); 281 ut_asserteq(1, tstc()); 282 ut_asserteq('a', getc()); 283 ut_asserteq(1, tstc()); 284 ut_asserteq('b', getc()); 285 ut_asserteq(0, tstc()); 286 287 ut_assertok(usb_stop()); 288 289 return 0; 290 } 291 DM_TEST(dm_test_usb_keyb, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 292