Commit 85c009e8 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull device properties framework updates from Rafael Wysocki:
 "Add support for reference properties in sofrware nodes (Dmitry
  Torokhov) and a basic test for property entries along with fixes on
  top of it (Dmitry Torokhov, Qian Cai, Alan Maguire)"

* tag 'devprop-5.6-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm:
  software node: introduce CONFIG_KUNIT_DRIVER_PE_TEST
  usb: dwc3: use proper initializers for property entries
  drivers/base/test: fix global-out-of-bounds error
  software node: add basic tests for property entries
  software node: remove separate handling of references
  platform/x86: intel_cht_int33fe: use inline reference properties
  software node: implement reference properties
  software node: allow embedding of small arrays into property_entry
  software node: replace is_array with is_inline
parents 55816dc1 aa811e3c

drivers/base/swnode.c

+84 −70
Original line number Diff line number Diff line
@@ -108,10 +108,7 @@ static const void *property_get_pointer(const struct property_entry *prop) 
	if (!prop->length)

		return NULL;



	if (prop->is_array)

		return prop->pointer;



	return &prop->value;

	return prop->is_inline ? &prop->value : prop->pointer;

}



static const void *property_entry_find(const struct property_entry *props,
@@ -201,94 +198,93 @@ static int property_entry_read_string_array(const struct property_entry *props, 


static void property_entry_free_data(const struct property_entry *p)

{

	const void *pointer = property_get_pointer(p);

	const char * const *src_str;

	size_t i, nval;



	if (p->is_array) {

		if (p->type == DEV_PROP_STRING && p->pointer) {

			src_str = p->pointer;

			nval = p->length / sizeof(const char *);

	if (p->type == DEV_PROP_STRING) {

		src_str = property_get_pointer(p);

		nval = p->length / sizeof(*src_str);

		for (i = 0; i < nval; i++)

			kfree(src_str[i]);

	}

		kfree(pointer);

	} else if (p->type == DEV_PROP_STRING) {

		kfree(p->value.str);

	}



	if (!p->is_inline)

		kfree(p->pointer);



	kfree(p->name);

}



static const char * const *

property_copy_string_array(const struct property_entry *src)

static bool property_copy_string_array(const char **dst_ptr,

				       const char * const *src_ptr,

				       size_t nval)

{

	const char **d;

	const char * const *src_str = src->pointer;

	size_t nval = src->length / sizeof(*d);

	int i;



	d = kcalloc(nval, sizeof(*d), GFP_KERNEL);

	if (!d)

		return NULL;



	for (i = 0; i < nval; i++) {

		d[i] = kstrdup(src_str[i], GFP_KERNEL);

		if (!d[i] && src_str[i]) {

		dst_ptr[i] = kstrdup(src_ptr[i], GFP_KERNEL);

		if (!dst_ptr[i] && src_ptr[i]) {

			while (--i >= 0)

				kfree(d[i]);

			kfree(d);

			return NULL;

				kfree(dst_ptr[i]);

			return false;

		}

	}



	return d;

	return true;

}



static int property_entry_copy_data(struct property_entry *dst,

				    const struct property_entry *src)

{

	const void *pointer = property_get_pointer(src);

	const void *new;

	void *dst_ptr;

	size_t nval;



	if (src->is_array) {

		if (!src->length)

	/*

	 * Properties with no data should not be marked as stored

	 * out of line.

	 */

	if (!src->is_inline && !src->length)

		return -ENODATA;



		if (src->type == DEV_PROP_STRING) {

			new = property_copy_string_array(src);

			if (!new)

				return -ENOMEM;

	/*

	 * Reference properties are never stored inline as

	 * they are too big.

	 */

	if (src->type == DEV_PROP_REF && src->is_inline)

		return -EINVAL;



	if (src->length <= sizeof(dst->value)) {

		dst_ptr = &dst->value;

		dst->is_inline = true;

	} else {

			new = kmemdup(pointer, src->length, GFP_KERNEL);

			if (!new)

		dst_ptr = kmalloc(src->length, GFP_KERNEL);

		if (!dst_ptr)

			return -ENOMEM;

		dst->pointer = dst_ptr;

	}



		dst->is_array = true;

		dst->pointer = new;

	} else if (src->type == DEV_PROP_STRING) {

		new = kstrdup(src->value.str, GFP_KERNEL);

		if (!new && src->value.str)

	if (src->type == DEV_PROP_STRING) {

		nval = src->length / sizeof(const char *);

		if (!property_copy_string_array(dst_ptr, pointer, nval)) {

			if (!dst->is_inline)

				kfree(dst->pointer);

			return -ENOMEM;



		dst->value.str = new;

		}

	} else {

		dst->value = src->value;

		memcpy(dst_ptr, pointer, src->length);

	}



	dst->length = src->length;

	dst->type = src->type;

	dst->name = kstrdup(src->name, GFP_KERNEL);

	if (!dst->name)

		goto out_free_data;



	return 0;



out_free_data:

	if (!dst->name) {

		property_entry_free_data(dst);

		return -ENOMEM;

	}



	return 0;

}



/**

 * property_entries_dup - duplicate array of properties

 * @properties: array of properties to copy
@@ -483,31 +479,49 @@ software_node_get_reference_args(const struct fwnode_handle *fwnode, 
				 struct fwnode_reference_args *args)

{

	struct swnode *swnode = to_swnode(fwnode);

	const struct software_node_reference *ref;

	const struct software_node_ref_args *ref_array;

	const struct software_node_ref_args *ref;

	const struct property_entry *prop;

	struct fwnode_handle *refnode;

	u32 nargs_prop_val;

	int error;

	int i;



	if (!swnode || !swnode->node->references)

	if (!swnode)

		return -ENOENT;



	for (ref = swnode->node->references; ref->name; ref++)

		if (!strcmp(ref->name, propname))

			break;

	prop = property_entry_get(swnode->node->properties, propname);

	if (!prop)

		return -ENOENT;



	if (!ref->name || index > (ref->nrefs - 1))

	if (prop->type != DEV_PROP_REF)

		return -EINVAL;



	/*

	 * We expect that references are never stored inline, even

	 * single ones, as they are too big.

	 */

	if (prop->is_inline)

		return -EINVAL;



	if (index * sizeof(*ref) >= prop->length)

		return -ENOENT;



	refnode = software_node_fwnode(ref->refs[index].node);

	ref_array = prop->pointer;

	ref = &ref_array[index];



	refnode = software_node_fwnode(ref->node);

	if (!refnode)

		return -ENOENT;



	if (nargs_prop) {

		prop = property_entry_get(swnode->node->properties, nargs_prop);

		if (!prop)

			return -EINVAL;

		error = property_entry_read_int_array(swnode->node->properties,

						      nargs_prop, sizeof(u32),

						      &nargs_prop_val, 1);

		if (error)

			return error;



		nargs = prop->value.u32_data;

		nargs = nargs_prop_val;

	}



	if (nargs > NR_FWNODE_REFERENCE_ARGS)
@@ -517,7 +531,7 @@ software_node_get_reference_args(const struct fwnode_handle *fwnode, 
	args->nargs = nargs;



	for (i = 0; i < nargs; i++)

		args->args[i] = ref->refs[index].args[i];

		args->args[i] = ref->args[i];



	return 0;

}

drivers/base/test/Kconfig

+3 −0
Original line number Diff line number Diff line
@@ -8,3 +8,6 @@ config TEST_ASYNC_DRIVER_PROBE 
	  The module name will be test_async_driver_probe.ko



	  If unsure say N.

config KUNIT_DRIVER_PE_TEST

	bool "KUnit Tests for property entry API"

	depends on KUNIT=y

drivers/base/test/Makefile

+2 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0

obj-$(CONFIG_TEST_ASYNC_DRIVER_PROBE)	+= test_async_driver_probe.o



obj-$(CONFIG_KUNIT_DRIVER_PE_TEST) += property-entry-test.o

drivers/base/test/property-entry-test.c

0 → 100644
+475 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

// Unit tests for property entries API

//

// Copyright 2019 Google LLC.



#include <kunit/test.h>

#include <linux/property.h>

#include <linux/types.h>



static void pe_test_uints(struct kunit *test)

{

	static const struct property_entry entries[] = {

		PROPERTY_ENTRY_U8("prop-u8", 8),

		PROPERTY_ENTRY_U16("prop-u16", 16),

		PROPERTY_ENTRY_U32("prop-u32", 32),

		PROPERTY_ENTRY_U64("prop-u64", 64),

		{ }

	};



	struct fwnode_handle *node;

	u8 val_u8, array_u8[2];

	u16 val_u16, array_u16[2];

	u32 val_u32, array_u32[2];

	u64 val_u64, array_u64[2];

	int error;



	node = fwnode_create_software_node(entries, NULL);

	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, node);



	error = fwnode_property_read_u8(node, "prop-u8", &val_u8);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)val_u8, 8);



	error = fwnode_property_read_u8_array(node, "prop-u8", array_u8, 1);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)array_u8[0], 8);



	error = fwnode_property_read_u8_array(node, "prop-u8", array_u8, 2);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u8(node, "no-prop-u8", &val_u8);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u8_array(node, "no-prop-u8", array_u8, 1);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u16(node, "prop-u16", &val_u16);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)val_u16, 16);



	error = fwnode_property_read_u16_array(node, "prop-u16", array_u16, 1);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)array_u16[0], 16);



	error = fwnode_property_read_u16_array(node, "prop-u16", array_u16, 2);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u16(node, "no-prop-u16", &val_u16);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u16_array(node, "no-prop-u16", array_u16, 1);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u32(node, "prop-u32", &val_u32);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)val_u32, 32);



	error = fwnode_property_read_u32_array(node, "prop-u32", array_u32, 1);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)array_u32[0], 32);



	error = fwnode_property_read_u32_array(node, "prop-u32", array_u32, 2);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u32(node, "no-prop-u32", &val_u32);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u32_array(node, "no-prop-u32", array_u32, 1);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u64(node, "prop-u64", &val_u64);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)val_u64, 64);



	error = fwnode_property_read_u64_array(node, "prop-u64", array_u64, 1);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)array_u64[0], 64);



	error = fwnode_property_read_u64_array(node, "prop-u64", array_u64, 2);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u64(node, "no-prop-u64", &val_u64);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u64_array(node, "no-prop-u64", array_u64, 1);

	KUNIT_EXPECT_NE(test, error, 0);



	fwnode_remove_software_node(node);

}



