int syscon_get_by_driver_data(ulong driver_data, struct udevice **devp) { struct udevice *dev; struct uclass *uc; int ret; *devp = NULL; ret = uclass_get(UCLASS_SYSCON, &uc); if (ret) return ret; uclass_foreach_dev(dev, uc) { if (dev->driver_data == driver_data) { *devp = dev; return device_probe(dev); } } return -ENODEV; }
int scsi_scan(bool verbose) { struct uclass *uc; struct udevice *dev; /* SCSI controller */ int ret; if (verbose) printf("scanning bus for devices...\n"); blk_unbind_all(IF_TYPE_SCSI); ret = uclass_get(UCLASS_SCSI, &uc); if (ret) return ret; uclass_foreach_dev(dev, uc) { ret = scsi_scan_dev(dev, verbose); if (ret) return ret; }
void mmc_do_preinit(void) { struct udevice *dev; struct uclass *uc; int ret; ret = uclass_get(UCLASS_MMC, &uc); if (ret) return; uclass_foreach_dev(dev, uc) { struct mmc *m = mmc_get_mmc_dev(dev); if (!m) continue; #ifdef CONFIG_FSL_ESDHC_ADAPTER_IDENT mmc_set_preinit(m, 1); #endif if (m->preinit) mmc_start_init(m); } }
/** * print_remoteproc_list() - print all the remote processor devices * * Return: 0 if no error, else returns appropriate error value. */ static int print_remoteproc_list(void) { struct udevice *dev; struct uclass *uc; int ret; char *type; ret = uclass_get(UCLASS_REMOTEPROC, &uc); if (ret) { printf("Cannot find Remote processor class\n"); return ret; } uclass_foreach_dev(dev, uc) { struct dm_rproc_uclass_pdata *uc_pdata; const struct dm_rproc_ops *ops = rproc_get_ops(dev); uc_pdata = dev_get_uclass_platdata(dev); switch (uc_pdata->mem_type) { case RPROC_INTERNAL_MEMORY_MAPPED: type = "internal memory mapped"; break; default: type = "unknown"; break; } printf("%d - Name:'%s' type:'%s' supports: %s%s%s%s%s%s\n", dev->seq, uc_pdata->name, type, ops->load ? "load " : "", ops->start ? "start " : "", ops->stop ? "stop " : "", ops->reset ? "reset " : "", ops->is_running ? "is_running " : "", ops->ping ? "ping " : ""); } return 0; }
int usb_stop(void) { struct udevice *bus; struct uclass *uc; struct usb_uclass_priv *uc_priv; int err = 0, ret; /* De-activate any devices that have been activated */ ret = uclass_get(UCLASS_USB, &uc); if (ret) return ret; uc_priv = uc->priv; uclass_foreach_dev(bus, uc) { ret = device_remove(bus); if (ret && !err) err = ret; ret = device_unbind_children(bus); if (ret && !err) err = ret; }
int blk_get_device(int if_type, int devnum, struct udevice **devp) { struct uclass *uc; struct udevice *dev; int ret; ret = uclass_get(UCLASS_BLK, &uc); if (ret) return ret; uclass_foreach_dev(dev, uc) { struct blk_desc *desc = dev_get_uclass_platdata(dev); debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__, if_type, devnum, dev->name, desc->if_type, desc->devnum); if (desc->if_type == if_type && desc->devnum == devnum) { *devp = dev; return device_probe(dev); } } return -ENODEV; }
/* We need to renumber the GPIOs when any driver is probed/removed */ static int gpio_renumber(struct udevice *removed_dev) { struct gpio_dev_priv *uc_priv; struct udevice *dev; struct uclass *uc; unsigned base; int ret; ret = uclass_get(UCLASS_GPIO, &uc); if (ret) return ret; /* Ensure that we have a base for each bank */ base = 0; uclass_foreach_dev(dev, uc) { if (device_active(dev) && dev != removed_dev) { uc_priv = dev_get_uclass_priv(dev); uc_priv->gpio_base = base; base += uc_priv->gpio_count; } } return 0; }
/* 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) { struct dm_test_parent_data *parent_data; struct dm_test_state *dms = uts->priv; struct udevice *bus, *dev; struct uclass *uc; test_state = dms; ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus)); ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc)); uclass_foreach_dev(dev, uc) { /* Ignore these if they are not on this bus */ if (dev->parent != bus) continue; ut_asserteq_ptr(NULL, dev_get_parent_priv(dev)); ut_assertok(device_probe(dev)); parent_data = dev_get_parent_priv(dev); ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag); } uclass_foreach_dev(dev, uc) { /* Ignore these if they are not on this bus */ if (dev->parent != bus) continue; parent_data = dev_get_parent_priv(dev); ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag); ut_assertok(device_remove(dev)); ut_asserteq_ptr(NULL, dev_get_parent_priv(dev)); ut_asserteq_ptr(dms->removed, dev); } test_state = NULL; return 0; }
int blk_unbind_all(int if_type) { struct uclass *uc; struct udevice *dev, *next; int ret; ret = uclass_get(UCLASS_BLK, &uc); if (ret) return ret; uclass_foreach_dev_safe(dev, next, uc) { struct blk_desc *desc = dev_get_uclass_platdata(dev); if (desc->if_type == if_type) { ret = device_remove(dev); if (ret) return ret; ret = device_unbind(dev); if (ret) return ret; } } return 0; }
static int usb_emul_find_devnum(int devnum, struct udevice **emulp) { struct udevice *dev; struct uclass *uc; int ret; *emulp = NULL; ret = uclass_get(UCLASS_USB_EMUL, &uc); if (ret) return ret; uclass_foreach_dev(dev, uc) { struct usb_dev_platdata *udev = dev_get_parent_platdata(dev); if (udev->devnum == devnum) { debug("%s: Found emulator '%s', addr %d\n", __func__, dev->name, udev->devnum); *emulp = dev; return 0; } } debug("%s: No emulator found, addr %d\n", __func__, devnum); return -ENOENT; }
/* Test that autoprobe finds all the expected devices */ static int dm_test_autoprobe(struct unit_test_state *uts) { struct dm_test_state *dms = uts->priv; int expected_base_add; struct udevice *dev; struct uclass *uc; int i; ut_assertok(uclass_get(UCLASS_TEST, &uc)); ut_assert(uc); ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]); ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_PROBE]); ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]); /* The root device should not be activated until needed */ ut_assert(dms->root->flags & DM_FLAG_ACTIVATED); /* * We should be able to find the three test devices, and they should * all be activated as they are used (lazy activation, required by * U-Boot) */ for (i = 0; i < 3; i++) { ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev)); ut_assert(dev); ut_assertf(!(dev->flags & DM_FLAG_ACTIVATED), "Driver %d/%s already activated", i, dev->name); /* This should activate it */ ut_assertok(uclass_get_device(UCLASS_TEST, i, &dev)); ut_assert(dev); ut_assert(dev->flags & DM_FLAG_ACTIVATED); /* Activating a device should activate the root device */ if (!i) ut_assert(dms->root->flags & DM_FLAG_ACTIVATED); } /* * Our 3 dm_test_info children should be passed to pre_probe and * post_probe */ ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]); ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_PRE_PROBE]); /* Also we can check the per-device data */ expected_base_add = 0; for (i = 0; i < 3; i++) { struct dm_test_uclass_perdev_priv *priv; struct dm_test_pdata *pdata; ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev)); ut_assert(dev); priv = dev_get_uclass_priv(dev); ut_assert(priv); ut_asserteq(expected_base_add, priv->base_add); pdata = dev->platdata; expected_base_add += pdata->ping_add; } return 0; }
int mp_init(struct mp_params *p) { int num_aps; atomic_t *ap_count; struct udevice *cpu; int ret; /* This will cause the CPUs devices to be bound */ struct uclass *uc; ret = uclass_get(UCLASS_CPU, &uc); if (ret) return ret; ret = init_bsp(&cpu); if (ret) { debug("Cannot init boot CPU: err=%d\n", ret); return ret; } if (p == NULL || p->flight_plan == NULL || p->num_records < 1) { printf("Invalid MP parameters\n"); return -1; } num_cpus = cpu_get_count(cpu); if (num_cpus < 0) { debug("Cannot get number of CPUs: err=%d\n", num_cpus); return num_cpus; } if (num_cpus < 2) debug("Warning: Only 1 CPU is detected\n"); ret = check_cpu_devices(num_cpus); if (ret) debug("Warning: Device tree does not describe all CPUs. Extra ones will not be started correctly\n"); /* Copy needed parameters so that APs have a reference to the plan */ mp_info.num_records = p->num_records; mp_info.records = p->flight_plan; /* Load the SIPI vector */ ret = load_sipi_vector(&ap_count); if (ap_count == NULL) return -1; /* * Make sure SIPI data hits RAM so the APs that come up will see * the startup code even if the caches are disabled */ wbinvd(); /* Start the APs providing number of APs and the cpus_entered field */ num_aps = num_cpus - 1; ret = start_aps(num_aps, ap_count); if (ret) { mdelay(1000); debug("%d/%d eventually checked in?\n", atomic_read(ap_count), num_aps); return ret; } /* Walk the flight plan for the BSP */ ret = bsp_do_flight_plan(cpu, p); if (ret) { debug("CPU init failed: err=%d\n", ret); return ret; } return 0; }
uc_priv = uc->priv; uclass_foreach_dev(bus, uc) { ret = device_remove(bus); if (ret && !err) err = ret; ret = device_unbind_children(bus); if (ret && !err) err = ret; } #ifdef CONFIG_SANDBOX struct udevice *dev; /* Reset all enulation devices */ ret = uclass_get(UCLASS_USB_EMUL, &uc); if (ret) return ret; uclass_foreach_dev(dev, uc) usb_emul_reset(dev); #endif #ifdef CONFIG_USB_STORAGE usb_stor_reset(); #endif usb_hub_reset(); uc_priv->companion_device_count = 0; usb_started = 0; return err; }