Add some tests of driver model functionality. Coverage includes: - basic init - binding of drivers to devices using platform_data - automatic probing of devices when referenced - availability of platform data to devices - lifecycle from bind to probe to remove to unbind - renumbering within a uclass when devices are probed/removed - calling driver-defined operations - deactivation of drivers when removed - memory leak across creation and destruction of drivers/uclasses - uclass init/destroy methods - automatic probe/remove of children/parents when needed This function is enabled for sandbox, using CONFIG_DM_TEST. Signed-off-by: Simon Glass <sjg@chromium.org>master
Simon Glass
10 years ago
committed by
Tom Rini
parent
1ce6017679
commit
2e7d35d2a6
@ -0,0 +1,167 @@ |
||||
/*
|
||||
* Copyright (c) 2013 Google, Inc. |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
|
||||
#ifndef __DM_TEST_H |
||||
#define __DM_TEST_H |
||||
|
||||
#include <dm.h> |
||||
|
||||
/**
|
||||
* struct dm_test_cdata - configuration data for test instance |
||||
* |
||||
* @ping_add: Amonut to add each time we get a ping |
||||
* @base: Base address of this device |
||||
*/ |
||||
struct dm_test_pdata { |
||||
int ping_add; |
||||
uint32_t base; |
||||
}; |
||||
|
||||
/**
|
||||
* struct test_ops - Operations supported by the test device |
||||
* |
||||
* @ping: Ping operation |
||||
* @dev: Device to operate on |
||||
* @pingval: Value to ping the device with |
||||
* @pingret: Returns resulting value from driver |
||||
* @return 0 if OK, -ve on error |
||||
*/ |
||||
struct test_ops { |
||||
int (*ping)(struct device *dev, int pingval, int *pingret); |
||||
}; |
||||
|
||||
/* Operations that our test driver supports */ |
||||
enum { |
||||
DM_TEST_OP_BIND = 0, |
||||
DM_TEST_OP_UNBIND, |
||||
DM_TEST_OP_PROBE, |
||||
DM_TEST_OP_REMOVE, |
||||
|
||||
/* For uclass */ |
||||
DM_TEST_OP_POST_BIND, |
||||
DM_TEST_OP_PRE_UNBIND, |
||||
DM_TEST_OP_POST_PROBE, |
||||
DM_TEST_OP_PRE_REMOVE, |
||||
DM_TEST_OP_INIT, |
||||
DM_TEST_OP_DESTROY, |
||||
|
||||
DM_TEST_OP_COUNT, |
||||
}; |
||||
|
||||
/* Test driver types */ |
||||
enum { |
||||
DM_TEST_TYPE_FIRST = 0, |
||||
DM_TEST_TYPE_SECOND, |
||||
}; |
||||
|
||||
/* The number added to the ping total on each probe */ |
||||
#define DM_TEST_START_TOTAL 5 |
||||
|
||||
/**
|
||||
* struct dm_test_priv - private data for the test devices |
||||
*/ |
||||
struct dm_test_priv { |
||||
int ping_total; |
||||
int op_count[DM_TEST_OP_COUNT]; |
||||
}; |
||||
|
||||
/**
|
||||
* struct dm_test_perdev_class_priv - private per-device data for test uclass |
||||
*/ |
||||
struct dm_test_uclass_perdev_priv { |
||||
int base_add; |
||||
}; |
||||
|
||||
/**
|
||||
* struct dm_test_uclass_priv - private data for test uclass |
||||
*/ |
||||
struct dm_test_uclass_priv { |
||||
int total_add; |
||||
}; |
||||
|
||||
/*
|
||||
* Operation counts for the test driver, used to check that each method is |
||||
* called correctly |
||||
*/ |
||||
extern int dm_testdrv_op_count[DM_TEST_OP_COUNT]; |
||||
|
||||
extern struct dm_test_state global_test_state; |
||||
|
||||
/*
|
||||
* struct dm_test_state - Entire state of dm test system |
||||
* |
||||
* This is often abreviated to dms. |
||||
* |
||||
* @root: Root device |
||||
* @testdev: Test device |
||||
* @fail_count: Number of tests that failed |
||||
* @force_fail_alloc: Force all memory allocs to fail |
||||
* @skip_post_probe: Skip uclass post-probe processing |
||||
*/ |
||||
struct dm_test_state { |
||||
struct device *root; |
||||
struct device *testdev; |
||||
int fail_count; |
||||
int force_fail_alloc; |
||||
int skip_post_probe; |
||||
}; |
||||
|
||||
/* Test flags for each test */ |
||||
enum { |
||||
DM_TESTF_SCAN_PDATA = 1 << 0, /* test needs platform data */ |
||||
DM_TESTF_PROBE_TEST = 1 << 1, /* probe test uclass */ |
||||
DM_TESTF_SCAN_FDT = 1 << 2, /* scan device tree */ |
||||
}; |
||||
|
||||
/**
|
||||
* struct dm_test - Information about a driver model test |
||||
* |
||||
* @name: Name of test |
||||
* @func: Function to call to perform test |
||||
* @flags: Flags indicated pre-conditions for test |
||||
*/ |
||||
struct dm_test { |
||||
const char *name; |
||||
int (*func)(struct dm_test_state *dms); |
||||
int flags; |
||||
}; |
||||
|
||||
/* Declare a new driver model test */ |
||||
#define DM_TEST(_name, _flags) \ |
||||
ll_entry_declare(struct dm_test, _name, dm_test) = { \
|
||||
.name = #_name, \
|
||||
.flags = _flags, \
|
||||
.func = _name, \
|
||||
} |
||||
|
||||
/* Declare ping methods for the drivers */ |
||||
int test_ping(struct device *dev, int pingval, int *pingret); |
||||
int testfdt_ping(struct device *dev, int pingval, int *pingret); |
||||
|
||||
/**
|
||||
* dm_check_operations() - Check that we can perform ping operations |
||||
* |
||||
* This checks that the ping operations work as expected for a device |
||||
* |
||||
* @dms: Overall test state |
||||
* @dev: Device to test |
||||
* @base: Base address, used to check ping return value |
||||
* @priv: Pointer to private test information |
||||
* @return 0 if OK, -ve on error |
||||
*/ |
||||
int dm_check_operations(struct dm_test_state *dms, struct device *dev, |
||||
uint32_t base, struct dm_test_priv *priv); |
||||
|
||||
/**
|
||||
* dm_test_main() - Run all the tests |
||||
* |
||||
* This runs all available driver model tests |
||||
* |
||||
* @return 0 if OK, -ve on error |
||||
*/ |
||||
int dm_test_main(void); |
||||
|
||||
#endif |
||||
@ -0,0 +1,95 @@ |
||||
/*
|
||||
* Simple unit test library for driver model |
||||
* |
||||
* Copyright (c) 2013 Google, Inc |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
|
||||
#ifndef __DM_UT_H |
||||
#define __DM_UT_H |
||||
|
||||
struct dm_test_state; |
||||
|
||||
/**
|
||||
* ut_fail() - Record failure of a unit test |
||||
* |
||||
* @dms: Test state |
||||
* @fname: Filename where the error occured |
||||
* @line: Line number where the error occured |
||||
* @func: Function name where the error occured |
||||
* @cond: The condition that failed |
||||
*/ |
||||
void ut_fail(struct dm_test_state *dms, const char *fname, int line, |
||||
const char *func, const char *cond); |
||||
|
||||
/**
|
||||
* ut_failf() - Record failure of a unit test |
||||
* |
||||
* @dms: Test state |
||||
* @fname: Filename where the error occured |
||||
* @line: Line number where the error occured |
||||
* @func: Function name where the error occured |
||||
* @cond: The condition that failed |
||||
* @fmt: printf() format string for the error, followed by args |
||||
*/ |
||||
void ut_failf(struct dm_test_state *dms, const char *fname, int line, |
||||
const char *func, const char *cond, const char *fmt, ...) |
||||
__attribute__ ((format (__printf__, 6, 7))); |
||||
|
||||
|
||||
/* Assert that a condition is non-zero */ |
||||
#define ut_assert(cond) \ |
||||
if (!(cond)) { \
|
||||
ut_fail(dms, __FILE__, __LINE__, __func__, #cond); \
|
||||
return -1; \
|
||||
} |
||||
|
||||
/* Assert that a condition is non-zero, with printf() string */ |
||||
#define ut_assertf(cond, fmt, args...) \ |
||||
if (!(cond)) { \
|
||||
ut_failf(dms, __FILE__, __LINE__, __func__, #cond, \
|
||||
fmt, ##args); \
|
||||
return -1; \
|
||||
} |
||||
|
||||
/* Assert that two int expressions are equal */ |
||||
#define ut_asserteq(expr1, expr2) { \ |
||||
unsigned int val1 = (expr1), val2 = (expr2); \
|
||||
\
|
||||
if (val1 != val2) { \
|
||||
ut_failf(dms, __FILE__, __LINE__, __func__, \
|
||||
#expr1 " == " #expr2, \ |
||||
"Expected %d, got %d", val1, val2); \
|
||||
return -1; \
|
||||
} \
|
||||
} |
||||
|
||||
/* Assert that two string expressions are equal */ |
||||
#define ut_asserteq_str(expr1, expr2) { \ |
||||
const char *val1 = (expr1), *val2 = (expr2); \
|
||||
\
|
||||
if (strcmp(val1, val2)) { \
|
||||
ut_failf(dms, __FILE__, __LINE__, __func__, \
|
||||
#expr1 " = " #expr2, \ |
||||
"Expected \"%s\", got \"%s\"", val1, val2); \
|
||||
return -1; \
|
||||
} \
|
||||
} |
||||
|
||||
/* Assert that two pointers are equal */ |
||||
#define ut_asserteq_ptr(expr1, expr2) { \ |
||||
const void *val1 = (expr1), *val2 = (expr2); \
|
||||
\
|
||||
if (val1 != val2) { \
|
||||
ut_failf(dms, __FILE__, __LINE__, __func__, \
|
||||
#expr1 " = " #expr2, \ |
||||
"Expected %p, got %p", val1, val2); \
|
||||
return -1; \
|
||||
} \
|
||||
} |
||||
|
||||
/* Assert that an operation succeeds (returns 0) */ |
||||
#define ut_assertok(cond) ut_asserteq(0, cond) |
||||
|
||||
#endif |
||||
@ -0,0 +1 @@ |
||||
/test.dtb |
||||
@ -0,0 +1,17 @@ |
||||
#
|
||||
# Copyright (c) 2013 Google, Inc
|
||||
#
|
||||
# SPDX-License-Identifier: GPL-2.0+
|
||||
#
|
||||
|
||||
obj-$(CONFIG_DM_TEST) += test-driver.o
|
||||
obj-$(CONFIG_DM_TEST) += test-fdt.o
|
||||
obj-$(CONFIG_DM_TEST) += test-main.o
|
||||
obj-$(CONFIG_DM_TEST) += test-uclass.o
|
||||
obj-$(CONFIG_DM_TEST) += ut.o
|
||||
|
||||
# Tests for particular subsystems - when enabling driver model for a new
|
||||
# subsystem you must add sandbox tests here.
|
||||
obj-$(CONFIG_DM_TEST) += core.o
|
||||
obj-$(CONFIG_DM_TEST) += ut.o
|
||||
obj-$(CONFIG_DM_GPIO) += gpio.o
|
||||
@ -0,0 +1,544 @@ |
||||
/*
|
||||
* Tests for the core driver model code |
||||
* |
||||
* Copyright (c) 2013 Google, Inc |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
|
||||
#include <common.h> |
||||
#include <errno.h> |
||||
#include <dm.h> |
||||
#include <fdtdec.h> |
||||
#include <malloc.h> |
||||
#include <dm/device-internal.h> |
||||
#include <dm/root.h> |
||||
#include <dm/ut.h> |
||||
#include <dm/util.h> |
||||
#include <dm/test.h> |
||||
#include <dm/uclass-internal.h> |
||||
|
||||
DECLARE_GLOBAL_DATA_PTR; |
||||
|
||||
enum { |
||||
TEST_INTVAL1 = 0, |
||||
TEST_INTVAL2 = 3, |
||||
TEST_INTVAL3 = 6, |
||||
TEST_INTVAL_MANUAL = 101112, |
||||
}; |
||||
|
||||
static const struct dm_test_pdata test_pdata[] = { |
||||
{ .ping_add = TEST_INTVAL1, }, |
||||
{ .ping_add = TEST_INTVAL2, }, |
||||
{ .ping_add = TEST_INTVAL3, }, |
||||
}; |
||||
|
||||
static const struct dm_test_pdata test_pdata_manual = { |
||||
.ping_add = TEST_INTVAL_MANUAL, |
||||
}; |
||||
|
||||
U_BOOT_DEVICE(dm_test_info1) = { |
||||
.name = "test_drv", |
||||
.platdata = &test_pdata[0], |
||||
}; |
||||
|
||||
U_BOOT_DEVICE(dm_test_info2) = { |
||||
.name = "test_drv", |
||||
.platdata = &test_pdata[1], |
||||
}; |
||||
|
||||
U_BOOT_DEVICE(dm_test_info3) = { |
||||
.name = "test_drv", |
||||
.platdata = &test_pdata[2], |
||||
}; |
||||
|
||||
static struct driver_info driver_info_manual = { |
||||
.name = "test_manual_drv", |
||||
.platdata = &test_pdata_manual, |
||||
}; |
||||
|
||||
/* Test that binding with platdata occurs correctly */ |
||||
static int dm_test_autobind(struct dm_test_state *dms) |
||||
{ |
||||
struct device *dev; |
||||
|
||||
/*
|
||||
* We should have a single class (UCLASS_ROOT) and a single root |
||||
* device with no children. |
||||
*/ |
||||
ut_assert(dms->root); |
||||
ut_asserteq(1, list_count_items(&gd->uclass_root)); |
||||
ut_asserteq(0, list_count_items(&gd->dm_root->child_head)); |
||||
ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_BIND]); |
||||
|
||||
ut_assertok(dm_scan_platdata()); |
||||
|
||||
/* We should have our test class now at least, plus more children */ |
||||
ut_assert(1 < list_count_items(&gd->uclass_root)); |
||||
ut_assert(0 < list_count_items(&gd->dm_root->child_head)); |
||||
|
||||
/* Our 3 dm_test_infox children should be bound to the test uclass */ |
||||
ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_POST_BIND]); |
||||
|
||||
/* No devices should be probed */ |
||||
list_for_each_entry(dev, &gd->dm_root->child_head, sibling_node) |
||||
ut_assert(!(dev->flags & DM_FLAG_ACTIVATED)); |
||||
|
||||
/* Our test driver should have been bound 3 times */ |
||||
ut_assert(dm_testdrv_op_count[DM_TEST_OP_BIND] == 3); |
||||
|
||||
return 0; |
||||
} |
||||
DM_TEST(dm_test_autobind, 0); |
||||
|
||||
/* Test that autoprobe finds all the expected devices */ |
||||
static int dm_test_autoprobe(struct dm_test_state *dms) |
||||
{ |
||||
int expected_base_add; |
||||
struct device *dev; |
||||
struct uclass *uc; |
||||
int i; |
||||
|
||||
ut_assertok(uclass_get(UCLASS_TEST, &uc)); |
||||
ut_assert(uc); |
||||
|
||||
ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]); |
||||
ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]); |
||||
|
||||
/* The root device should not be activated until needed */ |
||||
ut_assert(!(dms->root->flags & DM_FLAG_ACTIVATED)); |
||||
|
||||
/*
|
||||
* We should be able to find the three test devices, and they should |
||||
* all be activated as they are used (lazy activation, required by |
||||
* U-Boot) |
||||
*/ |
||||
for (i = 0; i < 3; i++) { |
||||
ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev)); |
||||
ut_assert(dev); |
||||
ut_assertf(!(dev->flags & DM_FLAG_ACTIVATED), |
||||
"Driver %d/%s already activated", i, dev->name); |
||||
|
||||
/* This should activate it */ |
||||
ut_assertok(uclass_get_device(UCLASS_TEST, i, &dev)); |
||||
ut_assert(dev); |
||||
ut_assert(dev->flags & DM_FLAG_ACTIVATED); |
||||
|
||||
/* Activating a device should activate the root device */ |
||||
if (!i) |
||||
ut_assert(dms->root->flags & DM_FLAG_ACTIVATED); |
||||
} |
||||
|
||||
/* Our 3 dm_test_infox children should be passed to post_probe */ |
||||
ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]); |
||||
|
||||
/* Also we can check the per-device data */ |
||||
expected_base_add = 0; |
||||
for (i = 0; i < 3; i++) { |
||||
struct dm_test_uclass_perdev_priv *priv; |
||||
struct dm_test_pdata *pdata; |
||||
|
||||
ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev)); |
||||
ut_assert(dev); |
||||
|
||||
priv = dev->uclass_priv; |
||||
ut_assert(priv); |
||||
ut_asserteq(expected_base_add, priv->base_add); |
||||
|
||||
pdata = dev->platdata; |
||||
expected_base_add += pdata->ping_add; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
DM_TEST(dm_test_autoprobe, DM_TESTF_SCAN_PDATA); |
||||
|
||||
/* Check that we see the correct platdata in each device */ |
||||
static int dm_test_platdata(struct dm_test_state *dms) |
||||
{ |
||||
const struct dm_test_pdata *pdata; |
||||
struct device *dev; |
||||
int i; |
||||
|
||||
for (i = 0; i < 3; i++) { |
||||
ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev)); |
||||
ut_assert(dev); |
||||
pdata = dev->platdata; |
||||
ut_assert(pdata->ping_add == test_pdata[i].ping_add); |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
DM_TEST(dm_test_platdata, DM_TESTF_SCAN_PDATA); |
||||
|
||||
/* Test that we can bind, probe, remove, unbind a driver */ |
||||
static int dm_test_lifecycle(struct dm_test_state *dms) |
||||
{ |
||||
int op_count[DM_TEST_OP_COUNT]; |
||||
struct device *dev, *test_dev; |
||||
int pingret; |
||||
int ret; |
||||
|
||||
memcpy(op_count, dm_testdrv_op_count, sizeof(op_count)); |
||||
|
||||
ut_assertok(device_bind_by_name(dms->root, &driver_info_manual, |
||||
&dev)); |
||||
ut_assert(dev); |
||||
ut_assert(dm_testdrv_op_count[DM_TEST_OP_BIND] |
||||
== op_count[DM_TEST_OP_BIND] + 1); |
||||
ut_assert(!dev->priv); |
||||
|
||||
/* Probe the device - it should fail allocating private data */ |
||||
dms->force_fail_alloc = 1; |
||||
ret = device_probe(dev); |
||||
ut_assert(ret == -ENOMEM); |
||||
ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE] |
||||
== op_count[DM_TEST_OP_PROBE] + 1); |
||||
ut_assert(!dev->priv); |
||||
|
||||
/* Try again without the alloc failure */ |
||||
dms->force_fail_alloc = 0; |
||||
ut_assertok(device_probe(dev)); |
||||
ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE] |
||||
== op_count[DM_TEST_OP_PROBE] + 2); |
||||
ut_assert(dev->priv); |
||||
|
||||
/* This should be device 3 in the uclass */ |
||||
ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev)); |
||||
ut_assert(dev == test_dev); |
||||
|
||||
/* Try ping */ |
||||
ut_assertok(test_ping(dev, 100, &pingret)); |
||||
ut_assert(pingret == 102); |
||||
|
||||
/* Now remove device 3 */ |
||||
ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]); |
||||
ut_assertok(device_remove(dev)); |
||||
ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]); |
||||
|
||||
ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_UNBIND]); |
||||
ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]); |
||||
ut_assertok(device_unbind(dev)); |
||||
ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_UNBIND]); |
||||
ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]); |
||||
|
||||
return 0; |
||||
} |
||||
DM_TEST(dm_test_lifecycle, DM_TESTF_SCAN_PDATA | DM_TESTF_PROBE_TEST); |
||||
|
||||
/* Test that we can bind/unbind and the lists update correctly */ |
||||
static int dm_test_ordering(struct dm_test_state *dms) |
||||
{ |
||||
struct device *dev, *dev_penultimate, *dev_last, *test_dev; |
||||
int pingret; |
||||
|
||||
ut_assertok(device_bind_by_name(dms->root, &driver_info_manual, |
||||
&dev)); |
||||
ut_assert(dev); |
||||
|
||||
/* Bind two new devices (numbers 4 and 5) */ |
||||
ut_assertok(device_bind_by_name(dms->root, &driver_info_manual, |
||||
&dev_penultimate)); |
||||
ut_assert(dev_penultimate); |
||||
ut_assertok(device_bind_by_name(dms->root, &driver_info_manual, |
||||
&dev_last)); |
||||
ut_assert(dev_last); |
||||
|
||||
/* Now remove device 3 */ |
||||
ut_assertok(device_remove(dev)); |
||||
ut_assertok(device_unbind(dev)); |
||||
|
||||
/* The device numbering should have shifted down one */ |
||||
ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev)); |
||||
ut_assert(dev_penultimate == test_dev); |
||||
ut_assertok(uclass_find_device(UCLASS_TEST, 4, &test_dev)); |
||||
ut_assert(dev_last == test_dev); |
||||
|
||||
/* Add back the original device 3, now in position 5 */ |
||||
ut_assertok(device_bind_by_name(dms->root, &driver_info_manual, &dev)); |
||||
ut_assert(dev); |
||||
|
||||
/* Try ping */ |
||||
ut_assertok(test_ping(dev, 100, &pingret)); |
||||
ut_assert(pingret == 102); |
||||
|
||||
/* Remove 3 and 4 */ |
||||
ut_assertok(device_remove(dev_penultimate)); |
||||
ut_assertok(device_unbind(dev_penultimate)); |
||||
ut_assertok(device_remove(dev_last)); |
||||
ut_assertok(device_unbind(dev_last)); |
||||
|
||||
/* Our device should now be in position 3 */ |
||||
ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev)); |
||||
ut_assert(dev == test_dev); |
||||
|
||||
/* Now remove device 3 */ |
||||
ut_assertok(device_remove(dev)); |
||||
ut_assertok(device_unbind(dev)); |
||||
|
||||
return 0; |
||||
} |
||||
DM_TEST(dm_test_ordering, DM_TESTF_SCAN_PDATA); |
||||
|
||||
/* Check that we can perform operations on a device (do a ping) */ |
||||
int dm_check_operations(struct dm_test_state *dms, struct device *dev, |
||||
uint32_t base, struct dm_test_priv *priv) |
||||
{ |
||||
int expected; |
||||
int pingret; |
||||
|
||||
/* Getting the child device should allocate platdata / priv */ |
||||
ut_assertok(testfdt_ping(dev, 10, &pingret)); |
||||
ut_assert(dev->priv); |
||||
ut_assert(dev->platdata); |
||||
|
||||
expected = 10 + base; |
||||
ut_asserteq(expected, pingret); |
||||
|
||||
/* Do another ping */ |
||||
ut_assertok(testfdt_ping(dev, 20, &pingret)); |
||||
expected = 20 + base; |
||||
ut_asserteq(expected, pingret); |
||||
|
||||
/* Now check the ping_total */ |
||||
priv = dev->priv; |
||||
ut_asserteq(DM_TEST_START_TOTAL + 10 + 20 + base * 2, |
||||
priv->ping_total); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
/* Check that we can perform operations on devices */ |
||||
static int dm_test_operations(struct dm_test_state *dms) |
||||
{ |
||||
struct device *dev; |
||||
int i; |
||||
|
||||
/*
|
||||
* Now check that the ping adds are what we expect. This is using the |
||||
* ping-add property in each node. |
||||
*/ |
||||
for (i = 0; i < ARRAY_SIZE(test_pdata); i++) { |
||||
uint32_t base; |
||||
|
||||
ut_assertok(uclass_get_device(UCLASS_TEST, i, &dev)); |
||||
|
||||
/*
|
||||
* Get the 'reg' property, which tells us what the ping add |
||||
* should be. We don't use the platdata because we want |
||||
* to test the code that sets that up (testfdt_drv_probe()). |
||||
*/ |
||||
base = test_pdata[i].ping_add; |
||||
debug("dev=%d, base=%d\n", i, base); |
||||
|
||||
ut_assert(!dm_check_operations(dms, dev, base, dev->priv)); |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
DM_TEST(dm_test_operations, DM_TESTF_SCAN_PDATA); |
||||
|
||||
/* Remove all drivers and check that things work */ |
||||
static int dm_test_remove(struct dm_test_state *dms) |
||||
{ |
||||
struct device *dev; |
||||
int i; |
||||
|
||||
for (i = 0; i < 3; i++) { |
||||
ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev)); |
||||
ut_assert(dev); |
||||
ut_assertf(dev->flags & DM_FLAG_ACTIVATED, |
||||
"Driver %d/%s not activated", i, dev->name); |
||||
ut_assertok(device_remove(dev)); |
||||
ut_assertf(!(dev->flags & DM_FLAG_ACTIVATED), |
||||
"Driver %d/%s should have deactivated", i, |
||||
dev->name); |
||||
ut_assert(!dev->priv); |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
DM_TEST(dm_test_remove, DM_TESTF_SCAN_PDATA | DM_TESTF_PROBE_TEST); |
||||
|
||||
/* Remove and recreate everything, check for memory leaks */ |
||||
static int dm_test_leak(struct dm_test_state *dms) |
||||
{ |
||||
int i; |
||||
|
||||
for (i = 0; i < 2; i++) { |
||||
struct mallinfo start, end; |
||||
struct device *dev; |
||||
int ret; |
||||
int id; |
||||
|
||||
start = mallinfo(); |
||||
if (!start.uordblks) |
||||
puts("Warning: Please add '#define DEBUG' to the top of common/dlmalloc.c\n"); |
||||
|
||||
ut_assertok(dm_scan_platdata()); |
||||
ut_assertok(dm_scan_fdt(gd->fdt_blob)); |
||||
|
||||
/* Scanning the uclass is enough to probe all the devices */ |
||||
for (id = UCLASS_ROOT; id < UCLASS_COUNT; id++) { |
||||
for (ret = uclass_first_device(UCLASS_TEST, &dev); |
||||
dev; |
||||
ret = uclass_next_device(&dev)) |
||||
; |
||||
ut_assertok(ret); |
||||
} |
||||
|
||||
/* Don't delete the root class, since we started with that */ |
||||
for (id = UCLASS_ROOT + 1; id < UCLASS_COUNT; id++) { |
||||
struct uclass *uc; |
||||
|
||||
uc = uclass_find(id); |
||||
if (!uc) |
||||
continue; |
||||
ut_assertok(uclass_destroy(uc)); |
||||
} |
||||
|
||||
end = mallinfo(); |
||||
ut_asserteq(start.uordblks, end.uordblks); |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
DM_TEST(dm_test_leak, 0); |
||||
|
||||
/* Test uclass init/destroy methods */ |
||||
static int dm_test_uclass(struct dm_test_state *dms) |
||||
{ |
||||
struct uclass *uc; |
||||
|
||||
ut_assertok(uclass_get(UCLASS_TEST, &uc)); |
||||
ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]); |
||||
ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_DESTROY]); |
||||
ut_assert(uc->priv); |
||||
|
||||
ut_assertok(uclass_destroy(uc)); |
||||
ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]); |
||||
ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_DESTROY]); |
||||
|
||||
return 0; |
||||
} |
||||
DM_TEST(dm_test_uclass, 0); |
||||
|
||||
/**
|
||||
* create_children() - Create children of a parent node |
||||
* |
||||
* @dms: Test system state |
||||
* @parent: Parent device |
||||
* @count: Number of children to create |
||||
* @key: Key value to put in first child. Subsequence children |
||||
* receive an incrementing value |
||||
* @child: If not NULL, then the child device pointers are written into |
||||
* this array. |
||||
* @return 0 if OK, -ve on error |
||||
*/ |
||||
static int create_children(struct dm_test_state *dms, struct device *parent, |
||||
int count, int key, struct device *child[]) |
||||
{ |
||||
struct device *dev; |
||||
int i; |
||||
|
||||
for (i = 0; i < count; i++) { |
||||
struct dm_test_pdata *pdata; |
||||
|
||||
ut_assertok(device_bind_by_name(parent, &driver_info_manual, |
||||
&dev)); |
||||
pdata = calloc(1, sizeof(*pdata)); |
||||
pdata->ping_add = key + i; |
||||
dev->platdata = pdata; |
||||
if (child) |
||||
child[i] = dev; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
#define NODE_COUNT 10 |
||||
|
||||
static int dm_test_children(struct dm_test_state *dms) |
||||
{ |
||||
struct device *top[NODE_COUNT]; |
||||
struct device *child[NODE_COUNT]; |
||||
struct device *grandchild[NODE_COUNT]; |
||||
struct device *dev; |
||||
int total; |
||||
int ret; |
||||
int i; |
||||
|
||||
/* We don't care about the numbering for this test */ |
||||
dms->skip_post_probe = 1; |
||||
|
||||
ut_assert(NODE_COUNT > 5); |
||||
|
||||
/* First create 10 top-level children */ |
||||
ut_assertok(create_children(dms, dms->root, NODE_COUNT, 0, top)); |
||||
|
||||
/* Now a few have their own children */ |
||||
ut_assertok(create_children(dms, top[2], NODE_COUNT, 2, NULL)); |
||||
ut_assertok(create_children(dms, top[5], NODE_COUNT, 5, child)); |
||||
|
||||
/* And grandchildren */ |
||||
for (i = 0; i < NODE_COUNT; i++) |
||||
ut_assertok(create_children(dms, child[i], NODE_COUNT, 50 * i, |
||||
i == 2 ? grandchild : NULL)); |
||||
|
||||
/* Check total number of devices */ |
||||
total = NODE_COUNT * (3 + NODE_COUNT); |
||||
ut_asserteq(total, dm_testdrv_op_count[DM_TEST_OP_BIND]); |
||||
|
||||
/* Try probing one of the grandchildren */ |
||||
ut_assertok(uclass_get_device(UCLASS_TEST, |
||||
NODE_COUNT * 3 + 2 * NODE_COUNT, &dev)); |
||||
ut_asserteq_ptr(grandchild[0], dev); |
||||
|
||||
/*
|
||||
* This should have probed the child and top node also, for a total |
||||
* of 3 nodes. |
||||
*/ |
||||
ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_PROBE]); |
||||
|
||||
/* Probe the other grandchildren */ |
||||
for (i = 1; i < NODE_COUNT; i++) |
||||
ut_assertok(device_probe(grandchild[i])); |
||||
|
||||
ut_asserteq(2 + NODE_COUNT, dm_testdrv_op_count[DM_TEST_OP_PROBE]); |
||||
|
||||
/* Probe everything */ |
||||
for (ret = uclass_first_device(UCLASS_TEST, &dev); |
||||
dev; |
||||
ret = uclass_next_device(&dev)) |
||||
; |
||||
ut_assertok(ret); |
||||
|
||||
ut_asserteq(total, dm_testdrv_op_count[DM_TEST_OP_PROBE]); |
||||
|
||||
/* Remove a top-level child and check that the children are removed */ |
||||
ut_assertok(device_remove(top[2])); |
||||
ut_asserteq(NODE_COUNT + 1, dm_testdrv_op_count[DM_TEST_OP_REMOVE]); |
||||
dm_testdrv_op_count[DM_TEST_OP_REMOVE] = 0; |
||||
|
||||
/* Try one with grandchildren */ |
||||
ut_assertok(uclass_get_device(UCLASS_TEST, 5, &dev)); |
||||
ut_asserteq_ptr(dev, top[5]); |
||||
ut_assertok(device_remove(dev)); |
||||
ut_asserteq(1 + NODE_COUNT * (1 + NODE_COUNT), |
||||
dm_testdrv_op_count[DM_TEST_OP_REMOVE]); |
||||
|
||||
/* Try the same with unbind */ |
||||
ut_assertok(device_unbind(top[2])); |
||||
ut_asserteq(NODE_COUNT + 1, dm_testdrv_op_count[DM_TEST_OP_UNBIND]); |
||||
dm_testdrv_op_count[DM_TEST_OP_UNBIND] = 0; |
||||
|
||||
/* Try one with grandchildren */ |
||||
ut_assertok(uclass_get_device(UCLASS_TEST, 5, &dev)); |
||||
ut_asserteq_ptr(dev, top[6]); |
||||
ut_assertok(device_unbind(top[5])); |
||||
ut_asserteq(1 + NODE_COUNT * (1 + NODE_COUNT), |
||||
dm_testdrv_op_count[DM_TEST_OP_UNBIND]); |
||||
|
||||
return 0; |
||||
} |
||||
DM_TEST(dm_test_children, 0); |
||||
@ -0,0 +1,7 @@ |
||||
#!/bin/sh |
||||
|
||||
NUM_CPUS=$(cat /proc/cpuinfo |grep -c processor) |
||||
dtc -I dts -O dtb test/dm/test.dts -o test/dm/test.dtb |
||||
make O=sandbox sandbox_config |
||||
make O=sandbox -s -j${NUM_CPUS} |
||||
./sandbox/u-boot -d test/dm/test.dtb -c "dm test" |
||||
@ -0,0 +1,146 @@ |
||||
/*
|
||||
* Copyright (c) 2013 Google, Inc |
||||
* |
||||
* (C) Copyright 2012 |
||||
* Pavel Herrmann <morpheus.ibis@gmail.com> |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
|
||||
#include <common.h> |
||||
#include <dm.h> |
||||
#include <errno.h> |
||||
#include <malloc.h> |
||||
#include <dm/test.h> |
||||
#include <dm/ut.h> |
||||
#include <asm/io.h> |
||||
|
||||
int dm_testdrv_op_count[DM_TEST_OP_COUNT]; |
||||
static struct dm_test_state *dms = &global_test_state; |
||||
|
||||
static int testdrv_ping(struct device *dev, int pingval, int *pingret) |
||||
{ |
||||
const struct dm_test_pdata *pdata = dev_get_platdata(dev); |
||||
struct dm_test_priv *priv = dev_get_priv(dev); |
||||
|
||||
*pingret = pingval + pdata->ping_add; |
||||
priv->ping_total += *pingret; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static const struct test_ops test_ops = { |
||||
.ping = testdrv_ping, |
||||
}; |
||||
|
||||
static int test_bind(struct device *dev) |
||||
{ |
||||
/* Private data should not be allocated */ |
||||
ut_assert(!dev_get_priv(dev)); |
||||
|
||||
dm_testdrv_op_count[DM_TEST_OP_BIND]++; |
||||
return 0; |
||||
} |
||||
|
||||
static int test_probe(struct device *dev) |
||||
{ |
||||
struct dm_test_priv *priv = dev_get_priv(dev); |
||||
|
||||
/* Private data should be allocated */ |
||||
ut_assert(priv); |
||||
|
||||
dm_testdrv_op_count[DM_TEST_OP_PROBE]++; |
||||
priv->ping_total += DM_TEST_START_TOTAL; |
||||
return 0; |
||||
} |
||||
|
||||
static int test_remove(struct device *dev) |
||||
{ |
||||
/* Private data should still be allocated */ |
||||
ut_assert(dev_get_priv(dev)); |
||||
|
||||
dm_testdrv_op_count[DM_TEST_OP_REMOVE]++; |
||||
return 0; |
||||
} |
||||
|
||||
static int test_unbind(struct device *dev) |
||||
{ |
||||
/* Private data should not be allocated */ |
||||
ut_assert(!dev->priv); |
||||
|
||||
dm_testdrv_op_count[DM_TEST_OP_UNBIND]++; |
||||
return 0; |
||||
} |
||||
|
||||
U_BOOT_DRIVER(test_drv) = { |
||||
.name = "test_drv", |
||||
.id = UCLASS_TEST, |
||||
.ops = &test_ops, |
||||
.bind = test_bind, |
||||
.probe = test_probe, |
||||
.remove = test_remove, |
||||
.unbind = test_unbind, |
||||
.priv_auto_alloc_size = sizeof(struct dm_test_priv), |
||||
}; |
||||
|
||||
U_BOOT_DRIVER(test2_drv) = { |
||||
.name = "test2_drv", |
||||
.id = UCLASS_TEST, |
||||
.ops = &test_ops, |
||||
.bind = test_bind, |
||||
.probe = test_probe, |
||||
.remove = test_remove, |
||||
.unbind = test_unbind, |
||||
.priv_auto_alloc_size = sizeof(struct dm_test_priv), |
||||
}; |
||||
|
||||
static int test_manual_drv_ping(struct device *dev, int pingval, int *pingret) |
||||
{ |
||||
*pingret = pingval + 2; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static const struct test_ops test_manual_ops = { |
||||
.ping = test_manual_drv_ping, |
||||
}; |
||||
|
||||
static int test_manual_bind(struct device *dev) |
||||
{ |
||||
dm_testdrv_op_count[DM_TEST_OP_BIND]++; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int test_manual_probe(struct device *dev) |
||||
{ |
||||
dm_testdrv_op_count[DM_TEST_OP_PROBE]++; |
||||
if (!dms->force_fail_alloc) |
||||
dev->priv = calloc(1, sizeof(struct dm_test_priv)); |
||||
if (!dev->priv) |
||||
return -ENOMEM; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int test_manual_remove(struct device *dev) |
||||
{ |
||||
dm_testdrv_op_count[DM_TEST_OP_REMOVE]++; |
||||
return 0; |
||||
} |
||||
|
||||
static int test_manual_unbind(struct device *dev) |
||||
{ |
||||
dm_testdrv_op_count[DM_TEST_OP_UNBIND]++; |
||||
return 0; |
||||
} |
||||
|
||||
U_BOOT_DRIVER(test_manual_drv) = { |
||||
.name = "test_manual_drv", |
||||
.id = UCLASS_TEST, |
||||
.ops = &test_manual_ops, |
||||
.bind = test_manual_bind, |
||||
.probe = test_manual_probe, |
||||
.remove = test_manual_remove, |
||||
.unbind = test_manual_unbind, |
||||
}; |
||||
@ -0,0 +1,144 @@ |
||||
/*
|
||||
* Copyright (c) 2013 Google, Inc |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
|
||||
#include <common.h> |
||||
#include <dm.h> |
||||
#include <errno.h> |
||||
#include <fdtdec.h> |
||||
#include <malloc.h> |
||||
#include <asm/io.h> |
||||
#include <dm/test.h> |
||||
#include <dm/root.h> |
||||
#include <dm/ut.h> |
||||
#include <dm/uclass-internal.h> |
||||
#include <dm/util.h> |
||||
|
||||
DECLARE_GLOBAL_DATA_PTR; |
||||
|
||||
static int testfdt_drv_ping(struct device *dev, int pingval, int *pingret) |
||||
{ |
||||
const struct dm_test_pdata *pdata = dev->platdata; |
||||
struct dm_test_priv *priv = dev_get_priv(dev); |
||||
|
||||
*pingret = pingval + pdata->ping_add; |
||||
priv->ping_total += *pingret; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static const struct test_ops test_ops = { |
||||
.ping = testfdt_drv_ping, |
||||
}; |
||||
|
||||
static int testfdt_ofdata_to_platdata(struct device *dev) |
||||
{ |
||||
struct dm_test_pdata *pdata = dev_get_platdata(dev); |
||||
|
||||
pdata->ping_add = fdtdec_get_int(gd->fdt_blob, dev->of_offset, |
||||
"ping-add", -1); |
||||
pdata->base = fdtdec_get_addr(gd->fdt_blob, dev->of_offset, "reg"); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int testfdt_drv_probe(struct device *dev) |
||||
{ |
||||
struct dm_test_priv *priv = dev_get_priv(dev); |
||||
|
||||
priv->ping_total += DM_TEST_START_TOTAL; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static const struct device_id testfdt_ids[] = { |
||||
{ |
||||
.compatible = "denx,u-boot-fdt-test", |
||||
.data = DM_TEST_TYPE_FIRST }, |
||||
{ |
||||
.compatible = "google,another-fdt-test", |
||||
.data = DM_TEST_TYPE_SECOND }, |
||||
{ } |
||||
}; |
||||
|
||||
U_BOOT_DRIVER(testfdt_drv) = { |
||||
.name = "testfdt_drv", |
||||
.of_match = testfdt_ids, |
||||
.id = UCLASS_TEST_FDT, |
||||
.ofdata_to_platdata = testfdt_ofdata_to_platdata, |
||||
.probe = testfdt_drv_probe, |
||||
.ops = &test_ops, |
||||
.priv_auto_alloc_size = sizeof(struct dm_test_priv), |
||||
.platdata_auto_alloc_size = sizeof(struct dm_test_pdata), |
||||
}; |
||||
|
||||
/* From here is the testfdt uclass code */ |
||||
int testfdt_ping(struct device *dev, int pingval, int *pingret) |
||||
{ |
||||
const struct test_ops *ops = device_get_ops(dev); |
||||
|
||||
if (!ops->ping) |
||||
return -ENOSYS; |
||||
|
||||
return ops->ping(dev, pingval, pingret); |
||||
} |
||||
|
||||
UCLASS_DRIVER(testfdt) = { |
||||
.name = "testfdt", |
||||
.id = UCLASS_TEST_FDT, |
||||
}; |
||||
|
||||
/* Test that FDT-based binding works correctly */ |
||||
static int dm_test_fdt(struct dm_test_state *dms) |
||||
{ |
||||
const int num_drivers = 3; |
||||
struct device *dev; |
||||
struct uclass *uc; |
||||
int ret; |
||||
int i; |
||||
|
||||
ret = dm_scan_fdt(gd->fdt_blob); |
||||
ut_assert(!ret); |
||||
|
||||
ret = uclass_get(UCLASS_TEST_FDT, &uc); |
||||
ut_assert(!ret); |
||||
|
||||
/* These are num_drivers compatible root-level device tree nodes */ |
||||
ut_asserteq(num_drivers, list_count_items(&uc->dev_head)); |
||||
|
||||
/* Each should have no platdata / priv */ |
||||
for (i = 0; i < num_drivers; i++) { |
||||
ret = uclass_find_device(UCLASS_TEST_FDT, i, &dev); |
||||
ut_assert(!ret); |
||||
ut_assert(!dev_get_priv(dev)); |
||||
ut_assert(!dev->platdata); |
||||
} |
||||
|
||||
/*
|
||||
* Now check that the ping adds are what we expect. This is using the |
||||
* ping-add property in each node. |
||||
*/ |
||||
for (i = 0; i < num_drivers; i++) { |
||||
uint32_t base; |
||||
|
||||
ret = uclass_get_device(UCLASS_TEST_FDT, i, &dev); |
||||
ut_assert(!ret); |
||||
|
||||
/*
|
||||
* Get the 'reg' property, which tells us what the ping add |
||||
* should be. We don't use the platdata because we want |
||||
* to test the code that sets that up (testfdt_drv_probe()). |
||||
*/ |
||||
base = fdtdec_get_addr(gd->fdt_blob, dev->of_offset, "reg"); |
||||
debug("dev=%d, base=%d: %s\n", i, base, |
||||
fdt_get_name(gd->fdt_blob, dev->of_offset, NULL)); |
||||
|
||||
ut_assert(!dm_check_operations(dms, dev, base, |
||||
dev_get_priv(dev))); |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
DM_TEST(dm_test_fdt, 0); |
||||
@ -0,0 +1,107 @@ |
||||
/*
|
||||
* Copyright (c) 2013 Google, Inc |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
|
||||
#include <common.h> |
||||
#include <dm.h> |
||||
#include <errno.h> |
||||
#include <dm/test.h> |
||||
#include <dm/root.h> |
||||
#include <dm/uclass-internal.h> |
||||
#include <dm/ut.h> |
||||
|
||||
DECLARE_GLOBAL_DATA_PTR; |
||||
|
||||
struct dm_test_state global_test_state; |
||||
|
||||
/* Get ready for testing */ |
||||
static int dm_test_init(struct dm_test_state *dms) |
||||
{ |
||||
memset(dms, '\0', sizeof(*dms)); |
||||
gd->dm_root = NULL; |
||||
memset(dm_testdrv_op_count, '\0', sizeof(dm_testdrv_op_count)); |
||||
|
||||
ut_assertok(dm_init()); |
||||
dms->root = dm_root(); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
/* Ensure all the test devices are probed */ |
||||
static int do_autoprobe(struct dm_test_state *dms) |
||||
{ |
||||
struct device *dev; |
||||
int ret; |
||||
|
||||
/* Scanning the uclass is enough to probe all the devices */ |
||||
for (ret = uclass_first_device(UCLASS_TEST, &dev); |
||||
dev; |
||||
ret = uclass_next_device(&dev)) |
||||
; |
||||
|
||||
return ret; |
||||
} |
||||
|
||||
static int dm_test_destroy(struct dm_test_state *dms) |
||||
{ |
||||
int id; |
||||
|
||||
for (id = 0; id < UCLASS_COUNT; id++) { |
||||
struct uclass *uc; |
||||
|
||||
/*
|
||||
* If the uclass doesn't exist we don't want to create it. So |
||||
* check that here before we call uclass_find_device()/ |
||||
*/ |
||||
uc = uclass_find(id); |
||||
if (!uc) |
||||
continue; |
||||
ut_assertok(uclass_destroy(uc)); |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int dm_test_main(void) |
||||
{ |
||||
struct dm_test *tests = ll_entry_start(struct dm_test, dm_test); |
||||
const int n_ents = ll_entry_count(struct dm_test, dm_test); |
||||
struct dm_test_state *dms = &global_test_state; |
||||
struct dm_test *test; |
||||
|
||||
/*
|
||||
* If we have no device tree, or it only has a root node, then these |
||||
* tests clearly aren't going to work... |
||||
*/ |
||||
if (!gd->fdt_blob || fdt_next_node(gd->fdt_blob, 0, NULL) < 0) { |
||||
puts("Please run with test device tree:\n" |
||||
" dtc -I dts -O dtb test/dm/test.dts -o test/dm/test.dtb\n" |
||||
" ./u-boot -d test/dm/test.dtb\n"); |
||||
ut_assert(gd->fdt_blob); |
||||
} |
||||
|
||||
printf("Running %d driver model tests\n", n_ents); |
||||
|
||||
for (test = tests; test < tests + n_ents; test++) { |
||||
printf("Test: %s\n", test->name); |
||||
ut_assertok(dm_test_init(dms)); |
||||
|
||||
if (test->flags & DM_TESTF_SCAN_PDATA) |
||||
ut_assertok(dm_scan_platdata()); |
||||
if (test->flags & DM_TESTF_PROBE_TEST) |
||||
ut_assertok(do_autoprobe(dms)); |
||||
if (test->flags & DM_TESTF_SCAN_FDT) |
||||
ut_assertok(dm_scan_fdt(gd->fdt_blob)); |
||||
|
||||
if (test->func(dms)) |
||||
break; |
||||
|
||||
ut_assertok(dm_test_destroy(dms)); |
||||
} |
||||
|
||||
printf("Failures: %d\n", dms->fail_count); |
||||
|
||||
return 0; |
||||
} |
||||
@ -0,0 +1,104 @@ |
||||
/*
|
||||
* Copyright (c) 2013 Google, Inc |
||||
* |
||||
* (C) Copyright 2012 |
||||
* Pavel Herrmann <morpheus.ibis@gmail.com> |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
|
||||
#include <common.h> |
||||
#include <malloc.h> |
||||
#include <dm.h> |
||||
#include <errno.h> |
||||
#include <dm/test.h> |
||||
#include <dm/ut.h> |
||||
#include <asm/io.h> |
||||
#include <linux/list.h> |
||||
|
||||
static struct dm_test_state *dms = &global_test_state; |
||||
|
||||
int test_ping(struct device *dev, int pingval, int *pingret) |
||||
{ |
||||
const struct test_ops *ops = device_get_ops(dev); |
||||
|
||||
if (!ops->ping) |
||||
return -ENOSYS; |
||||
|
||||
return ops->ping(dev, pingval, pingret); |
||||
} |
||||
|
||||
static int test_post_bind(struct device *dev) |
||||
{ |
||||
dm_testdrv_op_count[DM_TEST_OP_POST_BIND]++; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int test_pre_unbind(struct device *dev) |
||||
{ |
||||
dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]++; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int test_post_probe(struct device *dev) |
||||
{ |
||||
struct device *prev = list_entry(dev->uclass_node.prev, struct device, |
||||
uclass_node); |
||||
struct dm_test_uclass_perdev_priv *priv = dev->uclass_priv; |
||||
struct uclass *uc = dev->uclass; |
||||
|
||||
dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]++; |
||||
ut_assert(priv); |
||||
ut_assert(device_active(dev)); |
||||
priv->base_add = 0; |
||||
if (dms->skip_post_probe) |
||||
return 0; |
||||
if (&prev->uclass_node != &uc->dev_head) { |
||||
struct dm_test_uclass_perdev_priv *prev_uc_priv |
||||
= prev->uclass_priv; |
||||
struct dm_test_pdata *pdata = prev->platdata; |
||||
|
||||
ut_assert(pdata); |
||||
ut_assert(prev_uc_priv); |
||||
priv->base_add = prev_uc_priv->base_add + pdata->ping_add; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int test_pre_remove(struct device *dev) |
||||
{ |
||||
dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]++; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int test_init(struct uclass *uc) |
||||
{ |
||||
dm_testdrv_op_count[DM_TEST_OP_INIT]++; |
||||
ut_assert(uc->priv); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int test_destroy(struct uclass *uc) |
||||
{ |
||||
dm_testdrv_op_count[DM_TEST_OP_DESTROY]++; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
UCLASS_DRIVER(test) = { |
||||
.name = "test", |
||||
.id = UCLASS_TEST, |
||||
.post_bind = test_post_bind, |
||||
.pre_unbind = test_pre_unbind, |
||||
.post_probe = test_post_probe, |
||||
.pre_remove = test_pre_remove, |
||||
.init = test_init, |
||||
.destroy = test_destroy, |
||||
.priv_auto_alloc_size = sizeof(struct dm_test_uclass_priv), |
||||
.per_device_auto_alloc_size = sizeof(struct dm_test_uclass_perdev_priv), |
||||
}; |
||||
@ -0,0 +1,59 @@ |
||||
/dts-v1/; |
||||
|
||||
/ { |
||||
model = "sandbox"; |
||||
compatible = "sandbox"; |
||||
#address-cells = <1>; |
||||
#size-cells = <0>; |
||||
|
||||
a-test { |
||||
reg = <0>; |
||||
compatible = "denx,u-boot-fdt-test"; |
||||
ping-add = <0>; |
||||
}; |
||||
|
||||
junk { |
||||
reg = <1>; |
||||
compatible = "not,compatible"; |
||||
}; |
||||
|
||||
no-compatible { |
||||
reg = <2>; |
||||
}; |
||||
|
||||
b-test { |
||||
reg = <3>; |
||||
compatible = "denx,u-boot-fdt-test"; |
||||
ping-add = <3>; |
||||
}; |
||||
|
||||
some-bus { |
||||
#address-cells = <1>; |
||||
#size-cells = <0>; |
||||
reg = <4>; |
||||
ping-add = <4>; |
||||
c-test { |
||||
compatible = "denx,u-boot-fdt-test"; |
||||
reg = <5>; |
||||
ping-add = <5>; |
||||
}; |
||||
}; |
||||
|
||||
d-test { |
||||
reg = <6>; |
||||
ping-add = <6>; |
||||
compatible = "google,another-fdt-test"; |
||||
}; |
||||
|
||||
base-gpios { |
||||
compatible = "sandbox,gpio"; |
||||
gpio-bank-name = "a"; |
||||
num-gpios = <20>; |
||||
}; |
||||
|
||||
extra-gpios { |
||||
compatible = "sandbox,gpio"; |
||||
gpio-bank-name = "b"; |
||||
num-gpios = <10>; |
||||
}; |
||||
}; |
||||
@ -0,0 +1,33 @@ |
||||
/*
|
||||
* Simple unit test library for driver model |
||||
* |
||||
* Copyright (c) 2013 Google, Inc |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
|
||||
#include <common.h> |
||||
#include <dm/test.h> |
||||
#include <dm/ut.h> |
||||
|
||||
struct dm_test_state; |
||||
|
||||
void ut_fail(struct dm_test_state *dms, const char *fname, int line, |
||||
const char *func, const char *cond) |
||||
{ |
||||
printf("%s:%d, %s(): %s\n", fname, line, func, cond); |
||||
dms->fail_count++; |
||||
} |
||||
|
||||
void ut_failf(struct dm_test_state *dms, const char *fname, int line, |
||||
const char *func, const char *cond, const char *fmt, ...) |
||||
{ |
||||
va_list args; |
||||
|
||||
printf("%s:%d, %s(): %s: ", fname, line, func, cond); |
||||
va_start(args, fmt); |
||||
vprintf(fmt, args); |
||||
va_end(args); |
||||
putc('\n'); |
||||
dms->fail_count++; |
||||
} |
||||
Loading…
Reference in new issue