static void pe_test_uint_arrays(struct kunit *test)

{

	static const u8 a_u8[16] = { 8, 9 };

	static const u16 a_u16[16] = { 16, 17 };

	static const u32 a_u32[16] = { 32, 33 };

	static const u64 a_u64[16] = { 64, 65 };

	static const struct property_entry entries[] = {

		PROPERTY_ENTRY_U8_ARRAY("prop-u8", a_u8),

		PROPERTY_ENTRY_U16_ARRAY("prop-u16", a_u16),

		PROPERTY_ENTRY_U32_ARRAY("prop-u32", a_u32),

		PROPERTY_ENTRY_U64_ARRAY("prop-u64", a_u64),

		{ }

	};



	struct fwnode_handle *node;

	u8 val_u8, array_u8[32];

	u16 val_u16, array_u16[32];

	u32 val_u32, array_u32[32];

	u64 val_u64, array_u64[32];

	int error;



	node = fwnode_create_software_node(entries, NULL);

	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, node);



	error = fwnode_property_read_u8(node, "prop-u8", &val_u8);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)val_u8, 8);



	error = fwnode_property_read_u8_array(node, "prop-u8", array_u8, 1);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)array_u8[0], 8);



	error = fwnode_property_read_u8_array(node, "prop-u8", array_u8, 2);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)array_u8[0], 8);

	KUNIT_EXPECT_EQ(test, (int)array_u8[1], 9);



	error = fwnode_property_read_u8_array(node, "prop-u8", array_u8, 17);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u8(node, "no-prop-u8", &val_u8);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u8_array(node, "no-prop-u8", array_u8, 1);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u16(node, "prop-u16", &val_u16);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)val_u16, 16);



	error = fwnode_property_read_u16_array(node, "prop-u16", array_u16, 1);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)array_u16[0], 16);



	error = fwnode_property_read_u16_array(node, "prop-u16", array_u16, 2);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)array_u16[0], 16);

	KUNIT_EXPECT_EQ(test, (int)array_u16[1], 17);



	error = fwnode_property_read_u16_array(node, "prop-u16", array_u16, 17);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u16(node, "no-prop-u16", &val_u16);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u16_array(node, "no-prop-u16", array_u16, 1);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u32(node, "prop-u32", &val_u32);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)val_u32, 32);



	error = fwnode_property_read_u32_array(node, "prop-u32", array_u32, 1);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)array_u32[0], 32);



	error = fwnode_property_read_u32_array(node, "prop-u32", array_u32, 2);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)array_u32[0], 32);

	KUNIT_EXPECT_EQ(test, (int)array_u32[1], 33);



	error = fwnode_property_read_u32_array(node, "prop-u32", array_u32, 17);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u32(node, "no-prop-u32", &val_u32);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u32_array(node, "no-prop-u32", array_u32, 1);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u64(node, "prop-u64", &val_u64);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)val_u64, 64);



	error = fwnode_property_read_u64_array(node, "prop-u64", array_u64, 1);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)array_u64[0], 64);



	error = fwnode_property_read_u64_array(node, "prop-u64", array_u64, 2);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_EQ(test, (int)array_u64[0], 64);

	KUNIT_EXPECT_EQ(test, (int)array_u64[1], 65);



	error = fwnode_property_read_u64_array(node, "prop-u64", array_u64, 17);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u64(node, "no-prop-u64", &val_u64);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_u64_array(node, "no-prop-u64", array_u64, 1);

	KUNIT_EXPECT_NE(test, error, 0);



	fwnode_remove_software_node(node);

}



