i2c_set_clientdata(client, priv);
- struct device_node *ledNode;
- for_each_child_of_node(client->dev.of_node, ledNode) {
+ device_for_each_child_node_scoped(client->dev, ledNode) {
+ const char *lname = fwnode_get_name(ledNode);
u32 regValue = 0;
- if (of_property_read_u32(ledNode, "reg", ®Value))
- pr_info("Missing entry \"reg\" in node %s\n",
- ledNode->name);
+ if (fwnode_property_read_u32(ledNode, "reg", ®Value))
+ pr_info("Missing entry \"reg\" in node %s\n", lname);
else if (regValue >= GCA230718_MAX_LEDS)
pr_info("Invalid entry \"reg\" in node %s (%u)\n",
- ledNode->name, regValue);
+ lname, regValue);
else {
struct led_classdev *ledClassDev =
&(priv->leds[regValue].ledClassDev);
struct led_init_data init_data = {};
priv->leds[regValue].client = client;
- init_data.fwnode = of_fwnode_handle(ledNode);
+ init_data.fwnode = fwnode_handle_get(ledNode);
pr_info("Creating LED for node %s: reg=%u\n",
- ledNode->name, regValue);
+ lname, regValue);
- ledClassDev->name =
- of_get_property(ledNode, "label", NULL);
- if (!ledClassDev->name)
- ledClassDev->name = ledNode->name;
+ ledClassDev->name = lname;
+ fwnode_property_read_string(ledNode, "label", &ledClassDev->name);
ledClassDev->brightness = LED_OFF;
ledClassDev->max_brightness = LED_FULL;
struct device *dev = &spi->dev;
int cur_led = 0;
struct ws2812b_priv *priv;
- struct fwnode_handle *led_node;
int num_leds, i, cnt, ret;
num_leds = device_get_child_node_count(dev);
priv->num_leds = num_leds;
priv->spi = spi;
- device_for_each_child_node(dev, led_node) {
+ device_for_each_child_node_scoped(dev, led_node) {
struct led_init_data init_data = {
- .fwnode = led_node,
+ .fwnode = fwnode_handle_get(led_node),
};
/* WS2812B LEDs usually come with GRB color */
u32 color_idx[WS2812B_NUM_COLORS] = {
{
struct device *dev = &spi->dev;
struct device_node *np = dev_of_node(dev);
- struct device_node *child;
int rc;
rc = msp430_check_workmode(spi);
if (rc)
return rc;
- for_each_available_child_of_node(np, child) {
+ for_each_available_child_of_node_scoped(np, child) {
u32 reg;
if (of_property_read_u32(child, "reg", ®))
}
rc = msp430_led_probe(spi, child, reg);
- if (rc < 0) {
- of_node_put(child);
+ if (rc < 0)
return rc;
- }
}
return 0;
add_remap_range(ctx, 0, ctx->reserve_area_begin);
} else {
struct device_node *parts_np;
- struct device_node *part_np;
parts_np = of_get_child_by_name(np, "partitions");
- for_each_child_of_node(parts_np, part_np) {
+ for_each_child_of_node_scoped(parts_np, part_np) {
u32 start;
u32 size;
const __be32 *reg;
int active, u32 bootnum_dt)
{
struct device_node *np = mtd_get_of_node(mtd);
- struct device_node *child;
struct mtd_partition *parts;
int ret, nr_parts, index = 0;
if (!parts)
return -ENOMEM;
- for_each_child_of_node(np, child) {
+ for_each_child_of_node_scoped(np, child) {
u32 reg[2];
if (of_n_addr_cells(child) != 1 ||
of_n_size_cells(child) != 1)
parts[index].size = reg[1];
index++;
}
- of_node_put(child);
if (ret)
kfree(parts);
/* First count the subnodes */
np = 0;
- for_each_child_of_node(rbpart_node, pp)
+ for_each_child_of_node_scoped(rbpart_node, pp)
np++;
if (!np)
np = 0;
master_ofs = 0;
- for_each_child_of_node(rbpart_node, pp) {
+ for_each_child_of_node_scoped(rbpart_node, pp) {
const __be32 *reg, *sz;
size_t offset, size;
int i, len, a_cells, s_cells;
rbpart_fail:
pr_err("%s: error parsing routerboot partition %pOF (%pOF)\n",
master->name, pp, rbpart_node);
- of_node_put(pp);
kfree(parts);
return -EINVAL;
}
const __be32 *paddr;
int len;
int i;
- struct device_node *leds, *child;
+ struct device_node *leds;
paddr = of_get_property(np, "qca,ar8327-initvals", &len);
if (!paddr || len < (2 * sizeof(*paddr)))
if (!data->leds)
return -ENOMEM;
- for_each_available_child_of_node(leds, child) {
+ for_each_available_child_of_node_scoped(leds, child) {
u32 reg = 0, mode = 0;
struct ar8327_led_info info;
int ret;
static int b53_configure_ports_of(struct b53_device *dev)
{
- struct device_node *dn, *pn;
+ struct device_node *dn;
u32 port_num;
dn = of_get_child_by_name(dev_of_node(dev->dev), "ports");
- for_each_available_child_of_node(dn, pn) {
+ for_each_available_child_of_node_scoped(dn, pn) {
struct device_node *fixed_link;
if (of_property_read_u32(pn, "reg", &port_num))
static int b53_switch_init_of(struct b53_device *dev)
{
- struct device_node *dn, *pn;
+ struct device_node *dn;
const char *alias;
u32 port_num;
u16 ports = 0;
if (!dn)
return -EINVAL;
- for_each_available_child_of_node(dn, pn) {
+ for_each_available_child_of_node_scoped(dn, pn) {
const char *label;
int len;
static void
of_switch_load_portmap(struct switch_dev *dev)
{
- struct device_node *port;
-
if (!dev->of_node)
return;
- for_each_child_of_node(dev->of_node, port) {
+ for_each_child_of_node_scoped(dev->of_node, port) {
const __be32 *prop;
const char *segment;
int size, phys;
+qca8k_do_dsa_sw_ports_self_test(struct qca8k_priv *priv, int parallel_test)
+{
+ struct device_node *dn = priv->dev->of_node;
-+ struct device_node *ports, *port;
++ struct device_node *ports;
+ struct device_node *phy_dn;
+ struct phy_device *phy;
+ int reg, err = 0, test_phase;
+ if (err)
+ goto error;
+ }
-+ for_each_available_child_of_node(ports, port) {
++ for_each_available_child_of_node_scoped(ports, port) {
+ err = of_property_read_u32(port, "reg", ®);
+ if (err)
+ goto error;
srg_led_probe(struct i2c_client *client)
{
- struct device_node *np = client->dev.of_node, *child;
+ struct device_node *np = client->dev.of_node;
struct srg_led_ctrl *sysled_ctrl;
int err;
i2c_set_clientdata(client, sysled_ctrl);
- for_each_available_child_of_node(np, child) {
+ for_each_available_child_of_node_scoped(np, child) {
if (srg_led_init_led(sysled_ctrl, child))
continue;
obj-$(CONFIG_SENSORS_IBMPOWERNV)+= ibmpowernv.o
--- /dev/null
+++ b/drivers/hwmon/iei-wt61p803-puzzle-hwmon.c
-@@ -0,0 +1,444 @@
+@@ -0,0 +1,442 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/* IEI WT61P803 PUZZLE MCU HWMON Driver
+ *
+ struct device *dev = &pdev->dev;
+ struct iei_wt61p803_puzzle *mcu = dev_get_drvdata(dev->parent);
+ struct iei_wt61p803_puzzle_hwmon *mcu_hwmon;
-+ struct fwnode_handle *child;
+ struct device *hwmon_dev;
+ int ret;
+
+
+ /* Control fans via PWM lines via Linux Kernel */
+ if (IS_ENABLED(CONFIG_THERMAL)) {
-+ device_for_each_child_node(dev, child) {
++ device_for_each_child_node_scoped(dev, child) {
+ ret = iei_wt61p803_puzzle_enable_thermal_cooling_dev(dev, child, mcu_hwmon);
+ if (ret) {
+ dev_err(dev, "Enabling the PWM fan failed\n");
-+ fwnode_handle_put(child);
+ return ret;
+ }
+ }
ret = iei_wt61p803_puzzle_write_command(priv->mcu, led_power_cmd,
sizeof(led_power_cmd),
-@@ -90,39 +106,168 @@ static enum led_brightness iei_wt61p803_
+@@ -90,39 +106,166 @@ static enum led_brightness iei_wt61p803_
return led_state;
}
{
struct device *dev = &pdev->dev;
+ struct device_node *np = dev_of_node(dev);
-+ struct device_node *child;
struct iei_wt61p803_puzzle *mcu = dev_get_drvdata(dev->parent);
struct iei_wt61p803_puzzle_led *priv;
- struct led_init_data init_data = {};
- priv->cdev.brightness_set_blocking = iei_wt61p803_puzzle_led_brightness_set_blocking;
- priv->cdev.brightness_get = iei_wt61p803_puzzle_led_brightness_get;
- priv->cdev.max_brightness = 1;
-+ for_each_available_child_of_node(np, child) {
++ for_each_available_child_of_node_scoped(np, child) {
+ struct led_init_data init_data = {};
- ret = devm_led_classdev_register_ext(dev, &priv->cdev, &init_data);
+ priv->id = reg;
+ priv->led_power_state = 1;
+ priv->blinking = 0;
-+ init_data.fwnode = of_fwnode_handle(child);
++ init_data.fwnode = of_fwnode_handle(of_node_get(child));
+
+ priv->cdev.brightness_set_blocking = iei_wt61p803_puzzle_led_brightness_set_blocking;
+ priv->cdev.brightness_get = iei_wt61p803_puzzle_led_brightness_get;
- fwnode_handle_put(child);
+put_child_node:
-+ of_node_put(child);
return ret;
}
int mtk_gsw_init(struct fe_priv *priv)
{
struct device_node *eth_node = priv->dev->of_node;
- struct device_node *phy_node, *mdiobus_node;
+ struct device_node *mdiobus_node;
struct device_node *np = priv->switch_np;
struct platform_device *pdev;
struct mt7620_gsw *gsw;
mdiobus_node = of_get_child_by_name(eth_node, "mdio-bus");
if (mdiobus_node) {
- for_each_child_of_node(mdiobus_node, phy_node) {
+ for_each_child_of_node_scoped(mdiobus_node, phy_node) {
id = of_get_property(phy_node, "reg", NULL);
if (id && (be32_to_cpu(*id) == 0x1f))
gsw->ephy_disable = true;
static int __init fe_init(struct net_device *dev)
{
struct fe_priv *priv = netdev_priv(dev);
- struct device_node *port;
int err;
fe_reset_fe(priv);
return err;
if (priv->soc->port_init)
- for_each_child_of_node(priv->dev->of_node, port)
+ for_each_child_of_node_scoped(priv->dev->of_node, port)
if (of_device_is_compatible(port, "mediatek,eth-port") &&
of_device_is_available(port))
priv->soc->port_init(priv, port);
static int gpio_shared_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
- struct fwnode_handle *child;
struct gpio_shared_ctx *ctx;
int msecs, ret, bus_num = -1;
if (device_get_child_node_count(dev) > GPIO_SHARED_MAX_BUS)
return dev_err_probe(dev, -EINVAL, "Too many channels\n");
- device_for_each_child_node(dev, child) {
+ device_for_each_child_node_scoped(dev, child) {
struct gpio_shared_bus *bus = &ctx->bus[++bus_num];
struct i2c_adapter *adap = &bus->adap;
struct i2c_algo_bit_data *bit_data = &bus->bit_data;
bus->sda = devm_fwnode_gpiod_get(dev, child, "sda", GPIOD_OUT_HIGH_OPEN_DRAIN,
fwnode_get_name(child));
if (IS_ERR(bus->sda)) {
- fwnode_handle_put(child);
dev_err(dev, "SDA node for bus %d not found\n", bus_num);
continue;
}
struct sf21_pcie_phy *p_phy;
struct phy_provider *provider;
struct phy *phy;
- struct device_node *child;
int num_insts = 0;
u32 reg_idx, num_lanes, lvds_idx;
int ret;
regmap_clear_bits(p_phy->pcie_regmap, PCIE_SYSM_INIT,
PCIE_L1_RSTN | PCIE_L0_RSTN | PCIE_PHY_RSTN);
- for_each_available_child_of_node(pdev->dev.of_node, child) {
+ for_each_available_child_of_node_scoped(pdev->dev.of_node, child) {
ret = of_property_read_u32(child, "reg", ®_idx);
if (ret)
return dev_err_probe(