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