/* Test if bus childs got probed propperly*/
static int dm_test_spmi_probe(struct unit_test_state *uts)
{
const char *name = "spmi@0";
struct udevice *bus, *dev;
ut_assertok(uclass_get_device(UCLASS_SPMI, 0, &bus));
/* Check bus name */
ut_asserteq_str(name, bus->name);
/* Check that it has some devices */
ut_asserteq(device_has_children(bus), true);
ut_assertok(device_find_first_child(bus, &dev));
/* There should be at least one child */
ut_assertnonnull(dev);
/* Check that only PMICs are connected to the bus */
while (dev) {
ut_asserteq(device_get_uclass_id(dev), UCLASS_PMIC);
device_find_next_child(&dev);
}
return 0;
}
static int dm_test_device_get_uclass_id(struct unit_test_state *uts)
{
struct udevice *dev;
ut_assertok(uclass_get_device(UCLASS_TEST, 0, &dev));
ut_asserteq(UCLASS_TEST, device_get_uclass_id(dev));
return 0;
}
/*
* Caution:
* This API requires the given device has alerady been bound to syscon driver.
* For example,
* compatible = "syscon", "simple-mfd";
* works, but
* compatible = "simple-mfd", "syscon";
* does not. The behavior is different from Linux.
*/
struct regmap *syscon_get_regmap(struct udevice *dev)
{
struct syscon_uc_info *priv;
if (device_get_uclass_id(dev) != UCLASS_SYSCON)
return ERR_PTR(-ENOEXEC);
priv = dev_get_uclass_priv(dev);
return priv->regmap;
}
static void ehci_update_endpt2_dev_n_port(struct usb_device *udev,
struct QH *qh)
{
struct usb_device *ttdev;
int parent_devnum;
if (udev->speed != USB_SPEED_LOW && udev->speed != USB_SPEED_FULL)
return;
/*
* For full / low speed devices we need to get the devnum and portnr of
* the tt, so of the first upstream usb-2 hub, there may be usb-1 hubs
* in the tree before that one!
*/
#ifdef CONFIG_DM_USB
/*
* When called from usb-uclass.c: usb_scan_device() udev->dev points
* to the parent udevice, not the actual udevice belonging to the
* udev as the device is not instantiated yet. So when searching
* for the first usb-2 parent start with udev->dev not
* udev->dev->parent .
*/
struct udevice *parent;
struct usb_device *uparent;
ttdev = udev;
parent = udev->dev;
uparent = dev_get_parentdata(parent);
while (uparent->speed != USB_SPEED_HIGH) {
struct udevice *dev = parent;
if (device_get_uclass_id(dev->parent) != UCLASS_USB_HUB) {
printf("ehci: Error cannot find high-speed parent of usb-1 device\n");
return;
}
ttdev = dev_get_parentdata(dev);
parent = dev->parent;
uparent = dev_get_parentdata(parent);
}
parent_devnum = uparent->devnum;
#else
ttdev = udev;
while (ttdev->parent && ttdev->parent->speed != USB_SPEED_HIGH)
ttdev = ttdev->parent;
if (!ttdev->parent)
return;
parent_devnum = ttdev->parent->devnum;
#endif
qh->qh_endpt2 |= cpu_to_hc32(QH_ENDPT2_PORTNUM(ttdev->portnr) |
QH_ENDPT2_HUBADDR(parent_devnum));
}
int cros_ec_probe(struct udevice *dev)
{
struct ec_state *ec = dev->priv;
struct cros_ec_dev *cdev = dev->uclass_priv;
const void *blob = gd->fdt_blob;
struct udevice *keyb_dev;
int node;
int err;
memcpy(ec, &s_state, sizeof(*ec));
err = cros_ec_decode_ec_flash(blob, dev_of_offset(dev), &ec->ec_config);
if (err)
return err;
node = -1;
for (device_find_first_child(dev, &keyb_dev);
keyb_dev;
device_find_next_child(&keyb_dev)) {
if (device_get_uclass_id(keyb_dev) == UCLASS_KEYBOARD) {
node = dev_of_offset(keyb_dev);
break;
}
}
if (node < 0) {
debug("%s: No cros_ec keyboard found\n", __func__);
} else if (keyscan_read_fdt_matrix(ec, blob, node)) {
debug("%s: Could not read key matrix\n", __func__);
return -1;
}
/* If we loaded EC data, check that the length matches */
if (ec->flash_data &&
ec->flash_data_len != ec->ec_config.flash.length) {
printf("EC data length is %x, expected %x, discarding data\n",
ec->flash_data_len, ec->ec_config.flash.length);
os_free(ec->flash_data);
ec->flash_data = NULL;
}
/* Otherwise allocate the memory */
if (!ec->flash_data) {
ec->flash_data_len = ec->ec_config.flash.length;
ec->flash_data = os_malloc(ec->flash_data_len);
if (!ec->flash_data)
return -ENOMEM;
}
cdev->dev = dev;
g_state = ec;
return cros_ec_register(dev);
}
u32 spl_boot_device(void)
{
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
const void *blob = gd->fdt_blob;
struct udevice *dev;
const char *bootdev;
int node;
int ret;
bootdev = fdtdec_get_config_string(blob, "u-boot,boot0");
debug("Boot device %s\n", bootdev);
if (!bootdev)
goto fallback;
node = fdt_path_offset(blob, bootdev);
if (node < 0) {
debug("node=%d\n", node);
goto fallback;
}
ret = device_get_global_by_of_offset(node, &dev);
if (ret) {
debug("device at node %s/%d not found: %d\n", bootdev, node,
ret);
goto fallback;
}
debug("Found device %s\n", dev->name);
switch (device_get_uclass_id(dev)) {
case UCLASS_SPI_FLASH:
return BOOT_DEVICE_SPI;
case UCLASS_MMC:
return BOOT_DEVICE_MMC1;
default:
debug("Booting from device uclass '%s' not supported\n",
dev_get_uclass_name(dev));
}
fallback:
#elif defined(CONFIG_TARGET_CHROMEBOOK_JERRY) || \
defined(CONFIG_TARGET_CHROMEBIT_MICKEY) || \
defined(CONFIG_TARGET_CHROMEBOOK_MINNIE)
return BOOT_DEVICE_SPI;
#endif
return BOOT_DEVICE_MMC1;
}
static int syscon_pre_probe(struct udevice *dev)
{
struct syscon_uc_info *priv = dev_get_uclass_priv(dev);
/* Special case for PCI devices, which don't have a regmap */
if (device_get_uclass_id(dev->parent) == UCLASS_PCI)
return 0;
/*
* With OF_PLATDATA we really have no way of knowing the format of
* the device-specific platform data. So we assume that it starts with
* a 'reg' member, and this holds a single address and size. Drivers
* using OF_PLATDATA will need to ensure that this is true.
*/
#if CONFIG_IS_ENABLED(OF_PLATDATA)
struct syscon_base_platdata *plat = dev_get_platdata(dev);
return regmap_init_mem_platdata(dev, plat->reg, ARRAY_SIZE(plat->reg),
&priv->regmap);
#else
return regmap_init_mem(dev_ofnode(dev), &priv->regmap);
#endif
}
/* Test if it's possible to access GPIO that should be in pmic */
static int dm_test_spmi_access_peripheral(struct unit_test_state *uts)
{
struct udevice *dev;
unsigned int offset, gpio;
const char *name;
int offset_count;
/* Get second pin of PMIC GPIO */
ut_assertok(gpio_lookup_name("spmi1", &dev, &offset, &gpio));
/* Check if PMIC is parent */
ut_asserteq(device_get_uclass_id(dev->parent), UCLASS_PMIC);
/* This should be second gpio */
ut_asserteq(1, offset);
name = gpio_get_bank_info(dev, &offset_count);
/* Check bank name */
ut_asserteq_str("spmi", name);
/* Check pin count */
ut_asserteq(4, offset_count);
ut_assertok(gpio_request(gpio, "testing"));
/* Try to set/clear gpio */
ut_assertok(gpio_direction_output(gpio, 0));
ut_asserteq(gpio_get_value(gpio), 0);
ut_assertok(gpio_direction_output(gpio, 1));
ut_asserteq(gpio_get_value(gpio), 1);
ut_assertok(gpio_direction_input(gpio));
ut_asserteq(gpio_get_value(gpio), 1);
ut_assertok(gpio_free(gpio));
return 0;
}