It is sometimes useful to see what memory is being allocated early during boot. Add logging to support this, using a new LOGC_ALLOC category.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: - Rebase to master - Correct definition of log() when logging is disabled

common/malloc_simple.c | 58 +++++++++++++++++++++++++++--------------- include/log.h | 2 +- include/malloc.h | 1 + 3 files changed, 39 insertions(+), 22 deletions(-)

diff --git a/common/malloc_simple.c b/common/malloc_simple.c index 871b5444bd7..eabbb70128b 100644 --- a/common/malloc_simple.c +++ b/common/malloc_simple.c @@ -5,6 +5,8 @@ * Copyright (c) 2014 Google, Inc */

+#define LOG_CATEGORY LOGC_ALLOC + #include <common.h> #include <malloc.h> #include <mapmem.h> @@ -12,40 +14,47 @@

DECLARE_GLOBAL_DATA_PTR;

-void *malloc_simple(size_t bytes) +static void *alloc_simple(size_t bytes, int align) { - ulong new_ptr; + ulong addr, new_ptr; void *ptr;

- new_ptr = gd->malloc_ptr + bytes; - debug("%s: size=%zx, ptr=%lx, limit=%lx: ", __func__, bytes, new_ptr, - gd->malloc_limit); + addr = ALIGN(gd->malloc_base + gd->malloc_ptr, align); + new_ptr = addr + bytes - gd->malloc_base; + log_debug("size=%zx, ptr=%lx, limit=%lx: ", bytes, new_ptr, + gd->malloc_limit); if (new_ptr > gd->malloc_limit) { - debug("space exhausted\n"); + log_err("alloc space exhausted\n"); return NULL; } - ptr = map_sysmem(gd->malloc_base + gd->malloc_ptr, bytes); + + ptr = map_sysmem(addr, bytes); gd->malloc_ptr = ALIGN(new_ptr, sizeof(new_ptr)); - debug("%lx\n", (ulong)ptr);

return ptr; }

-void *memalign_simple(size_t align, size_t bytes) +void *malloc_simple(size_t bytes) { - ulong addr, new_ptr; void *ptr;

- addr = ALIGN(gd->malloc_base + gd->malloc_ptr, align); - new_ptr = addr + bytes - gd->malloc_base; - if (new_ptr > gd->malloc_limit) { - debug("space exhausted\n"); - return NULL; - } + ptr = alloc_simple(bytes, 1); + if (!ptr) + return ptr;

- ptr = map_sysmem(addr, bytes); - gd->malloc_ptr = ALIGN(new_ptr, sizeof(new_ptr)); - debug("%lx\n", (ulong)ptr); + log_debug("%lx\n", (ulong)ptr); + + return ptr; +} + +void *memalign_simple(size_t align, size_t bytes) +{ + void *ptr; + + ptr = alloc_simple(bytes, align); + if (!ptr) + return ptr; + log_debug("aligned to %lx\n", (ulong)ptr);

return ptr; } @@ -57,9 +66,16 @@ void *calloc(size_t nmemb, size_t elem_size) void *ptr;

ptr = malloc(size); - if (ptr) - memset(ptr, '\0', size); + if (!ptr) + return ptr; + memset(ptr, '\0', size);

return ptr; } #endif + +void malloc_simple_info(void) +{ + log_info("malloc_simple: %lx bytes used, %lx remain\n", gd->malloc_ptr, + CONFIG_VAL(SYS_MALLOC_F_LEN) - gd->malloc_ptr); +} diff --git a/include/log.h b/include/log.h index a872fc6ef5f..5fa80d53856 100644 --- a/include/log.h +++ b/include/log.h @@ -110,7 +110,7 @@ int _log(enum log_category_t cat, enum log_level_t level, const char *file, /* Emit a log record if the level is less that the maximum */ #define log(_cat, _level, _fmt, _args...) ({ \ int _l = _level; \ - if (_l <= _LOG_MAX_LEVEL) \ + if (CONFIG_IS_ENABLED(LOG) && _l <= _LOG_MAX_LEVEL) \ _log((enum log_category_t)(_cat), _l, __FILE__, __LINE__, \ __func__, \ pr_fmt(_fmt), ##_args); \ diff --git a/include/malloc.h b/include/malloc.h index 8175c75920c..b714fedf457 100644 --- a/include/malloc.h +++ b/include/malloc.h @@ -880,6 +880,7 @@ static inline void free(void *ptr) {} void *calloc(size_t nmemb, size_t size); void *memalign_simple(size_t alignment, size_t bytes); void *realloc_simple(void *ptr, size_t size); +void malloc_simple_info(void); #else

# ifdef USE_DL_PREFIX

In some cases it is necessary to read the keyboard in early phases of U-Boot. The cros_ec keyboard is kept in the misc directory. Update the config to allow this.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: - Leave the misc uclass alone since it stops sandbox_spl working

drivers/misc/Kconfig | 72 +++++++++++++++++++++++++++++++++++++++++++ drivers/misc/Makefile | 8 +++-- 2 files changed, 77 insertions(+), 3 deletions(-)

diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig index 48febc47d26..802046cf966 100644 --- a/drivers/misc/Kconfig +++ b/drivers/misc/Kconfig @@ -13,6 +13,24 @@ config MISC set of generic read, write and ioctl methods may be used to access the device.

