mirrors/linux
2
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2026-07-21 22:47:51 -04:00
Code Issues Packages Projects Releases Wiki Activity

of: Factor arguments passed to of_map_id() into a struct

Browse Source 
Change of_map_id() to take a pointer to struct of_phandle_args
instead of passing target device node and translated IDs separately.
Update all callers accordingly.

Add an explicit filter_np parameter to of_map_id() and of_map_msi_id()
to separate the filter input from the output. Previously, the target
parameter served dual purpose: as an input filter (if non-NULL, only
match entries targeting that node) and as an output (receiving the
matched node with a reference held). Now filter_np is the explicit
input filter and arg->np is the pure output.

Previously, of_map_id() would call of_node_put() on the matched node
when a filter was provided, making reference ownership inconsistent.
Remove this internal of_node_put() call so that of_map_id() now always
transfers ownership of the matched node reference to the caller via
arg->np. Callers are now consistently responsible for releasing this
reference with of_node_put(arg->np) when done.

Acked-by: Frank Li <Frank.Li@nxp.com>
Suggested-by: Rob Herring (Arm) <robh@kernel.org>
Suggested-by: Dmitry Baryshkov <dmitry.baryshkov@oss.qualcomm.com>
Signed-off-by: Charan Teja Kalla <charan.kalla@oss.qualcomm.com>
Signed-off-by: Vijayanand Jitta <vijayanand.jitta@oss.qualcomm.com>
Link: https://patch.msgid.link/20260603-parse_iommu_cells-v16-2-dc509dacb19a@oss.qualcomm.com
Signed-off-by: Rob Herring (Arm) <robh@kernel.org>
This commit is contained in:
Charan Teja Kalla
2026-06-03 12:43:13 +05:30
committed by Rob Herring (Arm)
parent d4b52f83f1
commit f71f07bee9
9 changed files with 119 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
drivers/cdx/cdx_msi.c
View File

