OpenE2K/linux
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Device properties framework updates for 5.6-rc1

Browse Source 
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).
 -----BEGIN PGP SIGNATURE-----
 
 iQJGBAABCAAwFiEE4fcc61cGeeHD/fCwgsRv/nhiVHEFAl4u21kSHHJqd0Byand5
 c29ja2kubmV0AAoJEILEb/54YlRxpFQP/j/TYgzdC3PVWDTzbjOC2W8UStAfjG9M
 DMdCM6vnAmtS+npuO1/4hx4SM8OXVrJSbccpUik1LatfWhKftpAznNssDnnqV475
 ldUdObEHf7g/K6rGkbzELU5SknqHSGs+Gk9PfgV6ahjKy9jgq3jSaSkazVho2OwS
 nIWWnRXeyvJ8TZr+0WjhZGgrLxl1XvDJfqrcckbjluiCx0sxIDfMdq3xgavvvt4J
 qbm/8LFr46WR2fb+78EjaCwfLKZ3i8vLJDLDEf5A6UW3o9h9Xyk0avXB5ECqElrf
 AYqH5GkWThePwHZsezCVyh0MTu6C4TlEOaLFLVuAh3lLEZZ6dmHwpLeqotVhIIQG
 nERXyJNvAJ2PShJQExX67XMhaCvzX8897vMsMQgWTzBztt5aLx4JiMu+pKoxt+I8
 FvyHOhiwFP4pEp6OuJX9oxV8fVTPKU3jaLprZfce41+33yQP+jHg5zeLgpsgvvKY
 SmnxuG3I8R9yXN/AETikerddQwQxw/cc4B9va17XsaEtf6SBEzJPIqbo9cAT6AZs
 +vSr4uEHBB0Wlyrlo75XEKRfCs2f67r1IWr7pfACrHadiSowNNGEFan+tPIIelLU
 n8wgKfIEYyrjyLppZsMWGQLOkzshNZHqdPQUWpb6ywJ1qUWriZXSlh2jviex9G2m
 3wrYBGL5M+o6
 =wnoj
 -----END PGP SIGNATURE-----

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
This commit is contained in:
Linus Torvalds 2020-01-27 11:57:40 -08:00
commit 85c009e8e5
7 changed files with 663 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
drivers/base/swnode.c
View File

