lkml.org 
[lkml]   [2018]   [Oct]   [16]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: [RFC PATCH 3/5] drivers: base: Introducing software nodes to the firmware node framework
On Fri, Oct 12, 2018 at 02:39:32PM +0300, Heikki Krogerus wrote:
> Software node is a new struct fwnode_handle type that can be
> used to describe devices in kernel (software). It is meant
> to complement fwnodes representing real firmware nodes when
> they are incomplete (for example missing device properties)
> and to supply the primary fwnode when the firmware lacks
> hardware description for a device completely.
>
> The software node type is really meant to replace the
> currently used "property_set" struct fwnode_handle type. The
> handling of struct property_set is glued to the generic
> device property handling code, and it is not possible to
> create a struct property_set independently from a device
> that it is bind to. struct property_set is only created when
> device properties are added to already initialized struct
> device, and control of it is only possible from the generic
> property handling code.
>
> Software nodes are instead designed to be created
> independently from the device entries (struct device). It
> makes them much more flexible, as then the device meant to
> be bind to the node can be created at a later time, and from
> another location. It is also possible to bind multiple
> devices to a single software node if needed.
>
> The software node implementation also includes support for
> node hierarchy, which was the main motivation for this
> commit. The node hierarchy was something that was requested
> for the struct property_set, but it did not seem reasonable
> to try to extend the property_set support for that purpose.
> struct property_set was really meant only for device
> property handling like the name suggests.
>
> Support for struct property_set is not yet removed in this
> commit, but it will be in the following one.

> +static int property_entry_read_string_array(const struct property_entry *props,
> + const char *propname,
> + const char **strings, size_t nval)
> +{
> + const struct property_entry *prop;
> + const void *pointer;
> + size_t array_len, length;
> +
> + /* Find out the array length. */
> + prop = property_entry_get(props, propname);
> + if (!prop)
> + return -EINVAL;
> +

> + if (!prop->is_array)
> + /* The array length for a non-array string property is 1. */
> + array_len = 1;
> + else
> + /* Find the length of an array. */
> + array_len = property_entry_count_elems_of_size(props, propname,
> + sizeof(const char *));

I understand where it comes from, but here we may use positive condition.

> +
> + /* Return how many there are if strings is NULL. */
> + if (!strings)
> + return array_len;
> +
> + array_len = min(nval, array_len);
> + length = array_len * sizeof(*strings);
> +
> + pointer = property_entry_find(props, propname, length);
> + if (IS_ERR(pointer))
> + return PTR_ERR(pointer);
> +
> + memcpy(strings, pointer, length);
> +
> + return array_len;
> +}

> +struct fwnode_handle *
> +software_node_get_next_child(const struct fwnode_handle *fwnode,
> + struct fwnode_handle *child)
> +{
> + struct software_node *p = to_software_node(fwnode);
> + struct software_node *c = to_software_node(child);
> +
> + if (list_empty(&p->children) ||
> + (c && list_is_last(&c->entry, &p->children)))
> + return NULL;
> +
> + if (c)
> + c = list_next_entry(c, entry);
> + else
> + c = list_first_entry(&p->children, struct software_node, entry);
> + return &c->fwnode;
> +}

> +static ssize_t software_node_property_show(struct kobject *kobj,
> + struct kobj_attribute *attr,
> + char *buf)
> +{
> + struct software_node *swnode = kobj_to_swnode(kobj);
> + const struct property_entry *prop;
> +
> + for (prop = swnode->properties; prop->name; prop++)
> + if (prop->name == attr->attr.name)
> + break;
> +
> + if (prop->is_array)
> + return property_array_show(prop, buf);
> +
> + /* boolean property */
> + if (!prop->length)
> + return sprintf(buf, "1\n");
> +
> + switch (prop->type) {

> + case DEV_PROP_U8:
> + return sprintf(buf, "%u\n", prop->value.u8_data);

I would expect same base for all numbers.

> + case DEV_PROP_U16:
> + return sprintf(buf, "0x%x\n", prop->value.u16_data);
> + case DEV_PROP_U32:
> + return sprintf(buf, "0x%x\n", prop->value.u32_data);
> + case DEV_PROP_U64:
> + return sprintf(buf, "0x%llx\n", prop->value.u64_data);
> + case DEV_PROP_STRING:
> + return sprintf(buf, "%s\n", prop->value.str);
> + default:
> + break;
> + }

I just realize that we might need to export type of the node as well.
How can we distinguish string "251" from a number?

> +
> + return -EINVAL;
> +}

> +}

> +#define NODE_NAME_MAXSIZE 11

sizeof(int) = 4 (32 bits), so, 32 * 3 / 10 ~= 10. On top are "node" and '\0'.
Thus, I would rather put 16 here. Or limit the maximum for ida_simple_get().

> +struct fwnode_handle *
> +fwnode_create_software_node(const struct property_entry *properties,
> + const struct fwnode_handle *parent)
> +{
> + char node_name[NODE_NAME_MAXSIZE];
> + struct software_node *p = NULL;
> + struct software_node *swnode;
> + int ret;
> +
> + if (parent) {
> + if (IS_ERR(parent))
> + return ERR_CAST(parent);
> + if (!is_software_node(parent))
> + return ERR_PTR(-EINVAL);
> + p = to_software_node(parent);
> + }
> +
> + swnode = kzalloc(sizeof(*swnode), GFP_KERNEL);
> + if (!swnode)
> + return ERR_PTR(-ENOMEM);
> +

> + swnode->id = ida_simple_get(p ? &p->child_ids : &swnode_root_ids, 0, 0,
> + GFP_KERNEL);

> + if (swnode->id < 0) {
> + kfree(swnode);
> + return ERR_PTR(swnode->id);
> + }
> +
> + sprintf(node_name, "node%d", swnode->id);
> +
> + swnode->kobj.kset = swnode_kset;
> + swnode->fwnode.ops = &software_node_ops;
> +
> + ida_init(&swnode->child_ids);
> + INIT_LIST_HEAD(&swnode->entry);
> + INIT_LIST_HEAD(&swnode->children);
> + swnode->parent = p;
> +
> + if (p)
> + list_add_tail(&swnode->entry, &p->children);
> +
> + ret = kobject_init_and_add(&swnode->kobj, &software_node_type,
> + p ? &p->kobj : NULL, node_name);
> + if (ret) {
> + kobject_put(&swnode->kobj);
> + return ERR_PTR(ret);
> + }
> +
> + ret = software_node_register_properties(swnode, properties);
> + if (ret) {
> + kobject_put(&swnode->kobj);
> + return ERR_PTR(ret);
> + }
> +
> + kobject_uevent(&swnode->kobj, KOBJ_ADD);
> + return &swnode->fwnode;
> +}


--
With Best Regards,
Andy Shevchenko


\
 
 \ /
  Last update: 2018-10-16 14:59    [W:0.117 / U:8.132 seconds]
©2003-2018 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site