static void pe_test_strings(struct kunit *test)

{

	static const char *strings[] = {

		"string-a",

		"string-b",

	};



	static const struct property_entry entries[] = {

		PROPERTY_ENTRY_STRING("str", "single"),

		PROPERTY_ENTRY_STRING("empty", ""),

		PROPERTY_ENTRY_STRING_ARRAY("strs", strings),

		{ }

	};



	struct fwnode_handle *node;

	const char *str;

	const char *strs[10];

	int error;



	node = fwnode_create_software_node(entries, NULL);

	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, node);



	error = fwnode_property_read_string(node, "str", &str);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_STREQ(test, str, "single");



	error = fwnode_property_read_string_array(node, "str", strs, 1);

	KUNIT_EXPECT_EQ(test, error, 1);

	KUNIT_EXPECT_STREQ(test, strs[0], "single");



	/* asking for more data returns what we have */

	error = fwnode_property_read_string_array(node, "str", strs, 2);

	KUNIT_EXPECT_EQ(test, error, 1);

	KUNIT_EXPECT_STREQ(test, strs[0], "single");



	error = fwnode_property_read_string(node, "no-str", &str);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_read_string_array(node, "no-str", strs, 1);

	KUNIT_EXPECT_LT(test, error, 0);



	error = fwnode_property_read_string(node, "empty", &str);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_STREQ(test, str, "");



	error = fwnode_property_read_string_array(node, "strs", strs, 3);

	KUNIT_EXPECT_EQ(test, error, 2);

	KUNIT_EXPECT_STREQ(test, strs[0], "string-a");

	KUNIT_EXPECT_STREQ(test, strs[1], "string-b");



	error = fwnode_property_read_string_array(node, "strs", strs, 1);

	KUNIT_EXPECT_EQ(test, error, 1);

	KUNIT_EXPECT_STREQ(test, strs[0], "string-a");



	/* NULL argument -> returns size */

	error = fwnode_property_read_string_array(node, "strs", NULL, 0);

	KUNIT_EXPECT_EQ(test, error, 2);



	/* accessing array as single value */

	error = fwnode_property_read_string(node, "strs", &str);

	KUNIT_EXPECT_EQ(test, error, 0);

	KUNIT_EXPECT_STREQ(test, str, "string-a");



	fwnode_remove_software_node(node);

}



