static int pwm_backlight_ofdata_to_platdata(struct udevice *dev) { struct pwm_backlight_priv *priv = dev_get_priv(dev); struct ofnode_phandle_args args; int index, ret, count, len; const u32 *cell; log_debug("start\n"); ret = uclass_get_device_by_phandle(UCLASS_REGULATOR, dev, "power-supply", &priv->reg); if (ret) log_debug("Cannot get power supply: ret=%d\n", ret); ret = gpio_request_by_name(dev, "enable-gpios", 0, &priv->enable, GPIOD_IS_OUT); if (ret) { log_debug("Warning: cannot get enable GPIO: ret=%d\n", ret); if (ret != -ENOENT) return log_ret(ret); } ret = dev_read_phandle_with_args(dev, "pwms", "#pwm-cells", 0, 0, &args); if (ret) { log_debug("Cannot get PWM phandle: ret=%d\n", ret); return log_ret(ret); } ret = uclass_get_device_by_ofnode(UCLASS_PWM, args.node, &priv->pwm); if (ret) { log_debug("Cannot get PWM: ret=%d\n", ret); return log_ret(ret); } if (args.args_count < 2) return log_msg_ret("Not enough arguments to pwm\n", -EINVAL); priv->channel = args.args[0]; priv->period_ns = args.args[1]; if (args.args_count > 2) priv->polarity = args.args[2]; index = dev_read_u32_default(dev, "default-brightness-level", 255); cell = dev_read_prop(dev, "brightness-levels", &len); count = len / sizeof(u32); if (cell && count > index) { priv->levels = malloc(len); if (!priv->levels) return log_ret(-ENOMEM); dev_read_u32_array(dev, "brightness-levels", priv->levels, count); priv->num_levels = count; priv->default_level = priv->levels[index]; priv->max_level = priv->levels[count - 1]; } else { priv->default_level = index; priv->max_level = 255; } priv->cur_level = priv->default_level; log_debug("done\n"); return 0; }
static int pwm_backlight_ofdata_to_platdata(struct udevice *dev) { struct pwm_backlight_priv *priv = dev_get_priv(dev); struct ofnode_phandle_args args; int index, ret, count, len; const u32 *cell; debug("%s: start\n", __func__); ret = uclass_get_device_by_phandle(UCLASS_REGULATOR, dev, "power-supply", &priv->reg); if (ret) debug("%s: Cannot get power supply: ret=%d\n", __func__, ret); ret = gpio_request_by_name(dev, "enable-gpios", 0, &priv->enable, GPIOD_IS_OUT); if (ret) { debug("%s: Warning: cannot get enable GPIO: ret=%d\n", __func__, ret); if (ret != -ENOENT) return ret; } ret = dev_read_phandle_with_args(dev, "pwms", "#pwm-cells", 0, 0, &args); if (ret) { debug("%s: Cannot get PWM phandle: ret=%d\n", __func__, ret); return ret; } ret = uclass_get_device_by_ofnode(UCLASS_PWM, args.node, &priv->pwm); if (ret) { debug("%s: Cannot get PWM: ret=%d\n", __func__, ret); return ret; } priv->channel = args.args[0]; priv->period_ns = args.args[1]; index = dev_read_u32_default(dev, "default-brightness-level", 255); cell = dev_read_prop(dev, "brightness-levels", &len); count = len / sizeof(u32); if (cell && count > index) { priv->default_level = fdt32_to_cpu(cell[index]); priv->max_level = fdt32_to_cpu(cell[count - 1]); } else { priv->default_level = index; priv->max_level = 255; } debug("%s: done\n", __func__); return 0; }
/* * Linux-compatible syscon-to-regmap * The syscon node can be bound to another driver, but still works * as a syscon provider. */ struct regmap *syscon_node_to_regmap(ofnode node) { struct udevice *dev; struct regmap *r; if (uclass_get_device_by_ofnode(UCLASS_SYSCON, node, &dev)) if (syscon_probe_by_ofnode(node, &dev)) return ERR_PTR(-ENODEV); r = syscon_get_regmap(dev); if (!r) { dev_dbg(dev, "unable to find regmap\n"); return ERR_PTR(-ENODEV); } return r; }
static int pinctrl_gpio_get_pinctrl_and_offset(struct udevice *dev, unsigned offset, struct udevice **pctldev, unsigned int *pin_selector) { struct ofnode_phandle_args args; unsigned gpio_offset, pfc_base, pfc_pins; int ret; ret = dev_read_phandle_with_args(dev, "gpio-ranges", NULL, 3, 0, &args); if (ret) { dev_dbg(dev, "%s: dev_read_phandle_with_args: err=%d\n", __func__, ret); return ret; } ret = uclass_get_device_by_ofnode(UCLASS_PINCTRL, args.node, pctldev); if (ret) { dev_dbg(dev, "%s: uclass_get_device_by_of_offset failed: err=%d\n", __func__, ret); return ret; } gpio_offset = args.args[0]; pfc_base = args.args[1]; pfc_pins = args.args[2]; if (offset < gpio_offset || offset > gpio_offset + pfc_pins) { dev_dbg(dev, "%s: GPIO can not be mapped to pincontrol pin\n", __func__); return -EINVAL; } offset -= gpio_offset; offset += pfc_base; *pin_selector = offset; return 0; }
int clk_get_by_index(struct udevice *dev, int index, struct clk *clk) { int ret; struct ofnode_phandle_args args; struct udevice *dev_clk; struct clk_ops *ops; debug("%s(dev=%p, index=%d, clk=%p)\n", __func__, dev, index, clk); assert(clk); clk->dev = NULL; ret = dev_read_phandle_with_args(dev, "clocks", "#clock-cells", 0, index, &args); if (ret) { debug("%s: fdtdec_parse_phandle_with_args failed: err=%d\n", __func__, ret); return ret; } ret = uclass_get_device_by_ofnode(UCLASS_CLK, args.node, &dev_clk); if (ret) { debug("%s: uclass_get_device_by_of_offset failed: err=%d\n", __func__, ret); return ret; } clk->dev = dev_clk; ops = clk_dev_ops(dev_clk); if (ops->of_xlate) ret = ops->of_xlate(clk, &args); else ret = clk_of_xlate_default(clk, &args); if (ret) { debug("of_xlate() failed: %d\n", ret); return ret; } return clk_request(dev_clk, clk); }
static int gpio_request_tail(int ret, ofnode node, struct ofnode_phandle_args *args, const char *list_name, int index, struct gpio_desc *desc, int flags, bool add_index) { desc->dev = NULL; desc->offset = 0; desc->flags = 0; if (ret) goto err; ret = uclass_get_device_by_ofnode(UCLASS_GPIO, args->node, &desc->dev); if (ret) { debug("%s: uclass_get_device_by_of_offset failed\n", __func__); goto err; } ret = gpio_find_and_xlate(desc, args); if (ret) { debug("%s: gpio_find_and_xlate failed\n", __func__); goto err; } ret = dm_gpio_requestf(desc, add_index ? "%s.%s%d" : "%s.%s", ofnode_get_name(node), list_name, index); if (ret) { debug("%s: dm_gpio_requestf failed\n", __func__); goto err; } ret = dm_gpio_set_dir_flags(desc, flags | desc->flags); if (ret) { debug("%s: dm_gpio_set_dir failed\n", __func__); goto err; } return 0; err: debug("%s: Node '%s', property '%s', failed to request GPIO index %d: %d\n", __func__, ofnode_get_name(node), list_name, index, ret); return ret; }
static void serial_find_console_or_panic(void) { const void *blob = gd->fdt_blob; struct udevice *dev; #ifdef CONFIG_SERIAL_SEARCH_ALL int ret; #endif if (CONFIG_IS_ENABLED(OF_PLATDATA)) { uclass_first_device(UCLASS_SERIAL, &dev); if (dev) { gd->cur_serial_dev = dev; return; } } else if (CONFIG_IS_ENABLED(OF_CONTROL) && blob) { /* Live tree has support for stdout */ if (of_live_active()) { struct device_node *np = of_get_stdout(); if (np && !uclass_get_device_by_ofnode(UCLASS_SERIAL, np_to_ofnode(np), &dev)) { gd->cur_serial_dev = dev; return; } } else { if (!serial_check_stdout(blob, &dev)) { gd->cur_serial_dev = dev; return; } } } if (!SPL_BUILD || !CONFIG_IS_ENABLED(OF_CONTROL) || !blob) { /* * Try to use CONFIG_CONS_INDEX if available (it is numbered * from 1!). * * Failing that, get the device with sequence number 0, or in * extremis just the first working serial device we can find. * But we insist on having a console (even if it is silent). */ #ifdef CONFIG_CONS_INDEX #define INDEX (CONFIG_CONS_INDEX - 1) #else #define INDEX 0 #endif #ifdef CONFIG_SERIAL_SEARCH_ALL if (!uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) || !uclass_get_device(UCLASS_SERIAL, INDEX, &dev)) { if (dev->flags & DM_FLAG_ACTIVATED) { gd->cur_serial_dev = dev; return; } } /* Search for any working device */ for (ret = uclass_first_device_check(UCLASS_SERIAL, &dev); dev; ret = uclass_next_device_check(&dev)) { if (!ret) { /* Device did succeed probing */ gd->cur_serial_dev = dev; return; } } #else if (!uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) || !uclass_get_device(UCLASS_SERIAL, INDEX, &dev) || (!uclass_first_device(UCLASS_SERIAL, &dev) && dev)) { gd->cur_serial_dev = dev; return; } #endif #undef INDEX } #ifdef CONFIG_REQUIRE_SERIAL_CONSOLE panic_str("No serial driver found"); #endif }