cregit-Linux how code gets into the kernel

Release 4.14 drivers/base/property.c

Directory: drivers/base
/*
 * property.c - Unified device property interface.
 *
 * Copyright (C) 2014, Intel Corporation
 * Authors: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
 *          Mika Westerberg <mika.westerberg@linux.intel.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/acpi.h>
#include <linux/export.h>
#include <linux/kernel.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_graph.h>
#include <linux/property.h>
#include <linux/etherdevice.h>
#include <linux/phy.h>


struct property_set {
	
struct device *dev;
	
struct fwnode_handle fwnode;
	
const struct property_entry *properties;
};


static const struct fwnode_operations pset_fwnode_ops;


static inline bool is_pset_node(const struct fwnode_handle *fwnode) { return !IS_ERR_OR_NULL(fwnode) && fwnode->ops == &pset_fwnode_ops; }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki1866.67%120.00%
Sakari Ailus414.81%240.00%
Heikki Krogerus414.81%120.00%
Andy Shevchenko13.70%120.00%
Total27100.00%5100.00%

#define to_pset_node(__fwnode) \ ({ \ typeof(__fwnode) __to_pset_node_fwnode = __fwnode; \ \ is_pset_node(__to_pset_node_fwnode) ? \ container_of(__to_pset_node_fwnode, \ struct property_set, fwnode) : \ NULL; \ })
static const struct property_entry * pset_prop_get(const struct property_set *pset, const char *name) { const struct property_entry *prop; if (!pset || !pset->properties) return NULL; for (prop = pset->properties; prop->name; prop++) if (!strcmp(name, prop->name)) return prop; return NULL; }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki6995.83%133.33%
Dmitry Torokhov22.78%133.33%
Sakari Ailus11.39%133.33%
Total72100.00%3100.00%


static const void *pset_prop_find(const struct property_set *pset, const char *propname, size_t length) { const struct property_entry *prop; const void *pointer; prop = pset_prop_get(pset, propname); if (!prop) return ERR_PTR(-EINVAL); if (prop->is_array) pointer = prop->pointer.raw_data; else pointer = &prop->value.raw_data; if (!pointer) return ERR_PTR(-ENODATA); if (length > prop->length) return ERR_PTR(-EOVERFLOW); return pointer; }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki5349.07%120.00%
Andy Shevchenko5147.22%240.00%
Dmitry Torokhov32.78%120.00%
Sakari Ailus10.93%120.00%
Total108100.00%5100.00%


static int pset_prop_read_u8_array(const struct property_set *pset, const char *propname, u8 *values, size_t nval) { const void *pointer; size_t length = nval * sizeof(*values); pointer = pset_prop_find(pset, propname, length); if (IS_ERR(pointer)) return PTR_ERR(pointer); memcpy(values, pointer, length); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Andy Shevchenko7294.74%125.00%
Rafael J. Wysocki22.63%125.00%
Sakari Ailus11.32%125.00%
Dmitry Torokhov11.32%125.00%
Total76100.00%4100.00%


static int pset_prop_read_u16_array(const struct property_set *pset, const char *propname, u16 *values, size_t nval) { const void *pointer; size_t length = nval * sizeof(*values); pointer = pset_prop_find(pset, propname, length); if (IS_ERR(pointer)) return PTR_ERR(pointer); memcpy(values, pointer, length); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Andy Shevchenko6382.89%125.00%
Rafael J. Wysocki1114.47%125.00%
Sakari Ailus11.32%125.00%
Dmitry Torokhov11.32%125.00%
Total76100.00%4100.00%


static int pset_prop_read_u32_array(const struct property_set *pset, const char *propname, u32 *values, size_t nval) { const void *pointer; size_t length = nval * sizeof(*values); pointer = pset_prop_find(pset, propname, length); if (IS_ERR(pointer)) return PTR_ERR(pointer); memcpy(values, pointer, length); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Andy Shevchenko6990.79%125.00%
Rafael J. Wysocki56.58%125.00%
Dmitry Torokhov11.32%125.00%
Sakari Ailus11.32%125.00%
Total76100.00%4100.00%


static int pset_prop_read_u64_array(const struct property_set *pset, const char *propname, u64 *values, size_t nval) { const void *pointer; size_t length = nval * sizeof(*values); pointer = pset_prop_find(pset, propname, length); if (IS_ERR(pointer)) return PTR_ERR(pointer); memcpy(values, pointer, length); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Andy Shevchenko6484.21%125.00%
Rafael J. Wysocki1013.16%125.00%
Sakari Ailus11.32%125.00%
Dmitry Torokhov11.32%125.00%
Total76100.00%4100.00%


static int pset_prop_count_elems_of_size(const struct property_set *pset, const char *propname, size_t length) { const struct property_entry *prop; prop = pset_prop_get(pset, propname); if (!prop) return -EINVAL; return prop->length / length; }

Contributors

PersonTokensPropCommitsCommitProp
Andy Shevchenko4792.16%125.00%
Rafael J. Wysocki23.92%125.00%
Sakari Ailus11.96%125.00%
Dmitry Torokhov11.96%125.00%
Total51100.00%4100.00%


static int pset_prop_read_string_array(const struct property_set *pset, 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 = pset_prop_get(pset, 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 = pset_prop_count_elems_of_size(pset, propname, sizeof(const char *)); /* 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 = pset_prop_find(pset, propname, length); if (IS_ERR(pointer)) return PTR_ERR(pointer); memcpy(strings, pointer, length); return array_len; }

Contributors

PersonTokensPropCommitsCommitProp
Sakari Ailus8152.26%350.00%
Andy Shevchenko6642.58%116.67%
Rafael J. Wysocki74.52%116.67%
Dmitry Torokhov10.65%116.67%
Total155100.00%6100.00%


struct fwnode_handle *dev_fwnode(struct device *dev) { return IS_ENABLED(CONFIG_OF) && dev->of_node ? &dev->of_node->fwnode : dev->fwnode; }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki33100.00%2100.00%
Total33100.00%2100.00%

EXPORT_SYMBOL_GPL(dev_fwnode);
static bool pset_fwnode_property_present(const struct fwnode_handle *fwnode, const char *propname) { return !!pset_prop_get(to_pset_node(fwnode), propname); }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki2066.67%250.00%
Sakari Ailus1033.33%250.00%
Total30100.00%4100.00%


static int pset_fwnode_read_int_array(const struct fwnode_handle *fwnode, const char *propname, unsigned int elem_size, void *val, size_t nval) { const struct property_set *node = to_pset_node(fwnode); if (!val) return pset_prop_count_elems_of_size(node, propname, elem_size); switch (elem_size) { case sizeof(u8): return pset_prop_read_u8_array(node, propname, val, nval); case sizeof(u16): return pset_prop_read_u16_array(node, propname, val, nval); case sizeof(u32): return pset_prop_read_u32_array(node, propname, val, nval); case sizeof(u64): return pset_prop_read_u64_array(node, propname, val, nval); } return -ENXIO; }

Contributors

PersonTokensPropCommitsCommitProp
Sakari Ailus9872.06%240.00%
Rafael J. Wysocki3525.74%120.00%
Andy Shevchenko32.21%240.00%
Total136100.00%5100.00%


static int pset_fwnode_property_read_string_array(const struct fwnode_handle *fwnode, const char *propname, const char **val, size_t nval) { return pset_prop_read_string_array(to_pset_node(fwnode), propname, val, nval); }

Contributors

PersonTokensPropCommitsCommitProp
Sakari Ailus3278.05%240.00%
Rafael J. Wysocki819.51%240.00%
Andy Shevchenko12.44%120.00%
Total41100.00%5100.00%

static const struct fwnode_operations pset_fwnode_ops = { .property_present = pset_fwnode_property_present, .property_read_int_array = pset_fwnode_read_int_array, .property_read_string_array = pset_fwnode_property_read_string_array, }; /** * device_property_present - check if a property of a device is present * @dev: Device whose property is being checked * @propname: Name of the property * * Check if property @propname is present in the device firmware description. */
bool device_property_present(struct device *dev, const char *propname) { return fwnode_property_present(dev_fwnode(dev), propname); }

