+5 -8

sound/soc/fsl/imx-card.c

reviewed

··· 513 513 struct device_node *platform = NULL; 514 514 struct device_node *codec = NULL; 515 515 struct device_node *cpu = NULL; 516 516 - struct device_node *np; 517 516 struct device *dev = card->dev; 518 517 struct snd_soc_dai_link *link; 519 518 struct dai_link_data *link_data; ··· 551 552 link = card->dai_link; 552 553 link_data = data->link_data; 553 554 554 554 - for_each_child_of_node(dev->of_node, np) { 555 555 + for_each_child_of_node_scoped(dev->of_node, np) { 555 556 dlc = devm_kzalloc(dev, 2 * sizeof(*dlc), GFP_KERNEL); 556 557 if (!dlc) { 557 557 - ret = -ENOMEM; 558 558 - goto err_put_np; 558 558 + return -ENOMEM; 559 559 } 560 560 561 561 link->cpus = &dlc[0]; ··· 565 567 566 568 ret = of_property_read_string(np, "link-name", &link->name); 567 569 if (ret) { 568 568 - dev_err(card->dev, "error getting codec dai_link name\n"); 569 569 - goto err_put_np; 570 570 + return dev_err_probe(card->dev, ret, 571 571 + "error getting codec dai_link name\n"); 570 572 } 571 573 572 574 cpu = of_get_child_by_name(np, "cpu"); ··· 723 725 of_node_put(cpu); 724 726 of_node_put(codec); 725 727 of_node_put(platform); 726 726 - err_put_np: 727 727 - of_node_put(np); 728 728 + 728 729 return ret; 729 730 } 730 731

+1 -2

sound/soc/meson/axg-card.c

reviewed

··· 222 222 struct axg_dai_link_tdm_data *be) 223 223 { 224 224 struct axg_dai_link_tdm_mask *codec_mask; 225 225 - struct device_node *np; 226 225 227 226 codec_mask = devm_kcalloc(card->dev, link->num_codecs, 228 227 sizeof(*codec_mask), GFP_KERNEL); ··· 230 231 231 232 be->codec_masks = codec_mask; 232 233 233 233 - for_each_child_of_node(node, np) { 234 234 + for_each_child_of_node_scoped(node, np) { 234 235 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-rx-mask", 235 236 &codec_mask->rx); 236 237 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-tx-mask",

+5 -11

sound/soc/meson/meson-card-utils.c

reviewed

··· 137 137 struct device_node *node) 138 138 { 139 139 struct snd_soc_dai_link_component *codec; 140 140 - struct device_node *np; 141 140 int ret, num_codecs; 142 141 143 142 num_codecs = of_get_child_count(node); ··· 153 154 link->codecs = codec; 154 155 link->num_codecs = num_codecs; 155 156 156 156 - for_each_child_of_node(node, np) { 157 157 + for_each_child_of_node_scoped(node, np) { 157 158 ret = meson_card_parse_dai(card, np, codec); 158 158 - if (ret) { 159 159 - of_node_put(np); 159 159 + if (ret) 160 160 return ret; 161 161 - } 162 161 163 162 codec++; 164 163 } 165 164 166 165 ret = meson_card_set_link_name(card, link, node, "be"); 167 166 if (ret) 168 168 - dev_err(card->dev, "error setting %pOFn link name\n", np); 167 167 + dev_err(card->dev, "error setting %pOFn link name\n", node); 169 168 170 169 return ret; 171 170 } ··· 195 198 { 196 199 struct meson_card *priv = snd_soc_card_get_drvdata(card); 197 200 struct device_node *node = card->dev->of_node; 198 198 - struct device_node *np; 199 201 int num, i, ret; 200 202 201 203 num = of_get_child_count(node); ··· 208 212 return ret; 209 213 210 214 i = 0; 211 211 - for_each_child_of_node(node, np) { 215 215 + for_each_child_of_node_scoped(node, np) { 212 216 ret = priv->match_data->add_link(card, np, &i); 213 213 - if (ret) { 214 214 - of_node_put(np); 217 217 + if (ret) 215 218 return ret; 216 216 - } 217 219 218 220 i++; 219 221 }

+11 -24

sound/soc/renesas/rcar/core.c

reviewed

··· 1075 1075 { 1076 1076 struct device *dev = rsnd_priv_to_dev(priv); 1077 1077 struct device_node *ssiu_np = rsnd_ssiu_of_node(priv); 1078 1078 - struct device_node *np; 1079 1078 int is_play = rsnd_io_is_play(io); 1080 1079 int i; 1081 1080 ··· 1093 1094 if (!node) 1094 1095 break; 1095 1096 1096 1096 - for_each_child_of_node(ssiu_np, np) { 1097 1097 + for_each_child_of_node_scoped(ssiu_np, np) { 1097 1098 if (np == node) { 1098 1099 rsnd_flags_set(io, RSND_STREAM_TDM_SPLIT); 1099 1100 dev_dbg(dev, "%s is part of TDM Split\n", io->name); ··· 1153 1154 { 1154 1155 struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai); 1155 1156 struct device *dev = rsnd_priv_to_dev(priv); 1156 1156 - struct device_node *np; 1157 1157 int i; 1158 1158 1159 1159 if (!node) 1160 1160 return; 1161 1161 1162 1162 i = 0; 1163 1163 - for_each_child_of_node(node, np) { 1163 1163 + for_each_child_of_node_scoped(node, np) { 1164 1164 struct rsnd_mod *mod; 1165 1165 1166 1166 i = rsnd_node_fixed_index(dev, np, name, i); 1167 1167 - if (i < 0) { 1168 1168 - of_node_put(np); 1167 1167 + if (i < 0) 1169 1168 break; 1170 1170 - } 1171 1169 1172 1170 mod = mod_get(priv, i); 1173 1171 ··· 1213 1217 int rsnd_node_count(struct rsnd_priv *priv, struct device_node *node, char *name) 1214 1218 { 1215 1219 struct device *dev = rsnd_priv_to_dev(priv); 1216 1216 - struct device_node *np; 1217 1220 int i; 1218 1221 1219 1222 i = 0; 1220 1220 - for_each_child_of_node(node, np) { 1223 1223 + for_each_child_of_node_scoped(node, np) { 1221 1224 i = rsnd_node_fixed_index(dev, np, name, i); 1222 1222 - if (i < 0) { 1223 1223 - of_node_put(np); 1225 1225 + if (i < 0) 1224 1226 return 0; 1225 1225 - } 1226 1227 i++; 1227 1228 } 1228 1229 ··· 1243 1250 { 1244 1251 struct device *dev = rsnd_priv_to_dev(priv); 1245 1252 struct device_node *np = dev->of_node; 1246 1246 - struct device_node *ports, *node; 1253 1253 + struct device_node *node; 1247 1254 int nr = 0; 1248 1255 int i = 0; 1249 1256 ··· 1263 1270 1264 1271 of_node_put(node); 1265 1272 1266 1266 - for_each_child_of_node(np, node) { 1273 1273 + for_each_child_of_node_scoped(np, node) { 1267 1274 if (!of_node_name_eq(node, RSND_NODE_DAI)) 1268 1275 continue; 1269 1276 ··· 1272 1279 i++; 1273 1280 if (i >= RSND_MAX_COMPONENT) { 1274 1281 dev_info(dev, "reach to max component\n"); 1275 1275 - of_node_put(node); 1276 1282 break; 1277 1283 } 1278 1284 } ··· 1282 1290 /* 1283 1291 * Audio-Graph-Card 1284 1292 */ 1285 1285 - for_each_child_of_node(np, ports) { 1293 1293 + for_each_child_of_node_scoped(np, ports) { 1286 1294 node = rsnd_pick_endpoint_node_for_ports(ports, np); 1287 1295 if (!node) 1288 1296 continue; ··· 1291 1299 i++; 1292 1300 if (i >= RSND_MAX_COMPONENT) { 1293 1301 dev_info(dev, "reach to max component\n"); 1294 1294 - of_node_put(ports); 1295 1302 break; 1296 1303 } 1297 1304 } ··· 1496 1505 dai_i = 0; 1497 1506 if (is_graph) { 1498 1507 struct device_node *dai_np_port; 1499 1499 - struct device_node *ports; 1500 1508 struct device_node *dai_np; 1501 1509 1502 1502 - for_each_child_of_node(np, ports) { 1510 1510 + for_each_child_of_node_scoped(np, ports) { 1503 1511 dai_np_port = rsnd_pick_endpoint_node_for_ports(ports, np); 1504 1512 if (!dai_np_port) 1505 1513 continue; ··· 1515 1525 } 1516 1526 } 1517 1527 } else { 1518 1518 - struct device_node *node; 1519 1519 - struct device_node *dai_np; 1520 1520 - 1521 1521 - for_each_child_of_node(np, node) { 1528 1528 + for_each_child_of_node_scoped(np, node) { 1522 1529 if (!of_node_name_eq(node, RSND_NODE_DAI)) 1523 1530 continue; 1524 1531 1525 1525 - for_each_child_of_node(node, dai_np) { 1532 1532 + for_each_child_of_node_scoped(node, dai_np) { 1526 1533 __rsnd_dai_probe(priv, dai_np, np, dai_i, dai_i); 1527 1534 if (!rsnd_is_gen1(priv) && !rsnd_is_gen2(priv)) { 1528 1535 rdai = rsnd_rdai_get(priv, dai_i);

+2 -6

sound/soc/renesas/rcar/ctu.c

reviewed

··· 316 316 int rsnd_ctu_probe(struct rsnd_priv *priv) 317 317 { 318 318 struct device_node *node; 319 319 - struct device_node *np; 320 319 struct device *dev = rsnd_priv_to_dev(priv); 321 320 struct rsnd_ctu *ctu; 322 321 struct clk *clk; ··· 343 344 344 345 i = 0; 345 346 ret = 0; 346 346 - for_each_child_of_node(node, np) { 347 347 + for_each_child_of_node_scoped(node, np) { 347 348 ctu = rsnd_ctu_get(priv, i); 348 349 349 350 /* ··· 356 357 clk = devm_clk_get(dev, name); 357 358 if (IS_ERR(clk)) { 358 359 ret = PTR_ERR(clk); 359 359 - of_node_put(np); 360 360 goto rsnd_ctu_probe_done; 361 361 } 362 362 363 363 ret = rsnd_mod_init(priv, rsnd_mod_get(ctu), &rsnd_ctu_ops, 364 364 clk, RSND_MOD_CTU, i); 365 365 - if (ret) { 366 366 - of_node_put(np); 365 365 + if (ret) 367 366 goto rsnd_ctu_probe_done; 368 368 - } 369 367 370 368 i++; 371 369 }

+1 -3

sound/soc/renesas/rcar/dma.c

reviewed

··· 194 194 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 195 195 struct device *dev = rsnd_priv_to_dev(priv); 196 196 struct dma_chan *chan = NULL; 197 197 - struct device_node *np; 198 197 int i = 0; 199 198 200 200 - for_each_child_of_node(of_node, np) { 199 199 + for_each_child_of_node_scoped(of_node, np) { 201 200 i = rsnd_node_fixed_index(dev, np, name, i); 202 201 if (i < 0) { 203 202 chan = NULL; 204 204 - of_node_put(np); 205 203 break; 206 204 } 207 205

+2 -6

sound/soc/renesas/rcar/dvc.c

reviewed

··· 324 324 int rsnd_dvc_probe(struct rsnd_priv *priv) 325 325 { 326 326 struct device_node *node; 327 327 - struct device_node *np; 328 327 struct device *dev = rsnd_priv_to_dev(priv); 329 328 struct rsnd_dvc *dvc; 330 329 struct clk *clk; ··· 351 352 352 353 i = 0; 353 354 ret = 0; 354 354 - for_each_child_of_node(node, np) { 355 355 + for_each_child_of_node_scoped(node, np) { 355 356 dvc = rsnd_dvc_get(priv, i); 356 357 357 358 snprintf(name, RSND_DVC_NAME_SIZE, "%s.%d", ··· 360 361 clk = devm_clk_get(dev, name); 361 362 if (IS_ERR(clk)) { 362 363 ret = PTR_ERR(clk); 363 363 - of_node_put(np); 364 364 goto rsnd_dvc_probe_done; 365 365 } 366 366 367 367 ret = rsnd_mod_init(priv, rsnd_mod_get(dvc), &rsnd_dvc_ops, 368 368 clk, RSND_MOD_DVC, i); 369 369 - if (ret) { 370 370 - of_node_put(np); 369 369 + if (ret) 371 370 goto rsnd_dvc_probe_done; 372 372 - } 373 371 374 372 i++; 375 373 }

+2 -6

sound/soc/renesas/rcar/mix.c

reviewed

··· 288 288 int rsnd_mix_probe(struct rsnd_priv *priv) 289 289 { 290 290 struct device_node *node; 291 291 - struct device_node *np; 292 291 struct device *dev = rsnd_priv_to_dev(priv); 293 292 struct rsnd_mix *mix; 294 293 struct clk *clk; ··· 315 316 316 317 i = 0; 317 318 ret = 0; 318 318 - for_each_child_of_node(node, np) { 319 319 + for_each_child_of_node_scoped(node, np) { 319 320 mix = rsnd_mix_get(priv, i); 320 321 321 322 snprintf(name, MIX_NAME_SIZE, "%s.%d", ··· 324 325 clk = devm_clk_get(dev, name); 325 326 if (IS_ERR(clk)) { 326 327 ret = PTR_ERR(clk); 327 327 - of_node_put(np); 328 328 goto rsnd_mix_probe_done; 329 329 } 330 330 331 331 ret = rsnd_mod_init(priv, rsnd_mod_get(mix), &rsnd_mix_ops, 332 332 clk, RSND_MOD_MIX, i); 333 333 - if (ret) { 334 334 - of_node_put(np); 333 333 + if (ret) 335 334 goto rsnd_mix_probe_done; 336 336 - } 337 335 338 336 i++; 339 337 }

+2 -8

sound/soc/renesas/rcar/src.c

reviewed

··· 715 715 int rsnd_src_probe(struct rsnd_priv *priv) 716 716 { 717 717 struct device_node *node; 718 718 - struct device_node *np; 719 718 struct device *dev = rsnd_priv_to_dev(priv); 720 719 struct rsnd_src *src; 721 720 struct clk *clk; ··· 741 742 priv->src = src; 742 743 743 744 i = 0; 744 744 - for_each_child_of_node(node, np) { 745 745 + for_each_child_of_node_scoped(node, np) { 745 746 if (!of_device_is_available(np)) 746 747 goto skip; 747 748 748 749 i = rsnd_node_fixed_index(dev, np, SRC_NAME, i); 749 750 if (i < 0) { 750 751 ret = -EINVAL; 751 751 - of_node_put(np); 752 752 goto rsnd_src_probe_done; 753 753 } 754 754 ··· 759 761 src->irq = irq_of_parse_and_map(np, 0); 760 762 if (!src->irq) { 761 763 ret = -EINVAL; 762 762 - of_node_put(np); 763 764 goto rsnd_src_probe_done; 764 765 } 765 766 766 767 clk = devm_clk_get(dev, name); 767 768 if (IS_ERR(clk)) { 768 769 ret = PTR_ERR(clk); 769 769 - of_node_put(np); 770 770 goto rsnd_src_probe_done; 771 771 } 772 772 773 773 ret = rsnd_mod_init(priv, rsnd_mod_get(src), 774 774 &rsnd_src_ops, clk, RSND_MOD_SRC, i); 775 775 - if (ret) { 776 776 - of_node_put(np); 775 775 + if (ret) 777 776 goto rsnd_src_probe_done; 778 778 - } 779 777 780 778 skip: 781 779 i++;

+5 -13

sound/soc/renesas/rcar/ssi.c

reviewed

··· 1115 1115 struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai); 1116 1116 struct device *dev = rsnd_priv_to_dev(priv); 1117 1117 struct device_node *node; 1118 1118 - struct device_node *np; 1119 1118 int i; 1120 1119 1121 1120 node = rsnd_ssi_of_node(priv); ··· 1122 1123 return; 1123 1124 1124 1125 i = 0; 1125 1125 - for_each_child_of_node(node, np) { 1126 1126 + for_each_child_of_node_scoped(node, np) { 1126 1127 struct rsnd_mod *mod; 1127 1128 1128 1129 i = rsnd_node_fixed_index(dev, np, SSI_NAME, i); 1129 1129 - if (i < 0) { 1130 1130 - of_node_put(np); 1130 1130 + if (i < 0) 1131 1131 break; 1132 1132 - } 1133 1132 1134 1133 mod = rsnd_ssi_mod_get(priv, i); 1135 1134 ··· 1160 1163 int rsnd_ssi_probe(struct rsnd_priv *priv) 1161 1164 { 1162 1165 struct device_node *node; 1163 1163 - struct device_node *np; 1164 1166 struct device *dev = rsnd_priv_to_dev(priv); 1165 1167 struct rsnd_mod_ops *ops; 1166 1168 struct clk *clk; ··· 1187 1191 priv->ssi_nr = nr; 1188 1192 1189 1193 i = 0; 1190 1190 - for_each_child_of_node(node, np) { 1194 1194 + for_each_child_of_node_scoped(node, np) { 1191 1195 if (!of_device_is_available(np)) 1192 1196 goto skip; 1193 1197 1194 1198 i = rsnd_node_fixed_index(dev, np, SSI_NAME, i); 1195 1199 if (i < 0) { 1196 1200 ret = -EINVAL; 1197 1197 - of_node_put(np); 1198 1201 goto rsnd_ssi_probe_done; 1199 1202 } 1200 1203 ··· 1205 1210 clk = devm_clk_get(dev, name); 1206 1211 if (IS_ERR(clk)) { 1207 1212 ret = PTR_ERR(clk); 1208 1208 - of_node_put(np); 1209 1213 goto rsnd_ssi_probe_done; 1210 1214 } 1211 1215 ··· 1217 1223 ssi->irq = irq_of_parse_and_map(np, 0); 1218 1224 if (!ssi->irq) { 1219 1225 ret = -EINVAL; 1220 1220 - of_node_put(np); 1221 1226 goto rsnd_ssi_probe_done; 1222 1227 } 1223 1228 ··· 1227 1234 1228 1235 ret = rsnd_mod_init(priv, rsnd_mod_get(ssi), ops, clk, 1229 1236 RSND_MOD_SSI, i); 1230 1230 - if (ret) { 1231 1231 - of_node_put(np); 1237 1237 + if (ret) 1232 1238 goto rsnd_ssi_probe_done; 1233 1233 - } 1239 1239 + 1234 1240 skip: 1235 1241 i++; 1236 1242 }

+2 -5

sound/soc/renesas/rcar/ssiu.c

reviewed

··· 478 478 479 479 /* use rcar_sound,ssiu if exist */ 480 480 if (node) { 481 481 - struct device_node *np; 482 481 int i = 0; 483 482 484 484 - for_each_child_of_node(node, np) { 483 483 + for_each_child_of_node_scoped(node, np) { 485 484 struct rsnd_mod *mod; 486 485 487 486 i = rsnd_node_fixed_index(dev, np, SSIU_NAME, i); 488 488 - if (i < 0) { 489 489 - of_node_put(np); 487 487 + if (i < 0) 490 488 break; 491 491 - } 492 489 493 490 mod = rsnd_ssiu_mod_get(priv, i); 494 491