Merge tag 'rproc-v6.14' of git://git.kernel.org/pub/scm/linux/kernel/git/remoteproc/linux

+4 -13

drivers/remoteproc/keystone_remoteproc.c

··· 335 335 { 336 336 struct device_node *np = pdev->dev.of_node; 337 337 struct device *dev = &pdev->dev; 338 - int ret; 339 338 340 339 if (!of_property_read_bool(np, "ti,syscon-dev")) { 341 340 dev_err(dev, "ti,syscon-dev property is absent\n"); 342 341 return -EINVAL; 343 342 } 344 343 345 - ksproc->dev_ctrl = 346 - syscon_regmap_lookup_by_phandle(np, "ti,syscon-dev"); 347 - if (IS_ERR(ksproc->dev_ctrl)) { 348 - ret = PTR_ERR(ksproc->dev_ctrl); 349 - return ret; 350 - } 351 - 352 - if (of_property_read_u32_index(np, "ti,syscon-dev", 1, 353 - &ksproc->boot_offset)) { 354 - dev_err(dev, "couldn't read the boot register offset\n"); 355 - return -EINVAL; 356 - } 344 + ksproc->dev_ctrl = syscon_regmap_lookup_by_phandle_args(np, "ti,syscon-dev", 345 + 1, &ksproc->boot_offset); 346 + if (IS_ERR(ksproc->dev_ctrl)) 347 + return PTR_ERR(ksproc->dev_ctrl); 357 348 358 349 return 0; 359 350 }

+10 -2

drivers/remoteproc/mtk_scp.c

··· 1326 1326 return ret; 1327 1327 } 1328 1328 1329 + static const struct of_device_id scp_core_match[] = { 1330 + { .compatible = "mediatek,scp-core" }, 1331 + {} 1332 + }; 1333 + 1329 1334 static int scp_probe(struct platform_device *pdev) 1330 1335 { 1331 1336 struct device *dev = &pdev->dev; ··· 1362 1357 INIT_LIST_HEAD(&scp_cluster->mtk_scp_list); 1363 1358 mutex_init(&scp_cluster->cluster_lock); 1364 1359 1365 - ret = devm_of_platform_populate(dev); 1360 + ret = of_platform_populate(dev_of_node(dev), scp_core_match, NULL, dev); 1366 1361 if (ret) 1367 1362 return dev_err_probe(dev, ret, "Failed to populate platform devices\n"); 1368 1363 1369 1364 ret = scp_cluster_init(pdev, scp_cluster); 1370 - if (ret) 1365 + if (ret) { 1366 + of_platform_depopulate(dev); 1371 1367 return ret; 1368 + } 1372 1369 1373 1370 return 0; 1374 1371 } ··· 1386 1379 rproc_del(scp->rproc); 1387 1380 scp_free(scp); 1388 1381 } 1382 + of_platform_depopulate(&pdev->dev); 1389 1383 mutex_destroy(&scp_cluster->cluster_lock); 1390 1384 } 1391 1385

+19 -5

drivers/remoteproc/omap_remoteproc.c

··· 37 37 38 38 #include <linux/platform_data/dmtimer-omap.h> 39 39 40 + #ifdef CONFIG_ARM_DMA_USE_IOMMU 41 + #include <asm/dma-iommu.h> 42 + #endif 43 + 40 44 #include "omap_remoteproc.h" 41 45 #include "remoteproc_internal.h" 42 46 ··· 1137 1133 struct device_node *np = pdev->dev.of_node; 1138 1134 struct omap_rproc *oproc = rproc->priv; 1139 1135 const struct omap_rproc_dev_data *data; 1140 - int ret; 1141 1136 1142 1137 data = of_device_get_match_data(&pdev->dev); 1143 1138 if (!data) ··· 1152 1149 1153 1150 oproc->boot_data->syscon = 1154 1151 syscon_regmap_lookup_by_phandle(np, "ti,bootreg"); 1155 - if (IS_ERR(oproc->boot_data->syscon)) { 1156 - ret = PTR_ERR(oproc->boot_data->syscon); 1157 - return ret; 1158 - } 1152 + if (IS_ERR(oproc->boot_data->syscon)) 1153 + return PTR_ERR(oproc->boot_data->syscon); 1159 1154 1160 1155 if (of_property_read_u32_index(np, "ti,bootreg", 1, 1161 1156 &oproc->boot_data->boot_reg)) { ··· 1323 1322 oproc->reset = reset; 1324 1323 /* All existing OMAP IPU and DSP processors have an MMU */ 1325 1324 rproc->has_iommu = true; 1325 + 1326 + #ifdef CONFIG_ARM_DMA_USE_IOMMU 1327 + /* 1328 + * Throw away the ARM DMA mapping that we'll never use, so it doesn't 1329 + * interfere with the core rproc->domain and we get the right DMA ops. 1330 + */ 1331 + if (pdev->dev.archdata.mapping) { 1332 + struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(&pdev->dev); 1333 + 1334 + arm_iommu_detach_device(&pdev->dev); 1335 + arm_iommu_release_mapping(mapping); 1336 + } 1337 + #endif 1326 1338 1327 1339 ret = omap_rproc_of_get_internal_memories(pdev, rproc); 1328 1340 if (ret)