Contributors

PersonTokensPropCommitsCommitProp
Sakari Ailus2388.46%133.33%
Andy Shevchenko27.69%133.33%
Rafael J. Wysocki13.85%133.33%
Total26100.00%3100.00%

EXPORT_SYMBOL_GPL(device_property_present); /** * fwnode_property_present - check if a property of a firmware node is present * @fwnode: Firmware node whose property to check * @propname: Name of the property */
bool fwnode_property_present(const struct fwnode_handle *fwnode, const char *propname) { bool ret; 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); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Andy Shevchenko4974.24%114.29%
Heikki Krogerus1015.15%342.86%
Sakari Ailus710.61%342.86%
Total66100.00%7100.00%

EXPORT_SYMBOL_GPL(fwnode_property_present); /** * device_property_read_u8_array - return a u8 array property of a device * @dev: Device to get the property of * @propname: Name of the property * @val: The values are stored here or %NULL to return the number of values * @nval: Size of the @val array * * Function reads an array of u8 properties with @propname from the device * firmware description and stores them to @val if found. * * Return: number of values if @val was %NULL, * %0 if the property was found (success), * %-EINVAL if given arguments are not valid, * %-ENODATA if the property does not have a value, * %-EPROTO if the property is not an array of numbers, * %-EOVERFLOW if the size of the property is not as expected. * %-ENXIO if no suitable firmware interface is present. */
int device_property_read_u8_array(struct device *dev, const char *propname, u8 *val, size_t nval) { return fwnode_property_read_u8_array(dev_fwnode(dev), propname, val, nval); }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki37100.00%2100.00%
Total37100.00%2100.00%

EXPORT_SYMBOL_GPL(device_property_read_u8_array); /** * device_property_read_u16_array - return a u16 array property of a device * @dev: Device to get the property of * @propname: Name of the property * @val: The values are stored here or %NULL to return the number of values * @nval: Size of the @val array * * Function reads an array of u16 properties with @propname from the device * firmware description and stores them to @val if found. * * Return: number of values if @val was %NULL, * %0 if the property was found (success), * %-EINVAL if given arguments are not valid, * %-ENODATA if the property does not have a value, * %-EPROTO if the property is not an array of numbers, * %-EOVERFLOW if the size of the property is not as expected. * %-ENXIO if no suitable firmware interface is present. */
int device_property_read_u16_array(struct device *dev, const char *propname, u16 *val, size_t nval) { return fwnode_property_read_u16_array(dev_fwnode(dev), propname, val, nval); }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki37100.00%2100.00%
Total37100.00%2100.00%

EXPORT_SYMBOL_GPL(device_property_read_u16_array); /** * device_property_read_u32_array - return a u32 array property of a device * @dev: Device to get the property of * @propname: Name of the property * @val: The values are stored here or %NULL to return the number of values * @nval: Size of the @val array * * Function reads an array of u32 properties with @propname from the device * firmware description and stores them to @val if found. * * Return: number of values if @val was %NULL, * %0 if the property was found (success), * %-EINVAL if given arguments are not valid, * %-ENODATA if the property does not have a value, * %-EPROTO if the property is not an array of numbers, * %-EOVERFLOW if the size of the property is not as expected. * %-ENXIO if no suitable firmware interface is present. */
int device_property_read_u32_array(struct device *dev, const char *propname, u32 *val, size_t nval) { return fwnode_property_read_u32_array(dev_fwnode(dev), propname, val, nval); }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki37100.00%2100.00%
Total37100.00%2100.00%

