| // SPDX-License-Identifier: GPL-2.0+ |
| /* |
| * Copyright (C) 2015 Google, Inc |
| */ |
| |
| #include <common.h> |
| #include <console.h> |
| #include <dm.h> |
| #include <part.h> |
| #include <usb.h> |
| #include <asm/io.h> |
| #include <asm/state.h> |
| #include <asm/test.h> |
| #include <dm/device-internal.h> |
| #include <dm/test.h> |
| #include <dm/uclass-internal.h> |
| #include <test/test.h> |
| #include <test/ut.h> |
| |
| struct keyboard_test_data { |
| const char modifiers; |
| const char scancode; |
| const char result[6]; |
| }; |
| |
| /* Test that sandbox USB works correctly */ |
| static int dm_test_usb_base(struct unit_test_state *uts) |
| { |
| struct udevice *bus; |
| |
| ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_USB, 0, &bus)); |
| ut_assertok(uclass_get_device(UCLASS_USB, 0, &bus)); |
| ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_USB, 2, &bus)); |
| |
| return 0; |
| } |
| DM_TEST(dm_test_usb_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT); |
| |
| /* |
| * Test that we can use the flash stick. This is more of a functional test. It |
| * covers scanning the bug, setting up a hub and a flash stick and reading |
| * data from the flash stick. |
| */ |
| static int dm_test_usb_flash(struct unit_test_state *uts) |
| { |
| struct udevice *dev; |
| struct blk_desc *dev_desc; |
| char cmp[1024]; |
| |
| state_set_skip_delays(true); |
| ut_assertok(usb_init()); |
| ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &dev)); |
| ut_assertok(blk_get_device_by_str("usb", "0", &dev_desc)); |
| |
| /* Read a few blocks and look for the string we expect */ |
| ut_asserteq(512, dev_desc->blksz); |
| memset(cmp, '\0', sizeof(cmp)); |
| ut_asserteq(2, blk_dread(dev_desc, 0, 2, cmp)); |
| ut_assertok(strcmp(cmp, "this is a test")); |
| ut_assertok(usb_stop()); |
| |
| return 0; |
| } |
| DM_TEST(dm_test_usb_flash, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT); |
| |
| /* test that we can handle multiple storage devices */ |
| static int dm_test_usb_multi(struct unit_test_state *uts) |
| { |
| struct udevice *dev; |
| |
| state_set_skip_delays(true); |
| ut_assertok(usb_init()); |
| ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &dev)); |
| ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 1, &dev)); |
| ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 2, &dev)); |
| ut_assertok(usb_stop()); |
| |
| return 0; |
| } |
| DM_TEST(dm_test_usb_multi, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT); |
| |
| /* test that we have an associated ofnode with the usb device */ |
| static int dm_test_usb_fdt_node(struct unit_test_state *uts) |
| { |
| struct udevice *dev; |
| ofnode node; |
| |
| state_set_skip_delays(true); |
| ut_assertok(usb_init()); |
| ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &dev)); |
| node = ofnode_path("/usb@1/hub/usbstor@1"); |
| ut_asserteq(1, ofnode_equal(node, dev_ofnode(dev))); |
| ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 1, &dev)); |
| ut_asserteq(1, ofnode_equal(ofnode_null(), dev_ofnode(dev))); |
| ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 2, &dev)); |
| node = ofnode_path("/usb@1/hub/usbstor@3"); |
| ut_asserteq(1, ofnode_equal(node, dev_ofnode(dev))); |
| ut_assertok(usb_stop()); |
| |
| return 0; |
| } |
| DM_TEST(dm_test_usb_fdt_node, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT); |
| |
| static int count_usb_devices(void) |
| { |
| struct udevice *hub; |
| struct uclass *uc; |
| int count = 0; |
| int ret; |
| |
| ret = uclass_get(UCLASS_USB_HUB, &uc); |
| if (ret) |
| return ret; |
| |
| uclass_foreach_dev(hub, uc) { |
| struct udevice *dev; |
| |
| count++; |
| for (device_find_first_child(hub, &dev); |
| dev; |
| device_find_next_child(&dev)) { |
| count++; |
| } |
| } |
| |
| return count; |
| } |
| |
| /* test that no USB devices are found after we stop the stack */ |
| static int dm_test_usb_stop(struct unit_test_state *uts) |
| { |
| struct udevice *dev; |
| |
| /* Scan and check that all devices are present */ |
| state_set_skip_delays(true); |
| ut_assertok(usb_init()); |
| ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &dev)); |
| ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 1, &dev)); |
| ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 2, &dev)); |
| ut_asserteq(6, count_usb_devices()); |
| ut_assertok(usb_stop()); |
| ut_asserteq(0, count_usb_devices()); |
| |
| return 0; |
| } |
| DM_TEST(dm_test_usb_stop, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT); |
| |
| /** |
| * dm_test_usb_keyb() - test USB keyboard driver |
| * |
| * This test copies USB keyboard scan codes into the key buffer of the USB |
| * keyboard emulation driver. These are picked up during emulated interrupts |
| * by the USB keyboard driver and converted to characters and escape sequences. |
| * The test then reads and verifies these characters and escape sequences from |
| * the standard input. |
| * |
| * TODO: The following features are not yet tested: |
| * |
| * * LED status |
| * * caps-lock |
| * * num-lock |
| * * numerical pad keys |
| * |
| * TODO: The following features are not yet implemented by the USB keyboard |
| * driver and therefore not tested: |
| * |
| * * modifiers for non-alpha-numeric keys, e.g. <SHIFT><TAB> and <ALT><F4> |
| * * some special keys, e.g. <PRINT> |
| * * some modifiers, e.g. <ALT> and <META> |
| * * alternative keyboard layouts |
| * |
| * @uts: unit test state |
| * Return: 0 on success |
| */ |
| static int dm_test_usb_keyb(struct unit_test_state *uts) |
| { |
| struct udevice *dev; |
| const struct keyboard_test_data *pos; |
| const struct keyboard_test_data kbd_test_data[] = { |
| /* <A> */ |
| {0x00, 0x04, "a"}, |
| /* <B> */ |
| {0x00, 0x05, "b"}, |
| /* <C> */ |
| {0x00, 0x06, "c"}, |
| /* <D> */ |
| {0x00, 0x07, "d"}, |
| /* <E> */ |
| {0x00, 0x08, "e"}, |
| /* <F> */ |
| {0x00, 0x09, "f"}, |
| /* <G> */ |
| {0x00, 0x0a, "g"}, |
| /* <H> */ |
| {0x00, 0x0b, "h"}, |
| /* <I> */ |
| {0x00, 0x0c, "i"}, |
| /* <J> */ |
| {0x00, 0x0d, "j"}, |
| /* <K> */ |
| {0x00, 0x0e, "k"}, |
| /* <L> */ |
| {0x00, 0x0f, "l"}, |
| /* <M> */ |
| {0x00, 0x10, "m"}, |
| /* <N> */ |
| {0x00, 0x11, "n"}, |
| /* <O> */ |
| {0x00, 0x12, "o"}, |
| /* <P> */ |
| {0x00, 0x13, "p"}, |
| /* <Q> */ |
| {0x00, 0x14, "q"}, |
| /* <R> */ |
| {0x00, 0x15, "r"}, |
| /* <S> */ |
| {0x00, 0x16, "s"}, |
| /* <T> */ |
| {0x00, 0x17, "t"}, |
| /* <U> */ |
| {0x00, 0x18, "u"}, |
| /* <V> */ |
| {0x00, 0x19, "v"}, |
| /* <W> */ |
| {0x00, 0x1a, "w"}, |
| /* <X> */ |
| {0x00, 0x1b, "x"}, |
| /* <Y> */ |
| {0x00, 0x1c, "y"}, |
| /* <Z> */ |
| {0x00, 0x1d, "z"}, |
| |
| /* <LEFT-SHIFT><A> */ |
| {0x02, 0x04, "A"}, |
| /* <RIGHT-SHIFT><Z> */ |
| {0x20, 0x1d, "Z"}, |
| |
| /* <LEFT-CONTROL><A> */ |
| {0x01, 0x04, "\x01"}, |
| /* <RIGHT-CONTROL><Z> */ |
| {0x10, 0x1d, "\x1a"}, |
| |
| /* <1> */ |
| {0x00, 0x1e, "1"}, |
| /* <2> */ |
| {0x00, 0x1f, "2"}, |
| /* <3> */ |
| {0x00, 0x20, "3"}, |
| /* <4> */ |
| {0x00, 0x21, "4"}, |
| /* <5> */ |
| {0x00, 0x22, "5"}, |
| /* <6> */ |
| {0x00, 0x23, "6"}, |
| /* <7> */ |
| {0x00, 0x24, "7"}, |
| /* <8> */ |
| {0x00, 0x25, "8"}, |
| /* <9> */ |
| {0x00, 0x26, "9"}, |
| /* <0> */ |
| {0x00, 0x27, "0"}, |
| |
| /* <LEFT-SHIFT><1> */ |
| {0x02, 0x1e, "!"}, |
| /* <RIGHT-SHIFT><2> */ |
| {0x20, 0x1f, "@"}, |
| /* <LEFT-SHIFT><3> */ |
| {0x02, 0x20, "#"}, |
| /* <RIGHT-SHIFT><4> */ |
| {0x20, 0x21, "$"}, |
| /* <LEFT-SHIFT><5> */ |
| {0x02, 0x22, "%"}, |
| /* <RIGHT-SHIFT><6> */ |
| {0x20, 0x23, "^"}, |
| /* <LEFT-SHIFT><7> */ |
| {0x02, 0x24, "&"}, |
| /* <RIGHT-SHIFT><8> */ |
| {0x20, 0x25, "*"}, |
| /* <LEFT-SHIFT><9> */ |
| {0x02, 0x26, "("}, |
| /* <RIGHT-SHIFT><0> */ |
| {0x20, 0x27, ")"}, |
| |
| /* <ENTER> */ |
| {0x00, 0x28, "\r"}, |
| /* <ESCAPE> */ |
| {0x00, 0x29, "\x1b"}, |
| /* <BACKSPACE> */ |
| {0x00, 0x2a, "\x08"}, |
| /* <TAB> */ |
| {0x00, 0x2b, "\x09"}, |
| /* <SPACE> */ |
| {0x00, 0x2c, " "}, |
| /* <MINUS> */ |
| {0x00, 0x2d, "-"}, |
| /* <EQUAL> */ |
| {0x00, 0x2e, "="}, |
| /* <LEFT BRACE> */ |
| {0x00, 0x2f, "["}, |
| /* <RIGHT BRACE> */ |
| {0x00, 0x30, "]"}, |
| /* <BACKSLASH> */ |
| {0x00, 0x31, "\\"}, |
| /* <HASH-TILDE> */ |
| {0x00, 0x32, "#"}, |
| /* <SEMICOLON> */ |
| {0x00, 0x33, ";"}, |
| /* <APOSTROPHE> */ |
| {0x00, 0x34, "'"}, |
| /* <GRAVE> */ |
| {0x00, 0x35, "`"}, |
| /* <COMMA> */ |
| {0x00, 0x36, ","}, |
| /* <DOT> */ |
| {0x00, 0x37, "."}, |
| /* <SLASH> */ |
| {0x00, 0x38, "/"}, |
| |
| /* <LEFT-SHIFT><ENTER> */ |
| {0x02, 0x28, "\r"}, |
| /* <RIGHT-SHIFT><ESCAPE> */ |
| {0x20, 0x29, "\x1b"}, |
| /* <LEFT-SHIFT><BACKSPACE> */ |
| {0x02, 0x2a, "\x08"}, |
| /* <RIGHT-SHIFT><TAB> */ |
| {0x20, 0x2b, "\x09"}, |
| /* <LEFT-SHIFT><SPACE> */ |
| {0x02, 0x2c, " "}, |
| /* <MINUS> */ |
| {0x20, 0x2d, "_"}, |
| /* <LEFT-SHIFT><EQUAL> */ |
| {0x02, 0x2e, "+"}, |
| /* <RIGHT-SHIFT><LEFT BRACE> */ |
| {0x20, 0x2f, "{"}, |
| /* <LEFT-SHIFT><RIGHT BRACE> */ |
| {0x02, 0x30, "}"}, |
| /* <RIGHT-SHIFT><BACKSLASH> */ |
| {0x20, 0x31, "|"}, |
| /* <LEFT-SHIFT><HASH-TILDE> */ |
| {0x02, 0x32, "~"}, |
| /* <RIGHT-SHIFT><SEMICOLON> */ |
| {0x20, 0x33, ":"}, |
| /* <LEFT-SHIFT><APOSTROPHE> */ |
| {0x02, 0x34, "\""}, |
| /* <RIGHT-SHIFT><GRAVE> */ |
| {0x20, 0x35, "~"}, |
| /* <LEFT-SHIFT><COMMA> */ |
| {0x02, 0x36, "<"}, |
| /* <RIGHT-SHIFT><DOT> */ |
| {0x20, 0x37, ">"}, |
| /* <LEFT-SHIFT><SLASH> */ |
| {0x02, 0x38, "?"}, |
| #ifdef CONFIG_USB_KEYBOARD_FN_KEYS |
| /* <F1> */ |
| {0x00, 0x3a, "\x1bOP"}, |
| /* <F2> */ |
| {0x00, 0x3b, "\x1bOQ"}, |
| /* <F3> */ |
| {0x00, 0x3c, "\x1bOR"}, |
| /* <F4> */ |
| {0x00, 0x3d, "\x1bOS"}, |
| /* <F5> */ |
| {0x00, 0x3e, "\x1b[15~"}, |
| /* <F6> */ |
| {0x00, 0x3f, "\x1b[17~"}, |
| /* <F7> */ |
| {0x00, 0x40, "\x1b[18~"}, |
| /* <F8> */ |
| {0x00, 0x41, "\x1b[19~"}, |
| /* <F9> */ |
| {0x00, 0x42, "\x1b[20~"}, |
| /* <F10> */ |
| {0x00, 0x43, "\x1b[21~"}, |
| /* <F11> */ |
| {0x00, 0x44, "\x1b[23~"}, |
| /* <F12> */ |
| {0x00, 0x45, "\x1b[24~"}, |
| /* <INSERT> */ |
| {0x00, 0x49, "\x1b[2~"}, |
| /* <HOME> */ |
| {0x00, 0x4a, "\x1b[H"}, |
| /* <PAGE UP> */ |
| {0x00, 0x4b, "\x1b[5~"}, |
| /* <DELETE> */ |
| {0x00, 0x4c, "\x1b[3~"}, |
| /* <END> */ |
| {0x00, 0x4d, "\x1b[F"}, |
| /* <PAGE DOWN> */ |
| {0x00, 0x4e, "\x1b[6~"}, |
| /* <RIGHT> */ |
| {0x00, 0x4f, "\x1b[C"}, |
| /* <LEFT> */ |
| {0x00, 0x50, "\x1b[D"}, |
| /* <DOWN> */ |
| {0x00, 0x51, "\x1b[B"}, |
| /* <UP> */ |
| {0x00, 0x52, "\x1b[A"}, |
| #endif /* CONFIG_USB_KEYBOARD_FN_KEYS */ |
| |
| /* End of list */ |
| {0x00, 0x00, "\0"} |
| }; |
| |
| |
| state_set_skip_delays(true); |
| ut_assertok(usb_init()); |
| |
| /* Initially there should be no characters */ |
| ut_asserteq(0, tstc()); |
| |
| ut_assertok(uclass_get_device_by_name(UCLASS_USB_EMUL, "keyb@3", |
| &dev)); |
| |
| /* |
| * Add scan codes to the USB keyboard buffer. They should appear as |
| * corresponding characters and escape sequences in stdin. |
| */ |
| for (pos = kbd_test_data; pos->scancode; ++pos) { |
| const char *c; |
| char scancodes[USB_KBD_BOOT_REPORT_SIZE] = {0}; |
| |
| scancodes[0] = pos->modifiers; |
| scancodes[2] = pos->scancode; |
| |
| ut_assertok(sandbox_usb_keyb_add_string(dev, scancodes)); |
| |
| for (c = pos->result; *c; ++c) { |
| ut_asserteq(1, tstc()); |
| ut_asserteq(*c, getchar()); |
| } |
| ut_asserteq(0, tstc()); |
| } |
| ut_assertok(usb_stop()); |
| |
| return 0; |
| } |
| DM_TEST(dm_test_usb_keyb, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT); |