/* 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; }