Commit 268db333 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'devprop-5.19-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm 

Pull device properties framework updates from Rafael Wysocki:
 "These mostly extend the device property API and make it easier to use
  in some cases.

  Specifics:

   - Allow error pointer to be passed to fwnode APIs (Andy Shevchenko).

   - Introduce fwnode_for_each_parent_node() (Andy Shevchenko, Douglas
     Anderson).

   - Advertise fwnode and device property count API calls (Andy
     Shevchenko).

   - Clean up fwnode_is_ancestor_of() (Andy Shevchenko).

   - Convert device_{dma_supported,get_dma_attr} to fwnode (Sakari
     Ailus).

   - Release subnode properties with data nodes (Sakari Ailus).

   - Add ->iomap() and ->irq_get() to fwnode operations (Sakari Ailus)"

* tag 'devprop-5.19-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm:
  device property: Advertise fwnode and device property count API calls
  device property: Fix recent breakage of fwnode_get_next_parent_dev()
  device property: Drop 'test' prefix in parameters of fwnode_is_ancestor_of()
  device property: Introduce fwnode_for_each_parent_node()
  device property: Allow error pointer to be passed to fwnode APIs
  ACPI: property: Release subnode properties with data nodes
  device property: Add irq_get to fwnode operation
  device property: Add iomap to fwnode operations
  ACPI: property: Move acpi_fwnode_device_get_match_data() up
  device property: Convert device_{dma_supported,get_dma_attr} to fwnode
parents f4fb8596 f6e109a0

drivers/acpi/property.c

+44 −10
Original line number Diff line number Diff line
@@ -433,6 +433,16 @@ void acpi_init_properties(struct acpi_device *adev) 
		acpi_extract_apple_properties(adev);

}



static void acpi_free_device_properties(struct list_head *list)

{

	struct acpi_device_properties *props, *tmp;



	list_for_each_entry_safe(props, tmp, list, list) {

		list_del(&props->list);

		kfree(props);

	}

}



static void acpi_destroy_nondev_subnodes(struct list_head *list)

{

	struct acpi_data_node *dn, *next;
@@ -445,22 +455,18 @@ static void acpi_destroy_nondev_subnodes(struct list_head *list) 
		wait_for_completion(&dn->kobj_done);

		list_del(&dn->sibling);

		ACPI_FREE((void *)dn->data.pointer);

		acpi_free_device_properties(&dn->data.properties);

		kfree(dn);

	}

}



void acpi_free_properties(struct acpi_device *adev)

{

	struct acpi_device_properties *props, *tmp;



	acpi_destroy_nondev_subnodes(&adev->data.subnodes);

	ACPI_FREE((void *)adev->data.pointer);

	adev->data.of_compatible = NULL;

	adev->data.pointer = NULL;

	list_for_each_entry_safe(props, tmp, &adev->data.properties, list) {

		list_del(&props->list);

		kfree(props);

	}

	acpi_free_device_properties(&adev->data.properties);

}