EXPORT_SYMBOL_GPL(device_property_read_u32_array); /** * device_property_read_u64_array - return a u64 array property of a device * @dev: Device to get the property of * @propname: Name of the property * @val: The values are stored here or %NULL to return the number of values * @nval: Size of the @val array * * Function reads an array of u64 properties with @propname from the device * firmware description and stores them to @val if found. * * Return: number of values if @val was %NULL, * %0 if the property was found (success), * %-EINVAL if given arguments are not valid, * %-ENODATA if the property does not have a value, * %-EPROTO if the property is not an array of numbers, * %-EOVERFLOW if the size of the property is not as expected. * %-ENXIO if no suitable firmware interface is present. */
int device_property_read_u64_array(struct device *dev, const char *propname, u64 *val, size_t nval) { return fwnode_property_read_u64_array(dev_fwnode(dev), propname, val, nval); }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki37100.00%2100.00%
Total37100.00%2100.00%

EXPORT_SYMBOL_GPL(device_property_read_u64_array); /** * device_property_read_string_array - return a string array property of device * @dev: Device to get the property of * @propname: Name of the property * @val: The values are stored here or %NULL to return the number of values * @nval: Size of the @val array * * Function reads an array of string properties with @propname from the device * firmware description and stores them to @val if found. * * 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, * %-ENODATA if the property does not have a value, * %-EPROTO or %-EILSEQ if the property is not an array of strings, * %-EOVERFLOW if the size of the property is not as expected. * %-ENXIO if no suitable firmware interface is present. */
int device_property_read_string_array(struct device *dev, const char *propname, const char **val, size_t nval) { return fwnode_property_read_string_array(dev_fwnode(dev), propname, val, nval); }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki3794.87%266.67%
Adrian Hunter25.13%133.33%
Total39100.00%3100.00%

EXPORT_SYMBOL_GPL(device_property_read_string_array); /** * device_property_read_string - return a string property of a device * @dev: Device to get the property of * @propname: Name of the property * @val: The value is stored here * * Function reads property @propname from the device firmware description and * stores the value into @val if found. The value is checked to be a string. * * Return: %0 if the property was found (success), * %-EINVAL if given arguments are not valid, * %-ENODATA if the property does not have a value, * %-EPROTO or %-EILSEQ if the property type is not a string. * %-ENXIO if no suitable firmware interface is present. */
int device_property_read_string(struct device *dev, const char *propname, const char **val) { return fwnode_property_read_string(dev_fwnode(dev), propname, val); }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki34100.00%2100.00%
Total34100.00%2100.00%

EXPORT_SYMBOL_GPL(device_property_read_string); /** * device_property_match_string - find a string in an array and return index * @dev: Device to get the property of * @propname: Name of the property holding the array * @string: String to look for * * Find a given string in a string array and if it is found return the * index back. * * Return: %0 if the property was found (success), * %-EINVAL if given arguments are not valid, * %-ENODATA if the property does not have a value, * %-EPROTO if the property is not an array of strings, * %-ENXIO if no suitable firmware interface is present. */
int device_property_match_string(struct device *dev, const char *propname, const char *string) { return fwnode_property_match_string(dev_fwnode(dev), propname, string); }

Contributors

PersonTokensPropCommitsCommitProp
Mika Westerberg33100.00%1100.00%
Total33100.00%1100.00%

EXPORT_SYMBOL_GPL(device_property_match_string);
static int fwnode_property_read_int_array(const struct fwnode_handle *fwnode, const char *propname, unsigned int elem_size, void *val, size_t nval) { int ret; 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); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Sakari Ailus4751.65%266.67%
Rafael J. Wysocki4448.35%133.33%
Total91100.00%3100.00%

/** * fwnode_property_read_u8_array - return a u8 array property of firmware node * @fwnode: Firmware node to get the property of * @propname: Name of the property * @val: The values are stored here or %NULL to return the number of values * @nval: Size of the @val array * * Read an array of u8 properties with @propname from @fwnode and stores them to * @val if found. * * Return: number of values if @val was %NULL, * %0 if the property was found (success), * %-EINVAL if given arguments are not valid, * %-ENODATA if the property does not have a value, * %-EPROTO if the property is not an array of numbers, * %-EOVERFLOW if the size of the property is not as expected, * %-ENXIO if no suitable firmware interface is present. */
int fwnode_property_read_u8_array(const struct fwnode_handle *fwnode, const char *propname, u8 *val, size_t nval) { return fwnode_property_read_int_array(fwnode, propname, sizeof(u8), val, nval); }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki3280.00%133.33%
Sakari Ailus820.00%266.67%
Total40100.00%3100.00%

EXPORT_SYMBOL_GPL(fwnode_property_read_u8_array); /** * fwnode_property_read_u16_array - return a u16 array property of firmware node * @fwnode: Firmware node to get the property of * @propname: Name of the property * @val: The values are stored here or %NULL to return the number of values * @nval: Size of the @val array * * Read an array of u16 properties with @propname from @fwnode and store them to * @val if found. * * Return: number of values if @val was %NULL, * %0 if the property was found (success), * %-EINVAL if given arguments are not valid, * %-ENODATA if the property does not have a value, * %-EPROTO if the property is not an array of numbers, * %-EOVERFLOW if the size of the property is not as expected, * %-ENXIO if no suitable firmware interface is present. */
int fwnode_property_read_u16_array(const struct fwnode_handle *fwnode, const char *propname, u16 *val, size_t nval) { return fwnode_property_read_int_array(fwnode, propname, sizeof(u16), val, nval); }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki3280.00%133.33%
Sakari Ailus820.00%266.67%
Total40100.00%3100.00%