+config SPL_MISC + bool "Enable Driver Model for Misc drivers in SPL" + depends on SPL_DM + help + Enable driver model for miscellaneous devices. This class is + used only for those do not fit other more general classes. A + set of generic read, write and ioctl methods may be used to + access the device. + +config TPL_MISC + bool "Enable Driver Model for Misc drivers in TPL" + depends on TPL_DM + help + Enable driver model for miscellaneous devices. This class is + used only for those do not fit other more general classes. A + set of generic read, write and ioctl methods may be used to + access the device. + config ALTERA_SYSID bool "Altera Sysid support" depends on MISC @@ -68,6 +86,24 @@ config CROS_EC control access to the battery and main PMIC depending on the device. You can use the 'crosec' command to access it.

+config SPL_CROS_EC + bool "Enable Chrome OS EC in SPL" + help + Enable access to the Chrome OS EC in SPL. This is a separate + microcontroller typically available on a SPI bus on Chromebooks. It + provides access to the keyboard, some internal storage and may + control access to the battery and main PMIC depending on the + device. You can use the 'crosec' command to access it. + +config TPL_CROS_EC + bool "Enable Chrome OS EC in TPL" + help + Enable access to the Chrome OS EC in TPL. This is a separate + microcontroller typically available on a SPI bus on Chromebooks. It + provides access to the keyboard, some internal storage and may + control access to the battery and main PMIC depending on the + device. You can use the 'crosec' command to access it. + config CROS_EC_I2C bool "Enable Chrome OS EC I2C driver" depends on CROS_EC @@ -86,6 +122,24 @@ config CROS_EC_LPC through a legacy port interface, so on x86 machines the main function of the EC is power and thermal management.

+config SPL_CROS_EC_LPC + bool "Enable Chrome OS EC LPC driver in SPL" + depends on CROS_EC + help + Enable I2C access to the Chrome OS EC. This is used on x86 + Chromebooks such as link and falco. The keyboard is provided + through a legacy port interface, so on x86 machines the main + function of the EC is power and thermal management. + +config TPL_CROS_EC_LPC + bool "Enable Chrome OS EC LPC driver in TPL" + depends on CROS_EC + help + Enable I2C access to the Chrome OS EC. This is used on x86 + Chromebooks such as link and falco. The keyboard is provided + through a legacy port interface, so on x86 machines the main + function of the EC is power and thermal management. + config CROS_EC_SANDBOX bool "Enable Chrome OS EC sandbox driver" depends on CROS_EC && SANDBOX @@ -95,6 +149,24 @@ config CROS_EC_SANDBOX EC flash read/write/erase support and a few other things. It is enough to perform a Chrome OS verified boot on sandbox.

+config SPL_CROS_EC_SANDBOX + bool "Enable Chrome OS EC sandbox driver in SPL" + depends on SPL_CROS_EC && SANDBOX + help + Enable a sandbox emulation of the Chrome OS EC in SPL. This supports + keyboard (use the -l flag to enable the LCD), verified boot context, + EC flash read/write/erase support and a few other things. It is + enough to perform a Chrome OS verified boot on sandbox. + +config TPL_CROS_EC_SANDBOX + bool "Enable Chrome OS EC sandbox driver in TPL" + depends on TPL_CROS_EC && SANDBOX + help + Enable a sandbox emulation of the Chrome OS EC in TPL. This supports + keyboard (use the -l flag to enable the LCD), verified boot context, + EC flash read/write/erase support and a few other things. It is + enough to perform a Chrome OS verified boot on sandbox. + config CROS_EC_SPI bool "Enable Chrome OS EC SPI driver" depends on CROS_EC diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile index 302d4415927..6efb8134b14 100644 --- a/drivers/misc/Makefile +++ b/drivers/misc/Makefile @@ -4,11 +4,13 @@ # Wolfgang Denk, DENX Software Engineering, wd@denx.de.

obj-$(CONFIG_MISC) += misc-uclass.o + +obj-$(CONFIG_$(SPL_TPL_)CROS_EC) += cros_ec.o +obj-$(CONFIG_$(SPL_TPL_)CROS_EC_SANDBOX) += cros_ec_sandbox.o +obj-$(CONFIG_$(SPL_TPL_)CROS_EC_LPC) += cros_ec_lpc.o + ifndef CONFIG_SPL_BUILD -obj-$(CONFIG_CROS_EC) += cros_ec.o -obj-$(CONFIG_CROS_EC_LPC) += cros_ec_lpc.o obj-$(CONFIG_CROS_EC_I2C) += cros_ec_i2c.o -obj-$(CONFIG_CROS_EC_SANDBOX) += cros_ec_sandbox.o obj-$(CONFIG_CROS_EC_SPI) += cros_ec_spi.o endif

At present tests are quite slow to run, over a minute on my machine. This presents a considerable barrier to bisecting for failures.

The slowest tests are the filesystem ones and the buildman --fetch-arch test. Add a new 'qcheck' target that skips these tests. This reduces test time down to about 40 second, still too long, but bearable.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: None

Makefile | 6 +++++- test/README | 6 +++++- test/py/tests/test_fs/test_basic.py | 1 + test/py/tests/test_fs/test_ext.py | 1 + test/py/tests/test_fs/test_mkdir.py | 1 + test/py/tests/test_fs/test_unlink.py | 1 + test/run | 10 ++++++++-- 7 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/Makefile b/Makefile index 552687db538..15b710b214e 100644 --- a/Makefile +++ b/Makefile @@ -443,7 +443,7 @@ defaultenv_h := include/generated/defaultenv_autogenerated.h