static void pe_test_bool(struct kunit *test)

{

	static const struct property_entry entries[] = {

		PROPERTY_ENTRY_BOOL("prop"),

		{ }

	};



	struct fwnode_handle *node;



	node = fwnode_create_software_node(entries, NULL);

	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, node);



	KUNIT_EXPECT_TRUE(test, fwnode_property_read_bool(node, "prop"));

	KUNIT_EXPECT_FALSE(test, fwnode_property_read_bool(node, "not-prop"));



	fwnode_remove_software_node(node);

}



/* Verifies that small U8 array is stored inline when property is copied */

static void pe_test_move_inline_u8(struct kunit *test)

{

	static const u8 u8_array_small[8] = { 1, 2, 3, 4 };

	static const u8 u8_array_big[128] = { 5, 6, 7, 8 };

	static const struct property_entry entries[] = {

		PROPERTY_ENTRY_U8_ARRAY("small", u8_array_small),

		PROPERTY_ENTRY_U8_ARRAY("big", u8_array_big),

		{ }

	};



	struct property_entry *copy;

	const u8 *data_ptr;



	copy = property_entries_dup(entries);

	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, copy);



	KUNIT_EXPECT_TRUE(test, copy[0].is_inline);

	data_ptr = (u8 *)&copy[0].value;

	KUNIT_EXPECT_EQ(test, (int)data_ptr[0], 1);

	KUNIT_EXPECT_EQ(test, (int)data_ptr[1], 2);



	KUNIT_EXPECT_FALSE(test, copy[1].is_inline);

	data_ptr = copy[1].pointer;

	KUNIT_EXPECT_EQ(test, (int)data_ptr[0], 5);

	KUNIT_EXPECT_EQ(test, (int)data_ptr[1], 6);



	property_entries_free(copy);

}