+7 -7

drivers/remoteproc/remoteproc_core.c

··· 2486 2486 rproc->dev.driver_data = rproc; 2487 2487 idr_init(&rproc->notifyids); 2488 2488 2489 + /* Assign a unique device index and name */ 2490 + rproc->index = ida_alloc(&rproc_dev_index, GFP_KERNEL); 2491 + if (rproc->index < 0) { 2492 + dev_err(dev, "ida_alloc failed: %d\n", rproc->index); 2493 + goto put_device; 2494 + } 2495 + 2489 2496 rproc->name = kstrdup_const(name, GFP_KERNEL); 2490 2497 if (!rproc->name) 2491 2498 goto put_device; ··· 2502 2495 2503 2496 if (rproc_alloc_ops(rproc, ops)) 2504 2497 goto put_device; 2505 - 2506 - /* Assign a unique device index and name */ 2507 - rproc->index = ida_alloc(&rproc_dev_index, GFP_KERNEL); 2508 - if (rproc->index < 0) { 2509 - dev_err(dev, "ida_alloc failed: %d\n", rproc->index); 2510 - goto put_device; 2511 - } 2512 2498 2513 2499 dev_set_name(&rproc->dev, "remoteproc%d", rproc->index); 2514 2500

+22 -32

drivers/remoteproc/st_remoteproc.c

··· 290 290 if (ddata->config->sw_reset) { 291 291 ddata->sw_reset = devm_reset_control_get_exclusive(dev, 292 292 "sw_reset"); 293 - if (IS_ERR(ddata->sw_reset)) { 294 - dev_err(dev, "Failed to get S/W Reset\n"); 295 - return PTR_ERR(ddata->sw_reset); 296 - } 293 + if (IS_ERR(ddata->sw_reset)) 294 + return dev_err_probe(dev, PTR_ERR(ddata->sw_reset), 295 + "Failed to get S/W Reset\n"); 297 296 } 298 297 299 298 if (ddata->config->pwr_reset) { 300 299 ddata->pwr_reset = devm_reset_control_get_exclusive(dev, 301 300 "pwr_reset"); 302 - if (IS_ERR(ddata->pwr_reset)) { 303 - dev_err(dev, "Failed to get Power Reset\n"); 304 - return PTR_ERR(ddata->pwr_reset); 305 - } 301 + if (IS_ERR(ddata->pwr_reset)) 302 + return dev_err_probe(dev, PTR_ERR(ddata->pwr_reset), 303 + "Failed to get Power Reset\n"); 306 304 } 307 305 308 306 ddata->clk = devm_clk_get(dev, NULL); 309 - if (IS_ERR(ddata->clk)) { 310 - dev_err(dev, "Failed to get clock\n"); 311 - return PTR_ERR(ddata->clk); 312 - } 307 + if (IS_ERR(ddata->clk)) 308 + return dev_err_probe(dev, PTR_ERR(ddata->clk), 309 + "Failed to get clock\n"); 313 310 314 311 err = of_property_read_u32(np, "clock-frequency", &ddata->clk_rate); 315 312 if (err) { ··· 314 317 return err; 315 318 } 316 319 317 - ddata->boot_base = syscon_regmap_lookup_by_phandle(np, "st,syscfg"); 318 - if (IS_ERR(ddata->boot_base)) { 319 - dev_err(dev, "Boot base not found\n"); 320 - return PTR_ERR(ddata->boot_base); 321 - } 322 - 323 - err = of_property_read_u32_index(np, "st,syscfg", 1, 324 - &ddata->boot_offset); 325 - if (err) { 326 - dev_err(dev, "Boot offset not found\n"); 327 - return -EINVAL; 328 - } 320 + ddata->boot_base = syscon_regmap_lookup_by_phandle_args(np, "st,syscfg", 321 + 1, &ddata->boot_offset); 322 + if (IS_ERR(ddata->boot_base)) 323 + return dev_err_probe(dev, PTR_ERR(ddata->boot_base), 324 + "Boot base not found\n"); 329 325 330 326 err = clk_prepare(ddata->clk); 331 327 if (err) ··· 385 395 */ 386 396 chan = mbox_request_channel_byname(&ddata->mbox_client_vq0, "vq0_rx"); 387 397 if (IS_ERR(chan)) { 388 - dev_err(&rproc->dev, "failed to request mbox chan 0\n"); 389 - ret = PTR_ERR(chan); 398 + ret = dev_err_probe(&rproc->dev, PTR_ERR(chan), 399 + "failed to request mbox chan 0\n"); 390 400 goto free_clk; 391 401 } 392 402 ddata->mbox_chan[ST_RPROC_VQ0 * MBOX_MAX + MBOX_RX] = chan; 393 403 394 404 chan = mbox_request_channel_byname(&ddata->mbox_client_vq0, "vq0_tx"); 395 405 if (IS_ERR(chan)) { 396 - dev_err(&rproc->dev, "failed to request mbox chan 0\n"); 397 - ret = PTR_ERR(chan); 406 + ret = dev_err_probe(&rproc->dev, PTR_ERR(chan), 407 + "failed to request mbox chan 0\n"); 398 408 goto free_mbox; 399 409 } 400 410 ddata->mbox_chan[ST_RPROC_VQ0 * MBOX_MAX + MBOX_TX] = chan; 401 411 402 412 chan = mbox_request_channel_byname(&ddata->mbox_client_vq1, "vq1_rx"); 403 413 if (IS_ERR(chan)) { 404 - dev_err(&rproc->dev, "failed to request mbox chan 1\n"); 405 - ret = PTR_ERR(chan); 414 + ret = dev_err_probe(&rproc->dev, PTR_ERR(chan), 415 + "failed to request mbox chan 1\n"); 406 416 goto free_mbox; 407 417 } 408 418 ddata->mbox_chan[ST_RPROC_VQ1 * MBOX_MAX + MBOX_RX] = chan; 409 419 410 420 chan = mbox_request_channel_byname(&ddata->mbox_client_vq1, "vq1_tx"); 411 421 if (IS_ERR(chan)) { 412 - dev_err(&rproc->dev, "failed to request mbox chan 1\n"); 413 - ret = PTR_ERR(chan); 422 + ret = dev_err_probe(&rproc->dev, PTR_ERR(chan), 423 + "failed to request mbox chan 1\n"); 414 424 goto free_mbox; 415 425 } 416 426 ddata->mbox_chan[ST_RPROC_VQ1 * MBOX_MAX + MBOX_TX] = chan;