EXPORT_SYMBOL_GPL(fwnode_property_read_u16_array); /** * fwnode_property_read_u32_array - return a u32 array property of firmware node * @fwnode: Firmware node to get the property of * @propname: Name of the property * @val: The values are stored here or %NULL to return the number of values * @nval: Size of the @val array * * Read an array of u32 properties with @propname from @fwnode store them to * @val if found. * * Return: number of values if @val was %NULL, * %0 if the property was found (success), * %-EINVAL if given arguments are not valid, * %-ENODATA if the property does not have a value, * %-EPROTO if the property is not an array of numbers, * %-EOVERFLOW if the size of the property is not as expected, * %-ENXIO if no suitable firmware interface is present. */
int fwnode_property_read_u32_array(const struct fwnode_handle *fwnode, const char *propname, u32 *val, size_t nval) { return fwnode_property_read_int_array(fwnode, propname, sizeof(u32), val, nval); }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki2562.50%133.33%
Sakari Ailus1537.50%266.67%
Total40100.00%3100.00%

EXPORT_SYMBOL_GPL(fwnode_property_read_u32_array); /** * fwnode_property_read_u64_array - return a u64 array property firmware node * @fwnode: Firmware node to get the property of * @propname: Name of the property * @val: The values are stored here or %NULL to return the number of values * @nval: Size of the @val array * * Read an array of u64 properties with @propname from @fwnode and store them to * @val if found. * * Return: number of values if @val was %NULL, * %0 if the property was found (success), * %-EINVAL if given arguments are not valid, * %-ENODATA if the property does not have a value, * %-EPROTO if the property is not an array of numbers, * %-EOVERFLOW if the size of the property is not as expected, * %-ENXIO if no suitable firmware interface is present. */
int fwnode_property_read_u64_array(const struct fwnode_handle *fwnode, const char *propname, u64 *val, size_t nval) { return fwnode_property_read_int_array(fwnode, propname, sizeof(u64), val, nval); }

Contributors

PersonTokensPropCommitsCommitProp
Sakari Ailus2870.00%250.00%
Rafael J. Wysocki1230.00%250.00%
Total40100.00%4100.00%

EXPORT_SYMBOL_GPL(fwnode_property_read_u64_array); /** * fwnode_property_read_string_array - return string array property of a node * @fwnode: Firmware node to get the property of * @propname: Name of the property * @val: The values are stored here or %NULL to return the number of values * @nval: Size of the @val array * * Read an string list property @propname from the given firmware node and store * them to @val if found. * * 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, * %-ENODATA if the property does not have a value, * %-EPROTO or %-EILSEQ if the property is not an array of strings, * %-EOVERFLOW if the size of the property is not as expected, * %-ENXIO if no suitable firmware interface is present. */
int fwnode_property_read_string_array(const struct fwnode_handle *fwnode, const char *propname, const char **val, size_t nval) { int ret; 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); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Andy Shevchenko6779.76%116.67%
Heikki Krogerus1011.90%350.00%
Sakari Ailus78.33%233.33%
Total84100.00%6100.00%

EXPORT_SYMBOL_GPL(fwnode_property_read_string_array); /** * fwnode_property_read_string - return a string property of a firmware node * @fwnode: Firmware node to get the property of * @propname: Name of the property * @val: The value is stored here * * Read property @propname from the given firmware node and store the value into * @val if found. The value is checked to be a string. * * Return: %0 if the property was found (success), * %-EINVAL if given arguments are not valid, * %-ENODATA if the property does not have a value, * %-EPROTO or %-EILSEQ if the property is not a string, * %-ENXIO if no suitable firmware interface is present. */
int fwnode_property_read_string(const struct fwnode_handle *fwnode, const char *propname, const char **val) { int ret = fwnode_property_read_string_array(fwnode, propname, val, 1); return ret < 0 ? ret : 0; }

Contributors

PersonTokensPropCommitsCommitProp
Andy Shevchenko3475.56%125.00%
Sakari Ailus1124.44%375.00%
Total45100.00%4100.00%

