Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
net: Use of_reserved_mem_region_to_resource{_byname}() for "memory-region"
Use the newly added of_reserved_mem_region_to_resource{_byname}()
functions to handle "memory-region" properties.
The error handling is a bit different for mtk_wed_mcu_load_firmware().
A failed match of the "memory-region-names" would skip the entry, but
then other errors in the lookup and retrieval of the address would not
skip the entry. However, that distinction is not really important.
Either the region is available and usable or it is not. So now, errors
from of_reserved_mem_region_to_resource() are ignored so the region is
simply skipped.
Signed-off-by: Rob Herring (Arm) <robh@kernel.org>
Link: https://patch.msgid.link/20250703183459.2074381-1-robh@kernel.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
authored by
Rob Herring (Arm)
and committed by
Jakub Kicinski
e27dba19
f142028e
+27
-66
+9
-16
drivers/net/ethernet/airoha/airoha_npu.c
+9
-16
drivers/net/ethernet/airoha/airoha_npu.c
···
161
161
}
162
162
163
163
static int airoha_npu_run_firmware(struct device *dev, void __iomem *base,
164
-
struct reserved_mem *rmem)
164
+
struct resource *res)
165
165
{
166
166
const struct firmware *fw;
167
167
void __iomem *addr;
···
178
178
goto out;
179
179
}
180
180
181
-
addr = devm_ioremap(dev, rmem->base, rmem->size);
181
+
addr = devm_ioremap_resource(dev, res);
182
182
if (!addr) {
183
183
ret = -ENOMEM;
184
184
goto out;
···
474
474
static int airoha_npu_probe(struct platform_device *pdev)
475
475
{
476
476
struct device *dev = &pdev->dev;
477
-
struct reserved_mem *rmem;
478
477
struct airoha_npu *npu;
479
-
struct device_node *np;
478
+
struct resource res;
480
479
void __iomem *base;
481
480
int i, irq, err;
482
481
···
497
498
if (IS_ERR(npu->regmap))
498
499
return PTR_ERR(npu->regmap);
499
500
500
-
np = of_parse_phandle(dev->of_node, "memory-region", 0);
501
-
if (!np)
502
-
return -ENODEV;
503
-
504
-
rmem = of_reserved_mem_lookup(np);
505
-
of_node_put(np);
506
-
507
-
if (!rmem)
508
-
return -ENODEV;
501
+
err = of_reserved_mem_region_to_resource(dev->of_node, 0, &res);
502
+
if (err)
503
+
return err;
509
504
510
505
irq = platform_get_irq(pdev, 0);
511
506
if (irq < 0)
···
532
539
if (err)
533
540
return err;
534
541
535
-
err = airoha_npu_run_firmware(dev, base, rmem);
542
+
err = airoha_npu_run_firmware(dev, base, &res);
536
543
if (err)
537
544
return dev_err_probe(dev, err, "failed to run npu firmware\n");
538
545
539
546
regmap_write(npu->regmap, REG_CR_NPU_MIB(10),
540
-
rmem->base + NPU_EN7581_FIRMWARE_RV32_MAX_SIZE);
547
+
res.start + NPU_EN7581_FIRMWARE_RV32_MAX_SIZE);
541
548
regmap_write(npu->regmap, REG_CR_NPU_MIB(11), 0x40000); /* SRAM 256K */
542
549
regmap_write(npu->regmap, REG_CR_NPU_MIB(12), 0);
543
550
regmap_write(npu->regmap, REG_CR_NPU_MIB(21), 1);
···
545
552
546
553
/* setting booting address */
547
554
for (i = 0; i < NPU_NUM_CORES; i++)
548
-
regmap_write(npu->regmap, REG_CR_BOOT_BASE(i), rmem->base);
555
+
regmap_write(npu->regmap, REG_CR_BOOT_BASE(i), res.start);
549
556
usleep_range(1000, 2000);
550
557
551
558
/* enable NPU cores */
+6
-18
drivers/net/ethernet/mediatek/mtk_wed.c
+6
-18
drivers/net/ethernet/mediatek/mtk_wed.c
···
1318
1318
static int
1319
1319
mtk_wed_rro_alloc(struct mtk_wed_device *dev)
1320
1320
{
1321
-
struct reserved_mem *rmem;
1322
-
struct device_node *np;
1323
-
int index;
1321
+
struct resource res;
1322
+
int ret;
1324
1323
1325
-
index = of_property_match_string(dev->hw->node, "memory-region-names",
1326
-
"wo-dlm");
1327
-
if (index < 0)
1328
-
return index;
1324
+
ret = of_reserved_mem_region_to_resource_byname(dev->hw->node, "wo-dlm", &res);
1325
+
if (ret)
1326
+
return ret;
1329
1327
1330
-
np = of_parse_phandle(dev->hw->node, "memory-region", index);
1331
-
if (!np)
1332
-
return -ENODEV;
1333
-
1334
-
rmem = of_reserved_mem_lookup(np);
1335
-
of_node_put(np);
1336
-
1337
-
if (!rmem)
1338
-
return -ENODEV;
1339
-
1340
-
dev->rro.miod_phys = rmem->base;
1328
+
dev->rro.miod_phys = res.start;
1341
1329
dev->rro.fdbk_phys = MTK_WED_MIOD_COUNT + dev->rro.miod_phys;
1342
1330
1343
1331
return mtk_wed_rro_ring_alloc(dev, &dev->rro.ring,
+10
-22
drivers/net/ethernet/mediatek/mtk_wed_mcu.c
+10
-22
drivers/net/ethernet/mediatek/mtk_wed_mcu.c
···
234
234
}
235
235
236
236
static int
237
-
mtk_wed_get_memory_region(struct mtk_wed_hw *hw, int index,
237
+
mtk_wed_get_memory_region(struct mtk_wed_hw *hw, const char *name,
238
238
struct mtk_wed_wo_memory_region *region)
239
239
{
240
-
struct reserved_mem *rmem;
241
-
struct device_node *np;
240
+
struct resource res;
241
+
int ret;
242
242
243
-
np = of_parse_phandle(hw->node, "memory-region", index);
244
-
if (!np)
245
-
return -ENODEV;
243
+
ret = of_reserved_mem_region_to_resource_byname(hw->node, name, &res);
244
+
if (ret)
245
+
return 0;
246
246
247
-
rmem = of_reserved_mem_lookup(np);
248
-
of_node_put(np);
249
-
250
-
if (!rmem)
251
-
return -ENODEV;
252
-
253
-
region->phy_addr = rmem->base;
254
-
region->size = rmem->size;
255
-
region->addr = devm_ioremap(hw->dev, region->phy_addr, region->size);
247
+
region->phy_addr = res.start;
248
+
region->size = resource_size(&res);
249
+
region->addr = devm_ioremap_resource(hw->dev, &res);
256
250
257
251
return !region->addr ? -EINVAL : 0;
258
252
}
···
313
319
314
320
/* load firmware region metadata */
315
321
for (i = 0; i < ARRAY_SIZE(mem_region); i++) {
316
-
int index = of_property_match_string(wo->hw->node,
317
-
"memory-region-names",
318
-
mem_region[i].name);
319
-
if (index < 0)
320
-
continue;
321
-
322
-
ret = mtk_wed_get_memory_region(wo->hw, index, &mem_region[i]);
322
+
ret = mtk_wed_get_memory_region(wo->hw, mem_region[i].name, &mem_region[i]);
323
323
if (ret)
324
324
return ret;
325
325
}
+2
-10
drivers/net/ipa/ipa_main.c
+2
-10
drivers/net/ipa/ipa_main.c
···
9
9
#include <linux/io.h>
10
10
#include <linux/module.h>
11
11
#include <linux/of.h>
12
-
#include <linux/of_address.h>
12
+
#include <linux/of_reserved_mem.h>
13
13
#include <linux/platform_device.h>
14
14
#include <linux/pm_runtime.h>
15
15
#include <linux/types.h>
···
586
586
static int ipa_firmware_load(struct device *dev)
587
587
{
588
588
const struct firmware *fw;
589
-
struct device_node *node;
590
589
struct resource res;
591
590
phys_addr_t phys;
592
591
const char *path;
···
593
594
void *virt;
594
595
int ret;
595
596
596
-
node = of_parse_phandle(dev->of_node, "memory-region", 0);
597
-
if (!node) {
598
-
dev_err(dev, "DT error getting \"memory-region\" property\n");
599
-
return -EINVAL;
600
-
}
601
-
602
-
ret = of_address_to_resource(node, 0, &res);
603
-
of_node_put(node);
597
+
ret = of_reserved_mem_region_to_resource(dev->of_node, 0, &res);
604
598
if (ret) {
605
599
dev_err(dev, "error %d getting \"memory-region\" resource\n",
606
600
ret);