/* Test that binding with uclass platdata allocation occurs correctly */
static int dm_test_autobind_uclass_pdata_alloc(struct unit_test_state *uts)
{
struct dm_test_perdev_uc_pdata *uc_pdata;
struct udevice *dev;
struct uclass *uc;
ut_assertok(uclass_get(UCLASS_TEST, &uc));
ut_assert(uc);
/**
* Test if test uclass driver requires allocation for the uclass
* platform data and then check the dev->uclass_platdata pointer.
*/
ut_assert(uc->uc_drv->per_device_platdata_auto_alloc_size);
for (uclass_find_first_device(UCLASS_TEST, &dev);
dev;
uclass_find_next_device(&dev)) {
ut_assert(dev);
uc_pdata = dev_get_uclass_platdata(dev);
ut_assert(uc_pdata);
}
return 0;
}
static int dm_test_uclass_devices_find_by_name(struct unit_test_state *uts)
{
struct udevice *finddev;
struct udevice *testdev;
int findret, ret;
/*
* For each test device found in fdt like: "a-test", "b-test", etc.,
* use its name and try to find it by uclass_find_device_by_name().
* Then, on success check if:
* - current 'testdev' name is equal to the returned 'finddev' name
* - current 'testdev' pointer is equal to the returned 'finddev'
*
* We assume that, each uclass's device name is unique, so if not, then
* this will fail on checking condition: testdev == finddev, since the
* uclass_find_device_by_name(), returns the first device by given name.
*/
for (ret = uclass_find_first_device(UCLASS_TEST_FDT, &testdev);
testdev;
ret = uclass_find_next_device(&testdev)) {
ut_assertok(ret);
ut_assert(testdev);
findret = uclass_find_device_by_name(UCLASS_TEST_FDT,
testdev->name,
&finddev);
ut_assertok(findret);
ut_assert(testdev);
ut_asserteq_str(testdev->name, finddev->name);
ut_asserteq_ptr(testdev, finddev);
}
return 0;
}
static int qemu_cpu_fixup(void)
{
int ret;
int cpu_num;
int cpu_online;
struct udevice *dev, *pdev;
struct cpu_platdata *plat;
char *cpu;
/* first we need to find '/cpus' */
for (device_find_first_child(dm_root(), &pdev);
pdev;
device_find_next_child(&pdev)) {
if (!strcmp(pdev->name, "cpus"))
break;
}
if (!pdev) {
printf("unable to find cpus device\n");
return -ENODEV;
}
/* calculate cpus that are already bound */
cpu_num = 0;
for (uclass_find_first_device(UCLASS_CPU, &dev);
dev;
uclass_find_next_device(&dev)) {
cpu_num++;
}
/* get actual cpu number */
cpu_online = qemu_fwcfg_online_cpus();
if (cpu_online < 0) {
printf("unable to get online cpu number: %d\n", cpu_online);
return cpu_online;
}
/* bind addtional cpus */
dev = NULL;
for (; cpu_num < cpu_online; cpu_num++) {
/*
* allocate device name here as device_bind_driver() does
* not copy device name, 8 bytes are enough for
* sizeof("cpu@") + 3 digits cpu number + '\0'
*/
cpu = malloc(8);
if (!cpu) {
printf("unable to allocate device name\n");
return -ENOMEM;
}
sprintf(cpu, "cpu@%d", cpu_num);
ret = device_bind_driver(pdev, "cpu_qemu", cpu, &dev);
if (ret) {
printf("binding cpu@%d failed: %d\n", cpu_num, ret);
return ret;
}
plat = dev_get_parent_platdata(dev);
plat->cpu_id = cpu_num;
}
return 0;
}
void video_sync_all(void)
{
struct udevice *dev;
for (uclass_find_first_device(UCLASS_VIDEO, &dev);
dev;
uclass_find_next_device(&dev)) {
if (device_active(dev))
video_sync(dev);
}
}
static int dm_test_uclass_devices_find(struct unit_test_state *uts)
{
struct udevice *dev;
int ret;
for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_find_next_device(&dev)) {
ut_assert(!ret);
ut_assert(dev);
}
return 0;
}
unsigned long acpi_create_madt_lapics(unsigned long current)
{
struct udevice *dev;
for (uclass_find_first_device(UCLASS_CPU, &dev);
dev;
uclass_find_next_device(&dev)) {
struct cpu_platdata *plat = dev_get_parent_platdata(dev);
current += acpi_create_madt_lapic(
(struct acpi_madt_lapic *)current,
plat->cpu_id, plat->cpu_id);
}
return current;
}
static int find_cpu_by_apid_id(int apic_id, struct udevice **devp)
{
struct udevice *dev;
*devp = NULL;
for (uclass_find_first_device(UCLASS_CPU, &dev);
dev;
uclass_find_next_device(&dev)) {
struct cpu_platdata *plat = dev_get_parent_platdata(dev);
if (plat->cpu_id == apic_id) {
*devp = dev;
return 0;
}
}
return -ENOENT;
}
int acpi_create_madt_lapics(u32 current)
{
struct udevice *dev;
int total_length = 0;
for (uclass_find_first_device(UCLASS_CPU, &dev);
dev;
uclass_find_next_device(&dev)) {
struct cpu_platdata *plat = dev_get_parent_platdata(dev);
int length = acpi_create_madt_lapic(
(struct acpi_madt_lapic *)current,
plat->cpu_id, plat->cpu_id);
current += length;
total_length += length;
}
return total_length;
}
int video_reserve(ulong *addrp)
{
struct udevice *dev;
ulong size;
gd->video_top = *addrp;
for (uclass_find_first_device(UCLASS_VIDEO, &dev);
dev;
uclass_find_next_device(&dev)) {
size = alloc_fb(dev, addrp);
debug("%s: Reserving %lx bytes at %lx for video device '%s'\n",
__func__, size, *addrp, dev->name);
}
gd->video_bottom = *addrp;
debug("Video frame buffers from %lx to %lx\n", gd->video_bottom,
gd->video_top);
return 0;
}
/**
* for_each_remoteproc_device() - iterate through the list of rproc devices
* @fn: check function to call per match, if this function returns fail,
* iteration is aborted with the resultant error value
* @skip_dev: Device to skip calling the callback about.
* @data: Data to pass to the callback function
*
* Return: 0 if none of the callback returned a non 0 result, else returns the
* result from the callback function
*/
static int for_each_remoteproc_device(int (*fn) (struct udevice *dev,
struct dm_rproc_uclass_pdata *uc_pdata,
const void *data),
struct udevice *skip_dev,
const void *data)
{
struct udevice *dev;
struct dm_rproc_uclass_pdata *uc_pdata;
int ret;
for (ret = uclass_find_first_device(UCLASS_REMOTEPROC, &dev); dev;
ret = uclass_find_next_device(&dev)) {
if (ret || dev == skip_dev)
continue;
uc_pdata = dev_get_uclass_platdata(dev);
ret = fn(dev, uc_pdata, data);
if (ret)
return ret;
}
return 0;
}
/* Test that binding with uclass platdata setting occurs correctly */
static int dm_test_autobind_uclass_pdata_valid(struct unit_test_state *uts)
{
struct dm_test_perdev_uc_pdata *uc_pdata;
struct udevice *dev;
/**
* In the test_postbind() method of test uclass driver, the uclass
* platform data should be set to three test int values - test it.
*/
for (uclass_find_first_device(UCLASS_TEST, &dev);
dev;
uclass_find_next_device(&dev)) {
ut_assert(dev);
uc_pdata = dev_get_uclass_platdata(dev);
ut_assert(uc_pdata);
ut_assert(uc_pdata->intval1 == TEST_UC_PDATA_INTVAL1);
ut_assert(uc_pdata->intval2 == TEST_UC_PDATA_INTVAL2);
ut_assert(uc_pdata->intval3 == TEST_UC_PDATA_INTVAL3);
}
return 0;
}