EXPORT_SYMBOL_GPL(fwnode_property_read_string); /** * fwnode_property_match_string - find a string in an array and return index * @fwnode: Firmware node to get the property of * @propname: Name of the property holding the array * @string: String to look for * * Find a given string in a string array and if it is found return the * index back. * * Return: %0 if the property was found (success), * %-EINVAL if given arguments are not valid, * %-ENODATA if the property does not have a value, * %-EPROTO if the property is not an array of strings, * %-ENXIO if no suitable firmware interface is present. */
int fwnode_property_match_string(const struct fwnode_handle *fwnode, const char *propname, const char *string) { const char **values; int nval, ret; nval = fwnode_property_read_string_array(fwnode, propname, NULL, 0); if (nval < 0) return nval; if (nval == 0) return -ENODATA; values = kcalloc(nval, sizeof(*values), GFP_KERNEL); if (!values) return -ENOMEM; ret = fwnode_property_read_string_array(fwnode, propname, values, nval); if (ret < 0) goto out; ret = match_string(values, nval, string); if (ret < 0) ret = -ENODATA; out: kfree(values); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Mika Westerberg12084.51%125.00%
Andy Shevchenko2114.79%250.00%
Sakari Ailus10.70%125.00%
Total142100.00%4100.00%

EXPORT_SYMBOL_GPL(fwnode_property_match_string); /** * fwnode_property_get_reference_args() - Find a reference with arguments * @fwnode: Firmware node where to look for the reference * @prop: The name of the property * @nargs_prop: The name of the property telling the number of * arguments in the referred node. NULL if @nargs is known, * otherwise @nargs is ignored. Only relevant on OF. * @nargs: Number of arguments. Ignored if @nargs_prop is non-NULL. * @index: Index of the reference, from zero onwards. * @args: Result structure with reference and integer arguments. * * Obtain a reference based on a named property in an fwnode, with * integer arguments. * * Caller is responsible to call fwnode_handle_put() on the returned * args->fwnode pointer. * * Returns: %0 on success * %-ENOENT when the index is out of bounds, the index has an empty * reference or the property was not found * %-EINVAL on parse error */
int fwnode_property_get_reference_args(const struct fwnode_handle *fwnode, const char *prop, const char *nargs_prop, unsigned int nargs, unsigned int index, struct fwnode_reference_args *args) { return fwnode_call_int_op(fwnode, get_reference_args, prop, nargs_prop, nargs, index, args); }

Contributors

PersonTokensPropCommitsCommitProp
Sakari Ailus52100.00%1100.00%
Total52100.00%1100.00%

EXPORT_SYMBOL_GPL(fwnode_property_get_reference_args);
static int property_copy_string_array(struct property_entry *dst, const struct property_entry *src) { char **d; size_t nval = src->length / sizeof(*d); int i; d = kcalloc(nval, sizeof(*d), GFP_KERNEL); if (!d) return -ENOMEM; for (i = 0; i < nval; i++) { d[i] = kstrdup(src->pointer.str[i], GFP_KERNEL); if (!d[i] && src->pointer.str[i]) { while (--i >= 0) kfree(d[i]); kfree(d); return -ENOMEM; } } dst->pointer.raw_data = d; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov9160.67%150.00%
Mika Westerberg5939.33%150.00%
Total150100.00%2100.00%


static int property_entry_copy_data(struct property_entry *dst, const struct property_entry *src) { int error; dst->name = kstrdup(src->name, GFP_KERNEL); if (!dst->name) return -ENOMEM; if (src->is_array) { if (!src->length) { error = -ENODATA; goto out_free_name; } if (src->is_string) { error = property_copy_string_array(dst, src); if (error) goto out_free_name; } else { dst->pointer.raw_data = kmemdup(src->pointer.raw_data, src->length, GFP_KERNEL); if (!dst->pointer.raw_data) { error = -ENOMEM; goto out_free_name; } } } else if (src->is_string) { dst->value.str = kstrdup(src->value.str, GFP_KERNEL); if (!dst->value.str && src->value.str) { error = -ENOMEM; goto out_free_name; } } else { dst->value.raw_data = src->value.raw_data; } dst->length = src->length; dst->is_array = src->is_array; dst->is_string = src->is_string; return 0; out_free_name: kfree(dst->name); return error; }

Contributors

PersonTokensPropCommitsCommitProp
Mika Westerberg17873.86%125.00%
Dmitry Torokhov5422.41%250.00%
Andy Shevchenko93.73%125.00%
Total241100.00%4100.00%


static void property_entry_free_data(const struct property_entry *p) { size_t i, nval; if (p->is_array) { if (p->is_string && p->pointer.str) { nval = p->length / sizeof(const char *); for (i = 0; i < nval; i++) kfree(p->pointer.str[i]); } kfree(p->pointer.raw_data); } else if (p->is_string) { kfree(p->value.str); } kfree(p->name); }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov8576.58%150.00%
Mika Westerberg2623.42%150.00%
Total111100.00%2100.00%

/** * property_entries_dup - duplicate array of properties * @properties: array of properties to copy * * This function creates a deep copy of the given NULL-terminated array * of property entries. */
struct property_entry * property_entries_dup(const struct property_entry *properties) { struct property_entry *p; int i, n = 0; while (properties[n].name) n++; p = kcalloc(n + 1, sizeof(*p), GFP_KERNEL); if (!p) return ERR_PTR(-ENOMEM); for (i = 0; i < n; i++) { int ret = property_entry_copy_data(&p[i], &properties[i]); if (ret) { while (--i >= 0) property_entry_free_data(&p[i]); kfree(p); return ERR_PTR(ret); } } return p; }

Contributors

PersonTokensPropCommitsCommitProp
Mika Westerberg9066.67%133.33%
Dmitry Torokhov4533.33%266.67%
Total135100.00%3100.00%

EXPORT_SYMBOL_GPL(property_entries_dup); /** * property_entries_free - free previously allocated array of properties * @properties: array of properties to destroy * * This function frees given NULL-terminated array of property entries, * along with their data. */
void property_entries_free(const struct property_entry *properties) { const struct property_entry *p; for (p = properties; p->name; p++) property_entry_free_data(p); kfree(properties); }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov40100.00%1100.00%
Total40100.00%1100.00%

EXPORT_SYMBOL_GPL(property_entries_free); /** * pset_free_set - releases memory allocated for copied property set * @pset: Property set to release * * Function takes previously copied property set and releases all the * memory allocated to it. */
static void pset_free_set(struct property_set *pset) { if (!pset) return; property_entries_free(pset->properties); kfree(pset); }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov29100.00%1100.00%
Total29100.00%1100.00%

/** * pset_copy_set - copies property set * @pset: Property set to copy * * This function takes a deep copy of the given property set and returns * pointer to the copy. Call device_free_property_set() to free resources * allocated in this function. * * Return: Pointer to the new property set or error pointer. */
static struct property_set *pset_copy_set(const struct property_set *pset) { struct property_entry *properties; struct property_set *p; p = kzalloc(sizeof(*p), GFP_KERNEL); if (!p) return ERR_PTR(-ENOMEM); properties = property_entries_dup(pset->properties); if (IS_ERR(properties)) { kfree(p); return ERR_CAST(properties); } p->properties = properties; return p; }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov87100.00%1100.00%
Total87100.00%1100.00%

/** * device_remove_properties - Remove properties from a device object. * @dev: Device whose properties to remove. * * The function removes properties previously associated to the device * secondary firmware node with device_add_properties(). Memory allocated * to the properties will also be released. */
void device_remove_properties(struct device *dev) { struct fwnode_handle *fwnode; struct property_set *pset; fwnode = dev_fwnode(dev); if (!fwnode) return; /* * Pick either primary or secondary node depending which one holds * the pset. If there is no real firmware node (ACPI/DT) primary * will hold the pset. */ pset = to_pset_node(fwnode); if (pset) { set_primary_fwnode(dev, NULL); } else { pset = to_pset_node(fwnode->secondary); if (pset && dev == pset->dev) set_secondary_fwnode(dev, NULL); } if (pset && dev == pset->dev) pset_free_set(pset); }

Contributors

PersonTokensPropCommitsCommitProp
Mika Westerberg4444.90%125.00%
Jarkko Nikula3434.69%125.00%
Heikki Krogerus2020.41%250.00%
Total98100.00%4100.00%

EXPORT_SYMBOL_GPL(device_remove_properties); /** * device_add_properties - Add a collection of properties to a device object. * @dev: Device to add properties to. * @properties: Collection of properties to add. * * Associate a collection of device properties represented by @properties with * @dev as its secondary firmware node. The function takes a copy of * @properties. */
int device_add_properties(struct device *dev, const struct property_entry *properties) { struct property_set *p, pset; if (!properties) return -EINVAL; pset.properties = properties; p = pset_copy_set(&pset); if (IS_ERR(p)) return PTR_ERR(p); p->fwnode.ops = &pset_fwnode_ops; set_secondary_fwnode(dev, &p->fwnode); p->dev = dev; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Mika Westerberg6271.26%120.00%
Heikki Krogerus1314.94%120.00%
Jarkko Nikula66.90%120.00%
Sakari Ailus55.75%120.00%
Dmitry Torokhov11.15%120.00%
Total87100.00%5100.00%

EXPORT_SYMBOL_GPL(device_add_properties); /** * fwnode_get_next_parent - Iterate to the node's parent * @fwnode: Firmware whose parent is retrieved * * This is like fwnode_get_parent() except that it drops the refcount * on the passed node, making it suitable for iterating through a * node's parents. * * Returns a node pointer with refcount incremented, use * fwnode_handle_node() on it when done. */
struct fwnode_handle *fwnode_get_next_parent(struct fwnode_handle *fwnode) { struct fwnode_handle *parent = fwnode_get_parent(fwnode); fwnode_handle_put(fwnode); return parent; }

Contributors

PersonTokensPropCommitsCommitProp
Sakari Ailus30100.00%1100.00%
Total30100.00%1100.00%

EXPORT_SYMBOL_GPL(fwnode_get_next_parent); /** * fwnode_get_parent - Return parent firwmare node * @fwnode: Firmware whose parent is retrieved * * Return parent firmware node of the given node if possible or %NULL if no * parent was available. */
struct fwnode_handle *fwnode_get_parent(const struct fwnode_handle *fwnode) { return fwnode_call_ptr_op(fwnode, get_parent); }

Contributors

PersonTokensPropCommitsCommitProp
Mika Westerberg1676.19%133.33%
Sakari Ailus523.81%266.67%
Total21100.00%3100.00%

EXPORT_SYMBOL_GPL(fwnode_get_parent); /** * fwnode_get_next_child_node - Return the next child node handle for a node * @fwnode: Firmware node to find the next child node for. * @child: Handle to one of the node's child nodes or a %NULL handle. */
struct fwnode_handle * fwnode_get_next_child_node(const struct fwnode_handle *fwnode, struct fwnode_handle *child) { return fwnode_call_ptr_op(fwnode, get_next_child_node, child); }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki2071.43%240.00%
Sakari Ailus414.29%240.00%
Mika Westerberg414.29%120.00%
Total28100.00%5100.00%

EXPORT_SYMBOL_GPL(fwnode_get_next_child_node); /** * device_get_next_child_node - Return the next child node handle for a device * @dev: Device to find the next child node for. * @child: Handle to one of the device's child nodes or a null handle. */
struct fwnode_handle *device_get_next_child_node(struct device *dev, struct fwnode_handle *child) { struct acpi_device *adev = ACPI_COMPANION(dev); struct fwnode_handle *fwnode = NULL; if (dev->of_node) fwnode = &dev->of_node->fwnode; else if (adev) fwnode = acpi_fwnode_handle(adev); return fwnode_get_next_child_node(fwnode, child); }

Contributors

PersonTokensPropCommitsCommitProp
Mika Westerberg69100.00%1100.00%
Total69100.00%1100.00%

EXPORT_SYMBOL_GPL(device_get_next_child_node); /** * fwnode_get_named_child_node - Return first matching named child node handle * @fwnode: Firmware node to find the named child node for. * @childname: String to match child node name against. */
struct fwnode_handle * fwnode_get_named_child_node(const struct fwnode_handle *fwnode, const char *childname) { return fwnode_call_ptr_op(fwnode, get_named_child_node, childname); }

Contributors

PersonTokensPropCommitsCommitProp
Adam Thomson2071.43%125.00%
Sakari Ailus517.86%250.00%
Mika Westerberg310.71%125.00%
Total28100.00%4100.00%

EXPORT_SYMBOL_GPL(fwnode_get_named_child_node); /** * device_get_named_child_node - Return first matching named child node handle * @dev: Device to find the named child node for. * @childname: String to match child node name against. */
struct fwnode_handle *device_get_named_child_node(struct device *dev, const char *childname) { return fwnode_get_named_child_node(dev_fwnode(dev), childname); }

Contributors

PersonTokensPropCommitsCommitProp
Mika Westerberg28100.00%1100.00%
Total28100.00%1100.00%

EXPORT_SYMBOL_GPL(device_get_named_child_node); /** * fwnode_handle_get - Obtain a reference to a device node * @fwnode: Pointer to the device node to obtain the reference to. */
void fwnode_handle_get(struct fwnode_handle *fwnode) { fwnode_call_void_op(fwnode, get); }

Contributors

PersonTokensPropCommitsCommitProp
Sakari Ailus17100.00%2100.00%
Total17100.00%2100.00%

EXPORT_SYMBOL_GPL(fwnode_handle_get); /** * fwnode_handle_put - Drop reference to a device node * @fwnode: Pointer to the device node to drop the reference to. * * This has to be used when terminating device_for_each_child_node() iteration * with break or return to prevent stale device node references from being left * behind. */
void fwnode_handle_put(struct fwnode_handle *fwnode) { fwnode_call_void_op(fwnode, put); }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki1482.35%150.00%
Sakari Ailus317.65%150.00%
Total17100.00%2100.00%

EXPORT_SYMBOL_GPL(fwnode_handle_put); /** * fwnode_device_is_available - check if a device is available for use * @fwnode: Pointer to the fwnode of the device. */
bool fwnode_device_is_available(const struct fwnode_handle *fwnode) { return fwnode_call_bool_op(fwnode, device_is_available); }

Contributors

PersonTokensPropCommitsCommitProp
Sakari Ailus19100.00%3100.00%
Total19100.00%3100.00%

EXPORT_SYMBOL_GPL(fwnode_device_is_available); /** * device_get_child_node_count - return the number of child nodes for device * @dev: Device to cound the child nodes for */
unsigned int device_get_child_node_count(struct device *dev) { struct fwnode_handle *child; unsigned int count = 0; device_for_each_child_node(dev, child) count++; return count; }

Contributors

PersonTokensPropCommitsCommitProp
Rafael J. Wysocki34100.00%1100.00%
Total34100.00%1100.00%

EXPORT_SYMBOL_GPL(device_get_child_node_count);
bool device_dma_supported(struct device *dev) { /* For DT, this is always supported. * For ACPI, this depends on CCA, which * is determined by the acpi_dma_supported(). */ if (IS_ENABLED(CONFIG_OF) && dev->of_node) return true; return acpi_dma_supported(ACPI_COMPANION(dev)); }

Contributors

PersonTokensPropCommitsCommitProp
Suravee Suthikulpanit34100.00%1100.00%
Total34100.00%1100.00%

EXPORT_SYMBOL_GPL(device_dma_supported);
enum dev_dma_attr device_get_dma_attr(struct device *dev) { enum dev_dma_attr attr = DEV_DMA_NOT_SUPPORTED; if (IS_ENABLED(CONFIG_OF) && dev->of_node) { if (of_dma_is_coherent(dev->of_node)) attr = DEV_DMA_COHERENT; else attr = DEV_DMA_NON_COHERENT; } else attr = acpi_get_dma_attr(ACPI_COMPANION(dev)); return attr; }

Contributors

PersonTokensPropCommitsCommitProp
Suravee Suthikulpanit62100.00%1100.00%
Total62100.00%1100.00%

EXPORT_SYMBOL_GPL(device_get_dma_attr); /** * device_get_phy_mode - Get phy mode for given device * @dev: Pointer to the given device * * The function gets phy interface string from property 'phy-mode' or * 'phy-connection-type', and return its index in phy_modes table, or errno in * error case. */
int device_get_phy_mode(struct device *dev) { const char *pm; int err, i; err = device_property_read_string(dev, "phy-mode", &pm); if (err < 0) err = device_property_read_string(dev, "phy-connection-type", &pm); if (err < 0) return err; for (i = 0; i < PHY_INTERFACE_MODE_MAX; i++) if (!strcasecmp(pm, phy_modes(i))) return i; return -ENODEV; }

Contributors

PersonTokensPropCommitsCommitProp
Jeremy Linton92100.00%1100.00%
Total92100.00%1100.00%

EXPORT_SYMBOL_GPL(device_get_phy_mode);
static void *device_get_mac_addr(struct device *dev, const char *name, char *addr, int alen) { int ret = device_property_read_u8_array(dev, name, addr, alen); if (ret == 0 && alen == ETH_ALEN && is_valid_ether_addr(addr)) return addr; return NULL; }

Contributors

PersonTokensPropCommitsCommitProp
Jeremy Linton59100.00%2100.00%
Total59100.00%2100.00%

/** * device_get_mac_address - Get the MAC for a given device * @dev: Pointer to the device * @addr: Address of buffer to store the MAC in * @alen: Length of the buffer pointed to by addr, should be ETH_ALEN * * Search the firmware node for the best MAC address to use. 'mac-address' is * checked first, because that is supposed to contain to "most recent" MAC * address. If that isn't set, then 'local-mac-address' is checked next, * because that is the default address. If that isn't set, then the obsolete * 'address' is checked, just in case we're using an old device tree. * * Note that the 'address' property is supposed to contain a virtual address of * the register set, but some DTS files have redefined that property to be the * MAC address. * * All-zero MAC addresses are rejected, because those could be properties that * exist in the firmware tables, but were not updated by the firmware. For * example, the DTS could define 'mac-address' and 'local-mac-address', with * zero MAC addresses. Some older U-Boots only initialized 'local-mac-address'. * In this case, the real MAC is in 'local-mac-address', and 'mac-address' * exists but is all zeros. */
void *device_get_mac_address(struct device *dev, char *addr, int alen) { char *res; res = device_get_mac_addr(dev, "mac-address", addr, alen); if (res) return res; res = device_get_mac_addr(dev, "local-mac-address", addr, alen); if (res) return res; return device_get_mac_addr(dev, "address", addr, alen); }

Contributors

PersonTokensPropCommitsCommitProp
Jeremy Linton6486.49%150.00%
Julien Grall1013.51%150.00%
Total74100.00%2100.00%

EXPORT_SYMBOL(device_get_mac_address); /** * device_graph_get_next_endpoint - Get next endpoint firmware node * @fwnode: Pointer to the parent firmware node * @prev: Previous endpoint node or %NULL to get the first * * Returns an endpoint firmware node pointer or %NULL if no more endpoints * are available. */
struct fwnode_handle * fwnode_graph_get_next_endpoint(const struct fwnode_handle *fwnode, struct fwnode_handle *prev) { return fwnode_call_ptr_op(fwnode, graph_get_next_endpoint, prev); }

Contributors

PersonTokensPropCommitsCommitProp
Mika Westerberg2485.71%133.33%
Sakari Ailus414.29%266.67%
Total28100.00%3100.00%

EXPORT_SYMBOL_GPL(fwnode_graph_get_next_endpoint); /** * fwnode_graph_get_port_parent - Return the device fwnode of a port endpoint * @endpoint: Endpoint firmware node of the port * * Return: the firmware node of the device the @endpoint belongs to. */
struct fwnode_handle * fwnode_graph_get_port_parent(const struct fwnode_handle *endpoint) { struct fwnode_handle *port, *parent; port = fwnode_get_parent(endpoint); parent = fwnode_call_ptr_op(port, graph_get_port_parent); fwnode_handle_put(port); return parent; }

Contributors

PersonTokensPropCommitsCommitProp
Mika Westerberg2964.44%125.00%
Sakari Ailus1226.67%250.00%
Kieran Bingham48.89%125.00%
Total45100.00%4100.00%

EXPORT_SYMBOL_GPL(fwnode_graph_get_port_parent); /** * fwnode_graph_get_remote_port_parent - Return fwnode of a remote device * @fwnode: Endpoint firmware node pointing to the remote endpoint * * Extracts firmware node of a remote device the @fwnode points to. */
struct fwnode_handle * fwnode_graph_get_remote_port_parent(const struct fwnode_handle *fwnode) { struct fwnode_handle *endpoint, *parent; endpoint = fwnode_graph_get_remote_endpoint(fwnode); parent = fwnode_graph_get_port_parent(endpoint); fwnode_handle_put(endpoint); return parent; }

Contributors

PersonTokensPropCommitsCommitProp
Kieran Bingham4297.67%150.00%
Sakari Ailus12.33%150.00%
Total43100.00%2100.00%

EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_port_parent); /** * fwnode_graph_get_remote_port - Return fwnode of a remote port * @fwnode: Endpoint firmware node pointing to the remote endpoint * * Extracts firmware node of a remote port the @fwnode points to. */
struct fwnode_handle * fwnode_graph_get_remote_port(const struct fwnode_handle *fwnode) { return fwnode_get_next_parent(fwnode_graph_get_remote_endpoint(fwnode)); }

Contributors

PersonTokensPropCommitsCommitProp
Mika Westerberg1881.82%133.33%
Sakari Ailus418.18%266.67%
Total22100.00%3100.00%

EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_port); /** * fwnode_graph_get_remote_endpoint - Return fwnode of a remote endpoint * @fwnode: Endpoint firmware node pointing to the remote endpoint * * Extracts firmware node of a remote endpoint the @fwnode points to. */
struct fwnode_handle * fwnode_graph_get_remote_endpoint(const struct fwnode_handle *fwnode) { return fwnode_call_ptr_op(fwnode, graph_get_remote_endpoint); }

Contributors

PersonTokensPropCommitsCommitProp
Mika Westerberg1780.95%133.33%
Sakari Ailus419.05%266.67%
Total21100.00%3100.00%

EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_endpoint); /** * fwnode_graph_get_remote_node - get remote parent node for given port/endpoint * @fwnode: pointer to parent fwnode_handle containing graph port/endpoint * @port_id: identifier of the parent port node * @endpoint_id: identifier of the endpoint node * * Return: Remote fwnode handle associated with remote endpoint node linked * to @node. Use fwnode_node_put() on it when done. */
struct fwnode_handle * fwnode_graph_get_remote_node(const struct fwnode_handle *fwnode, u32 port_id, u32 endpoint_id) { struct fwnode_handle *endpoint = NULL; while ((endpoint = fwnode_graph_get_next_endpoint(fwnode, endpoint))) { struct fwnode_endpoint fwnode_ep; struct fwnode_handle *remote; int ret; ret = fwnode_graph_parse_endpoint(endpoint, &fwnode_ep); if (ret < 0) continue; if (fwnode_ep.port != port_id || fwnode_ep.id != endpoint_id) continue; remote = fwnode_graph_get_remote_port_parent(endpoint); if (!remote) return NULL; return fwnode_device_is_available(remote) ? remote : NULL; } return NULL; }

