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 /* Test that sandbox USB works correctly */
  20 static int dm_test_usb_base(struct unit_test_state *uts)
  21 {
  22         struct udevice *bus;
  23
  24         ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_USB, 0, &bus));
  25         ut_assertok(uclass_get_device(UCLASS_USB, 0, &bus));
  26         ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_USB, 2, &bus));
  27
  28         return 0;
  29 }
  30 DM_TEST(dm_test_usb_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  31
  32 /*
  33  * Test that we can use the flash stick. This is more of a functional test. It
  34  * covers scanning the bug, setting up a hub and a flash stick and reading
  35  * data from the flash stick.
  36  */
  37 static int dm_test_usb_flash(struct unit_test_state *uts)
  38 {
  39         struct udevice *dev;
  40         struct blk_desc *dev_desc;
  41         char cmp[1024];
  42
  43         state_set_skip_delays(true);
  44         ut_assertok(usb_init());
  45         ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &dev));
  46         ut_assertok(blk_get_device_by_str("usb", "0", &dev_desc));
  47
  48         /* Read a few blocks and look for the string we expect */
  49         ut_asserteq(512, dev_desc->blksz);
  50         memset(cmp, '\0', sizeof(cmp));
  51         ut_asserteq(2, blk_dread(dev_desc, 0, 2, cmp));
  52         ut_assertok(strcmp(cmp, "this is a test"));
  53         ut_assertok(usb_stop());
  54
  55         return 0;
  56 }
  57 DM_TEST(dm_test_usb_flash, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  58
  59 /* test that we can handle multiple storage devices */
  60 static int dm_test_usb_multi(struct unit_test_state *uts)
  61 {
  62         struct udevice *dev;
  63
  64         state_set_skip_delays(true);
  65         ut_assertok(usb_init());
  66         ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &dev));
  67         ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 1, &dev));
  68         ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 2, &dev));
  69         ut_assertok(usb_stop());
  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 no USB devices are found after we stop the stack */
 101 static int dm_test_usb_stop(struct unit_test_state *uts)
 102 {
 103         struct udevice *dev;
 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(0, count_usb_devices());
 114
 115         return 0;
 116 }
 117 DM_TEST(dm_test_usb_stop, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 118
 119 static int dm_test_usb_keyb(struct unit_test_state *uts)
 120 {
 121         struct udevice *dev;
 122
 123         state_set_skip_delays(true);
 124         ut_assertok(usb_init());
 125
 126         /* Initially there should be no characters */
 127         ut_asserteq(0, tstc());
 128
 129         ut_assertok(uclass_get_device_by_name(UCLASS_USB_EMUL, "keyb",
 130                                               &dev));
 131
 132         /*
 133          * Add a string to the USB keyboard buffer - it should appear in
 134          * stdin
 135          */
 136         ut_assertok(sandbox_usb_keyb_add_string(dev, "ab"));
 137         ut_asserteq(1, tstc());
 138         ut_asserteq('a', getc());
 139         ut_asserteq(1, tstc());
 140         ut_asserteq('b', getc());
 141         ut_asserteq(0, tstc());
 142
 143         ut_assertok(usb_stop());
 144
 145         return 0;
 146 }
 147 DM_TEST(dm_test_usb_keyb, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);