+35 -53

drivers/remoteproc/ti_k3_r5_remoteproc.c

··· 955 955 return ret; 956 956 } 957 957 958 + static void k3_r5_mem_release(void *data) 959 + { 960 + struct device *dev = data; 961 + 962 + of_reserved_mem_device_release(dev); 963 + } 964 + 958 965 static int k3_r5_reserved_mem_init(struct k3_r5_rproc *kproc) 959 966 { 960 967 struct device *dev = kproc->dev; ··· 992 985 return ret; 993 986 } 994 987 988 + ret = devm_add_action_or_reset(dev, k3_r5_mem_release, dev); 989 + if (ret) 990 + return ret; 991 + 995 992 num_rmems--; 996 - kproc->rmem = kcalloc(num_rmems, sizeof(*kproc->rmem), GFP_KERNEL); 997 - if (!kproc->rmem) { 998 - ret = -ENOMEM; 999 - goto release_rmem; 1000 - } 993 + kproc->rmem = devm_kcalloc(dev, num_rmems, sizeof(*kproc->rmem), GFP_KERNEL); 994 + if (!kproc->rmem) 995 + return -ENOMEM; 1001 996 1002 997 /* use remaining reserved memory regions for static carveouts */ 1003 998 for (i = 0; i < num_rmems; i++) { 1004 999 rmem_np = of_parse_phandle(np, "memory-region", i + 1); 1005 - if (!rmem_np) { 1006 - ret = -EINVAL; 1007 - goto unmap_rmem; 1008 - } 1000 + if (!rmem_np) 1001 + return -EINVAL; 1009 1002 1010 1003 rmem = of_reserved_mem_lookup(rmem_np); 1011 1004 of_node_put(rmem_np); 1012 - if (!rmem) { 1013 - ret = -EINVAL; 1014 - goto unmap_rmem; 1015 - } 1005 + if (!rmem) 1006 + return -EINVAL; 1016 1007 1017 1008 kproc->rmem[i].bus_addr = rmem->base; 1018 1009 /* ··· 1025 1020 */ 1026 1021 kproc->rmem[i].dev_addr = (u32)rmem->base; 1027 1022 kproc->rmem[i].size = rmem->size; 1028 - kproc->rmem[i].cpu_addr = ioremap_wc(rmem->base, rmem->size); 1023 + kproc->rmem[i].cpu_addr = devm_ioremap_wc(dev, rmem->base, rmem->size); 1029 1024 if (!kproc->rmem[i].cpu_addr) { 1030 1025 dev_err(dev, "failed to map reserved memory#%d at %pa of size %pa\n", 1031 1026 i + 1, &rmem->base, &rmem->size); 1032 - ret = -ENOMEM; 1033 - goto unmap_rmem; 1027 + return -ENOMEM; 1034 1028 } 1035 1029 1036 1030 dev_dbg(dev, "reserved memory%d: bus addr %pa size 0x%zx va %pK da 0x%x\n", ··· 1040 1036 kproc->num_rmems = num_rmems; 1041 1037 1042 1038 return 0; 1043 - 1044 - unmap_rmem: 1045 - for (i--; i >= 0; i--) 1046 - iounmap(kproc->rmem[i].cpu_addr); 1047 - kfree(kproc->rmem); 1048 - release_rmem: 1049 - of_reserved_mem_device_release(dev); 1050 - return ret; 1051 - } 1052 - 1053 - static void k3_r5_reserved_mem_exit(struct k3_r5_rproc *kproc) 1054 - { 1055 - int i; 1056 - 1057 - for (i = 0; i < kproc->num_rmems; i++) 1058 - iounmap(kproc->rmem[i].cpu_addr); 1059 - kfree(kproc->rmem); 1060 - 1061 - of_reserved_mem_device_release(kproc->dev); 1062 1039 } 1063 1040 1064 1041 /* ··· 1266 1281 goto out; 1267 1282 } 1268 1283 1269 - ret = rproc_add(rproc); 1284 + ret = devm_rproc_add(dev, rproc); 1270 1285 if (ret) { 1271 - dev_err(dev, "rproc_add failed, ret = %d\n", ret); 1272 - goto err_add; 1286 + dev_err_probe(dev, ret, "rproc_add failed\n"); 1287 + goto out; 1273 1288 } 1274 1289 1275 1290 /* create only one rproc in lockstep, single-cpu or ··· 1297 1312 dev_err(dev, 1298 1313 "Timed out waiting for %s core to power up!\n", 1299 1314 rproc->name); 1300 - goto err_powerup; 1315 + goto out; 1301 1316 } 1302 1317 } 1303 1318 ··· 1313 1328 } 1314 1329 } 1315 1330 1316 - err_powerup: 1317 - rproc_del(rproc); 1318 - err_add: 1319 - k3_r5_reserved_mem_exit(kproc); 1320 1331 out: 1321 1332 /* undo core0 upon any failures on core1 in split-mode */ 1322 1333 if (cluster->mode == CLUSTER_MODE_SPLIT && core == core1) { ··· 1355 1374 } 1356 1375 1357 1376 mbox_free_channel(kproc->mbox); 1358 - 1359 - rproc_del(rproc); 1360 - 1361 - k3_r5_reserved_mem_exit(kproc); 1362 1377 } 1363 1378 } 1364 1379 ··· 1487 1510 return 0; 1488 1511 } 1489 1512 1513 + static void k3_r5_release_tsp(void *data) 1514 + { 1515 + struct ti_sci_proc *tsp = data; 1516 + 1517 + ti_sci_proc_release(tsp); 1518 + } 1519 + 1490 1520 static int k3_r5_core_of_init(struct platform_device *pdev) 1491 1521 { 1492 1522 struct device *dev = &pdev->dev; ··· 1587 1603 goto err; 1588 1604 } 1589 1605 1606 + ret = devm_add_action_or_reset(dev, k3_r5_release_tsp, core->tsp); 1607 + if (ret) 1608 + goto err; 1609 + 1590 1610 platform_set_drvdata(pdev, core); 1591 1611 devres_close_group(dev, k3_r5_core_of_init); 1592 1612 ··· 1607 1619 */ 1608 1620 static void k3_r5_core_of_exit(struct platform_device *pdev) 1609 1621 { 1610 - struct k3_r5_core *core = platform_get_drvdata(pdev); 1611 1622 struct device *dev = &pdev->dev; 1612 - int ret; 1613 - 1614 - ret = ti_sci_proc_release(core->tsp); 1615 - if (ret) 1616 - dev_err(dev, "failed to release proc, ret = %d\n", ret); 1617 1623 1618 1624 platform_set_drvdata(pdev, NULL); 1619 1625 devres_release_group(dev, k3_r5_core_of_init);

Configure Feed

Configure Feed