no-dot-config-targets := clean clobber mrproper distclean \ help %docs check% coccicheck \ - ubootversion backup tests + ubootversion backup tests check qcheck

config-targets := 0 mixed-targets := 0 @@ -1703,6 +1703,7 @@ help: @echo 'Test targets:' @echo '' @echo ' check - Run all automated tests that use sandbox' + @echo ' qcheck - Run quick automated tests that use sandbox' @echo '' @echo 'Other generic targets:' @echo ' all - Build all necessary images depending on configuration' @@ -1745,6 +1746,9 @@ help: tests check: $(srctree)/test/run

+qcheck: + $(srctree)/test/run quick + # Documentation targets # --------------------------------------------------------------------------- DOC_TARGETS := xmldocs latexdocs pdfdocs htmldocs epubdocs cleandocs \ diff --git a/test/README b/test/README index 873a4e19313..4bc9ca3a6ae 100644 --- a/test/README +++ b/test/README @@ -10,11 +10,15 @@ Running tests

To run most tests on sandbox, type this:

- test/run + make check

in the U-Boot directory. Note that only the pytest suite is run using this command.

+Some tests take ages to run. To run just the quick ones, type this: + + make qcheck +

Sandbox ------- diff --git a/test/py/tests/test_fs/test_basic.py b/test/py/tests/test_fs/test_basic.py index c067cc9ba3f..140ca29ac73 100644 --- a/test/py/tests/test_fs/test_basic.py +++ b/test/py/tests/test_fs/test_basic.py @@ -13,6 +13,7 @@ import re from fstest_defs import *

@pytest.mark.boardspec('sandbox') +@pytest.mark.slow class TestFsBasic(object): def test_fs1(self, u_boot_console, fs_obj_basic): """ diff --git a/test/py/tests/test_fs/test_ext.py b/test/py/tests/test_fs/test_ext.py index 38217d08bf6..06cad5516d5 100644 --- a/test/py/tests/test_fs/test_ext.py +++ b/test/py/tests/test_fs/test_ext.py @@ -13,6 +13,7 @@ import re from fstest_defs import *

@pytest.mark.boardspec('sandbox') +@pytest.mark.slow class TestFsExt(object): def test_fs_ext1(self, u_boot_console, fs_obj_ext): """ diff --git a/test/py/tests/test_fs/test_mkdir.py b/test/py/tests/test_fs/test_mkdir.py index d9da97b56b5..b3fe11cf3b5 100644 --- a/test/py/tests/test_fs/test_mkdir.py +++ b/test/py/tests/test_fs/test_mkdir.py @@ -11,6 +11,7 @@ This test verifies mkdir operation on file system. import pytest

@pytest.mark.boardspec('sandbox') +@pytest.mark.slow class TestMkdir(object): def test_mkdir1(self, u_boot_console, fs_obj_mkdir): """ diff --git a/test/py/tests/test_fs/test_unlink.py b/test/py/tests/test_fs/test_unlink.py index 69c1a6e078c..2b817468eda 100644 --- a/test/py/tests/test_fs/test_unlink.py +++ b/test/py/tests/test_fs/test_unlink.py @@ -12,6 +12,7 @@ on file system. import pytest

@pytest.mark.boardspec('sandbox') +@pytest.mark.slow class TestUnlink(object): def test_unlink1(self, u_boot_console, fs_obj_unlink): """ diff --git a/test/run b/test/run index fb8ff5da0cb..c212cfe7916 100755 --- a/test/run +++ b/test/run @@ -1,6 +1,7 @@ #!/bin/bash

# Script to run all U-Boot tests that use sandbox. +# $1: tests to run (empty for all, 'quick' for quick ones only)

# Runs a test and checks the exit code to decide if it passed # $1: Test name @@ -12,10 +13,13 @@ run_test() { [ $? -ne 0 ] && failures=$((failures+1)) }

+# SKip slow tests if requested +[ "$1" == "quick" ] && mark_expr="not slow" + failures=0

# Run all tests that the standard sandbox build can support -run_test "sandbox" ./test/py/test.py --bd sandbox --build +run_test "sandbox" ./test/py/test.py --bd sandbox --build -m "${mark_expr}"

# Run tests which require sandbox_spl run_test "sandbox_spl" ./test/py/test.py --bd sandbox_spl --build \ @@ -36,7 +40,9 @@ export DTC=${DTC_DIR}/dtc

run_test "binman" ./tools/binman/binman -t run_test "patman" ./tools/patman/patman --test -run_test "buildman" ./tools/buildman/buildman -t + +[ "$1" == "quick" ] && skip=--skip-net-tests +run_test "buildman" ./tools/buildman/buildman -t ${skip} run_test "fdt" ./tools/dtoc/test_fdt -t run_test "dtoc" ./tools/dtoc/dtoc -t

This function may be useful to code outside of the code driver-model implementation. Export it and add a test.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: None

drivers/core/uclass.c | 6 ++---- include/dm/uclass-internal.h | 17 +++++++++++++++++ test/dm/test-fdt.c | 20 ++++++++++++++++++++ 3 files changed, 39 insertions(+), 4 deletions(-)

diff --git a/drivers/core/uclass.c b/drivers/core/uclass.c index d9c5719a878..9766aeabd19 100644 --- a/drivers/core/uclass.c +++ b/drivers/core/uclass.c @@ -354,10 +354,8 @@ done: }