@@ -121,22 +121,23 @@ static int cdx_msi_prepare(struct irq_domain *msi_domain,
struct device *dev,
int nvec, msi_alloc_info_t *info)
{
struct of_phandle_args msi_spec = {};
struct cdx_device *cdx_dev = to_cdx_device(dev);
struct device *parent = cdx_dev->cdx->dev;
struct msi_domain_info *msi_info;
u32 dev_id;
int ret;
/* Retrieve device ID from requestor ID using parent device */
ret = of_map_msi_id(parent->of_node, cdx_dev->msi_dev_id, NULL, &dev_id);
ret = of_map_msi_id(parent->of_node, cdx_dev->msi_dev_id, NULL, &msi_spec);
if (ret) {
dev_err(dev, "of_map_msi_id failed for MSI: %d\n", ret);
return ret;
}
of_node_put(msi_spec.np);
#ifdef GENERIC_MSI_DOMAIN_OPS
/* Set the device Id to be passed to the GIC-ITS */
info->scratchpad[0].ul = dev_id;
info->scratchpad[0].ul = msi_spec.args[0];
#endif
msi_info = msi_get_domain_info(msi_domain->parent);

4
drivers/iommu/of_iommu.c
View File

@@ -45,10 +45,10 @@ static int of_iommu_configure_dev_id(struct device_node *master_np,
struct device *dev,
const u32 *id)
{
struct of_phandle_args iommu_spec = { .args_count = 1 };
struct of_phandle_args iommu_spec = {};
int err;
err = of_map_iommu_id(master_np, *id, &iommu_spec.np, iommu_spec.args);
err = of_map_iommu_id(master_np, *id, &iommu_spec);
if (err)
return err;

10
drivers/irqchip/irq-gic-its-msi-parent.c
View File

@@ -151,6 +151,8 @@ static int its_v5_pci_msi_prepare(struct irq_domain *domain, struct device *dev,
static int of_pmsi_get_msi_info(struct irq_domain *domain, struct device *dev, u32 *dev_id,
phys_addr_t *pa)
{
struct device_node *msi_ctrl = NULL;
struct of_phandle_args msi_spec = {};
struct of_phandle_iterator it;
int ret;
@@ -177,9 +179,11 @@ static int of_pmsi_get_msi_info(struct irq_domain *domain, struct device *dev, u
}
}
struct device_node *msi_ctrl __free(device_node) = NULL;
return of_map_msi_id(dev->of_node, dev->id, &msi_ctrl, dev_id);
ret = of_map_msi_id(dev->of_node, dev->id, &msi_ctrl, &msi_spec);
if (!ret)
*dev_id = msi_spec.args[0];
of_node_put(msi_spec.np);
return ret;
}
static int its_pmsi_prepare(struct irq_domain *domain, struct device *dev,

71
drivers/of/base.c
View File

@@ -2131,36 +2131,40 @@ int of_find_last_cache_level(unsigned int cpu)
* @id: device ID to map.
* @map_name: property name of the map to use.
* @map_mask_name: optional property name of the mask to use.
* @target: optional pointer to a target device node.
* @id_out: optional pointer to receive the translated ID.
* @filter_np: pointer to an optional filter node, or NULL to allow bypass.
* If non-NULL, the map property must exist (-ENODEV if absent). If
* *filter_np is also non-NULL, only entries targeting that node match.
* @arg: pointer to a &struct of_phandle_args for the result. On success,
* @arg->args[0] will contain the translated ID. If a map entry was
* matched, @arg->np will be set to the target node with a reference
* held that the caller must release with of_node_put().
*
* Given a device ID, look up the appropriate implementation-defined
* platform ID and/or the target device which receives transactions on that
* ID, as per the "iommu-map" and "msi-map" bindings. Either of @target or
* @id_out may be NULL if only the other is required. If @target points to
* a non-NULL device node pointer, only entries targeting that node will be
* matched; if it points to a NULL value, it will receive the device node of
* the first matching target phandle, with a reference held.
* ID, as per the "iommu-map" and "msi-map" bindings.
*
* Return: 0 on success or a standard error code on failure.
*/
int of_map_id(const struct device_node *np, u32 id,
const char *map_name, const char *map_mask_name,
struct device_node **target, u32 *id_out)
struct device_node * const *filter_np, struct of_phandle_args *arg)
{
u32 map_mask, masked_id;
int map_len;
const __be32 *map = NULL;
if (!np || !map_name || (!target && !id_out))
if (!np || !map_name || !arg)
return -EINVAL;
/* Ensure bypass/no-match success never returns a stale target node. */
arg->np = NULL;
map = of_get_property(np, map_name, &map_len);
if (!map) {
if (target)
if (filter_np)
return -ENODEV;
/* Otherwise, no map implies no translation */
*id_out = id;
arg->args[0] = id;
arg->args_count = 1;
return 0;
}
@@ -2202,18 +2206,14 @@ int of_map_id(const struct device_node *np, u32 id,
if (!phandle_node)
return -ENODEV;
if (target) {
if (*target)
of_node_put(phandle_node);
else
*target = phandle_node;
if (*target != phandle_node)
continue;
if (filter_np && *filter_np && *filter_np != phandle_node) {
of_node_put(phandle_node);
continue;
}
if (id_out)
*id_out = masked_id - id_base + out_base;
arg->np = phandle_node;
arg->args[0] = masked_id - id_base + out_base;
arg->args_count = 1;
pr_debug("%pOF: %s, using mask %08x, id-base: %08x, out-base: %08x, length: %08x, id: %08x -> %08x\n",
np, map_name, map_mask, id_base, out_base,
@@ -2222,11 +2222,11 @@ int of_map_id(const struct device_node *np, u32 id,
}
pr_info("%pOF: no %s translation for id 0x%x on %pOF\n", np, map_name,
id, target && *target ? *target : NULL);
id, filter_np && *filter_np ? *filter_np : NULL);
/* Bypasses translation */
if (id_out)
*id_out = id;
arg->args[0] = id;
arg->args_count = 1;
return 0;
}
EXPORT_SYMBOL_GPL(of_map_id);
@@ -2236,17 +2236,19 @@ EXPORT_SYMBOL_GPL(of_map_id);
* @np: root complex device node.
* @id: Requester ID of the device (e.g. PCI RID/BDF or a platform
* stream/device ID) used as the lookup key in the iommu-map table.
* @target: optional pointer to a target device node.
* @id_out: optional pointer to receive the translated ID.
* @arg: pointer to a &struct of_phandle_args for the result. On success,
* @arg->args[0] contains the translated ID. If a map entry was matched,
* @arg->np holds a reference to the target node that the caller must
* release with of_node_put().
*
* Convenience wrapper around of_map_id() using "iommu-map" and "iommu-map-mask".
*
* Return: 0 on success or a standard error code on failure.
*/
int of_map_iommu_id(const struct device_node *np, u32 id,
struct device_node **target, u32 *id_out)
struct of_phandle_args *arg)
{
return of_map_id(np, id, "iommu-map", "iommu-map-mask", target, id_out);
return of_map_id(np, id, "iommu-map", "iommu-map-mask", NULL, arg);
}
EXPORT_SYMBOL_GPL(of_map_iommu_id);
@@ -2255,16 +2257,21 @@ EXPORT_SYMBOL_GPL(of_map_iommu_id);
* @np: root complex device node.
* @id: Requester ID of the device (e.g. PCI RID/BDF or a platform
* stream/device ID) used as the lookup key in the msi-map table.
* @target: optional pointer to a target device node.
* @id_out: optional pointer to receive the translated ID.
* @filter_np: pointer to an optional filter node, or NULL to allow bypass.
* If non-NULL, the map property must exist (-ENODEV if absent). If
* *filter_np is also non-NULL, only entries targeting that node match.
* @arg: pointer to a &struct of_phandle_args for the result. On success,
* @arg->args[0] contains the translated ID. If a map entry was matched,
* @arg->np holds a reference to the target node that the caller must
* release with of_node_put().
*
* Convenience wrapper around of_map_id() using "msi-map" and "msi-map-mask".
*
* Return: 0 on success or a standard error code on failure.
*/
int of_map_msi_id(const struct device_node *np, u32 id,
struct device_node **target, u32 *id_out)
struct device_node * const *filter_np, struct of_phandle_args *arg)
{
return of_map_id(np, id, "msi-map", "msi-map-mask", target, id_out);
return of_map_id(np, id, "msi-map", "msi-map-mask", filter_np, arg);
}
EXPORT_SYMBOL_GPL(of_map_msi_id);

31
drivers/of/irq.c
View File

@@ -796,14 +796,15 @@ static int of_check_msi_parent(struct device_node *dev_node, struct device_node
/**
* of_msi_xlate - map a MSI ID and find relevant MSI controller node
* @dev: device for which the mapping is to be done.
* @msi_np: Pointer to target MSI controller node
* @msi_np: Pointer to target MSI controller node, or NULL if the caller
* only needs the translated ID without receiving the controller node.
* If non-NULL and pointing to a non-NULL node, only entries targeting
* that node will be matched. If non-NULL and pointing to NULL, it will
* receive the first matching target node with a reference held.
* @id_in: Device ID.
*
* Walk up the device hierarchy looking for devices with a "msi-map"
* or "msi-parent" property. If found, apply the mapping to @id_in.
* If @msi_np points to a non-NULL device node pointer, only entries targeting
* that node will be matched; if it points to a NULL value, it will receive the
* device node of the first matching target phandle, with a reference held.
*
* Returns: The mapped MSI id.
*/
@@ -817,9 +818,22 @@ u32 of_msi_xlate(struct device *dev, struct device_node **msi_np, u32 id_in)
* "msi-map" or an "msi-parent" property.
*/
for (parent_dev = dev; parent_dev; parent_dev = parent_dev->parent) {
if (!of_map_msi_id(parent_dev->of_node, id_in, msi_np, &id_out))
struct of_phandle_args msi_spec = {};
if (!of_map_msi_id(parent_dev->of_node, id_in, msi_np, &msi_spec)) {
if (msi_spec.np) {
/* msi-map matched: use the translated ID and target node */
if (msi_spec.args_count > 0)
id_out = msi_spec.args[0];
if (msi_np && !*msi_np)
*msi_np = of_node_get(msi_spec.np);
of_node_put(msi_spec.np);
}
/* msi-map present but no match → stop walking */
break;
if (!of_check_msi_parent(parent_dev->of_node, msi_np))
}
/* -ENODEV: msi-map absent → check for msi-parent */
if (msi_np && !of_check_msi_parent(parent_dev->of_node, msi_np))
break;
}
return id_out;
@@ -841,9 +855,12 @@ struct irq_domain *of_msi_map_get_device_domain(struct device *dev, u32 id,
u32 bus_token)
{
struct device_node *np = NULL;
struct irq_domain *d;
of_msi_xlate(dev, &np, id);
return irq_find_matching_host(np, bus_token);
d = irq_find_matching_host(np, bus_token);
of_node_put(np);
return d;
}
/**

53
drivers/pci/controller/dwc/pci-imx6.c
View File

@@ -1126,41 +1126,42 @@ static void imx_pcie_remove_lut(struct imx_pcie *imx_pcie, u16 rid)
static int imx_pcie_add_lut_by_rid(struct imx_pcie *imx_pcie, u32 rid)
{
struct of_phandle_args iommu_spec = {};
struct of_phandle_args msi_spec = {};
struct device *dev = imx_pcie->pci->dev;
struct device_node *target;
struct device_node *msi_filter = NULL;
u32 sid_i, sid_m;
int err_i, err_m;
u32 sid = 0;
target = NULL;
err_i = of_map_iommu_id(dev->of_node, rid, &target, &sid_i);
if (target) {
of_node_put(target);
} else {
/*
* "target == NULL && err_i == 0" means RID out of map range.
* Use 1:1 map RID to streamID. Hardware can't support this
* because the streamID is only 6 bits
*/
err_i = -EINVAL;
err_i = of_map_iommu_id(dev->of_node, rid, &iommu_spec);
if (!err_i) {
if (!iommu_spec.np)
/*
* "iommu_spec.np == NULL && err_i == 0" means RID out of map
* range. Use 1:1 map RID to streamID. Hardware can't support
* this because the streamID is only 6 bits.
*/
err_i = -EINVAL;
else
sid_i = iommu_spec.args[0];
}
of_node_put(iommu_spec.np);
target = NULL;
err_m = of_map_msi_id(dev->of_node, rid, &target, &sid_m);
err_m = of_map_msi_id(dev->of_node, rid, &msi_filter, &msi_spec);
/*
* err_m target
* 0 NULL RID out of range. Use 1:1 map RID to
* streamID, Current hardware can't
* support it, so return -EINVAL.
* != 0 NULL msi-map does not exist, use built-in MSI
* 0 != NULL Get correct streamID from RID
* != 0 != NULL Invalid combination
* err_m msi_spec.np
* 0 != NULL Got correct streamID from RID via msi-map
* 0 NULL msi-map present but RID out of range
* -ENODEV NULL msi-map absent, use built-in MSI controller
*/
if (!err_m && !target)
return -EINVAL;
else if (target)
of_node_put(target); /* Find streamID map entry for RID in msi-map */
if (!err_m) {
if (!msi_spec.np)
/* msi-map present but RID out of range */
return -EINVAL;
sid_m = msi_spec.args[0];
}
of_node_put(msi_spec.np);
/*
* msi-map iommu-map

5
drivers/pci/controller/pcie-apple.c
View File

@@ -755,6 +755,7 @@ static int apple_pcie_enable_device(struct pci_host_bridge *bridge, struct pci_d
{
u32 sid, rid = pci_dev_id(pdev);
struct apple_pcie_port *port;
struct of_phandle_args iommu_spec = {};
int idx, err;
port = apple_pcie_get_port(pdev);
@@ -764,10 +765,12 @@ static int apple_pcie_enable_device(struct pci_host_bridge *bridge, struct pci_d
dev_dbg(&pdev->dev, "added to bus %s, index %d\n",
pci_name(pdev->bus->self), port->idx);
err = of_map_iommu_id(port->pcie->dev->of_node, rid, NULL, &sid);
err = of_map_iommu_id(port->pcie->dev->of_node, rid, &iommu_spec);
if (err)
return err;
of_node_put(iommu_spec.np);
sid = iommu_spec.args[0];
mutex_lock(&port->pcie->lock);
idx = bitmap_find_free_region(port->sid_map, port->sid_map_sz, 0);

4
drivers/xen/grant-dma-ops.c
View File

@@ -319,13 +319,13 @@ static int xen_dt_grant_init_backend_domid(struct device *dev,
struct device_node *np,
domid_t *backend_domid)
{
struct of_phandle_args iommu_spec = { .args_count = 1 };
struct of_phandle_args iommu_spec = {};
if (dev_is_pci(dev)) {
struct pci_dev *pdev = to_pci_dev(dev);
u32 rid = PCI_DEVID(pdev->bus->number, pdev->devfn);
if (of_map_iommu_id(np, rid, &iommu_spec.np, iommu_spec.args)) {
if (of_map_iommu_id(np, rid, &iommu_spec)) {
dev_dbg(dev, "Cannot translate ID\n");
return -ESRCH;
}

16
include/linux/of.h
View File

@@ -466,13 +466,15 @@ bool of_console_check(const struct device_node *dn, char *name, int index);
int of_map_id(const struct device_node *np, u32 id,
const char *map_name, const char *map_mask_name,
struct device_node **target, u32 *id_out);
struct device_node * const *filter_np,
struct of_phandle_args *arg);
int of_map_iommu_id(const struct device_node *np, u32 id,
struct device_node **target, u32 *id_out);
struct of_phandle_args *arg);
int of_map_msi_id(const struct device_node *np, u32 id,
struct device_node **target, u32 *id_out);
struct device_node * const *filter_np,
struct of_phandle_args *arg);
phys_addr_t of_dma_get_max_cpu_address(struct device_node *np);
@@ -949,19 +951,21 @@ static inline void of_property_clear_flag(struct property *p, unsigned long flag
static inline int of_map_id(const struct device_node *np, u32 id,
const char *map_name, const char *map_mask_name,
struct device_node **target, u32 *id_out)
struct device_node * const *filter_np,
struct of_phandle_args *arg)
{
return -EINVAL;
}
static inline int of_map_iommu_id(const struct device_node *np, u32 id,
struct device_node **target, u32 *id_out)
struct of_phandle_args *arg)
{
return -EINVAL;
}
static inline int of_map_msi_id(const struct device_node *np, u32 id,
struct device_node **target, u32 *id_out)
struct device_node * const *filter_np,
struct of_phandle_args *arg)
{
return -EINVAL;
}