/**
@@ -1256,6 +1262,24 @@ static bool acpi_fwnode_device_is_available(const struct fwnode_handle *fwnode) 
	return acpi_device_is_present(to_acpi_device_node(fwnode));

}



static const void *

acpi_fwnode_device_get_match_data(const struct fwnode_handle *fwnode,

				  const struct device *dev)

{

	return acpi_device_get_match_data(dev);

}



static bool acpi_fwnode_device_dma_supported(const struct fwnode_handle *fwnode)

{

	return acpi_dma_supported(to_acpi_device_node(fwnode));

}



static enum dev_dma_attr

acpi_fwnode_device_get_dma_attr(const struct fwnode_handle *fwnode)

{

	return acpi_get_dma_attr(to_acpi_device_node(fwnode));

}



static bool acpi_fwnode_property_present(const struct fwnode_handle *fwnode,

					 const char *propname)

{
@@ -1376,17 +1400,26 @@ static int acpi_fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode, 
	return 0;

}



static const void *

acpi_fwnode_device_get_match_data(const struct fwnode_handle *fwnode,

				  const struct device *dev)

static int acpi_fwnode_irq_get(const struct fwnode_handle *fwnode,

			       unsigned int index)

{

	return acpi_device_get_match_data(dev);

	struct resource res;

	int ret;



	ret = acpi_irq_get(ACPI_HANDLE_FWNODE(fwnode), index, &res);

	if (ret)

		return ret;



	return res.start;

}



#define DECLARE_ACPI_FWNODE_OPS(ops) \

	const struct fwnode_operations ops = {				\

		.device_is_available = acpi_fwnode_device_is_available, \

		.device_get_match_data = acpi_fwnode_device_get_match_data, \

		.device_dma_supported =				\

			acpi_fwnode_device_dma_supported,		\

		.device_get_dma_attr = acpi_fwnode_device_get_dma_attr,	\

		.property_present = acpi_fwnode_property_present,	\

		.property_read_int_array =				\

			acpi_fwnode_property_read_int_array,		\
@@ -1404,6 +1437,7 @@ acpi_fwnode_device_get_match_data(const struct fwnode_handle *fwnode, 
			acpi_graph_get_remote_endpoint,			\

		.graph_get_port_parent = acpi_fwnode_get_parent,	\

		.graph_parse_endpoint = acpi_fwnode_graph_parse_endpoint, \

		.irq_get = acpi_fwnode_irq_get,				\

	};								\

	EXPORT_SYMBOL_GPL(ops)

drivers/base/property.c

+115 −102
Original line number Diff line number Diff line
@@ -47,12 +47,14 @@ bool fwnode_property_present(const struct fwnode_handle *fwnode, 
{

	bool ret;



	if (IS_ERR_OR_NULL(fwnode))

		return false;



	ret = fwnode_call_bool_op(fwnode, property_present, propname);

	if (ret == false && !IS_ERR_OR_NULL(fwnode) &&

	    !IS_ERR_OR_NULL(fwnode->secondary))

		ret = fwnode_call_bool_op(fwnode->secondary, property_present,

					 propname);

	if (ret)

		return ret;



	return fwnode_call_bool_op(fwnode->secondary, property_present, propname);

}

EXPORT_SYMBOL_GPL(fwnode_property_present);
@@ -66,6 +68,9 @@ EXPORT_SYMBOL_GPL(fwnode_property_present); 
 * Function reads an array of u8 properties with @propname from the device

 * firmware description and stores them to @val if found.

 *

 * It's recommended to call device_property_count_u8() instead of calling

 * this function with @val equals %NULL and @nval equals 0.

 *

 * Return: number of values if @val was %NULL,

 *         %0 if the property was found (success),

 *	   %-EINVAL if given arguments are not valid,
@@ -91,6 +96,9 @@ EXPORT_SYMBOL_GPL(device_property_read_u8_array); 
 * Function reads an array of u16 properties with @propname from the device

 * firmware description and stores them to @val if found.

 *

 * It's recommended to call device_property_count_u16() instead of calling

 * this function with @val equals %NULL and @nval equals 0.

 *

 * Return: number of values if @val was %NULL,

 *         %0 if the property was found (success),

 *	   %-EINVAL if given arguments are not valid,
@@ -116,6 +124,9 @@ EXPORT_SYMBOL_GPL(device_property_read_u16_array); 
 * Function reads an array of u32 properties with @propname from the device

 * firmware description and stores them to @val if found.

 *

 * It's recommended to call device_property_count_u32() instead of calling

 * this function with @val equals %NULL and @nval equals 0.

 *

 * Return: number of values if @val was %NULL,

 *         %0 if the property was found (success),

 *	   %-EINVAL if given arguments are not valid,
@@ -141,6 +152,9 @@ EXPORT_SYMBOL_GPL(device_property_read_u32_array); 
 * Function reads an array of u64 properties with @propname from the device

 * firmware description and stores them to @val if found.

 *

 * It's recommended to call device_property_count_u64() instead of calling

 * this function with @val equals %NULL and @nval equals 0.

 *

 * Return: number of values if @val was %NULL,

 *         %0 if the property was found (success),

 *	   %-EINVAL if given arguments are not valid,
@@ -166,6 +180,9 @@ EXPORT_SYMBOL_GPL(device_property_read_u64_array); 
 * Function reads an array of string properties with @propname from the device

 * firmware description and stores them to @val if found.

 *

 * It's recommended to call device_property_string_array_count() instead of calling

 * this function with @val equals %NULL and @nval equals 0.

 *

 * Return: number of values read on success if @val is non-NULL,

 *	   number of values available on success if @val is NULL,

 *	   %-EINVAL if given arguments are not valid,
@@ -232,15 +249,16 @@ static int fwnode_property_read_int_array(const struct fwnode_handle *fwnode, 
{

	int ret;



	if (IS_ERR_OR_NULL(fwnode))

		return -EINVAL;



	ret = fwnode_call_int_op(fwnode, property_read_int_array, propname,

				 elem_size, val, nval);

	if (ret == -EINVAL && !IS_ERR_OR_NULL(fwnode) &&

	    !IS_ERR_OR_NULL(fwnode->secondary))

		ret = fwnode_call_int_op(

			fwnode->secondary, property_read_int_array, propname,

			elem_size, val, nval);



	if (ret != -EINVAL)

		return ret;



	return fwnode_call_int_op(fwnode->secondary, property_read_int_array, propname,

				  elem_size, val, nval);

}



/**
@@ -253,6 +271,9 @@ static int fwnode_property_read_int_array(const struct fwnode_handle *fwnode, 
 * Read an array of u8 properties with @propname from @fwnode and stores them to

 * @val if found.

 *

 * It's recommended to call fwnode_property_count_u8() instead of calling

 * this function with @val equals %NULL and @nval equals 0.

 *

 * Return: number of values if @val was %NULL,

 *         %0 if the property was found (success),

 *	   %-EINVAL if given arguments are not valid,
@@ -279,6 +300,9 @@ EXPORT_SYMBOL_GPL(fwnode_property_read_u8_array); 
 * Read an array of u16 properties with @propname from @fwnode and store them to

 * @val if found.

 *

 * It's recommended to call fwnode_property_count_u16() instead of calling

 * this function with @val equals %NULL and @nval equals 0.

 *

 * Return: number of values if @val was %NULL,

 *         %0 if the property was found (success),

 *	   %-EINVAL if given arguments are not valid,
@@ -305,6 +329,9 @@ EXPORT_SYMBOL_GPL(fwnode_property_read_u16_array); 
 * Read an array of u32 properties with @propname from @fwnode store them to

 * @val if found.

 *

 * It's recommended to call fwnode_property_count_u32() instead of calling

 * this function with @val equals %NULL and @nval equals 0.

 *

 * Return: number of values if @val was %NULL,

 *         %0 if the property was found (success),

 *	   %-EINVAL if given arguments are not valid,
@@ -331,6 +358,9 @@ EXPORT_SYMBOL_GPL(fwnode_property_read_u32_array); 
 * Read an array of u64 properties with @propname from @fwnode and store them to

 * @val if found.

 *

 * It's recommended to call fwnode_property_count_u64() instead of calling

 * this function with @val equals %NULL and @nval equals 0.

 *

 * Return: number of values if @val was %NULL,

 *         %0 if the property was found (success),

 *	   %-EINVAL if given arguments are not valid,
@@ -357,6 +387,9 @@ EXPORT_SYMBOL_GPL(fwnode_property_read_u64_array); 
 * Read an string list property @propname from the given firmware node and store

 * them to @val if found.

 *

 * It's recommended to call fwnode_property_string_array_count() instead of calling

 * this function with @val equals %NULL and @nval equals 0.

 *

 * Return: number of values read on success if @val is non-NULL,

 *	   number of values available on success if @val is NULL,

 *	   %-EINVAL if given arguments are not valid,
@@ -371,14 +404,16 @@ int fwnode_property_read_string_array(const struct fwnode_handle *fwnode, 
{

	int ret;



	if (IS_ERR_OR_NULL(fwnode))

		return -EINVAL;



	ret = fwnode_call_int_op(fwnode, property_read_string_array, propname,

				 val, nval);

	if (ret == -EINVAL && !IS_ERR_OR_NULL(fwnode) &&

	    !IS_ERR_OR_NULL(fwnode->secondary))

		ret = fwnode_call_int_op(fwnode->secondary,

					 property_read_string_array, propname,

					 val, nval);

	if (ret != -EINVAL)

		return ret;



	return fwnode_call_int_op(fwnode->secondary, property_read_string_array, propname,

				  val, nval);

}

EXPORT_SYMBOL_GPL(fwnode_property_read_string_array);
@@ -480,15 +515,19 @@ int fwnode_property_get_reference_args(const struct fwnode_handle *fwnode, 
{

	int ret;



	if (IS_ERR_OR_NULL(fwnode))

		return -ENOENT;



	ret = fwnode_call_int_op(fwnode, get_reference_args, prop, nargs_prop,

				 nargs, index, args);

	if (ret == 0)

		return ret;



	if (ret < 0 && !IS_ERR_OR_NULL(fwnode) &&

	    !IS_ERR_OR_NULL(fwnode->secondary))

		ret = fwnode_call_int_op(fwnode->secondary, get_reference_args,

					 prop, nargs_prop, nargs, index, args);



	if (IS_ERR_OR_NULL(fwnode->secondary))

		return ret;



	return fwnode_call_int_op(fwnode->secondary, get_reference_args, prop, nargs_prop,

				  nargs, index, args);

}

EXPORT_SYMBOL_GPL(fwnode_property_get_reference_args);
@@ -587,18 +626,18 @@ EXPORT_SYMBOL_GPL(fwnode_get_next_parent); 
 */