Contributors

PersonTokensPropCommitsCommitProp
Sakari Ailus113100.00%2100.00%
Total113100.00%2100.00%

EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_node); /** * fwnode_graph_parse_endpoint - parse common endpoint node properties * @fwnode: pointer to endpoint fwnode_handle * @endpoint: pointer to the fwnode endpoint data structure * * Parse @fwnode representing a graph endpoint node and store the * information in @endpoint. The caller must hold a reference to * @fwnode. */
int fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode, struct fwnode_endpoint *endpoint) { memset(endpoint, 0, sizeof(*endpoint)); return fwnode_call_int_op(fwnode, graph_parse_endpoint, endpoint); }

Contributors

PersonTokensPropCommitsCommitProp
Sakari Ailus39100.00%3100.00%
Total39100.00%3100.00%

EXPORT_SYMBOL(fwnode_graph_parse_endpoint);

Overall Contributors

PersonTokensPropCommitsCommitProp
Mika Westerberg88621.50%611.32%
Sakari Ailus80119.44%1732.08%
Rafael J. Wysocki78919.15%59.43%
Andy Shevchenko62715.22%713.21%
Dmitry Torokhov45811.12%35.66%
Jeremy Linton2335.66%23.77%
Suravee Suthikulpanit1092.65%23.77%
Heikki Krogerus751.82%59.43%
Kieran Bingham531.29%11.89%
Jarkko Nikula451.09%11.89%
Adam Thomson250.61%11.89%
Julien Grall100.24%11.89%
Guenter Roeck70.17%11.89%
Adrian Hunter20.05%11.89%
Total4120100.00%53100.00%
Directory: drivers/base
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.