/* Verifies that single string array is stored inline when property is copied */

static void pe_test_move_inline_str(struct kunit *test)

{

	static char *str_array_small[] = { "a" };

	static char *str_array_big[] = { "b", "c", "d", "e" };

	static char *str_array_small_empty[] = { "" };

	static struct property_entry entries[] = {

		PROPERTY_ENTRY_STRING_ARRAY("small", str_array_small),

		PROPERTY_ENTRY_STRING_ARRAY("big", str_array_big),

		PROPERTY_ENTRY_STRING_ARRAY("small-empty", str_array_small_empty),

		{ }

	};



	struct property_entry *copy;

	const char * const *data_ptr;



	copy = property_entries_dup(entries);

	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, copy);



	KUNIT_EXPECT_TRUE(test, copy[0].is_inline);

	KUNIT_EXPECT_STREQ(test, copy[0].value.str[0], "a");



	KUNIT_EXPECT_FALSE(test, copy[1].is_inline);

	data_ptr = copy[1].pointer;

	KUNIT_EXPECT_STREQ(test, data_ptr[0], "b");

	KUNIT_EXPECT_STREQ(test, data_ptr[1], "c");



	KUNIT_EXPECT_TRUE(test, copy[2].is_inline);

	KUNIT_EXPECT_STREQ(test, copy[2].value.str[0], "");



	property_entries_free(copy);

}



/* Handling of reference properties */

static void pe_test_reference(struct kunit *test)