struct device *fwnode_get_next_parent_dev(struct fwnode_handle *fwnode)

{

	struct fwnode_handle *parent;

	struct device *dev;



	fwnode_handle_get(fwnode);

	do {

		fwnode = fwnode_get_next_parent(fwnode);

		if (!fwnode)

			return NULL;

		dev = get_dev_from_fwnode(fwnode);

	} while (!dev);

	fwnode_handle_put(fwnode);

	fwnode_for_each_parent_node(fwnode, parent) {

		dev = get_dev_from_fwnode(parent);

		if (dev) {

			fwnode_handle_put(parent);

			return dev;

		}

	}

	return NULL;

}



/**

 * fwnode_count_parents - Return the number of parents a node has
@@ -608,13 +647,11 @@ struct device *fwnode_get_next_parent_dev(struct fwnode_handle *fwnode) 
 */

unsigned int fwnode_count_parents(const struct fwnode_handle *fwnode)

{

	struct fwnode_handle *__fwnode;

	unsigned int count;



	__fwnode = fwnode_get_parent(fwnode);

	struct fwnode_handle *parent;

	unsigned int count = 0;



	for (count = 0; __fwnode; count++)

		__fwnode = fwnode_get_next_parent(__fwnode);

	fwnode_for_each_parent_node(fwnode, parent)

		count++;



	return count;

}
@@ -635,40 +672,43 @@ EXPORT_SYMBOL_GPL(fwnode_count_parents); 
struct fwnode_handle *fwnode_get_nth_parent(struct fwnode_handle *fwnode,

					    unsigned int depth)