@ -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,92 +198,91 @@ 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 *);
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->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]);
}
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)
return -ENODATA;
/*
* 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;
} else {
new = kmemdup(pointer, src->length, GFP_KERNEL);
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;
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)
return -ENOMEM;
dst->value.str = new;
if (src->length <= sizeof(dst->value)) {
dst_ptr = &dst->value;
dst->is_inline = true;
} else {
dst->value = src->value;
dst_ptr = kmalloc(src->length, GFP_KERNEL);
if (!dst_ptr)
return -ENOMEM;
dst->pointer = dst_ptr;
}
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;
}
} else {
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;
if (!dst->name) {
property_entry_free_data(dst);
return -ENOMEM;
}
return 0;
out_free_data:
property_entry_free_data(dst);
return -ENOMEM;
}
/**
@ -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;
if (!ref->name || index > (ref->nrefs - 1))
prop = property_entry_get(swnode->node->properties, propname);
if (!prop)
return -ENOENT;
refnode = software_node_fwnode(ref->refs[index].node);
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;
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;
}

3
drivers/base/test/Kconfig
View File

@ -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

2
drivers/base/test/Makefile
View File

@ -1,2 +1,4 @@
# 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

475
drivers/base/test/property-entry-test.c Normal file
View File

@ -0,0 +1,475 @@
// 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);

81
drivers/platform/x86/intel_cht_int33fe_typec.c
View File

@ -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

6
drivers/usb/dwc3/host.c
View File

@ -88,10 +88,10 @@ int dwc3_host_init(struct dwc3 *dwc)
memset(props, 0, sizeof(struct property_entry) * ARRAY_SIZE(props));
if (dwc->usb3_lpm_capable)
props[prop_idx++].name = "usb3-lpm-capable";
props[prop_idx++] = PROPERTY_ENTRY_BOOL("usb3-lpm-capable");
if (dwc->usb2_lpm_disable)
props[prop_idx++].name = "usb2-lpm-disable";
props[prop_idx++] = PROPERTY_ENTRY_BOOL("usb2-lpm-disable");
/**
* WORKAROUND: dwc3 revisions <=3.00a have a limitation
@ -103,7 +103,7 @@ int dwc3_host_init(struct dwc3 *dwc)
* This following flag tells XHCI to do just that.
*/
if (dwc->revision <= DWC3_REVISION_300A)
props[prop_idx++].name = "quirk-broken-port-ped";
props[prop_idx++] = PROPERTY_ENTRY_BOOL("quirk-broken-port-ped");
if (prop_idx) {
ret = platform_device_add_properties(xhci, props);

96
include/linux/property.h
View File

@ -22,6 +22,7 @@ enum dev_prop_type {
DEV_PROP_U32,
DEV_PROP_U64,
DEV_PROP_STRING,
DEV_PROP_REF,
};
enum dev_dma_attr {
@ -223,28 +224,42 @@ static inline int fwnode_property_count_u64(const struct fwnode_handle *fwnode,
return fwnode_property_read_u64_array(fwnode, propname, NULL, 0);
}
struct software_node;
/**
* struct software_node_ref_args - Reference property with additional arguments
* @node: Reference to a software node
* @nargs: Number of elements in @args array
* @args: Integer arguments
*/
struct software_node_ref_args {
const struct software_node *node;
unsigned int nargs;
u64 args[NR_FWNODE_REFERENCE_ARGS];
};
/**
* struct property_entry - "Built-in" device property representation.
* @name: Name of the property.
* @length: Length of data making up the value.
* @is_array: True when the property is an array.
* @is_inline: True when the property value is stored inline.
* @type: Type of the data in unions.
* @pointer: Pointer to the property (an array of items of the given type).
* @value: Value of the property (when it is a single item of the given type).
* @pointer: Pointer to the property when it is not stored inline.
* @value: Value of the property when it is stored inline.
*/
struct property_entry {
const char *name;
size_t length;
bool is_array;
bool is_inline;
enum dev_prop_type type;
union {
const void *pointer;
union {
u8 u8_data;
u16 u16_data;
u32 u32_data;
u64 u64_data;
const char *str;
u8 u8_data[sizeof(u64) / sizeof(u8)];
u16 u16_data[sizeof(u64) / sizeof(u16)];
u32 u32_data[sizeof(u64) / sizeof(u32)];
u64 u64_data[sizeof(u64) / sizeof(u64)];
const char *str[sizeof(u64) / sizeof(char *)];
} value;
};
};
@ -256,17 +271,22 @@ struct property_entry {
*/
#define __PROPERTY_ENTRY_ELEMENT_SIZE(_elem_) \
sizeof(((struct property_entry *)NULL)->value._elem_)
sizeof(((struct property_entry *)NULL)->value._elem_[0])
#define __PROPERTY_ENTRY_ARRAY_LEN(_name_, _elem_, _Type_, _val_, _len_)\
#define __PROPERTY_ENTRY_ARRAY_ELSIZE_LEN(_name_, _elsize_, _Type_, \
_val_, _len_) \
(struct property_entry) { \
.name = _name_, \
.length = (_len_) * __PROPERTY_ENTRY_ELEMENT_SIZE(_elem_), \
.is_array = true, \
.length = (_len_) * (_elsize_), \
.type = DEV_PROP_##_Type_, \
{ .pointer = _val_ }, \
}
#define __PROPERTY_ENTRY_ARRAY_LEN(_name_, _elem_, _Type_, _val_, _len_)\
__PROPERTY_ENTRY_ARRAY_ELSIZE_LEN(_name_, \
__PROPERTY_ENTRY_ELEMENT_SIZE(_elem_), \
_Type_, _val_, _len_)
#define PROPERTY_ENTRY_U8_ARRAY_LEN(_name_, _val_, _len_) \
__PROPERTY_ENTRY_ARRAY_LEN(_name_, u8_data, U8, _val_, _len_)
#define PROPERTY_ENTRY_U16_ARRAY_LEN(_name_, _val_, _len_) \
@ -277,6 +297,10 @@ struct property_entry {
__PROPERTY_ENTRY_ARRAY_LEN(_name_, u64_data, U64, _val_, _len_)
#define PROPERTY_ENTRY_STRING_ARRAY_LEN(_name_, _val_, _len_) \
__PROPERTY_ENTRY_ARRAY_LEN(_name_, str, STRING, _val_, _len_)
#define PROPERTY_ENTRY_REF_ARRAY_LEN(_name_, _val_, _len_) \
__PROPERTY_ENTRY_ARRAY_ELSIZE_LEN(_name_, \
sizeof(struct software_node_ref_args), \
REF, _val_, _len_)
#define PROPERTY_ENTRY_U8_ARRAY(_name_, _val_) \
PROPERTY_ENTRY_U8_ARRAY_LEN(_name_, _val_, ARRAY_SIZE(_val_))
@ -288,13 +312,16 @@ struct property_entry {
PROPERTY_ENTRY_U64_ARRAY_LEN(_name_, _val_, ARRAY_SIZE(_val_))
#define PROPERTY_ENTRY_STRING_ARRAY(_name_, _val_) \
PROPERTY_ENTRY_STRING_ARRAY_LEN(_name_, _val_, ARRAY_SIZE(_val_))
#define PROPERTY_ENTRY_REF_ARRAY(_name_, _val_) \
PROPERTY_ENTRY_REF_ARRAY_LEN(_name_, _val_, ARRAY_SIZE(_val_))
#define __PROPERTY_ENTRY_ELEMENT(_name_, _elem_, _Type_, _val_) \
(struct property_entry) { \
.name = _name_, \
.length = __PROPERTY_ENTRY_ELEMENT_SIZE(_elem_), \
.is_inline = true, \
.type = DEV_PROP_##_Type_, \
{ .value = { ._elem_ = _val_ } }, \
{ .value = { ._elem_[0] = _val_ } }, \
}
#define PROPERTY_ENTRY_U8(_name_, _val_) \
@ -311,6 +338,19 @@ struct property_entry {
#define PROPERTY_ENTRY_BOOL(_name_) \
(struct property_entry) { \
.name = _name_, \
.is_inline = true, \
}
#define PROPERTY_ENTRY_REF(_name_, _ref_, ...) \
(struct property_entry) { \
.name = _name_, \
.length = sizeof(struct software_node_ref_args), \
.type = DEV_PROP_REF, \
{ .pointer = &(const struct software_node_ref_args) { \
.node = _ref_, \
.nargs = ARRAY_SIZE(((u64[]){ 0, ##__VA_ARGS__ })) - 1, \
.args = { __VA_ARGS__ }, \
} }, \
}
struct property_entry *
@ -376,44 +416,16 @@ int fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode,
/* -------------------------------------------------------------------------- */
/* Software fwnode support - when HW description is incomplete or missing */
struct software_node;
/**
* struct software_node_ref_args - Reference with additional arguments
* @node: Reference to a software node
* @nargs: Number of elements in @args array
* @args: Integer arguments
*/
struct software_node_ref_args {
const struct software_node *node;
unsigned int nargs;
u64 args[NR_FWNODE_REFERENCE_ARGS];
};
/**
* struct software_node_reference - Named software node reference property
* @name: Name of the property
* @nrefs: Number of elements in @refs array
* @refs: Array of references with optional arguments
*/
struct software_node_reference {
const char *name;
unsigned int nrefs;
const struct software_node_ref_args *refs;
};
/**
* struct software_node - Software node description
* @name: Name of the software node
* @parent: Parent of the software node
* @properties: Array of device properties
* @references: Array of software node reference properties
*/
struct software_node {
const char *name;
const struct software_node *parent;
const struct property_entry *properties;
const struct software_node_reference *references;
};
bool is_software_node(const struct fwnode_handle *fwnode);