{

	static const struct software_node nodes[] = {

		{ .name = "1", },

		{ .name = "2", },

		{ }

	};



	static const struct software_node_ref_args refs[] = {

		{

			.node = &nodes[0],

			.nargs = 0,

		},

		{

			.node = &nodes[1],

			.nargs = 2,

			.args = { 3, 4 },

		},

	};



	const struct property_entry entries[] = {

		PROPERTY_ENTRY_REF("ref-1", &nodes[0]),

		PROPERTY_ENTRY_REF("ref-2", &nodes[1], 1, 2),

		PROPERTY_ENTRY_REF_ARRAY("ref-3", refs),

		{ }

	};



	struct fwnode_handle *node;

	struct fwnode_reference_args ref;

	int error;



	error = software_node_register_nodes(nodes);

	KUNIT_ASSERT_EQ(test, error, 0);



	node = fwnode_create_software_node(entries, NULL);

	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, node);



	error = fwnode_property_get_reference_args(node, "ref-1", NULL,

						   0, 0, &ref);

	KUNIT_ASSERT_EQ(test, error, 0);

	KUNIT_EXPECT_PTR_EQ(test, to_software_node(ref.fwnode), &nodes[0]);

	KUNIT_EXPECT_EQ(test, ref.nargs, 0U);



	/* wrong index */

	error = fwnode_property_get_reference_args(node, "ref-1", NULL,

						   0, 1, &ref);

	KUNIT_EXPECT_NE(test, error, 0);



	error = fwnode_property_get_reference_args(node, "ref-2", NULL,

						   1, 0, &ref);

	KUNIT_ASSERT_EQ(test, error, 0);

	KUNIT_EXPECT_PTR_EQ(test, to_software_node(ref.fwnode), &nodes[1]);

	KUNIT_EXPECT_EQ(test, ref.nargs, 1U);

	KUNIT_EXPECT_EQ(test, ref.args[0], 1LLU);



	/* asking for more args, padded with zero data */

	error = fwnode_property_get_reference_args(node, "ref-2", NULL,

						   3, 0, &ref);

	KUNIT_ASSERT_EQ(test, error, 0);

	KUNIT_EXPECT_PTR_EQ(test, to_software_node(ref.fwnode), &nodes[1]);

	KUNIT_EXPECT_EQ(test, ref.nargs, 3U);

	KUNIT_EXPECT_EQ(test, ref.args[0], 1LLU);

	KUNIT_EXPECT_EQ(test, ref.args[1], 2LLU);

	KUNIT_EXPECT_EQ(test, ref.args[2], 0LLU);



	/* wrong index */

	error = fwnode_property_get_reference_args(node, "ref-2", NULL,

						   2, 1, &ref);

	KUNIT_EXPECT_NE(test, error, 0);



	/* array of references */

	error = fwnode_property_get_reference_args(node, "ref-3", NULL,

						   0, 0, &ref);

	KUNIT_ASSERT_EQ(test, error, 0);

	KUNIT_EXPECT_PTR_EQ(test, to_software_node(ref.fwnode), &nodes[0]);

	KUNIT_EXPECT_EQ(test, ref.nargs, 0U);



	/* second reference in the array */

	error = fwnode_property_get_reference_args(node, "ref-3", NULL,

						   2, 1, &ref);

	KUNIT_ASSERT_EQ(test, error, 0);

	KUNIT_EXPECT_PTR_EQ(test, to_software_node(ref.fwnode), &nodes[1]);

	KUNIT_EXPECT_EQ(test, ref.nargs, 2U);

	KUNIT_EXPECT_EQ(test, ref.args[0], 3LLU);

	KUNIT_EXPECT_EQ(test, ref.args[1], 4LLU);



	/* wrong index */

	error = fwnode_property_get_reference_args(node, "ref-1", NULL,

						   0, 2, &ref);

	KUNIT_EXPECT_NE(test, error, 0);



	fwnode_remove_software_node(node);

	software_node_unregister_nodes(nodes);

}



static struct kunit_case property_entry_test_cases[] = {

	KUNIT_CASE(pe_test_uints),

	KUNIT_CASE(pe_test_uint_arrays),

	KUNIT_CASE(pe_test_strings),

	KUNIT_CASE(pe_test_bool),

	KUNIT_CASE(pe_test_move_inline_u8),

	KUNIT_CASE(pe_test_move_inline_str),

	KUNIT_CASE(pe_test_reference),

	{ }

};



static struct kunit_suite property_entry_test_suite = {

	.name = "property-entry",

	.test_cases = property_entry_test_cases,

};



kunit_test_suite(property_entry_test_suite);

drivers/platform/x86/intel_cht_int33fe_typec.c

+41 −40
Original line number Diff line number Diff line
@@ -36,30 +36,6 @@ enum { 
	INT33FE_NODE_MAX,

};



static const struct software_node nodes[];



static const struct software_node_ref_args pi3usb30532_ref = {

	&nodes[INT33FE_NODE_PI3USB30532]

};



static const struct software_node_ref_args dp_ref = {

	&nodes[INT33FE_NODE_DISPLAYPORT]

};



static struct software_node_ref_args mux_ref;



static const struct software_node_reference usb_connector_refs[] = {

	{ "orientation-switch", 1, &pi3usb30532_ref},

	{ "mode-switch", 1, &pi3usb30532_ref},

	{ "displayport", 1, &dp_ref},

	{ }

};



static const struct software_node_reference fusb302_refs[] = {

	{ "usb-role-switch", 1, &mux_ref},

	{ }

};