{

	unsigned int i;



	fwnode_handle_get(fwnode);

	struct fwnode_handle *parent;



	for (i = 0; i < depth && fwnode; i++)

		fwnode = fwnode_get_next_parent(fwnode);

	if (depth == 0)

		return fwnode_handle_get(fwnode);



	return fwnode;

	fwnode_for_each_parent_node(fwnode, parent) {

		if (--depth == 0)

			return parent;

	}

	return NULL;

}

EXPORT_SYMBOL_GPL(fwnode_get_nth_parent);



/**

 * fwnode_is_ancestor_of - Test if @test_ancestor is ancestor of @test_child

 * @test_ancestor: Firmware which is tested for being an ancestor

 * @test_child: Firmware which is tested for being the child

 * fwnode_is_ancestor_of - Test if @ancestor is ancestor of @child

 * @ancestor: Firmware which is tested for being an ancestor

 * @child: Firmware which is tested for being the child

 *

 * A node is considered an ancestor of itself too.

 *

 * Returns true if @test_ancestor is an ancestor of @test_child.

 * Otherwise, returns false.

 * Returns true if @ancestor is an ancestor of @child. Otherwise, returns false.

 */

bool fwnode_is_ancestor_of(struct fwnode_handle *test_ancestor,

				  struct fwnode_handle *test_child)

