mirrors/u-boot
0
0
Fork 0
mirror of https://github.com/u-boot/u-boot.git synced 2024-11-24 04:34:22 +08:00
Code Issues Packages Projects Releases Wiki Activity

dm: Rename DM test flags to make them more generic

Browse Source 
The test flags used by driver model are currently not available to other
tests. Rather than creating two sets of flags, make these flags generic
by changing the DM_ prefix to UT_ and moving them to the test.h header.

This will allow adding other test flags without confusion.

Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Simon Glass 2020-07-28 19:41:12 -06:00 committed by Tom Rini
parent bd34715599
commit e180c2b129
77 changed files with 301 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
doc/README.commands
View File

@ -183,4 +183,4 @@ static int dm_test_acpi_cmd_items(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_cmd_items, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_cmd_items, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

9
include/dm/test.h
View File

@ -144,15 +144,6 @@ struct dm_test_state {
struct udevice *removed;
};
/* 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 */
DM_TESTF_FLAT_TREE = 1 << 3, /* test needs flat DT */
DM_TESTF_LIVE_TREE = 1 << 4, /* needs live device tree */
};
/* Declare a new driver model test */
#define DM_TEST(_name, _flags) UNIT_TEST(_name, _flags, dm_test)

10
include/test/test.h
View File

@ -7,6 +7,7 @@
#define __TEST_TEST_H
#include <malloc.h>
#include <linux/bitops.h>
/*
* struct unit_test_state - Entire state of test system
@ -27,6 +28,15 @@ struct unit_test_state {
char actual_str[256];
};
/* Test flags for each test */
enum {
UT_TESTF_SCAN_PDATA = BIT(0), /* test needs platform data */
UT_TESTF_PROBE_TEST = BIT(1), /* probe test uclass */
UT_TESTF_SCAN_FDT = BIT(2), /* scan device tree */
UT_TESTF_FLAT_TREE = BIT(3), /* test needs flat DT */
UT_TESTF_LIVE_TREE = BIT(4), /* needs live device tree */
};
/**
* struct unit_test - Information about a unit test
*

28
test/dm/acpi.c
View File

@ -171,7 +171,7 @@ static int dm_test_acpi_get_name(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_get_name, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_get_name, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test acpi_get_table_revision() */
static int dm_test_acpi_get_table_revision(struct unit_test_state *uts)
@ -184,7 +184,7 @@ static int dm_test_acpi_get_table_revision(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_get_table_revision,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test acpi_create_dmar() */
static int dm_test_acpi_create_dmar(struct unit_test_state *uts)
@ -200,7 +200,7 @@ static int dm_test_acpi_create_dmar(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_create_dmar, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_create_dmar, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test acpi_fill_header() */
static int dm_test_acpi_fill_header(struct unit_test_state *uts)
@ -227,7 +227,7 @@ static int dm_test_acpi_fill_header(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_fill_header, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_fill_header, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test ACPI write_tables() */
static int dm_test_acpi_write_tables(struct unit_test_state *uts)
@ -268,7 +268,7 @@ static int dm_test_acpi_write_tables(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_write_tables, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_write_tables, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test basic ACPI functions */
static int dm_test_acpi_basic(struct unit_test_state *uts)
@ -296,7 +296,7 @@ static int dm_test_acpi_basic(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_basic, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_basic, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test acpi_setup_base_tables */
static int dm_test_acpi_setup_base_tables(struct unit_test_state *uts)
@ -344,7 +344,7 @@ static int dm_test_acpi_setup_base_tables(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_setup_base_tables,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test 'acpi list' command */
static int dm_test_acpi_cmd_list(struct unit_test_state *uts)
@ -386,7 +386,7 @@ static int dm_test_acpi_cmd_list(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_cmd_list, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_cmd_list, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test 'acpi dump' command */
static int dm_test_acpi_cmd_dump(struct unit_test_state *uts)
@ -417,7 +417,7 @@ static int dm_test_acpi_cmd_dump(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_cmd_dump, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_cmd_dump, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test acpi_device_path() */
static int dm_test_acpi_device_path(struct unit_test_state *uts)
@ -454,7 +454,7 @@ static int dm_test_acpi_device_path(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_device_path, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_device_path, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test acpi_device_status() */
static int dm_test_acpi_device_status(struct unit_test_state *uts)
@ -466,7 +466,7 @@ static int dm_test_acpi_device_status(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_device_status, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_device_status, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test acpi_fill_ssdt() */
static int dm_test_acpi_fill_ssdt(struct unit_test_state *uts)
@ -496,7 +496,7 @@ static int dm_test_acpi_fill_ssdt(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_fill_ssdt, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_fill_ssdt, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test acpi_inject_dsdt() */
static int dm_test_acpi_inject_dsdt(struct unit_test_state *uts)
@ -526,7 +526,7 @@ static int dm_test_acpi_inject_dsdt(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_inject_dsdt, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_inject_dsdt, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test 'acpi items' command */
static int dm_test_acpi_cmd_items(struct unit_test_state *uts)
@ -565,4 +565,4 @@ static int dm_test_acpi_cmd_items(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_cmd_items, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_cmd_items, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/acpi_dp.c
View File

@ -489,4 +489,4 @@ static int dm_test_acpi_dp_copy(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_dp_copy, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_dp_copy, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

18
test/dm/acpigen.c
View File

@ -167,7 +167,7 @@ static int dm_test_acpi_interrupt(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_interrupt, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_interrupt, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test emitting a GPIO descriptor */
static int dm_test_acpi_gpio(struct unit_test_state *uts)
@ -212,7 +212,7 @@ static int dm_test_acpi_gpio(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_gpio, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_gpio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test emitting a GPIO descriptor with an interrupt */
static int dm_test_acpi_gpio_irq(struct unit_test_state *uts)
@ -257,7 +257,7 @@ static int dm_test_acpi_gpio_irq(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_gpio_irq, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_gpio_irq, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test emitting either a GPIO or interrupt descriptor */
static int dm_test_acpi_interrupt_or_gpio(struct unit_test_state *uts)
@ -297,7 +297,7 @@ static int dm_test_acpi_interrupt_or_gpio(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_interrupt_or_gpio,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test emitting an I2C descriptor */
static int dm_test_acpi_i2c(struct unit_test_state *uts)
@ -329,7 +329,7 @@ static int dm_test_acpi_i2c(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_i2c, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_i2c, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test emitting a SPI descriptor */
static int dm_test_acpi_spi(struct unit_test_state *uts)
@ -365,7 +365,7 @@ static int dm_test_acpi_spi(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_spi, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_spi, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test emitting a length */
static int dm_test_acpi_len(struct unit_test_state *uts)
@ -806,7 +806,7 @@ static int dm_test_acpi_gpio_toggle(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_gpio_toggle, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_gpio_toggle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test writing ACPI code to output power-sequence info */
static int dm_test_acpi_power_seq(struct unit_test_state *uts)
@ -873,7 +873,7 @@ static int dm_test_acpi_power_seq(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_power_seq, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_power_seq, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test writing values */
static int dm_test_acpi_write_values(struct unit_test_state *uts)
@ -947,7 +947,7 @@ static int dm_test_acpi_scope(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_scope, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_scope, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test writing a resource template */
static int dm_test_acpi_resource_template(struct unit_test_state *uts)

16
test/dm/adc.c
View File

@ -33,7 +33,7 @@ static int dm_test_adc_bind(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_bind, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_bind, UT_TESTF_SCAN_FDT);
static int dm_test_adc_wrong_channel_selection(struct unit_test_state *uts)
{
@ -44,7 +44,7 @@ static int dm_test_adc_wrong_channel_selection(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_wrong_channel_selection, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_wrong_channel_selection, UT_TESTF_SCAN_FDT);
static int dm_test_adc_supply(struct unit_test_state *uts)
{
@ -80,7 +80,7 @@ static int dm_test_adc_supply(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_supply, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_supply, UT_TESTF_SCAN_FDT);
struct adc_channel adc_channel_test_data[] = {
{ 0, SANDBOX_ADC_CHANNEL0_DATA },
@ -105,7 +105,7 @@ static int dm_test_adc_single_channel_conversion(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_single_channel_conversion, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_single_channel_conversion, UT_TESTF_SCAN_FDT);
static int dm_test_adc_multi_channel_conversion(struct unit_test_state *uts)
{
@ -128,7 +128,7 @@ static int dm_test_adc_multi_channel_conversion(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_multi_channel_conversion, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_multi_channel_conversion, UT_TESTF_SCAN_FDT);
static int dm_test_adc_single_channel_shot(struct unit_test_state *uts)
{
@ -144,7 +144,7 @@ static int dm_test_adc_single_channel_shot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_single_channel_shot, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_single_channel_shot, UT_TESTF_SCAN_FDT);
static int dm_test_adc_multi_channel_shot(struct unit_test_state *uts)
{
@ -164,7 +164,7 @@ static int dm_test_adc_multi_channel_shot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_multi_channel_shot, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_multi_channel_shot, UT_TESTF_SCAN_FDT);
static const int dm_test_adc_uV_data[SANDBOX_ADC_CHANNELS] = {
((u64)SANDBOX_ADC_CHANNEL0_DATA * SANDBOX_BUCK2_INITIAL_EXPECTED_UV) /
@ -195,4 +195,4 @@ static int dm_test_adc_raw_to_uV(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_raw_to_uV, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_raw_to_uV, UT_TESTF_SCAN_FDT);

2
test/dm/audio.c
View File

@ -32,4 +32,4 @@ static int dm_test_audio(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_audio, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_audio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

6
test/dm/axi.c
View File

@ -23,7 +23,7 @@ static int dm_test_axi_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_axi_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_axi_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that sandbox PCI bus numbering works correctly */
static int dm_test_axi_busnum(struct unit_test_state *uts)
@ -35,7 +35,7 @@ static int dm_test_axi_busnum(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_axi_busnum, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_axi_busnum, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that we can use the store device correctly */
static int dm_test_axi_store(struct unit_test_state *uts)
@ -76,4 +76,4 @@ static int dm_test_axi_store(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_axi_store, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_axi_store, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

10
test/dm/blk.c
View File

@ -43,7 +43,7 @@ static int dm_test_blk_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_blk_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_blk_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int count_blk_devices(void)
{
@ -89,7 +89,7 @@ static int dm_test_blk_usb(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_blk_usb, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_blk_usb, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that we can find block devices without probing them */
static int dm_test_blk_find(struct unit_test_state *uts)
@ -110,7 +110,7 @@ static int dm_test_blk_find(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_blk_find, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_blk_find, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that block device numbering works as expected */
static int dm_test_blk_devnum(struct unit_test_state *uts)
@ -145,7 +145,7 @@ static int dm_test_blk_devnum(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_blk_devnum, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_blk_devnum, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that we can get a block from its parent */
static int dm_test_blk_get_from_parent(struct unit_test_state *uts)
@ -163,4 +163,4 @@ static int dm_test_blk_get_from_parent(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_blk_get_from_parent, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_blk_get_from_parent, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/board.c
View File

@ -56,4 +56,4 @@ static int dm_test_board(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_board, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_board, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/bootcount.c
View File

@ -28,5 +28,5 @@ static int dm_test_bootcount(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bootcount, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_bootcount, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

26
test/dm/bus.c
View File

@ -138,7 +138,7 @@ static int dm_test_bus_children(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_children, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_bus_children, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test our functions for accessing children */
static int dm_test_bus_children_funcs(struct unit_test_state *uts)
@ -177,7 +177,7 @@ static int dm_test_bus_children_funcs(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_children_funcs, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_bus_children_funcs, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_bus_children_of_offset(struct unit_test_state *uts)
{
@ -201,7 +201,7 @@ static int dm_test_bus_children_of_offset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_children_of_offset,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
/* Test that we can iterate through children */
static int dm_test_bus_children_iterators(struct unit_test_state *uts)
@ -232,7 +232,7 @@ static int dm_test_bus_children_iterators(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_children_iterators,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that the bus can store data about each child */
static int test_bus_parent_data(struct unit_test_state *uts)
@ -299,7 +299,7 @@ static int dm_test_bus_parent_data(struct unit_test_state *uts)
{
return test_bus_parent_data(uts);
}
DM_TEST(dm_test_bus_parent_data, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_bus_parent_data, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* As above but the size is controlled by the uclass */
static int dm_test_bus_parent_data_uclass(struct unit_test_state *uts)
@ -329,7 +329,7 @@ static int dm_test_bus_parent_data_uclass(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_parent_data_uclass,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that the bus ops are called when a child is probed/removed */
static int dm_test_bus_parent_ops(struct unit_test_state *uts)
@ -368,7 +368,7 @@ static int dm_test_bus_parent_ops(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_parent_ops, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_bus_parent_ops, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int test_bus_parent_platdata(struct unit_test_state *uts)
{
@ -443,7 +443,7 @@ static int dm_test_bus_parent_platdata(struct unit_test_state *uts)
{
return test_bus_parent_platdata(uts);
}
DM_TEST(dm_test_bus_parent_platdata, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_bus_parent_platdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* As above but the size is controlled by the uclass */
static int dm_test_bus_parent_platdata_uclass(struct unit_test_state *uts)
@ -472,7 +472,7 @@ static int dm_test_bus_parent_platdata_uclass(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_parent_platdata_uclass,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that the child post_bind method is called */
static int dm_test_bus_child_post_bind(struct unit_test_state *uts)
@ -493,7 +493,7 @@ static int dm_test_bus_child_post_bind(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_child_post_bind, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_bus_child_post_bind, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that the child post_bind method is called */
static int dm_test_bus_child_post_bind_uclass(struct unit_test_state *uts)
@ -515,7 +515,7 @@ static int dm_test_bus_child_post_bind_uclass(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_child_post_bind_uclass,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/*
* Test that the bus' uclass' child_pre_probe() is called before the
@ -549,7 +549,7 @@ static int dm_test_bus_child_pre_probe_uclass(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_child_pre_probe_uclass,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/*
* Test that the bus' uclass' child_post_probe() is called after the
@ -582,4 +582,4 @@ static int dm_test_bus_child_post_probe_uclass(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_child_post_probe_uclass,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

6
test/dm/button.c
View File

@ -25,7 +25,7 @@ static int dm_test_button_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_button_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_button_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test of the button uclass using the button_gpio driver */
static int dm_test_button_gpio(struct unit_test_state *uts)
@ -50,7 +50,7 @@ static int dm_test_button_gpio(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_button_gpio, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_button_gpio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test obtaining an BUTTON by label */
static int dm_test_button_label(struct unit_test_state *uts)
@ -71,4 +71,4 @@ static int dm_test_button_label(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_button_label, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_button_label, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/cache.c
View File

@ -19,4 +19,4 @@ static int dm_test_reset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_reset, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_reset, UT_TESTF_SCAN_FDT);

6
test/dm/clk.c
View File

@ -34,7 +34,7 @@ static int dm_test_clk_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_clk_base, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_clk_base, UT_TESTF_SCAN_FDT);
static int dm_test_clk(struct unit_test_state *uts)
{
@ -161,7 +161,7 @@ static int dm_test_clk(struct unit_test_state *uts)
SANDBOX_CLK_ID_UART1));
return 0;
}
DM_TEST(dm_test_clk, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_clk, UT_TESTF_SCAN_FDT);
static int dm_test_clk_bulk(struct unit_test_state *uts)
{
@ -199,4 +199,4 @@ static int dm_test_clk_bulk(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_clk_bulk, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_clk_bulk, UT_TESTF_SCAN_FDT);

2
test/dm/clk_ccf.c
View File

@ -96,4 +96,4 @@ static int dm_test_clk_ccf(struct unit_test_state *uts)
return 1;
}
DM_TEST(dm_test_clk_ccf, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_clk_ccf, UT_TESTF_SCAN_FDT);

30
test/dm/core.c
View File

@ -167,7 +167,7 @@ static int dm_test_autobind_uclass_pdata_alloc(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_autobind_uclass_pdata_alloc, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_autobind_uclass_pdata_alloc, UT_TESTF_SCAN_PDATA);
/* Test that binding with uclass platdata setting occurs correctly */
static int dm_test_autobind_uclass_pdata_valid(struct unit_test_state *uts)
@ -193,7 +193,7 @@ static int dm_test_autobind_uclass_pdata_valid(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_autobind_uclass_pdata_valid, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_autobind_uclass_pdata_valid, UT_TESTF_SCAN_PDATA);
/* Test that autoprobe finds all the expected devices */
static int dm_test_autoprobe(struct unit_test_state *uts)
@ -261,7 +261,7 @@ static int dm_test_autoprobe(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_autoprobe, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_autoprobe, UT_TESTF_SCAN_PDATA);
/* Check that we see the correct platdata in each device */
static int dm_test_platdata(struct unit_test_state *uts)
@ -279,7 +279,7 @@ static int dm_test_platdata(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_platdata, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_platdata, UT_TESTF_SCAN_PDATA);
/* Test that we can bind, probe, remove, unbind a driver */
static int dm_test_lifecycle(struct unit_test_state *uts)
@ -335,7 +335,7 @@ static int dm_test_lifecycle(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_lifecycle, DM_TESTF_SCAN_PDATA | DM_TESTF_PROBE_TEST);
DM_TEST(dm_test_lifecycle, UT_TESTF_SCAN_PDATA | UT_TESTF_PROBE_TEST);
/* Test that we can bind/unbind and the lists update correctly */
static int dm_test_ordering(struct unit_test_state *uts)
@ -391,7 +391,7 @@ static int dm_test_ordering(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ordering, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_ordering, UT_TESTF_SCAN_PDATA);
/* Check that we can perform operations on a device (do a ping) */
int dm_check_operations(struct unit_test_state *uts, struct udevice *dev,
@ -449,7 +449,7 @@ static int dm_test_operations(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_operations, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_operations, UT_TESTF_SCAN_PDATA);
/* Remove all drivers and check that things work */
static int dm_test_remove(struct unit_test_state *uts)
@ -471,7 +471,7 @@ static int dm_test_remove(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_remove, DM_TESTF_SCAN_PDATA | DM_TESTF_PROBE_TEST);
DM_TEST(dm_test_remove, UT_TESTF_SCAN_PDATA | UT_TESTF_PROBE_TEST);
/* Remove and recreate everything, check for memory leaks */
static int dm_test_leak(struct unit_test_state *uts)
@ -756,7 +756,7 @@ static int dm_test_uclass_devices_find(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_uclass_devices_find, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_uclass_devices_find, UT_TESTF_SCAN_PDATA);
static int dm_test_uclass_devices_find_by_name(struct unit_test_state *uts)
{
@ -793,7 +793,7 @@ static int dm_test_uclass_devices_find_by_name(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_uclass_devices_find_by_name, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_uclass_devices_find_by_name, UT_TESTF_SCAN_FDT);
static int dm_test_uclass_devices_get(struct unit_test_state *uts)
{
@ -810,7 +810,7 @@ static int dm_test_uclass_devices_get(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_uclass_devices_get, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_uclass_devices_get, UT_TESTF_SCAN_PDATA);
static int dm_test_uclass_devices_get_by_name(struct unit_test_state *uts)
{
@ -854,7 +854,7 @@ static int dm_test_uclass_devices_get_by_name(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_uclass_devices_get_by_name, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_uclass_devices_get_by_name, UT_TESTF_SCAN_FDT);
static int dm_test_device_get_uclass_id(struct unit_test_state *uts)
{
@ -865,7 +865,7 @@ static int dm_test_device_get_uclass_id(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_device_get_uclass_id, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_device_get_uclass_id, UT_TESTF_SCAN_PDATA);
static int dm_test_uclass_names(struct unit_test_state *uts)
{
@ -874,7 +874,7 @@ static int dm_test_uclass_names(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_uclass_names, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_uclass_names, UT_TESTF_SCAN_PDATA);
static int dm_test_inactive_child(struct unit_test_state *uts)
{
@ -905,4 +905,4 @@ static int dm_test_inactive_child(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_inactive_child, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_inactive_child, UT_TESTF_SCAN_PDATA);

2
test/dm/cpu.c
View File

@ -47,4 +47,4 @@ static int dm_test_cpu(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_cpu, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_cpu, UT_TESTF_SCAN_FDT);

12
test/dm/devres.c
View File

@ -40,7 +40,7 @@ static int dm_test_devres_alloc(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_devres_alloc, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_devres_alloc, UT_TESTF_SCAN_PDATA);
/* Test devm_kfree() can be used to free memory too */
static int dm_test_devres_free(struct unit_test_state *uts)
@ -68,7 +68,7 @@ static int dm_test_devres_free(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_devres_free, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_devres_free, UT_TESTF_SCAN_PDATA);
/* Test that kzalloc() returns memory that is zeroed */
@ -88,7 +88,7 @@ static int dm_test_devres_kzalloc(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_devres_kzalloc, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_devres_kzalloc, UT_TESTF_SCAN_PDATA);
/* Test that devm_kmalloc_array() allocates an array that can be set */
static int dm_test_devres_kmalloc_array(struct unit_test_state *uts)
@ -111,7 +111,7 @@ static int dm_test_devres_kmalloc_array(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_devres_kmalloc_array, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_devres_kmalloc_array, UT_TESTF_SCAN_PDATA);
/* Test that devm_kcalloc() allocates a zeroed array */
static int dm_test_devres_kcalloc(struct unit_test_state *uts)
@ -140,7 +140,7 @@ static int dm_test_devres_kcalloc(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_devres_kcalloc, DM_TESTF_SCAN_PDATA);
DM_TEST(dm_test_devres_kcalloc, UT_TESTF_SCAN_PDATA);
/* Test devres releases resources automatically as expected */
static int dm_test_devres_phase(struct unit_test_state *uts)
@ -186,4 +186,4 @@ static int dm_test_devres_phase(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_devres_phase, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_devres_phase, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

6
test/dm/dma.c
View File

@ -35,7 +35,7 @@ static int dm_test_dma_m2m(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_dma_m2m, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_dma_m2m, UT_TESTF_SCAN_FDT);
static int dm_test_dma(struct unit_test_state *uts)
{
@ -77,7 +77,7 @@ static int dm_test_dma(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_dma, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_dma, UT_TESTF_SCAN_FDT);
static int dm_test_dma_rx(struct unit_test_state *uts)
{
@ -122,4 +122,4 @@ static int dm_test_dma_rx(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_dma_rx, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_dma_rx, UT_TESTF_SCAN_FDT);

2
test/dm/dsi_host.c
View File

@ -56,4 +56,4 @@ static int dm_test_dsi_host(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_dsi_host, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_dsi_host, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

16
test/dm/eth.c
View File

@ -40,7 +40,7 @@ static int dm_test_eth(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_eth, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_eth, UT_TESTF_SCAN_FDT);
static int dm_test_eth_alias(struct unit_test_state *uts)
{
@ -64,7 +64,7 @@ static int dm_test_eth_alias(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_eth_alias, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_eth_alias, UT_TESTF_SCAN_FDT);
static int dm_test_eth_prime(struct unit_test_state *uts)
{
@ -84,7 +84,7 @@ static int dm_test_eth_prime(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_eth_prime, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_eth_prime, UT_TESTF_SCAN_FDT);
/**
* This test case is trying to test the following scenario:
@ -145,7 +145,7 @@ static int dm_test_eth_act(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_eth_act, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_eth_act, UT_TESTF_SCAN_FDT);
/* The asserts include a return on fail; cleanup in the caller */
static int _dm_test_eth_rotate1(struct unit_test_state *uts)
@ -217,7 +217,7 @@ static int dm_test_eth_rotate(struct unit_test_state *uts)
return retval;
}
DM_TEST(dm_test_eth_rotate, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_eth_rotate, UT_TESTF_SCAN_FDT);
/* The asserts include a return on fail; cleanup in the caller */
static int _dm_test_net_retry(struct unit_test_state *uts)
@ -260,7 +260,7 @@ static int dm_test_net_retry(struct unit_test_state *uts)
return retval;
}
DM_TEST(dm_test_net_retry, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_net_retry, UT_TESTF_SCAN_FDT);
static int sb_check_arp_reply(struct udevice *dev, void *packet,
unsigned int len)
@ -345,7 +345,7 @@ static int dm_test_eth_async_arp_reply(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_eth_async_arp_reply, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_eth_async_arp_reply, UT_TESTF_SCAN_FDT);
static int sb_check_ping_reply(struct udevice *dev, void *packet,
unsigned int len)
@ -430,4 +430,4 @@ static int dm_test_eth_async_ping_reply(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_eth_async_ping_reply, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_eth_async_ping_reply, UT_TESTF_SCAN_FDT);

4
test/dm/fdtdec.c
View File

@ -58,7 +58,7 @@ static int dm_test_fdtdec_set_carveout(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fdtdec_set_carveout,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
static int dm_test_fdtdec_add_reserved_memory(struct unit_test_state *uts)
{
@ -127,4 +127,4 @@ static int dm_test_fdtdec_add_reserved_memory(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fdtdec_add_reserved_memory,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);

2
test/dm/firmware.c
View File

@ -20,4 +20,4 @@ static int dm_test_firmware_probe(struct unit_test_state *uts)
"sandbox-firmware", &dev));
return 0;
}
DM_TEST(dm_test_firmware_probe, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_firmware_probe, UT_TESTF_SCAN_FDT);

20
test/dm/gpio.c
View File

@ -145,7 +145,7 @@ static int dm_test_gpio(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that GPIO open-drain/open-source emulation works correctly */
static int dm_test_gpio_opendrain_opensource(struct unit_test_state *uts)
@ -234,7 +234,7 @@ static int dm_test_gpio_opendrain_opensource(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_opendrain_opensource,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that sandbox anonymous GPIOs work correctly */
static int dm_test_gpio_anon(struct unit_test_state *uts)
@ -256,7 +256,7 @@ static int dm_test_gpio_anon(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_anon, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_anon, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that gpio_requestf() works as expected */
static int dm_test_gpio_requestf(struct unit_test_state *uts)
@ -274,7 +274,7 @@ static int dm_test_gpio_requestf(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_requestf, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_requestf, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that gpio_request() copies its string */
static int dm_test_gpio_copy(struct unit_test_state *uts)
@ -296,7 +296,7 @@ static int dm_test_gpio_copy(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_copy, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_copy, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that we don't leak memory with GPIOs */
static int dm_test_gpio_leak(struct unit_test_state *uts)
@ -308,7 +308,7 @@ static int dm_test_gpio_leak(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_leak, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_leak, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that we can find GPIOs using phandles */
static int dm_test_gpio_phandles(struct unit_test_state *uts)
@ -382,7 +382,7 @@ static int dm_test_gpio_phandles(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_phandles, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_phandles, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Check the gpio pin configuration get from device tree information */
static int dm_test_gpio_get_dir_flags(struct unit_test_state *uts)
@ -418,7 +418,7 @@ static int dm_test_gpio_get_dir_flags(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_get_dir_flags, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_get_dir_flags, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test of gpio_get_acpi() */
static int dm_test_gpio_get_acpi(struct unit_test_state *uts)
@ -447,7 +447,7 @@ static int dm_test_gpio_get_acpi(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_get_acpi, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_get_acpi, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test of gpio_get_acpi() with an interrupt GPIO */
static int dm_test_gpio_get_acpi_irq(struct unit_test_state *uts)
@ -479,4 +479,4 @@ static int dm_test_gpio_get_acpi_irq(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_get_acpi_irq, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_get_acpi_irq, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/hwspinlock.c
View File

@ -38,4 +38,4 @@ static int dm_test_hwspinlock_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_hwspinlock_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_hwspinlock_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

16
test/dm/i2c.c
View File

@ -42,7 +42,7 @@ static int dm_test_i2c_find(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_find, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_find, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_i2c_read_write(struct unit_test_state *uts)
{
@ -59,7 +59,7 @@ static int dm_test_i2c_read_write(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_read_write, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_read_write, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_i2c_speed(struct unit_test_state *uts)
{
@ -81,7 +81,7 @@ static int dm_test_i2c_speed(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_speed, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_speed, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_i2c_offset_len(struct unit_test_state *uts)
{
@ -98,7 +98,7 @@ static int dm_test_i2c_offset_len(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_offset_len, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_offset_len, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_i2c_probe_empty(struct unit_test_state *uts)
{
@ -113,7 +113,7 @@ static int dm_test_i2c_probe_empty(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_probe_empty, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_probe_empty, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_i2c_bytewise(struct unit_test_state *uts)
{
@ -168,7 +168,7 @@ static int dm_test_i2c_bytewise(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_bytewise, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_bytewise, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_i2c_offset(struct unit_test_state *uts)
{
@ -241,7 +241,7 @@ static int dm_test_i2c_offset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_offset, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_offset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_i2c_addr_offset(struct unit_test_state *uts)
{
@ -306,4 +306,4 @@ static int dm_test_i2c_addr_offset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_addr_offset, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_addr_offset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/i2s.c
View File

@ -30,4 +30,4 @@ static int dm_test_i2s(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2s, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2s, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

10
test/dm/irq.c
View File

@ -31,7 +31,7 @@ static int dm_test_irq_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_irq_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_irq_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test of irq_first_device_type() */
static int dm_test_irq_type(struct unit_test_state *uts)
@ -43,7 +43,7 @@ static int dm_test_irq_type(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_irq_type, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_irq_type, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test of irq_read_and_clear() */
static int dm_test_read_and_clear(struct unit_test_state *uts)
@ -60,7 +60,7 @@ static int dm_test_read_and_clear(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_read_and_clear, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_read_and_clear, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test of irq_request() */
static int dm_test_request(struct unit_test_state *uts)
@ -75,7 +75,7 @@ static int dm_test_request(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_request, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_request, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test of irq_get_acpi() */
static int dm_test_irq_get_acpi(struct unit_test_state *uts)
@ -97,4 +97,4 @@ static int dm_test_irq_get_acpi(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_irq_get_acpi, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_irq_get_acpi, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

12
test/dm/led.c
View File

@ -26,7 +26,7 @@ static int dm_test_led_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_led_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_led_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test of the LED 'default-state' device tree property */
static int dm_test_led_default_state(struct unit_test_state *uts)
@ -45,7 +45,7 @@ static int dm_test_led_default_state(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_led_default_state, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_led_default_state, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test of the led uclass using the led_gpio driver */
static int dm_test_led_gpio(struct unit_test_state *uts)
@ -70,7 +70,7 @@ static int dm_test_led_gpio(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_led_gpio, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_led_gpio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that we can toggle LEDs */
static int dm_test_led_toggle(struct unit_test_state *uts)
@ -95,7 +95,7 @@ static int dm_test_led_toggle(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_led_toggle, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_led_toggle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test obtaining an LED by label */
static int dm_test_led_label(struct unit_test_state *uts)
@ -116,7 +116,7 @@ static int dm_test_led_label(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_led_label, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_led_label, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test LED blinking */
#ifdef CONFIG_LED_BLINK
@ -139,5 +139,5 @@ static int dm_test_led_blink(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_led_blink, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_led_blink, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
#endif

2
test/dm/mailbox.c
View File

@ -29,4 +29,4 @@ static int dm_test_mailbox(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_mailbox, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_mailbox, UT_TESTF_SCAN_FDT);

2
test/dm/mdio.c
View File

@ -55,4 +55,4 @@ static int dm_test_mdio(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_mdio, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_mdio, UT_TESTF_SCAN_FDT);

2
test/dm/mdio_mux.c
View File

@ -78,4 +78,4 @@ static int dm_test_mdio_mux(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_mdio_mux, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_mdio_mux, UT_TESTF_SCAN_FDT);

2
test/dm/misc.c
View File

@ -81,4 +81,4 @@ static int dm_test_misc(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_misc, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_misc, UT_TESTF_SCAN_FDT);

4
test/dm/mmc.c
View File

@ -23,7 +23,7 @@ static int dm_test_mmc_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_mmc_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_mmc_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_mmc_blk(struct unit_test_state *uts)
{
@ -42,4 +42,4 @@ static int dm_test_mmc_blk(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_mmc_blk, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_mmc_blk, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/nop.c
View File

@ -71,4 +71,4 @@ static int dm_test_nop(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_nop, DM_TESTF_FLAT_TREE | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_nop, UT_TESTF_FLAT_TREE | UT_TESTF_SCAN_FDT);

12
test/dm/ofnode.c
View File

@ -17,7 +17,7 @@ static int dm_test_ofnode_compatible(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_compatible, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_compatible, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_ofnode_by_prop_value(struct unit_test_state *uts)
{
@ -44,7 +44,7 @@ static int dm_test_ofnode_by_prop_value(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_by_prop_value, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_by_prop_value, UT_TESTF_SCAN_FDT);
static int dm_test_ofnode_fmap(struct unit_test_state *uts)
{
@ -59,7 +59,7 @@ static int dm_test_ofnode_fmap(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_fmap, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_fmap, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_ofnode_read(struct unit_test_state *uts)
{
@ -85,7 +85,7 @@ static int dm_test_ofnode_read(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_read, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_read, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_ofnode_read_chosen(struct unit_test_state *uts)
{
@ -114,7 +114,7 @@ static int dm_test_ofnode_read_chosen(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_read_chosen, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_read_chosen, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_ofnode_get_child_count(struct unit_test_state *uts)
{
@ -135,4 +135,4 @@ static int dm_test_ofnode_get_child_count(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_get_child_count,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/ofread.c
View File

@ -47,4 +47,4 @@ static int dm_test_ofnode_get_property_by_prop(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_get_property_by_prop,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

4
test/dm/osd.c
View File

@ -132,7 +132,7 @@ static int dm_test_osd_basics(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_osd_basics, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_osd_basics, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_osd_extended(struct unit_test_state *uts)
{
@ -216,4 +216,4 @@ static int dm_test_osd_extended(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_osd_extended, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_osd_extended, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/p2sb.c
View File

@ -25,4 +25,4 @@ static int dm_test_p2sb_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_p2sb_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_p2sb_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/panel.c
View File

@ -77,4 +77,4 @@ static int dm_test_panel(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_panel, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_panel, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

4
test/dm/pch.c
View File

@ -34,7 +34,7 @@ static int dm_test_pch_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pch_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_pch_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test sandbox PCH ioctl */
static int dm_test_pch_ioctl(struct unit_test_state *uts)
@ -53,4 +53,4 @@ static int dm_test_pch_ioctl(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pch_ioctl, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_pch_ioctl, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

26
test/dm/pci.c
View File

@ -20,7 +20,7 @@ static int dm_test_pci_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pci_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_pci_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that sandbox PCI bus numbering and device works correctly */
static int dm_test_pci_busdev(struct unit_test_state *uts)
@ -55,7 +55,7 @@ static int dm_test_pci_busdev(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pci_busdev, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_pci_busdev, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that we can use the swapcase device correctly */
static int dm_test_pci_swapcase(struct unit_test_state *uts)
@ -108,7 +108,7 @@ static int dm_test_pci_swapcase(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pci_swapcase, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_pci_swapcase, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that we can dynamically bind the device driver correctly */
static int dm_test_pci_drvdata(struct unit_test_state *uts)
@ -130,7 +130,7 @@ static int dm_test_pci_drvdata(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pci_drvdata, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_pci_drvdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that devices on PCI bus#2 can be accessed correctly */
static int dm_test_pci_mixed(struct unit_test_state *uts)
@ -193,7 +193,7 @@ static int dm_test_pci_mixed(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pci_mixed, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_pci_mixed, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test looking up PCI capability and extended capability */
static int dm_test_pci_cap(struct unit_test_state *uts)
@ -245,7 +245,7 @@ static int dm_test_pci_cap(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pci_cap, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_pci_cap, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test looking up BARs in EA capability structure */
static int dm_test_pci_ea(struct unit_test_state *uts)
@ -294,7 +294,7 @@ static int dm_test_pci_ea(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pci_ea, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_pci_ea, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test the dev_read_addr_pci() function */
static int dm_test_pci_addr_flat(struct unit_test_state *uts)
@ -316,14 +316,14 @@ static int dm_test_pci_addr_flat(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pci_addr_flat, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT |
DM_TESTF_FLAT_TREE);
DM_TEST(dm_test_pci_addr_flat, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT |
UT_TESTF_FLAT_TREE);
/*
* Test the dev_read_addr_pci() function with livetree. That function is
* not currently fully implemented, in that it fails to return the BAR address.
* Once that is implemented this test can be removed and dm_test_pci_addr_flat()
* can be used for both flattree and livetree by removing the DM_TESTF_FLAT_TREE
* can be used for both flattree and livetree by removing the UT_TESTF_FLAT_TREE
* flag above.
*/
static int dm_test_pci_addr_live(struct unit_test_state *uts)
@ -338,8 +338,8 @@ static int dm_test_pci_addr_live(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pci_addr_live, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT |
DM_TESTF_LIVE_TREE);
DM_TEST(dm_test_pci_addr_live, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT |
UT_TESTF_LIVE_TREE);
/* Test device_is_on_pci_bus() */
static int dm_test_pci_on_bus(struct unit_test_state *uts)
@ -353,4 +353,4 @@ static int dm_test_pci_on_bus(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pci_on_bus, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_pci_on_bus, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/pci_ep.c
View File

@ -61,5 +61,5 @@ static int dm_test_pci_ep_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pci_ep_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_pci_ep_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

6
test/dm/phy.c
View File

@ -53,7 +53,7 @@ static int dm_test_phy_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_phy_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_phy_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test of the phy uclass using the sandbox phy driver operations */
static int dm_test_phy_ops(struct unit_test_state *uts)
@ -111,7 +111,7 @@ static int dm_test_phy_ops(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_phy_ops, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_phy_ops, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_phy_bulk(struct unit_test_state *uts)
{
@ -144,4 +144,4 @@ static int dm_test_phy_bulk(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_phy_bulk, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_phy_bulk, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/pmc.c
View File

@ -30,4 +30,4 @@ static int dm_test_pmc_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pmc_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_pmc_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

10
test/dm/pmic.c
View File

@ -44,7 +44,7 @@ static int dm_test_power_pmic_get(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_power_pmic_get, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_pmic_get, UT_TESTF_SCAN_FDT);
/* PMIC get method - MC34708 - for 3 bytes transmission */
static int dm_test_power_pmic_mc34708_get(struct unit_test_state *uts)
@ -54,7 +54,7 @@ static int dm_test_power_pmic_mc34708_get(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_power_pmic_mc34708_get, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_pmic_mc34708_get, UT_TESTF_SCAN_FDT);
/* Test PMIC I/O */
static int dm_test_power_pmic_io(struct unit_test_state *uts)
@ -83,7 +83,7 @@ static int dm_test_power_pmic_io(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_power_pmic_io, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_pmic_io, UT_TESTF_SCAN_FDT);
#define MC34708_PMIC_REG_COUNT 64
#define MC34708_PMIC_TEST_VAL 0x125534
@ -101,7 +101,7 @@ static int dm_test_power_pmic_mc34708_regs_check(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_power_pmic_mc34708_regs_check, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_pmic_mc34708_regs_check, UT_TESTF_SCAN_FDT);
static int dm_test_power_pmic_mc34708_rw_val(struct unit_test_state *uts)
{
@ -128,4 +128,4 @@ static int dm_test_power_pmic_mc34708_rw_val(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_power_pmic_mc34708_rw_val, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_pmic_mc34708_rw_val, UT_TESTF_SCAN_FDT);

2
test/dm/power-domain.c
View File

@ -46,4 +46,4 @@ static int dm_test_power_domain(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_power_domain, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_domain, UT_TESTF_SCAN_FDT);

2
test/dm/pwm.c
View File

@ -29,4 +29,4 @@ static int dm_test_pwm_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pwm_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_pwm_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/ram.c
View File

@ -25,4 +25,4 @@ static int dm_test_ram_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ram_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_ram_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

10
test/dm/regmap.c
View File

@ -67,7 +67,7 @@ static int dm_test_regmap_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_regmap_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_regmap_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test we can access a regmap through syscon */
static int dm_test_regmap_syscon(struct unit_test_state *uts)
@ -93,7 +93,7 @@ static int dm_test_regmap_syscon(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_regmap_syscon, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_regmap_syscon, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Read/Write/Modify test */
static int dm_test_regmap_rw(struct unit_test_state *uts)
@ -127,7 +127,7 @@ static int dm_test_regmap_rw(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_regmap_rw, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_regmap_rw, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Get/Set test */
static int dm_test_regmap_getset(struct unit_test_state *uts)
@ -158,7 +158,7 @@ static int dm_test_regmap_getset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_regmap_getset, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_regmap_getset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Read polling test */
static int dm_test_regmap_poll(struct unit_test_state *uts)
@ -186,4 +186,4 @@ static int dm_test_regmap_poll(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_regmap_poll, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_regmap_poll, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

20
test/dm/regulator.c
View File

@ -90,7 +90,7 @@ static int dm_test_power_regulator_get(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_power_regulator_get, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_regulator_get, UT_TESTF_SCAN_FDT);
/* Test regulator set and get Voltage method */
static int dm_test_power_regulator_set_get_voltage(struct unit_test_state *uts)
@ -117,7 +117,7 @@ static int dm_test_power_regulator_set_get_voltage(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_power_regulator_set_get_voltage, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_regulator_set_get_voltage, UT_TESTF_SCAN_FDT);
/* Test regulator set and get Current method */
static int dm_test_power_regulator_set_get_current(struct unit_test_state *uts)
@ -156,7 +156,7 @@ static int dm_test_power_regulator_set_get_current(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_power_regulator_set_get_current, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_regulator_set_get_current, UT_TESTF_SCAN_FDT);
/* Test regulator set and get Enable method */
static int dm_test_power_regulator_set_get_enable(struct unit_test_state *uts)
@ -175,7 +175,7 @@ static int dm_test_power_regulator_set_get_enable(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_power_regulator_set_get_enable, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_regulator_set_get_enable, UT_TESTF_SCAN_FDT);
/* Test regulator set and get enable if allowed method */
static
@ -196,7 +196,7 @@ int dm_test_power_regulator_set_enable_if_allowed(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_power_regulator_set_enable_if_allowed, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_regulator_set_enable_if_allowed, UT_TESTF_SCAN_FDT);
/* Test regulator set and get mode method */
static int dm_test_power_regulator_set_get_mode(struct unit_test_state *uts)
@ -215,7 +215,7 @@ static int dm_test_power_regulator_set_get_mode(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_power_regulator_set_get_mode, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_regulator_set_get_mode, UT_TESTF_SCAN_FDT);
/* Test regulator set and get suspend Voltage method */
static int dm_test_power_regulator_set_get_suspend_voltage(struct unit_test_state *uts)
@ -245,7 +245,7 @@ static int dm_test_power_regulator_set_get_suspend_voltage(struct unit_test_stat
}
return 0;
}
DM_TEST(dm_test_power_regulator_set_get_suspend_voltage, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_regulator_set_get_suspend_voltage, UT_TESTF_SCAN_FDT);
/* Test regulator set and get suspend Enable method */
static int dm_test_power_regulator_set_get_suspend_enable(struct unit_test_state *uts)
@ -272,7 +272,7 @@ static int dm_test_power_regulator_set_get_suspend_enable(struct unit_test_state
}
return 0;
}
DM_TEST(dm_test_power_regulator_set_get_suspend_enable, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_regulator_set_get_suspend_enable, UT_TESTF_SCAN_FDT);
/* Test regulator autoset method */
static int dm_test_power_regulator_autoset(struct unit_test_state *uts)
@ -305,7 +305,7 @@ static int dm_test_power_regulator_autoset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_power_regulator_autoset, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_regulator_autoset, UT_TESTF_SCAN_FDT);
/*
* Struct setting: to keep the expected output settings.
@ -401,4 +401,4 @@ static int dm_test_power_regulator_autoset_list(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_power_regulator_autoset_list, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_power_regulator_autoset_list, UT_TESTF_SCAN_FDT);

4
test/dm/remoteproc.c
View File

@ -68,7 +68,7 @@ static int dm_test_remoteproc_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_remoteproc_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_remoteproc_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
#define DEVICE_TO_PHYSICAL_OFFSET 0x1000
/**
@ -256,4 +256,4 @@ static int dm_test_remoteproc_elf(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_remoteproc_elf, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_remoteproc_elf, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

6
test/dm/reset.c
View File

@ -39,7 +39,7 @@ static int dm_test_reset_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_reset_base, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_reset_base, UT_TESTF_SCAN_FDT);
static int dm_test_reset(struct unit_test_state *uts)
{
@ -64,7 +64,7 @@ static int dm_test_reset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_reset, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_reset, UT_TESTF_SCAN_FDT);
static int dm_test_reset_bulk(struct unit_test_state *uts)
{
@ -94,4 +94,4 @@ static int dm_test_reset_bulk(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_reset_bulk, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_reset_bulk, UT_TESTF_SCAN_FDT);

2
test/dm/rng.c
View File

@ -24,4 +24,4 @@ static int dm_test_rng_read(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_rng_read, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_rng_read, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

14
test/dm/rtc.c
View File

@ -28,7 +28,7 @@ static int dm_test_rtc_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_rtc_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_rtc_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static void show_time(const char *msg, struct rtc_time *time)
{
@ -131,7 +131,7 @@ static int dm_test_rtc_set_get(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_rtc_set_get, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_rtc_set_get, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_rtc_read_write(struct unit_test_state *uts)
{
@ -175,7 +175,7 @@ static int dm_test_rtc_read_write(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_rtc_read_write, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_rtc_read_write, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test 'rtc list' command */
static int dm_test_rtc_cmd_list(struct unit_test_state *uts)
@ -189,7 +189,7 @@ static int dm_test_rtc_cmd_list(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_rtc_cmd_list, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_rtc_cmd_list, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test 'rtc read' and 'rtc write' commands */
static int dm_test_rtc_cmd_rw(struct unit_test_state *uts)
@ -232,7 +232,7 @@ static int dm_test_rtc_cmd_rw(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_rtc_cmd_rw, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_rtc_cmd_rw, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Reset the time */
static int dm_test_rtc_reset(struct unit_test_state *uts)
@ -258,7 +258,7 @@ static int dm_test_rtc_reset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_rtc_reset, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_rtc_reset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Check that two RTC devices can be used independently */
static int dm_test_rtc_dual(struct unit_test_state *uts)
@ -290,4 +290,4 @@ static int dm_test_rtc_dual(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_rtc_dual, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_rtc_dual, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/serial.c
View File

@ -69,4 +69,4 @@ static int dm_test_serial(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_serial, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_serial, UT_TESTF_SCAN_FDT);

4
test/dm/sf.c
View File

@ -65,7 +65,7 @@ static int dm_test_spi_flash(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_spi_flash, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_spi_flash, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Functional test that sandbox SPI flash works correctly */
static int dm_test_spi_flash_func(struct unit_test_state *uts)
@ -93,4 +93,4 @@ static int dm_test_spi_flash_func(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_spi_flash_func, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_spi_flash_func, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/simple-pm-bus.c
View File

@ -42,4 +42,4 @@ static int dm_test_simple_pm_bus(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_simple_pm_bus, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_simple_pm_bus, UT_TESTF_SCAN_FDT);

2
test/dm/smem.c
View File

@ -24,5 +24,5 @@ static int dm_test_smem_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_smem_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_smem_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/soc.c
View File

@ -117,4 +117,4 @@ static int dm_test_soc(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_soc, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_soc, UT_TESTF_SCAN_FDT);

4
test/dm/sound.c
View File

@ -33,7 +33,7 @@ static int dm_test_sound(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_sound, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_sound, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test of the 'start beep' operations */
static int dm_test_sound_beep(struct unit_test_state *uts)
@ -54,4 +54,4 @@ static int dm_test_sound_beep(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_sound_beep, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_sound_beep, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

4
test/dm/spi.c
View File

@ -92,7 +92,7 @@ static int dm_test_spi_find(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_spi_find, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_spi_find, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that sandbox SPI works correctly */
static int dm_test_spi_xfer(struct unit_test_state *uts)
@ -124,4 +124,4 @@ static int dm_test_spi_xfer(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_spi_xfer, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_spi_xfer, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

6
test/dm/spmi.c
View File

@ -44,7 +44,7 @@ static int dm_test_spmi_probe(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_spmi_probe, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_spmi_probe, UT_TESTF_SCAN_FDT);
/* Test if it's possible to read bus directly and indirectly */
static int dm_test_spmi_access(struct unit_test_state *uts)
@ -69,7 +69,7 @@ static int dm_test_spmi_access(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_spmi_access, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_spmi_access, UT_TESTF_SCAN_FDT);
/* Test if it's possible to access GPIO that should be in pmic */
@ -110,4 +110,4 @@ static int dm_test_spmi_access_peripheral(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_spmi_access_peripheral, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_spmi_access_peripheral, UT_TESTF_SCAN_FDT);

2
test/dm/syscon-reset.c
View File

@ -56,4 +56,4 @@ static int dm_test_syscon_reset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_syscon_reset, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_syscon_reset, UT_TESTF_SCAN_FDT);

6
test/dm/syscon.c
View File

@ -29,7 +29,7 @@ static int dm_test_syscon_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_syscon_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_syscon_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test system controller finding */
static int dm_test_syscon_by_driver_data(struct unit_test_state *uts)
@ -46,7 +46,7 @@ static int dm_test_syscon_by_driver_data(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_syscon_by_driver_data, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_syscon_by_driver_data, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test system controller by phandle */
static int dm_test_syscon_by_phandle(struct unit_test_state *uts)
@ -81,4 +81,4 @@ static int dm_test_syscon_by_phandle(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_syscon_by_phandle, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_syscon_by_phandle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

8
test/dm/sysreset.c
View File

@ -44,7 +44,7 @@ static int dm_test_sysreset_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_sysreset_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_sysreset_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_sysreset_get_status(struct unit_test_state *uts)
{
@ -63,7 +63,7 @@ static int dm_test_sysreset_get_status(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_sysreset_get_status, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_sysreset_get_status, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that we can walk through the sysreset devices */
static int dm_test_sysreset_walk(struct unit_test_state *uts)
@ -91,7 +91,7 @@ static int dm_test_sysreset_walk(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_sysreset_walk, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_sysreset_walk, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_sysreset_get_last(struct unit_test_state *uts)
{
@ -110,4 +110,4 @@ static int dm_test_sysreset_get_last(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_sysreset_get_last, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_sysreset_get_last, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/tee.c
View File

@ -115,4 +115,4 @@ static int dm_test_tee(struct unit_test_state *uts)
return rc;
}
DM_TEST(dm_test_tee, DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_tee, UT_TESTF_SCAN_FDT);

46
test/dm/test-fdt.c
View File

@ -390,7 +390,7 @@ static int dm_test_fdt_uclass_seq(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fdt_uclass_seq, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_fdt_uclass_seq, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that we can find a device by device tree offset */
static int dm_test_fdt_offset(struct unit_test_state *uts)
@ -420,7 +420,7 @@ static int dm_test_fdt_offset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fdt_offset,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
/**
* Test various error conditions with uclass_first_device() and
@ -461,7 +461,7 @@ static int dm_test_first_next_device(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_first_next_device, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_first_next_device, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test iteration through devices in a uclass */
static int dm_test_uclass_foreach(struct unit_test_state *uts)
@ -482,7 +482,7 @@ static int dm_test_uclass_foreach(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_uclass_foreach, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_uclass_foreach, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/**
* check_devices() - Check return values and pointers
@ -562,7 +562,7 @@ static int dm_test_first_next_ok_device(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_first_next_ok_device, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_first_next_ok_device, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static const struct udevice_id fdt_dummy_ids[] = {
{ .compatible = "denx,u-boot-fdt-dummy", },
@ -617,7 +617,7 @@ static int dm_test_fdt_translation(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fdt_translation, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_fdt_translation, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_fdt_remap_addr_flat(struct unit_test_state *uts)
{
@ -637,7 +637,7 @@ static int dm_test_fdt_remap_addr_flat(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fdt_remap_addr_flat,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
static int dm_test_fdt_remap_addr_index_flat(struct unit_test_state *uts)
{
@ -659,7 +659,7 @@ static int dm_test_fdt_remap_addr_index_flat(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fdt_remap_addr_index_flat,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
static int dm_test_fdt_remap_addr_name_flat(struct unit_test_state *uts)
{
@ -681,7 +681,7 @@ static int dm_test_fdt_remap_addr_name_flat(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fdt_remap_addr_name_flat,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
static int dm_test_fdt_remap_addr_live(struct unit_test_state *uts)
{
@ -701,7 +701,7 @@ static int dm_test_fdt_remap_addr_live(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fdt_remap_addr_live,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_fdt_remap_addr_index_live(struct unit_test_state *uts)
{
@ -723,7 +723,7 @@ static int dm_test_fdt_remap_addr_index_live(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fdt_remap_addr_index_live,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_fdt_remap_addr_name_live(struct unit_test_state *uts)
{
@ -745,7 +745,7 @@ static int dm_test_fdt_remap_addr_name_live(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fdt_remap_addr_name_live,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_fdt_livetree_writing(struct unit_test_state *uts)
{
@ -797,7 +797,7 @@ static int dm_test_fdt_livetree_writing(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fdt_livetree_writing, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_fdt_livetree_writing, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_fdt_disable_enable_by_path(struct unit_test_state *uts)
{
@ -824,8 +824,8 @@ static int dm_test_fdt_disable_enable_by_path(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fdt_disable_enable_by_path, DM_TESTF_SCAN_PDATA |
DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_fdt_disable_enable_by_path, UT_TESTF_SCAN_PDATA |
UT_TESTF_SCAN_FDT);
/* Test a few uclass phandle functions */
static int dm_test_fdt_phandle(struct unit_test_state *uts)
@ -847,7 +847,7 @@ 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);
DM_TEST(dm_test_fdt_phandle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test device_find_first_child_by_uclass() */
static int dm_test_first_child(struct unit_test_state *uts)
@ -874,7 +874,7 @@ static int dm_test_first_child(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_first_child, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_first_child, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test integer functions in dm_read_...() */
static int dm_test_read_int(struct unit_test_state *uts)
@ -919,7 +919,7 @@ static int dm_test_read_int(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_read_int, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_read_int, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int dm_test_read_int_index(struct unit_test_state *uts)
{
@ -948,7 +948,7 @@ static int dm_test_read_int_index(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_read_int_index, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_read_int_index, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test iteration through devices by drvdata */
static int dm_test_uclass_drvdata(struct unit_test_state *uts)
@ -969,7 +969,7 @@ static int dm_test_uclass_drvdata(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_uclass_drvdata, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_uclass_drvdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test device_first_child_ofdata_err(), etc. */
static int dm_test_child_ofdata(struct unit_test_state *uts)
@ -988,7 +988,7 @@ static int dm_test_child_ofdata(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_child_ofdata, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_child_ofdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test device_first_child_err(), etc. */
static int dm_test_first_child_probe(struct unit_test_state *uts)
@ -1007,7 +1007,7 @@ static int dm_test_first_child_probe(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_first_child_probe, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_first_child_probe, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test that ofdata is read for parents before children */
static int dm_test_ofdata_order(struct unit_test_state *uts)
@ -1032,4 +1032,4 @@ static int dm_test_ofdata_order(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofdata_order, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofdata_order, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

10
test/dm/test-main.c
View File

@ -89,11 +89,11 @@ static int dm_do_test(struct unit_test_state *uts, struct unit_test *test,
ut_assertok(dm_test_init(uts, of_live));
uts->start = mallinfo();
if (test->flags & DM_TESTF_SCAN_PDATA)
if (test->flags & UT_TESTF_SCAN_PDATA)
ut_assertok(dm_scan_platdata(false));
if (test->flags & DM_TESTF_PROBE_TEST)
if (test->flags & UT_TESTF_PROBE_TEST)
ut_assertok(do_autoprobe(uts));
if (test->flags & DM_TESTF_SCAN_FDT)
if (test->flags & UT_TESTF_SCAN_FDT)
ut_assertok(dm_extended_scan_fdt(gd->fdt_blob, false));
/*
@ -168,7 +168,7 @@ static int dm_test_main(const char *test_name)
/* Run with the live tree if possible */
runs = 0;
if (IS_ENABLED(CONFIG_OF_LIVE)) {
if (!(test->flags & DM_TESTF_FLAT_TREE)) {
if (!(test->flags & UT_TESTF_FLAT_TREE)) {
ut_assertok(dm_do_test(uts, test, true));
runs++;
}
@ -178,7 +178,7 @@ static int dm_test_main(const char *test_name)
* Run with the flat tree if we couldn't run it with live tree,
* or it is a core test.
*/
if (!(test->flags & DM_TESTF_LIVE_TREE) &&
if (!(test->flags & UT_TESTF_LIVE_TREE) &&
(!runs || dm_test_run_on_flattree(test))) {
ut_assertok(dm_do_test(uts, test, false));
runs++;

2
test/dm/timer.c
View File

@ -22,4 +22,4 @@ static int dm_test_timer_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_timer_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_timer_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

12
test/dm/usb.c
View File

@ -34,7 +34,7 @@ static int dm_test_usb_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_usb_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
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
@ -61,7 +61,7 @@ static int dm_test_usb_flash(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_usb_flash, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
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)
@ -77,7 +77,7 @@ static int dm_test_usb_multi(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_usb_multi, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
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)
@ -99,7 +99,7 @@ static int dm_test_usb_fdt_node(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_usb_fdt_node, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_usb_fdt_node, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int count_usb_devices(void)
{
@ -143,7 +143,7 @@ static int dm_test_usb_stop(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_usb_stop, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_usb_stop, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/**
* dm_test_usb_keyb() - test USB keyboard driver
@ -435,4 +435,4 @@ static int dm_test_usb_keyb(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_usb_keyb, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_usb_keyb, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

26
test/dm/video.c
View File

@ -40,7 +40,7 @@ static int dm_test_video_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_video_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_video_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/**
* compress_frame_buffer() - Compress the frame buffer and return its size
@ -146,7 +146,7 @@ static int dm_test_video_text(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_video_text, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_video_text, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test handling of special characters in the console */
static int dm_test_video_chars(struct unit_test_state *uts)
@ -162,7 +162,7 @@ static int dm_test_video_chars(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_video_chars, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_video_chars, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
#ifdef CONFIG_VIDEO_ANSI
#define ANSI_ESC "\x1b"
@ -195,7 +195,7 @@ static int dm_test_video_ansi(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_video_ansi, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_video_ansi, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
#endif
/**
@ -252,7 +252,7 @@ static int dm_test_video_context(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_video_context, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_video_context, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test rotated text output through the console uclass */
static int dm_test_video_rotation1(struct unit_test_state *uts)
@ -261,7 +261,7 @@ static int dm_test_video_rotation1(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_video_rotation1, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_video_rotation1, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test rotated text output through the console uclass */
static int dm_test_video_rotation2(struct unit_test_state *uts)
@ -270,7 +270,7 @@ static int dm_test_video_rotation2(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_video_rotation2, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_video_rotation2, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test rotated text output through the console uclass */
static int dm_test_video_rotation3(struct unit_test_state *uts)
@ -279,7 +279,7 @@ static int dm_test_video_rotation3(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_video_rotation3, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_video_rotation3, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Read a file into memory and return a pointer to it */
static int read_file(struct unit_test_state *uts, const char *fname,
@ -317,7 +317,7 @@ static int dm_test_video_bmp(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_video_bmp, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_video_bmp, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test drawing a compressed bitmap file */
static int dm_test_video_bmp_comp(struct unit_test_state *uts)
@ -333,7 +333,7 @@ static int dm_test_video_bmp_comp(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_video_bmp_comp, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_video_bmp_comp, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test TrueType console */
static int dm_test_video_truetype(struct unit_test_state *uts)
@ -348,7 +348,7 @@ static int dm_test_video_truetype(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_video_truetype, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_video_truetype, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test scrolling TrueType console */
static int dm_test_video_truetype_scroll(struct unit_test_state *uts)
@ -369,7 +369,7 @@ static int dm_test_video_truetype_scroll(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_video_truetype_scroll, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_video_truetype_scroll, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test TrueType backspace, within and across lines */
static int dm_test_video_truetype_bs(struct unit_test_state *uts)
@ -390,4 +390,4 @@ static int dm_test_video_truetype_bs(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_video_truetype_bs, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_video_truetype_bs, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

8
test/dm/virtio.c
View File

@ -36,7 +36,7 @@ static int dm_test_virtio_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_virtio_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_virtio_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test all of the virtio uclass ops */
static int dm_test_virtio_all_ops(struct unit_test_state *uts)
@ -85,7 +85,7 @@ static int dm_test_virtio_all_ops(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_virtio_all_ops, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_virtio_all_ops, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test of the virtio driver that does not have required driver ops */
static int dm_test_virtio_missing_ops(struct unit_test_state *uts)
@ -103,7 +103,7 @@ static int dm_test_virtio_missing_ops(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_virtio_missing_ops, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_virtio_missing_ops, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test removal of virtio device driver */
static int dm_test_virtio_remove(struct unit_test_state *uts)
@ -127,4 +127,4 @@ static int dm_test_virtio_remove(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_virtio_remove, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_virtio_remove, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

2
test/dm/wdt.c
View File

@ -38,4 +38,4 @@ static int dm_test_wdt_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_wdt_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(dm_test_wdt_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

18
test/lib/lmb.c
View File

@ -201,7 +201,7 @@ static int lib_test_lmb_simple(struct unit_test_state *uts)
return test_multi_alloc_512mb(uts, 0xE0000000);
}
DM_TEST(lib_test_lmb_simple, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(lib_test_lmb_simple, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Create two memory regions with one reserved region and allocate */
static int lib_test_lmb_simple_x2(struct unit_test_state *uts)
@ -217,7 +217,7 @@ static int lib_test_lmb_simple_x2(struct unit_test_state *uts)
return test_multi_alloc_512mb_x2(uts, 0xE0000000, 0x40000000);
}
DM_TEST(lib_test_lmb_simple_x2, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(lib_test_lmb_simple_x2, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Simulate 512 MiB RAM, allocate some blocks that fit/don't fit */
static int test_bigblock(struct unit_test_state *uts, const phys_addr_t ram)
@ -284,7 +284,7 @@ static int lib_test_lmb_big(struct unit_test_state *uts)
return test_bigblock(uts, 0xE0000000);
}
DM_TEST(lib_test_lmb_big, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(lib_test_lmb_big, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Simulate 512 MiB RAM, allocate a block without previous reservation */
static int test_noreserved(struct unit_test_state *uts, const phys_addr_t ram,
@ -359,7 +359,7 @@ static int lib_test_lmb_noreserved(struct unit_test_state *uts)
return test_noreserved(uts, 0xE0000000, 4, 1);
}
DM_TEST(lib_test_lmb_noreserved, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(lib_test_lmb_noreserved, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
static int lib_test_lmb_unaligned_size(struct unit_test_state *uts)
{
@ -374,7 +374,7 @@ static int lib_test_lmb_unaligned_size(struct unit_test_state *uts)
return test_noreserved(uts, 0xE0000000, 5, 8);
}
DM_TEST(lib_test_lmb_unaligned_size, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(lib_test_lmb_unaligned_size, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/*
* Simulate a RAM that starts at 0 and allocate down to address 0, which must
* fail as '0' means failure for the lmb_alloc functions.
@ -417,7 +417,7 @@ static int lib_test_lmb_at_0(struct unit_test_state *uts)
return 0;
}
DM_TEST(lib_test_lmb_at_0, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(lib_test_lmb_at_0, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Check that calling lmb_reserve with overlapping regions fails. */
static int lib_test_lmb_overlapping_reserve(struct unit_test_state *uts)
@ -456,7 +456,7 @@ static int lib_test_lmb_overlapping_reserve(struct unit_test_state *uts)
}
DM_TEST(lib_test_lmb_overlapping_reserve,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/*
* Simulate 512 MiB RAM, reserve 3 blocks, allocate addresses in between.
@ -586,7 +586,7 @@ static int lib_test_lmb_alloc_addr(struct unit_test_state *uts)
return test_alloc_addr(uts, 0xE0000000);
}
DM_TEST(lib_test_lmb_alloc_addr, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
DM_TEST(lib_test_lmb_alloc_addr, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Simulate 512 MiB RAM, reserve 3 blocks, check addresses in between */
static int test_get_unreserved_size(struct unit_test_state *uts,
@ -658,4 +658,4 @@ static int lib_test_lmb_get_free_size(struct unit_test_state *uts)
}
DM_TEST(lib_test_lmb_get_free_size,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);