/*

 * Grrr I severly dislike buggy BIOS-es. At least one BIOS enumerates

 * the max17047 both through the INT33FE ACPI device (it is right there
@@ -95,8 +71,18 @@ static const struct property_entry max17047_props[] = { 
	{ }

};



/*

 * We are not using inline property here because those are constant,

 * and we need to adjust this one at runtime to point to real

 * software node.

 */

static struct software_node_ref_args fusb302_mux_refs[] = {

	{ .node = NULL },

};



static const struct property_entry fusb302_props[] = {

	PROPERTY_ENTRY_STRING("linux,extcon-name", "cht_wcove_pwrsrc"),

	PROPERTY_ENTRY_REF_ARRAY("usb-role-switch", fusb302_mux_refs),

	{ }

};
@@ -112,6 +98,8 @@ static const u32 snk_pdo[] = { 
	PDO_VAR(5000, 12000, 3000),

};



static const struct software_node nodes[];



static const struct property_entry usb_connector_props[] = {

	PROPERTY_ENTRY_STRING("data-role", "dual"),

	PROPERTY_ENTRY_STRING("power-role", "dual"),
@@ -119,15 +107,21 @@ static const struct property_entry usb_connector_props[] = { 
	PROPERTY_ENTRY_U32_ARRAY("source-pdos", src_pdo),

	PROPERTY_ENTRY_U32_ARRAY("sink-pdos", snk_pdo),

	PROPERTY_ENTRY_U32("op-sink-microwatt", 2500000),

	PROPERTY_ENTRY_REF("orientation-switch",

			   &nodes[INT33FE_NODE_PI3USB30532]),

	PROPERTY_ENTRY_REF("mode-switch",

			   &nodes[INT33FE_NODE_PI3USB30532]),

	PROPERTY_ENTRY_REF("displayport",

			   &nodes[INT33FE_NODE_DISPLAYPORT]),

	{ }

};



static const struct software_node nodes[] = {

	{ "fusb302", NULL, fusb302_props, fusb302_refs },

	{ "fusb302", NULL, fusb302_props },

	{ "max17047", NULL, max17047_props },

	{ "pi3usb30532" },

	{ "displayport" },

	{ "connector", &nodes[0], usb_connector_props, usb_connector_refs },

	{ "connector", &nodes[0], usb_connector_props },

	{ }

};
@@ -163,9 +157,10 @@ static void cht_int33fe_remove_nodes(struct cht_int33fe_data *data) 
{

	software_node_unregister_nodes(nodes);



	if (mux_ref.node) {

		fwnode_handle_put(software_node_fwnode(mux_ref.node));

		mux_ref.node = NULL;

	if (fusb302_mux_refs[0].node) {

		fwnode_handle_put(

			software_node_fwnode(fusb302_mux_refs[0].node));

		fusb302_mux_refs[0].node = NULL;

	}



	if (data->dp) {
@@ -177,25 +172,31 @@ static void cht_int33fe_remove_nodes(struct cht_int33fe_data *data) 


static int cht_int33fe_add_nodes(struct cht_int33fe_data *data)

{

	const struct software_node *mux_ref_node;

	int ret;



	ret = software_node_register_nodes(nodes);

	if (ret)

		return ret;



	/* The devices that are not created in this driver need extra steps. */



	/*

	 * There is no ACPI device node for the USB role mux, so we need to wait

	 * until the mux driver has created software node for the mux device.

	 * It means we depend on the mux driver. This function will return

	 * -EPROBE_DEFER until the mux device is registered.

	 */

	mux_ref.node = software_node_find_by_name(NULL, "intel-xhci-usb-sw");

	if (!mux_ref.node) {

		ret = -EPROBE_DEFER;

		goto err_remove_nodes;

	}

	mux_ref_node = software_node_find_by_name(NULL, "intel-xhci-usb-sw");

	if (!mux_ref_node)

		return -EPROBE_DEFER;



	/*

	 * Update node used in "usb-role-switch" property. Note that we

	 * rely on software_node_register_nodes() to use the original

	 * instance of properties instead of copying them.

	 */

	fusb302_mux_refs[0].node = mux_ref_node;



	ret = software_node_register_nodes(nodes);

	if (ret)

		return ret;



	/* The devices that are not created in this driver need extra steps. */



	/*

	 * The DP connector does have ACPI device node. In this case we can just

CRA Git | Maintained and supported by SUSTech CRA and CCSE