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);