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 no USB devices are found after we stop the stack */ 103 static int dm_test_usb_stop(struct unit_test_state *uts) 104 { 105 struct udevice *dev; 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(0, count_usb_devices()); 116 117 return 0; 118 } 119 DM_TEST(dm_test_usb_stop, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); 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); 150