leandrof/u-boot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

reset: implement a reset test

Browse Source 
This adds a sandbox reset implementation (provider), a test client
device, instantiates them both from Sandbox's DT, and adds a DM test
that excercises everything.

Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Stephen Warren 2016-06-17 09:43:59 -06:00 committed by Simon Glass
parent 89c1e2da78
commit 4581b717b1
9 changed files with 251 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
arch/sandbox/dts/test.dts
View File

@ -259,6 +259,17 @@
compatible = "sandbox,reset";
};
resetc: reset-ctl {
compatible = "sandbox,reset-ctl";
#reset-cells = <1>;
};
reset-ctl-test {
compatible = "sandbox,reset-ctl-test";
resets = <&resetc 100>, <&resetc 2>;
reset-names = "other", "test";
};
rproc_1: rproc@1 {
compatible = "sandbox,test-processor";
remoteproc-name = "remoteproc-test-dev1";

21
arch/sandbox/include/asm/reset.h Normal file
View File

@ -0,0 +1,21 @@
/*
* Copyright (c) 2016, NVIDIA CORPORATION.
*
* SPDX-License-Identifier: GPL-2.0
*/
#ifndef __SANDBOX_RESET_H
#define __SANDBOX_RESET_H
#include <common.h>
struct udevice;
int sandbox_reset_query(struct udevice *dev, unsigned long id);
int sandbox_reset_test_get(struct udevice *dev);
int sandbox_reset_test_assert(struct udevice *dev);
int sandbox_reset_test_deassert(struct udevice *dev);
int sandbox_reset_test_free(struct udevice *dev);
#endif

10
configs/sandbox_defconfig
View File

@ -1,4 +1,5 @@
CONFIG_SYS_MALLOC_F_LEN=0x2000
CONFIG_BLK=y
CONFIG_MMC=y
CONFIG_PCI=y
CONFIG_DEFAULT_DEVICE_TREE="sandbox"
@ -70,7 +71,6 @@ CONFIG_DEVRES=y
CONFIG_DEBUG_DEVRES=y
CONFIG_ADC=y
CONFIG_ADC_SANDBOX=y
CONFIG_BLK=y
CONFIG_CLK=y
CONFIG_CPU=y
CONFIG_DM_DEMO=y
@ -89,6 +89,9 @@ CONFIG_I2C_ARB_GPIO_CHALLENGE=y
CONFIG_CROS_EC_KEYB=y
CONFIG_LED=y
CONFIG_LED_GPIO=y
CONFIG_DM_MAILBOX=y
CONFIG_SANDBOX_MBOX=y
CONFIG_MISC=y
CONFIG_CMD_CROS_EC=y
CONFIG_CROS_EC=y
CONFIG_CROS_EC_I2C=y
@ -140,6 +143,8 @@ CONFIG_DM_REGULATOR_SANDBOX=y
CONFIG_REGULATOR_TPS65090=y
CONFIG_RAM=y
CONFIG_REMOTEPROC_SANDBOX=y
CONFIG_DM_RESET=y
CONFIG_SANDBOX_RESET=y
CONFIG_DM_RTC=y
CONFIG_SANDBOX_SERIAL=y
CONFIG_SOUND=y
@ -170,6 +175,3 @@ CONFIG_UNIT_TEST=y
CONFIG_UT_TIME=y
CONFIG_UT_DM=y
CONFIG_UT_ENV=y
CONFIG_MISC=y
CONFIG_DM_MAILBOX=y
CONFIG_SANDBOX_MBOX=y

8
drivers/reset/Kconfig
View File

@ -12,4 +12,12 @@ config DM_RESET
although driving such reset isgnals using GPIOs may be more
appropriate in this case.
config SANDBOX_RESET
bool "Enable the sandbox reset test driver"
depends on DM_MAILBOX && SANDBOX
help
Enable support for a test reset controller implementation, which
simply accepts requests to reset various HW modules without actually
doing anything beyond a little error checking.
endmenu

2
drivers/reset/Makefile
View File

@ -3,3 +3,5 @@
# SPDX-License-Identifier: GPL-2.0
obj-$(CONFIG_DM_RESET) += reset-uclass.o
obj-$(CONFIG_SANDBOX_MBOX) += sandbox-reset.o
obj-$(CONFIG_SANDBOX_MBOX) += sandbox-reset-test.o

55
drivers/reset/sandbox-reset-test.c Normal file
View File

@ -0,0 +1,55 @@
/*
* Copyright (c) 2016, NVIDIA CORPORATION.
*
* SPDX-License-Identifier: GPL-2.0
*/
#include <common.h>
#include <dm.h>
#include <reset.h>
#include <asm/io.h>
#include <asm/reset.h>
struct sandbox_reset_test {
struct reset_ctl ctl;
};
int sandbox_reset_test_get(struct udevice *dev)
{
struct sandbox_reset_test *sbrt = dev_get_priv(dev);
return reset_get_by_name(dev, "test", &sbrt->ctl);
}
int sandbox_reset_test_assert(struct udevice *dev)
{
struct sandbox_reset_test *sbrt = dev_get_priv(dev);
return reset_assert(&sbrt->ctl);
}
int sandbox_reset_test_deassert(struct udevice *dev)
{
struct sandbox_reset_test *sbrt = dev_get_priv(dev);
return reset_deassert(&sbrt->ctl);
}
int sandbox_reset_test_free(struct udevice *dev)
{
struct sandbox_reset_test *sbrt = dev_get_priv(dev);
return reset_free(&sbrt->ctl);
}
static const struct udevice_id sandbox_reset_test_ids[] = {
{ .compatible = "sandbox,reset-ctl-test" },
{ }
};
U_BOOT_DRIVER(sandbox_reset_test) = {
.name = "sandbox_reset_test",
.id = UCLASS_MISC,
.of_match = sandbox_reset_test_ids,
.priv_auto_alloc_size = sizeof(struct sandbox_reset_test),
};

108
drivers/reset/sandbox-reset.c Normal file
View File

@ -0,0 +1,108 @@
/*
* Copyright (c) 2016, NVIDIA CORPORATION.
*
* SPDX-License-Identifier: GPL-2.0
*/
#include <common.h>
#include <dm.h>
#include <reset-uclass.h>
#include <asm/io.h>
#include <asm/reset.h>
#define SANDBOX_RESET_SIGNALS 3
struct sandbox_reset_signal {
bool asserted;
};
struct sandbox_reset {
struct sandbox_reset_signal signals[SANDBOX_RESET_SIGNALS];
};
static int sandbox_reset_request(struct reset_ctl *reset_ctl)
{
debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
if (reset_ctl->id >= SANDBOX_RESET_SIGNALS)
return -EINVAL;
return 0;
}
static int sandbox_reset_free(struct reset_ctl *reset_ctl)
{
debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
return 0;
}
static int sandbox_reset_assert(struct reset_ctl *reset_ctl)
{
struct sandbox_reset *sbr = dev_get_priv(reset_ctl->dev);
debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
sbr->signals[reset_ctl->id].asserted = true;
return 0;
}
static int sandbox_reset_deassert(struct reset_ctl *reset_ctl)
{
struct sandbox_reset *sbr = dev_get_priv(reset_ctl->dev);
debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
sbr->signals[reset_ctl->id].asserted = false;
return 0;
}
static int sandbox_reset_bind(struct udevice *dev)
{
debug("%s(dev=%p)\n", __func__, dev);
return 0;
}
static int sandbox_reset_probe(struct udevice *dev)
{
debug("%s(dev=%p)\n", __func__, dev);
return 0;
}
static const struct udevice_id sandbox_reset_ids[] = {
{ .compatible = "sandbox,reset-ctl" },
{ }
};
struct reset_ops sandbox_reset_reset_ops = {
.request = sandbox_reset_request,
.free = sandbox_reset_free,
.rst_assert = sandbox_reset_assert,
.rst_deassert = sandbox_reset_deassert,
};
U_BOOT_DRIVER(sandbox_reset) = {
.name = "sandbox_reset",
.id = UCLASS_RESET,
.of_match = sandbox_reset_ids,
.bind = sandbox_reset_bind,
.probe = sandbox_reset_probe,
.priv_auto_alloc_size = sizeof(struct sandbox_reset),
.ops = &sandbox_reset_reset_ops,
};
int sandbox_reset_query(struct udevice *dev, unsigned long id)
{
struct sandbox_reset *sbr = dev_get_priv(dev);
debug("%s(dev=%p, id=%ld)\n", __func__, dev, id);
if (id >= SANDBOX_RESET_SIGNALS)
return -EINVAL;
return sbr->signals[id].asserted;
}

1
test/dm/Makefile
View File

@ -27,6 +27,7 @@ obj-$(CONFIG_DM_PCI) += pci.o
obj-$(CONFIG_RAM) += ram.o
obj-y += regmap.o
obj-$(CONFIG_REMOTEPROC) += remoteproc.o
obj-$(CONFIG_DM_RESET) += reset.o
obj-$(CONFIG_SYSRESET) += sysreset.o
obj-$(CONFIG_DM_RTC) += rtc.o
obj-$(CONFIG_DM_SPI_FLASH) += sf.o

39
test/dm/reset.c Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright (c) 2016, NVIDIA CORPORATION.
*
* SPDX-License-Identifier: GPL-2.0
*/
#include <common.h>
#include <dm.h>
#include <dm/test.h>
#include <asm/reset.h>
#include <test/ut.h>
/* This must match the specifier for mbox-names="test" in the DT node */
#define TEST_RESET_ID 2
static int dm_test_reset(struct unit_test_state *uts)
{
struct udevice *dev_reset;
struct udevice *dev_test;
ut_assertok(uclass_get_device_by_name(UCLASS_RESET, "reset-ctl",
&dev_reset));
ut_asserteq(0, sandbox_reset_query(dev_reset, TEST_RESET_ID));
ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "reset-ctl-test",
&dev_test));
ut_assertok(sandbox_reset_test_get(dev_test));
ut_assertok(sandbox_reset_test_assert(dev_test));
ut_asserteq(1, sandbox_reset_query(dev_reset, TEST_RESET_ID));
ut_assertok(sandbox_reset_test_deassert(dev_test));
ut_asserteq(0, sandbox_reset_query(dev_reset, TEST_RESET_ID));
ut_assertok(sandbox_reset_test_free(dev_test));
return 0;
}
DM_TEST(dm_test_reset, DM_TESTF_SCAN_FDT);