bool fwnode_is_ancestor_of(struct fwnode_handle *ancestor, struct fwnode_handle *child)

{

	if (!test_ancestor)

	struct fwnode_handle *parent;



	if (IS_ERR_OR_NULL(ancestor))

		return false;



	fwnode_handle_get(test_child);

	while (test_child) {

		if (test_child == test_ancestor) {

			fwnode_handle_put(test_child);

	if (child == ancestor)

		return true;



	fwnode_for_each_parent_node(child, parent) {

		if (parent == ancestor) {

			fwnode_handle_put(parent);

			return true;

		}

		test_child = fwnode_get_next_parent(test_child);

	}

	return false;

}
@@ -698,7 +738,7 @@ fwnode_get_next_available_child_node(const struct fwnode_handle *fwnode, 
{

	struct fwnode_handle *next_child = child;



	if (!fwnode)

	if (IS_ERR_OR_NULL(fwnode))

		return NULL;



	do {
@@ -722,16 +762,16 @@ struct fwnode_handle *device_get_next_child_node(struct device *dev, 
	const struct fwnode_handle *fwnode = dev_fwnode(dev);

	struct fwnode_handle *next;



	if (IS_ERR_OR_NULL(fwnode))

		return NULL;



	/* Try to find a child in primary fwnode */

	next = fwnode_get_next_child_node(fwnode, child);

	if (next)

		return next;



	/* When no more children in primary, continue with secondary */

	if (fwnode && !IS_ERR_OR_NULL(fwnode->secondary))

		next = fwnode_get_next_child_node(fwnode->secondary, child);



	return next;

	return fwnode_get_next_child_node(fwnode->secondary, child);

}

EXPORT_SYMBOL_GPL(device_get_next_child_node);
@@ -798,6 +838,9 @@ EXPORT_SYMBOL_GPL(fwnode_handle_put); 
 */

bool fwnode_device_is_available(const struct fwnode_handle *fwnode)

{

	if (IS_ERR_OR_NULL(fwnode))

		return false;



	if (!fwnode_has_op(fwnode, device_is_available))

		return true;
@@ -823,33 +866,16 @@ EXPORT_SYMBOL_GPL(device_get_child_node_count); 


bool device_dma_supported(struct device *dev)

{

	const struct fwnode_handle *fwnode = dev_fwnode(dev);



	/* For DT, this is always supported.

	 * For ACPI, this depends on CCA, which

	 * is determined by the acpi_dma_supported().

	 */

	if (is_of_node(fwnode))

		return true;



	return acpi_dma_supported(to_acpi_device_node(fwnode));

	return fwnode_call_bool_op(dev_fwnode(dev), device_dma_supported);

}

EXPORT_SYMBOL_GPL(device_dma_supported);



enum dev_dma_attr device_get_dma_attr(struct device *dev)

{

	const struct fwnode_handle *fwnode = dev_fwnode(dev);

	enum dev_dma_attr attr = DEV_DMA_NOT_SUPPORTED;

	if (!fwnode_has_op(dev_fwnode(dev), device_get_dma_attr))

		return DEV_DMA_NOT_SUPPORTED;



	if (is_of_node(fwnode)) {

		if (of_dma_is_coherent(to_of_node(fwnode)))

			attr = DEV_DMA_COHERENT;

		else

			attr = DEV_DMA_NON_COHERENT;

	} else

		attr = acpi_get_dma_attr(to_acpi_device_node(fwnode));



	return attr;

	return fwnode_call_int_op(dev_fwnode(dev), device_get_dma_attr);

}

EXPORT_SYMBOL_GPL(device_get_dma_attr);
@@ -904,10 +930,7 @@ EXPORT_SYMBOL_GPL(device_get_phy_mode); 
 */

void __iomem *fwnode_iomap(struct fwnode_handle *fwnode, int index)

{

	if (IS_ENABLED(CONFIG_OF_ADDRESS) && is_of_node(fwnode))

		return of_iomap(to_of_node(fwnode), index);



	return NULL;

	return fwnode_call_ptr_op(fwnode, iomap, index);

}

EXPORT_SYMBOL(fwnode_iomap);
@@ -921,17 +944,7 @@ EXPORT_SYMBOL(fwnode_iomap); 
 */

int fwnode_irq_get(const struct fwnode_handle *fwnode, unsigned int index)

{

	struct resource res;

	int ret;



	if (is_of_node(fwnode))

		return of_irq_get(to_of_node(fwnode), index);



	ret = acpi_irq_get(ACPI_HANDLE_FWNODE(fwnode), index, &res);

	if (ret)

		return ret;



	return res.start;

	return fwnode_call_int_op(fwnode, irq_get, index);

}

EXPORT_SYMBOL(fwnode_irq_get);
@@ -988,14 +1001,14 @@ fwnode_graph_get_next_endpoint(const struct fwnode_handle *fwnode, 
		parent = fwnode_graph_get_port_parent(prev);

	else

		parent = fwnode;

	if (IS_ERR_OR_NULL(parent))

		return NULL;



	ep = fwnode_call_ptr_op(parent, graph_get_next_endpoint, prev);



	if (IS_ERR_OR_NULL(ep) &&

	    !IS_ERR_OR_NULL(parent) && !IS_ERR_OR_NULL(parent->secondary))

		ep = fwnode_graph_get_next_endpoint(parent->secondary, NULL);



	if (ep)

		return ep;



	return fwnode_graph_get_next_endpoint(parent->secondary, NULL);

}

EXPORT_SYMBOL_GPL(fwnode_graph_get_next_endpoint);

drivers/of/property.c

+34 −0
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
#define pr_fmt(fmt)	"OF: " fmt



#include <linux/of.h>

#include <linux/of_address.h>

#include <linux/of_device.h>

#include <linux/of_graph.h>

#include <linux/of_irq.h>
@@ -872,6 +873,20 @@ static bool of_fwnode_device_is_available(const struct fwnode_handle *fwnode) 
	return of_device_is_available(to_of_node(fwnode));

}



static bool of_fwnode_device_dma_supported(const struct fwnode_handle *fwnode)

{

	return true;

}



static enum dev_dma_attr

of_fwnode_device_get_dma_attr(const struct fwnode_handle *fwnode)

{

	if (of_dma_is_coherent(to_of_node(fwnode)))

		return DEV_DMA_COHERENT;

	else

		return DEV_DMA_NON_COHERENT;

}



static bool of_fwnode_property_present(const struct fwnode_handle *fwnode,

				       const char *propname)

{
@@ -1450,6 +1465,21 @@ static int of_link_property(struct device_node *con_np, const char *prop_name) 
	return 0;

}



static void __iomem *of_fwnode_iomap(struct fwnode_handle *fwnode, int index)

{

#ifdef CONFIG_OF_ADDRESS

	return of_iomap(to_of_node(fwnode), index);

#else

	return NULL;

#endif

}



static int of_fwnode_irq_get(const struct fwnode_handle *fwnode,

			     unsigned int index)

{

	return of_irq_get(to_of_node(fwnode), index);

}



static int of_fwnode_add_links(struct fwnode_handle *fwnode)

{

	struct property *p;
@@ -1472,6 +1502,8 @@ const struct fwnode_operations of_fwnode_ops = { 
	.put = of_fwnode_put,

	.device_is_available = of_fwnode_device_is_available,

	.device_get_match_data = of_fwnode_device_get_match_data,

	.device_dma_supported = of_fwnode_device_dma_supported,

	.device_get_dma_attr = of_fwnode_device_get_dma_attr,

	.property_present = of_fwnode_property_present,

	.property_read_int_array = of_fwnode_property_read_int_array,

	.property_read_string_array = of_fwnode_property_read_string_array,
@@ -1485,6 +1517,8 @@ const struct fwnode_operations of_fwnode_ops = { 
	.graph_get_remote_endpoint = of_fwnode_graph_get_remote_endpoint,

	.graph_get_port_parent = of_fwnode_graph_get_port_parent,

	.graph_parse_endpoint = of_fwnode_graph_parse_endpoint,

	.iomap = of_fwnode_iomap,

	.irq_get = of_fwnode_irq_get,

	.add_links = of_fwnode_add_links,

};

EXPORT_SYMBOL_GPL(of_fwnode_ops);

include/linux/fwnode.h

+10 −5
Original line number Diff line number Diff line
@@ -113,6 +113,9 @@ struct fwnode_operations { 
	bool (*device_is_available)(const struct fwnode_handle *fwnode);

	const void *(*device_get_match_data)(const struct fwnode_handle *fwnode,

					     const struct device *dev);

	bool (*device_dma_supported)(const struct fwnode_handle *fwnode);

	enum dev_dma_attr

	(*device_get_dma_attr)(const struct fwnode_handle *fwnode);

	bool (*property_present)(const struct fwnode_handle *fwnode,

				 const char *propname);

	int (*property_read_int_array)(const struct fwnode_handle *fwnode,
@@ -145,15 +148,17 @@ struct fwnode_operations { 
	(*graph_get_port_parent)(struct fwnode_handle *fwnode);

	int (*graph_parse_endpoint)(const struct fwnode_handle *fwnode,

				    struct fwnode_endpoint *endpoint);

	void __iomem *(*iomap)(struct fwnode_handle *fwnode, int index);

	int (*irq_get)(const struct fwnode_handle *fwnode, unsigned int index);

	int (*add_links)(struct fwnode_handle *fwnode);

};



#define fwnode_has_op(fwnode, op)					\

	((fwnode) && (fwnode)->ops && (fwnode)->ops->op)

	(!IS_ERR_OR_NULL(fwnode) && (fwnode)->ops && (fwnode)->ops->op)



#define fwnode_call_int_op(fwnode, op, ...)				\

	(fwnode ? (fwnode_has_op(fwnode, op) ?				\

		   (fwnode)->ops->op(fwnode, ## __VA_ARGS__) : -ENXIO) : \

	 -EINVAL)

	(fwnode_has_op(fwnode, op) ?					\

	 (fwnode)->ops->op(fwnode, ## __VA_ARGS__) : (IS_ERR_OR_NULL(fwnode) ? -EINVAL : -ENXIO))



#define fwnode_call_bool_op(fwnode, op, ...)		\

	(fwnode_has_op(fwnode, op) ?			\

include/linux/property.h

+8 −4
Original line number Diff line number Diff line
@@ -83,15 +83,19 @@ struct fwnode_handle *fwnode_find_reference(const struct fwnode_handle *fwnode, 


const char *fwnode_get_name(const struct fwnode_handle *fwnode);

const char *fwnode_get_name_prefix(const struct fwnode_handle *fwnode);



struct fwnode_handle *fwnode_get_parent(const struct fwnode_handle *fwnode);

struct fwnode_handle *fwnode_get_next_parent(

	struct fwnode_handle *fwnode);

struct fwnode_handle *fwnode_get_next_parent(struct fwnode_handle *fwnode);



#define fwnode_for_each_parent_node(fwnode, parent)		\

	for (parent = fwnode_get_parent(fwnode); parent;	\

	     parent = fwnode_get_next_parent(parent))



struct device *fwnode_get_next_parent_dev(struct fwnode_handle *fwnode);

unsigned int fwnode_count_parents(const struct fwnode_handle *fwn);

struct fwnode_handle *fwnode_get_nth_parent(struct fwnode_handle *fwn,

					    unsigned int depth);

bool fwnode_is_ancestor_of(struct fwnode_handle *test_ancestor,

				  struct fwnode_handle *test_child);

bool fwnode_is_ancestor_of(struct fwnode_handle *ancestor, struct fwnode_handle *child);

struct fwnode_handle *fwnode_get_next_child_node(

	const struct fwnode_handle *fwnode, struct fwnode_handle *child);

struct fwnode_handle *fwnode_get_next_available_child_node(