#if CONFIG_IS_ENABLED(OF_CONTROL) -static int uclass_find_device_by_phandle(enum uclass_id id, - struct udevice *parent, - const char *name, - struct udevice **devp) +int uclass_find_device_by_phandle(enum uclass_id id, struct udevice *parent, + const char *name, struct udevice **devp) { struct udevice *dev; struct uclass *uc; diff --git a/include/dm/uclass-internal.h b/include/dm/uclass-internal.h index 30d5a4fb9bf..8a4839ee882 100644 --- a/include/dm/uclass-internal.h +++ b/include/dm/uclass-internal.h @@ -142,6 +142,23 @@ int uclass_find_device_by_of_offset(enum uclass_id id, int node, int uclass_find_device_by_ofnode(enum uclass_id id, ofnode node, struct udevice **devp);

+/** + * uclass_find_device_by_phandle() - Find a uclass device by phandle + * + * This searches the devices in the uclass for one with the given phandle. + * + * The device is NOT probed, it is merely returned. + * + * @id: ID to look up + * @parent: Parent device containing the phandle pointer + * @name: Name of property in the parent device node + * @devp: Returns pointer to device (there is only one for each node) + * @return 0 if OK, -ENOENT if there is no @name present in the node, other + * -ve on error + */ +int uclass_find_device_by_phandle(enum uclass_id id, struct udevice *parent, + const char *name, struct udevice **devp); + /** * uclass_bind_device() - Associate device with a uclass * diff --git a/test/dm/test-fdt.c b/test/dm/test-fdt.c index e43acb21d5e..b70e3fa18ac 100644 --- a/test/dm/test-fdt.c +++ b/test/dm/test-fdt.c @@ -611,3 +611,23 @@ static int dm_test_fdt_disable_enable_by_path(struct unit_test_state *uts) } DM_TEST(dm_test_fdt_disable_enable_by_path, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); + +/* Test a few uclass phandle functions */ +static int dm_test_fdt_phandle(struct unit_test_state *uts) +{ + struct udevice *back, *dev, *dev2; + + ut_assertok(uclass_find_first_device(UCLASS_PANEL_BACKLIGHT, &back)); + ut_asserteq(-ENOENT, uclass_find_device_by_phandle(UCLASS_REGULATOR, + back, "missing", &dev)); + ut_assertok(uclass_find_device_by_phandle(UCLASS_REGULATOR, back, + "power-supply", &dev)); + ut_asserteq(0, device_active(dev)); + ut_asserteq_str("ldo1", dev->name); + ut_assertok(uclass_get_device_by_phandle(UCLASS_REGULATOR, back, + "power-supply", &dev2)); + ut_asserteq_ptr(dev, dev2); + + return 0; +} +DM_TEST(dm_test_fdt_phandle, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

Add two functions which can find a child device by uclass or by name. The first is useful with Multi-Function-Devices (MFDs) to find one of a particular type. The second is useful when only the name is known.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: None

drivers/core/device.c | 34 ++++++++++++++++++++++++++++++++++ include/dm/device.h | 25 +++++++++++++++++++++++++ test/dm/test-fdt.c | 27 +++++++++++++++++++++++++++ 3 files changed, 86 insertions(+)

diff --git a/drivers/core/device.c b/drivers/core/device.c index 47a697f3e5c..836bcadced5 100644 --- a/drivers/core/device.c +++ b/drivers/core/device.c @@ -699,6 +699,40 @@ int device_find_first_inactive_child(struct udevice *parent, return -ENODEV; }

+int device_find_first_child_by_uclass(struct udevice *parent, + enum uclass_id uclass_id, + struct udevice **devp) +{ + struct udevice *dev; + + *devp = NULL; + list_for_each_entry(dev, &parent->child_head, sibling_node) { + if (device_get_uclass_id(dev) == uclass_id) { + *devp = dev; + return 0; + } + } + + return -ENODEV; +} + +int device_find_child_by_name(struct udevice *parent, const char *name, + struct udevice **devp) +{ + struct udevice *dev; + + *devp = NULL; + + list_for_each_entry(dev, &parent->child_head, sibling_node) { + if (!strcmp(dev->name, name)) { + *devp = dev; + return 0; + } + } + + return -ENODEV; +} + struct udevice *dev_get_parent(const struct udevice *child) { return child->parent; diff --git a/include/dm/device.h b/include/dm/device.h index 847934425bb..27a6d7b9fdb 100644 --- a/include/dm/device.h +++ b/include/dm/device.h @@ -525,6 +525,8 @@ int device_find_next_child(struct udevice **devp); * This is used to locate an existing child of a device which is of a given * uclass. * + * The device is NOT probed + * * @parent: Parent device to search * @uclass_id: Uclass to look for * @devp: Returns device found, if any @@ -534,6 +536,29 @@ int device_find_first_inactive_child(struct udevice *parent, enum uclass_id uclass_id, struct udevice **devp);

+/** + * device_find_first_child_by_uclass() - Find the first child of a device in uc + * + * @parent: Parent device to search + * @uclass_id: Uclass to look for + * @devp: Returns first child device in that uclass, if any + * @return 0 if found, else -ENODEV + */ +int device_find_first_child_by_uclass(struct udevice *parent, + enum uclass_id uclass_id, + struct udevice **devp); + +/** + * device_find_child_by_name() - Find a child by device name + * + * @parent: Parent device to search + * @name: Name to look for + * @devp: Returns device found, if any + * @return 0 if found, else -ENODEV + */ +int device_find_child_by_name(struct udevice *parent, const char *name, + struct udevice **devp); + /** * device_has_children() - check if a device has any children * diff --git a/test/dm/test-fdt.c b/test/dm/test-fdt.c index b70e3fa18ac..0fbd9be765a 100644 --- a/test/dm/test-fdt.c +++ b/test/dm/test-fdt.c @@ -631,3 +631,30 @@ static int dm_test_fdt_phandle(struct unit_test_state *uts) return 0; } DM_TEST(dm_test_fdt_phandle, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); + +/* Test device_find_first_child_by_uclass() */ +static int dm_test_first_child(struct unit_test_state *uts) +{ + struct udevice *i2c, *dev, *dev2; + + ut_assertok(uclass_first_device_err(UCLASS_I2C, &i2c)); + ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_RTC, &dev)); + ut_asserteq_str("rtc@43", dev->name); + ut_assertok(device_find_child_by_name(i2c, "rtc@43", &dev2)); + ut_asserteq_ptr(dev, dev2); + ut_assertok(device_find_child_by_name(i2c, "rtc@61", &dev2)); + ut_asserteq_str("rtc@61", dev2->name); + + ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_I2C_EEPROM, + &dev)); + ut_asserteq_str("eeprom@2c", dev->name); + ut_assertok(device_find_child_by_name(i2c, "eeprom@2c", &dev2)); + ut_asserteq_ptr(dev, dev2); + + ut_asserteq(-ENODEV, device_find_first_child_by_uclass(i2c, + UCLASS_VIDEO, &dev)); + ut_asserteq(-ENODEV, device_find_child_by_name(i2c, "missing", &dev)); + + return 0; +} +DM_TEST(dm_test_first_child, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

This is currently at the top in the space for internal use. But this uclass is used outside driver model and test code. Move it into the correct alpha order.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: None

include/dm/uclass-id.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/dm/uclass-id.h b/include/dm/uclass-id.h index c91dca1f824..cd4387e5ae2 100644 --- a/include/dm/uclass-id.h +++ b/include/dm/uclass-id.h @@ -24,7 +24,6 @@ enum uclass_id { UCLASS_PCI_EMUL, /* sandbox PCI device emulator */ UCLASS_USB_EMUL, /* sandbox USB bus device emulator */ UCLASS_AXI_EMUL, /* sandbox AXI bus device emulator */ - UCLASS_SIMPLE_BUS, /* bus with child devices */

/* U-Boot uclasses start here - in alphabetical order */ UCLASS_ADC, /* Analog-to-digital converter */ @@ -78,6 +77,7 @@ enum uclass_id { UCLASS_RTC, /* Real time clock device */ UCLASS_SCSI, /* SCSI device */ UCLASS_SERIAL, /* Serial UART */ + UCLASS_SIMPLE_BUS, /* Bus with child devices */ UCLASS_SMEM, /* Shared memory interface */ UCLASS_SPI, /* SPI bus */ UCLASS_SPMI, /* System Power Management Interface bus */

Sandbox i2c works using emulation drivers which are currently children of the i2c device:

rtc_0: rtc@43 { reg = <0x43>; compatible = "sandbox-rtc"; emul { compatible = "sandbox,i2c-rtc"; }; };

In this case the emulation device is attached to i2c bus on address 0x43 and provides the Real-Time-Clock (RTC) functionality.

However this is not ideal, since every device on an I2C bus has a child device. This is only really the case for sandbox, but we want to avoid special-case code for sandbox.

A better approach seems to be to add a separate node on the bus, an 'emulation parent'. This can be given a bogus address (such as 0xff) and hides all the emulators away. Then we can use a phandle to point from the device to the correct emualtor, and only on sandbox. The code to find an emulator does not interfere with normal i2c operation.

Add a new UCLASS_I2C_EMUL_PARENT uclass which allows finding an emulator given a bus, and finding a bus given an emulator. This will be used in a follow-on patch.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: None

drivers/i2c/i2c-emul-uclass.c | 77 +++++++++++++++++++++++++++++++++++ include/dm/uclass-id.h | 1 + include/i2c.h | 21 ++++++++++ 3 files changed, 99 insertions(+)

diff --git a/drivers/i2c/i2c-emul-uclass.c b/drivers/i2c/i2c-emul-uclass.c index a2bdd5aa844..ae5aae03e72 100644 --- a/drivers/i2c/i2c-emul-uclass.c +++ b/drivers/i2c/i2c-emul-uclass.c @@ -6,8 +6,85 @@ #include <common.h> #include <dm.h> #include <i2c.h> +#include <dm/device-internal.h> +#include <dm/uclass-internal.h> + +/* + * i2c emulation works using an 'emul' node at the bus level. Each device in + * that node is in the UCLASS_I2C_EMUL uclass, and emulates one i2c device. A + * pointer to the device it emulates is in the 'dev' property of the emul device + * uclass platdata (struct i2c_emul_platdata), put there by i2c_emul_find(). + * When sandbox wants an emulator for a device, it calls i2c_emul_find() which + * searches for the emulator with the correct address. To find the device for an + * emulator, call i2c_emul_get_device(). + * + * The 'emul' node is in the UCLASS_I2C_EMUL_PARENT uclass. We use a separate + * uclass so avoid having strange devices on the I2C bus. + */ + +/** + * struct i2c_emul_uc_platdata - information about the emulator for this device + * + * This is used by devices in UCLASS_I2C_EMUL to record information about the + * device being emulated. It is accessible with dev_get_uclass_platdata() + * + * @dev: Device being emulated + */ +struct i2c_emul_uc_platdata { + struct udevice *dev; +}; + +struct udevice *i2c_emul_get_device(struct udevice *emul) +{ + struct i2c_emul_uc_platdata *uc_plat = dev_get_uclass_platdata(emul); + + return uc_plat->dev; +} + +int i2c_emul_find(struct udevice *dev, struct udevice **emulp) +{ + struct i2c_emul_uc_platdata *uc_plat; + struct udevice *emul; + int ret; + + ret = uclass_find_device_by_phandle(UCLASS_I2C_EMUL, dev, + "sandbox,emul", &emul); + if (ret) { + log_err("No emulators for device '%s'\n", dev->name); + return ret; + } + uc_plat = dev_get_uclass_platdata(emul); + uc_plat->dev = dev; + *emulp = emul; + + return device_probe(emul); +}

UCLASS_DRIVER(i2c_emul) = { .id = UCLASS_I2C_EMUL, .name = "i2c_emul", + .per_device_platdata_auto_alloc_size = + sizeof(struct i2c_emul_uc_platdata), +}; + +/* + * This uclass is a child of the i2c bus. Its platdata is not defined here so + * is defined by its parent, UCLASS_I2C, which uses struct dm_i2c_chip. See + * per_child_platdata_auto_alloc_size in UCLASS_DRIVER(i2c). + */ +UCLASS_DRIVER(i2c_emul_parent) = { + .id = UCLASS_I2C_EMUL_PARENT, + .name = "i2c_emul_parent", + .post_bind = dm_scan_fdt_dev, +}; + +static const struct udevice_id i2c_emul_parent_ids[] = { + { .compatible = "sandbox,i2c-emul-parent" }, + { } +}; + +U_BOOT_DRIVER(i2c_emul_parent_drv) = { + .name = "i2c_emul_parent_drv", + .id = UCLASS_I2C_EMUL_PARENT, + .of_match = i2c_emul_parent_ids, }; diff --git a/include/dm/uclass-id.h b/include/dm/uclass-id.h index cd4387e5ae2..a5fcb69dbad 100644 --- a/include/dm/uclass-id.h +++ b/include/dm/uclass-id.h @@ -21,6 +21,7 @@ enum uclass_id { UCLASS_TEST_DUMMY, UCLASS_SPI_EMUL, /* sandbox SPI device emulator */ UCLASS_I2C_EMUL, /* sandbox I2C device emulator */ + UCLASS_I2C_EMUL_PARENT, /* parent for I2C device emulators */ UCLASS_PCI_EMUL, /* sandbox PCI device emulator */ UCLASS_USB_EMUL, /* sandbox USB bus device emulator */ UCLASS_AXI_EMUL, /* sandbox AXI bus device emulator */ diff --git a/include/i2c.h b/include/i2c.h index d33f827500b..ccffc195527 100644 --- a/include/i2c.h +++ b/include/i2c.h @@ -536,6 +536,27 @@ int i2c_chip_ofdata_to_platdata(struct udevice *dev, struct dm_i2c_chip *chip); */ void i2c_dump_msgs(struct i2c_msg *msg, int nmsgs);

+/** + * i2c_emul_find() - Find an emulator for an i2c sandbox device + * + * This looks at the device's 'emul' phandle + * + * @dev: Device to find an emulator for + * @emulp: Returns the associated emulator, if found * + * @return 0 if OK, -ENOENT or -ENODEV if not found + */ +int i2c_emul_find(struct udevice *dev, struct udevice **emulp); + +/** + * i2c_emul_get_device() - Find the device being emulated + * + * Given an emulator this returns the associated device + * + * @emul: Emulator for the device + * @return device that @emul is emulating + */ +struct udevice *i2c_emul_get_device(struct udevice *emul); + #ifndef CONFIG_DM_I2C

/*

Update the device tree, sandbox i2c driver and tests to use the new emulation parent to hold emulators.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: None

arch/sandbox/dts/sandbox.dts | 25 +++++++---- arch/sandbox/dts/sandbox_pmic.dtsi | 71 +++++++++++++++--------------- arch/sandbox/dts/test.dts | 30 +++++++++---- drivers/i2c/sandbox_i2c.c | 20 +-------- drivers/power/pmic/i2c_pmic_emul.c | 2 +- test/dm/i2c.c | 2 +- test/dm/rtc.c | 9 ++-- 7 files changed, 82 insertions(+), 77 deletions(-)

diff --git a/arch/sandbox/dts/sandbox.dts b/arch/sandbox/dts/sandbox.dts index fb866e88079..eda01893b49 100644 --- a/arch/sandbox/dts/sandbox.dts +++ b/arch/sandbox/dts/sandbox.dts @@ -91,19 +91,11 @@ eeprom@2c { reg = <0x2c>; compatible = "i2c-eeprom"; - emul { - compatible = "sandbox,i2c-eeprom"; - sandbox,filename = "i2c.bin"; - sandbox,size = <128>; - }; };

rtc_0: rtc@43 { reg = <0x43>; compatible = "sandbox-rtc"; - emul { - compatible = "sandbox,i2c-rtc"; - }; }; sandbox_pmic: sandbox_pmic { reg = <0x40>; @@ -112,6 +104,23 @@ mc34708: pmic@41 { reg = <0x41>; }; + + i2c_emul: emul { + #address-cells = <1>; + #size-cells = <0>; + reg = <0xff>; + compatible = "sandbox,i2c-emul-parent"; + emul-eeprom { + reg = <0x2c>; + compatible = "sandbox,i2c-eeprom"; + sandbox,filename = "i2c.bin"; + sandbox,size = <256>; + }; + emul0 { + reg = <0x43>; + compatible = "sandbox,i2c-rtc"; + }; + }; };

lcd { diff --git a/arch/sandbox/dts/sandbox_pmic.dtsi b/arch/sandbox/dts/sandbox_pmic.dtsi index 5ecafaab364..565c382ed45 100644 --- a/arch/sandbox/dts/sandbox_pmic.dtsi +++ b/arch/sandbox/dts/sandbox_pmic.dtsi @@ -11,40 +11,6 @@ &sandbox_pmic { compatible = "sandbox,pmic";

- pmic_emul { - compatible = "sandbox,i2c-pmic"; - - /* - * Default PMICs register values are set by macro - * VAL2REG(min, step, value) [uV/uA] - * VAL2OMREG(mode id) - * reg-defaults - byte array - */ - reg-defaults = /bits/ 8 < - /* BUCK1 */ - VAL2REG(800000, 25000, 1000000) - VAL2REG(150000, 25000, 150000) - VAL2OMREG(BUCK_OM_OFF) - /* BUCK2 */ - VAL2REG(750000, 50000, 3000000) - VAL2REG(150000, 25000, 150000) - VAL2OMREG(0) - /* LDO1 */ - VAL2REG(800000, 25000, 1600000) - VAL2REG(100000, 50000, 150000) - VAL2OMREG(LDO_OM_OFF) - /* LDO2 */ - VAL2REG(750000, 50000, 3000000) - VAL2REG(150000, 25000, 150000) - VAL2OMREG(0) - /* reg[12:15] - not used */ - 0x00 - 0x00 - 0x00 - 0x00 - >; - }; - buck1 { regulator-name = "SUPPLY_1.2V"; regulator-min-microvolt = <1200000>; @@ -84,10 +50,45 @@

&mc34708 { compatible = "fsl,mc34708"; +};

- pmic_emul { +&i2c_emul { + emul_pmic0: pmic-emul0 { compatible = "sandbox,i2c-pmic";

+ /* + * Default PMICs register values are set by macro + * VAL2REG(min, step, value) [uV/uA] + * VAL2OMREG(mode id) + * reg-defaults - byte array + */ + reg-defaults = /bits/ 8 < + /* BUCK1 */ + VAL2REG(800000, 25000, 1000000) + VAL2REG(150000, 25000, 150000) + VAL2OMREG(BUCK_OM_OFF) + /* BUCK2 */ + VAL2REG(750000, 50000, 3000000) + VAL2REG(150000, 25000, 150000) + VAL2OMREG(0) + /* LDO1 */ + VAL2REG(800000, 25000, 1600000) + VAL2REG(100000, 50000, 150000) + VAL2OMREG(LDO_OM_OFF) + /* LDO2 */ + VAL2REG(750000, 50000, 3000000) + VAL2REG(150000, 25000, 150000) + VAL2OMREG(0) + /* reg[12:15] - not used */ + 0x00 + 0x00 + 0x00 + 0x00 + >; + }; + + emul_pmic1: pmic-emul1 { + compatible = "sandbox,i2c-pmic"; reg-defaults = /bits/ 8 < 0x00 0x80 0x08 0xff 0xff 0xff 0x2e 0x01 0x08 0x40 0x80 0x81 0x5f 0xff 0xfb 0x1e 0x80 0x18 diff --git a/arch/sandbox/dts/test.dts b/arch/sandbox/dts/test.dts index 2c6b4223123..e4519ad48e9 100644 --- a/arch/sandbox/dts/test.dts +++ b/arch/sandbox/dts/test.dts @@ -266,35 +266,47 @@ eeprom@2c { reg = <0x2c>; compatible = "i2c-eeprom"; - emul { - compatible = "sandbox,i2c-eeprom"; - sandbox,filename = "i2c.bin"; - sandbox,size = <256>; - }; + sandbox,emul = <&emul_eeprom>; };

rtc_0: rtc@43 { reg = <0x43>; compatible = "sandbox-rtc"; - emul { - compatible = "sandbox,i2c-rtc"; - }; + sandbox,emul = <&emul0>; };

rtc_1: rtc@61 { reg = <0x61>; compatible = "sandbox-rtc"; - emul { + sandbox,emul = <&emul1>; + }; + + i2c_emul: emul { + #address-cells = <1>; + #size-cells = <0>; + reg = <0xff>; + compatible = "sandbox,i2c-emul-parent"; + emul_eeprom: emul-eeprom { + compatible = "sandbox,i2c-eeprom"; + sandbox,filename = "i2c.bin"; + sandbox,size = <256>; + }; + emul0: emul0 { + compatible = "sandbox,i2c-rtc"; + }; + emul1: emull { compatible = "sandbox,i2c-rtc"; }; };

sandbox_pmic: sandbox_pmic { reg = <0x40>; + sandbox,emul = <&emul_pmic0>; };

mc34708: pmic@41 { reg = <0x41>; + sandbox,emul = <&emul_pmic1>; }; };

diff --git a/drivers/i2c/sandbox_i2c.c b/drivers/i2c/sandbox_i2c.c index 66578510849..0dbbaa0c447 100644 --- a/drivers/i2c/sandbox_i2c.c +++ b/drivers/i2c/sandbox_i2c.c @@ -21,33 +21,15 @@ static int get_emul(struct udevice *dev, struct udevice **devp, struct dm_i2c_ops **opsp) { struct dm_i2c_chip *plat; - struct udevice *child; int ret;

*devp = NULL; *opsp = NULL; plat = dev_get_parent_platdata(dev); if (!plat->emul) { - ret = dm_scan_fdt_dev(dev); + ret = i2c_emul_find(dev, &plat->emul); if (ret) return ret; - - for (device_find_first_child(dev, &child); child; - device_find_next_child(&child)) { - if (device_get_uclass_id(child) != UCLASS_I2C_EMUL) - continue; - - ret = device_probe(child); - if (ret) - return ret; - - break; - } - - if (child) - plat->emul = child; - else - return -ENODEV; } *devp = plat->emul; *opsp = i2c_get_ops(plat->emul); diff --git a/drivers/power/pmic/i2c_pmic_emul.c b/drivers/power/pmic/i2c_pmic_emul.c index 61fa76a5619..80efc0265d9 100644 --- a/drivers/power/pmic/i2c_pmic_emul.c +++ b/drivers/power/pmic/i2c_pmic_emul.c @@ -104,7 +104,7 @@ static int sandbox_i2c_pmic_xfer(struct udevice *emul, struct i2c_msg *msg, static int sandbox_i2c_pmic_ofdata_to_platdata(struct udevice *emul) { struct sandbox_i2c_pmic_plat_data *plat = dev_get_platdata(emul); - struct udevice *pmic_dev = dev_get_parent(emul); + struct udevice *pmic_dev = i2c_emul_get_device(emul); struct uc_pmic_priv *priv = dev_get_uclass_priv(pmic_dev); const u8 *reg_defaults;

diff --git a/test/dm/i2c.c b/test/dm/i2c.c index 772f62b265d..cbbd4aa29a1 100644 --- a/test/dm/i2c.c +++ b/test/dm/i2c.c @@ -35,7 +35,7 @@ static int dm_test_i2c_find(struct unit_test_state *uts) */ ut_assertok(uclass_get_device_by_seq(UCLASS_I2C, busnum, &bus)); ut_assertok(dm_i2c_probe(bus, chip, 0, &dev)); - ut_asserteq(-ENODEV, dm_i2c_probe(bus, no_chip, 0, &dev)); + ut_asserteq(-ENOENT, dm_i2c_probe(bus, no_chip, 0, &dev)); ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_I2C, 1, &bus));

return 0; diff --git a/test/dm/rtc.c b/test/dm/rtc.c index e2bc648fdcf..71887427647 100644 --- a/test/dm/rtc.c +++ b/test/dm/rtc.c @@ -6,6 +6,7 @@

#include <common.h> #include <dm.h> +#include <i2c.h> #include <rtc.h> #include <asm/io.h> #include <asm/test.h> @@ -60,7 +61,7 @@ static int dm_test_rtc_set_get(struct unit_test_state *uts) ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev)); ut_assertok(dm_rtc_get(dev, &now));

- ut_assertok(device_find_first_child(dev, &emul)); + ut_assertok(i2c_emul_find(dev, &emul)); ut_assert(emul != NULL);

/* Tell the RTC to go into manual mode */ @@ -125,7 +126,7 @@ static int dm_test_rtc_reset(struct unit_test_state *uts) ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev)); ut_assertok(dm_rtc_get(dev, &now));

- ut_assertok(device_find_first_child(dev, &emul)); + ut_assertok(i2c_emul_find(dev, &emul)); ut_assert(emul != NULL);

old_base_time = sandbox_i2c_rtc_get_set_base_time(emul, 0); @@ -154,9 +155,9 @@ static int dm_test_rtc_dual(struct unit_test_state *uts) ut_assertok(uclass_get_device(UCLASS_RTC, 1, &dev2)); ut_assertok(dm_rtc_get(dev2, &now2));

- ut_assertok(device_find_first_child(dev1, &emul1)); + ut_assertok(i2c_emul_find(dev1, &emul1)); ut_assert(emul1 != NULL); - ut_assertok(device_find_first_child(dev2, &emul2)); + ut_assertok(i2c_emul_find(dev2, &emul2)); ut_assert(emul2 != NULL);

offset = sandbox_i2c_rtc_set_offset(emul1, false, -1);

Some RTC chips have child drivers, e.g. to provide access to their non-volatile RAM. Scan for these when binding.

Signed-off-by: Simon Glass sjg@chromium.org

---

Changes in v2: - Drop patches previously applied - Add new patches to support the RTC change

drivers/rtc/rtc-uclass.c | 1 + 1 file changed, 1 insertion(+)

diff --git a/drivers/rtc/rtc-uclass.c b/drivers/rtc/rtc-uclass.c index c676f0ff359..a0a238aedda 100644 --- a/drivers/rtc/rtc-uclass.c +++ b/drivers/rtc/rtc-uclass.c @@ -122,4 +122,5 @@ int rtc_write32(struct udevice *dev, unsigned int reg, u32 value) UCLASS_DRIVER(rtc) = { .name = "rtc", .id = UCLASS_RTC, + .post_bind = dm_scan_fdt_dev, };